]> 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 void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3795 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3796 #if wxUSE_HOTKEY
3797 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3798 #else
3799 return false;
3800 #endif
3801 }
3802 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3803
3804
3805
3806 return false;
3807
3808 }
3809 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3810 return wxPyGetWinHandle(self);
3811 }
3812 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3813 self->AssociateHandle((WXWidget)handle);
3814 }
3815 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3816
3817 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3818 return wxWindow::FindWindowById(id, parent);
3819 }
3820
3821 wxWindow* wxFindWindowByName( const wxString& name,
3822 const wxWindow *parent = NULL ) {
3823 return wxWindow::FindWindowByName(name, parent);
3824 }
3825
3826 wxWindow* wxFindWindowByLabel( const wxString& label,
3827 const wxWindow *parent = NULL ) {
3828 return wxWindow::FindWindowByLabel(label, parent);
3829 }
3830
3831
3832 #ifdef __WXMSW__
3833 #include <wx/msw/private.h> // to get wxGetWindowId
3834 #endif
3835
3836
3837 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3838 #ifdef __WXMSW__
3839 WXHWND hWnd = (WXHWND)_hWnd;
3840 long id = wxGetWindowId(hWnd);
3841 wxWindow* win = new wxWindow;
3842 if (parent)
3843 parent->AddChild(win);
3844 win->SetEventHandler(win);
3845 win->SetHWND(hWnd);
3846 win->SetId(id);
3847 win->SubclassWin(hWnd);
3848 win->AdoptAttributesFromHWND();
3849 win->SetupColours();
3850 return win;
3851 #else
3852 wxPyRaiseNotImplemented();
3853 return NULL;
3854 #endif
3855 }
3856
3857
3858 PyObject* GetTopLevelWindows() {
3859 return wxPy_ConvertList(&wxTopLevelWindows);
3860 }
3861
3862
3863 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3864 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3865 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3866
3867 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3868
3869
3870 SWIGINTERNINLINE int
3871 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3872 {
3873 unsigned long v;
3874 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3875 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3876 return res;
3877 }
3878
3879 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3880 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3881 wxMenuItemList& list = self->GetMenuItems();
3882 return wxPy_ConvertList(&list);
3883 }
3884 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3885 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3886 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3887 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3888 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3889 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3890 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3891 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3892 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3893 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3894 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3895 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3896 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3897 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3898 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3899 static const wxString wxPyControlNameStr(wxControlNameStr);
3900 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3901 if (clientData) {
3902 wxPyClientData* data = new wxPyClientData(clientData);
3903 return self->Append(item, data);
3904 } else
3905 return self->Append(item);
3906 }
3907 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3908 if (clientData) {
3909 wxPyClientData* data = new wxPyClientData(clientData);
3910 return self->Insert(item, pos, data);
3911 } else
3912 return self->Insert(item, pos);
3913 }
3914 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3915 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3916 if (data) {
3917 Py_INCREF(data->m_obj);
3918 return data->m_obj;
3919 } else {
3920 Py_INCREF(Py_None);
3921 return Py_None;
3922 }
3923 }
3924 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3925 wxPyClientData* data = new wxPyClientData(clientData);
3926 self->SetClientObject(n, data);
3927 }
3928
3929
3930 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3931 wxPyUserData* data = NULL;
3932 if ( userData ) {
3933 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3934 data = new wxPyUserData(userData);
3935 wxPyEndBlockThreads(blocked);
3936 }
3937 return new wxSizerItem(window, proportion, flag, border, data);
3938 }
3939 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3940 wxPyUserData* data = NULL;
3941 if ( userData ) {
3942 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3943 data = new wxPyUserData(userData);
3944 wxPyEndBlockThreads(blocked);
3945 }
3946 return new wxSizerItem(width, height, proportion, flag, border, data);
3947 }
3948 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3949 wxPyUserData* data = NULL;
3950 if ( userData ) {
3951 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3952 data = new wxPyUserData(userData);
3953 wxPyEndBlockThreads(blocked);
3954 }
3955 return new wxSizerItem(sizer, proportion, flag, border, data);
3956 }
3957
3958 #include <float.h>
3959
3960
3961 SWIGINTERN int
3962 SWIG_AsVal_float (PyObject * obj, float *val)
3963 {
3964 double v;
3965 int res = SWIG_AsVal_double (obj, &v);
3966 if (SWIG_IsOK(res)) {
3967 if ((v < -FLT_MAX || v > FLT_MAX)) {
3968 return SWIG_OverflowError;
3969 } else {
3970 if (val) *val = static_cast< float >(v);
3971 }
3972 }
3973 return res;
3974 }
3975
3976
3977 SWIGINTERNINLINE PyObject *
3978 SWIG_From_float (float value)
3979 {
3980 return SWIG_From_double (value);
3981 }
3982
3983 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3984 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3985 if (data) {
3986 Py_INCREF(data->m_obj);
3987 return data->m_obj;
3988 } else {
3989 Py_INCREF(Py_None);
3990 return Py_None;
3991 }
3992 }
3993 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
3994 wxPyUserData* data = NULL;
3995 if ( userData ) {
3996 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3997 data = new wxPyUserData(userData);
3998 wxPyEndBlockThreads(blocked);
3999 }
4000 self->SetUserData(data);
4001 }
4002
4003 // Figure out the type of the sizer item
4004
4005 struct wxPySizerItemInfo {
4006 wxPySizerItemInfo()
4007 : window(NULL), sizer(NULL), gotSize(false),
4008 size(wxDefaultSize), gotPos(false), pos(-1)
4009 {}
4010
4011 wxWindow* window;
4012 wxSizer* sizer;
4013 bool gotSize;
4014 wxSize size;
4015 bool gotPos;
4016 int pos;
4017 };
4018
4019 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4020
4021 wxPySizerItemInfo info;
4022 wxSize size;
4023 wxSize* sizePtr = &size;
4024
4025 // Find out what the type of the item is
4026 // try wxWindow
4027 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4028 PyErr_Clear();
4029 info.window = NULL;
4030
4031 // try wxSizer
4032 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4033 PyErr_Clear();
4034 info.sizer = NULL;
4035
4036 // try wxSize or (w,h)
4037 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4038 info.size = *sizePtr;
4039 info.gotSize = true;
4040 }
4041
4042 // or a single int
4043 if (checkIdx && PyInt_Check(item)) {
4044 info.pos = PyInt_AsLong(item);
4045 info.gotPos = true;
4046 }
4047 }
4048 }
4049
4050 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4051 // no expected type, figure out what kind of error message to generate
4052 if ( !checkSize && !checkIdx )
4053 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4054 else if ( checkSize && !checkIdx )
4055 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4056 else if ( !checkSize && checkIdx)
4057 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4058 else
4059 // can this one happen?
4060 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4061 }
4062
4063 return info;
4064 }
4065
4066 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4067 if (!self->GetClientObject())
4068 self->SetClientObject(new wxPyOORClientData(_self));
4069 }
4070 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4071
4072 wxPyUserData* data = NULL;
4073 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4074 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4075 if ( userData && (info.window || info.sizer || info.gotSize) )
4076 data = new wxPyUserData(userData);
4077 if ( info.sizer )
4078 PyObject_SetAttrString(item,"thisown",Py_False);
4079 wxPyEndBlockThreads(blocked);
4080
4081 // Now call the real Add method if a valid item type was found
4082 if ( info.window )
4083 return self->Add(info.window, proportion, flag, border, data);
4084 else if ( info.sizer )
4085 return self->Add(info.sizer, proportion, flag, border, data);
4086 else if (info.gotSize)
4087 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4088 proportion, flag, border, data);
4089 else
4090 return NULL;
4091 }
4092 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4093
4094 wxPyUserData* data = NULL;
4095 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4096 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4097 if ( userData && (info.window || info.sizer || info.gotSize) )
4098 data = new wxPyUserData(userData);
4099 if ( info.sizer )
4100 PyObject_SetAttrString(item,"thisown",Py_False);
4101 wxPyEndBlockThreads(blocked);
4102
4103 // Now call the real Insert method if a valid item type was found
4104 if ( info.window )
4105 return self->Insert(before, info.window, proportion, flag, border, data);
4106 else if ( info.sizer )
4107 return self->Insert(before, info.sizer, proportion, flag, border, data);
4108 else if (info.gotSize)
4109 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4110 proportion, flag, border, data);
4111 else
4112 return NULL;
4113 }
4114 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4115
4116 wxPyUserData* data = NULL;
4117 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4118 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4119 if ( userData && (info.window || info.sizer || info.gotSize) )
4120 data = new wxPyUserData(userData);
4121 if ( info.sizer )
4122 PyObject_SetAttrString(item,"thisown",Py_False);
4123 wxPyEndBlockThreads(blocked);
4124
4125 // Now call the real Prepend method if a valid item type was found
4126 if ( info.window )
4127 return self->Prepend(info.window, proportion, flag, border, data);
4128 else if ( info.sizer )
4129 return self->Prepend(info.sizer, proportion, flag, border, data);
4130 else if (info.gotSize)
4131 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4132 proportion, flag, border, data);
4133 else
4134 return NULL;
4135 }
4136 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4137 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4138 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4139 wxPyEndBlockThreads(blocked);
4140 if ( info.window )
4141 return self->Remove(info.window);
4142 else if ( info.sizer )
4143 return self->Remove(info.sizer);
4144 else if ( info.gotPos )
4145 return self->Remove(info.pos);
4146 else
4147 return false;
4148 }
4149 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4150 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4151 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4152 wxPyEndBlockThreads(blocked);
4153 if ( info.window )
4154 return self->Detach(info.window);
4155 else if ( info.sizer )
4156 return self->Detach(info.sizer);
4157 else if ( info.gotPos )
4158 return self->Detach(info.pos);
4159 else
4160 return false;
4161 }
4162 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4163 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4164 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4165 wxPyEndBlockThreads(blocked);
4166 if ( info.window )
4167 return self->GetItem(info.window);
4168 else if ( info.sizer )
4169 return self->GetItem(info.sizer);
4170 else if ( info.gotPos )
4171 return self->GetItem(info.pos);
4172 else
4173 return NULL;
4174 }
4175 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4176 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4177 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4178 wxPyEndBlockThreads(blocked);
4179 if ( info.window )
4180 self->SetItemMinSize(info.window, size);
4181 else if ( info.sizer )
4182 self->SetItemMinSize(info.sizer, size);
4183 else if ( info.gotPos )
4184 self->SetItemMinSize(info.pos, size);
4185 }
4186 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4187 wxSizerItemList& list = self->GetChildren();
4188 return wxPy_ConvertList(&list);
4189 }
4190 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4191 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4192 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4193 wxPyEndBlockThreads(blocked);
4194 if ( info.window )
4195 return self->Show(info.window, show, recursive);
4196 else if ( info.sizer )
4197 return self->Show(info.sizer, show, recursive);
4198 else if ( info.gotPos )
4199 return self->Show(info.pos, show);
4200 else
4201 return false;
4202 }
4203 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4204 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4205 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4206 wxPyEndBlockThreads(blocked);
4207 if ( info.window )
4208 return self->IsShown(info.window);
4209 else if ( info.sizer )
4210 return self->IsShown(info.sizer);
4211 else if ( info.gotPos )
4212 return self->IsShown(info.pos);
4213 else
4214 return false;
4215 }
4216
4217 // See pyclasses.h
4218 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4219 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4220 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4221
4222
4223
4224
4225 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4226 {
4227 if (source == Py_None) {
4228 **obj = wxGBPosition(-1,-1);
4229 return true;
4230 }
4231 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4232 }
4233
4234 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4235 {
4236 if (source == Py_None) {
4237 **obj = wxGBSpan(-1,-1);
4238 return true;
4239 }
4240 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4241 }
4242
4243
4244 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4245 wxGBPosition temp, *obj = &temp;
4246 if ( other == Py_None ) return false;
4247 if ( ! wxGBPosition_helper(other, &obj) ) {
4248 PyErr_Clear();
4249 return false;
4250 }
4251 return self->operator==(*obj);
4252 }
4253 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4254 wxGBPosition temp, *obj = &temp;
4255 if ( other == Py_None ) return true;
4256 if ( ! wxGBPosition_helper(other, &obj)) {
4257 PyErr_Clear();
4258 return true;
4259 }
4260 return self->operator!=(*obj);
4261 }
4262 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4263 self->SetRow(row);
4264 self->SetCol(col);
4265 }
4266 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4267 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4268 PyObject* tup = PyTuple_New(2);
4269 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4270 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4271 wxPyEndBlockThreads(blocked);
4272 return tup;
4273 }
4274 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4275 wxGBSpan temp, *obj = &temp;
4276 if ( other == Py_None ) return false;
4277 if ( ! wxGBSpan_helper(other, &obj) ) {
4278 PyErr_Clear();
4279 return false;
4280 }
4281 return self->operator==(*obj);
4282 }
4283 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4284 wxGBSpan temp, *obj = &temp;
4285 if ( other == Py_None ) return true;
4286 if ( ! wxGBSpan_helper(other, &obj)) {
4287 PyErr_Clear();
4288 return true;
4289 }
4290 return self->operator!=(*obj);
4291 }
4292 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4293 self->SetRowspan(rowspan);
4294 self->SetColspan(colspan);
4295 }
4296 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4297 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4298 PyObject* tup = PyTuple_New(2);
4299 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4300 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4301 wxPyEndBlockThreads(blocked);
4302 return tup;
4303 }
4304 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4305 wxPyUserData* data = NULL;
4306 if ( userData ) {
4307 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4308 data = new wxPyUserData(userData);
4309 wxPyEndBlockThreads(blocked);
4310 }
4311 return new wxGBSizerItem(window, pos, span, flag, border, data);
4312 }
4313 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4314 wxPyUserData* data = NULL;
4315 if ( userData ) {
4316 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4317 data = new wxPyUserData(userData);
4318 wxPyEndBlockThreads(blocked);
4319 }
4320 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4321 }
4322 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4323 wxPyUserData* data = NULL;
4324 if ( userData ) {
4325 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4326 data = new wxPyUserData(userData);
4327 wxPyEndBlockThreads(blocked);
4328 }
4329 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4330 }
4331 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4332 int row, col;
4333 self->GetEndPos(row, col);
4334 return wxGBPosition(row, col);
4335 }
4336 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4337
4338 wxPyUserData* data = NULL;
4339 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4340 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4341 if ( userData && (info.window || info.sizer || info.gotSize) )
4342 data = new wxPyUserData(userData);
4343 if ( info.sizer )
4344 PyObject_SetAttrString(item,"thisown",Py_False);
4345 wxPyEndBlockThreads(blocked);
4346
4347 // Now call the real Add method if a valid item type was found
4348 if ( info.window )
4349 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4350 else if ( info.sizer )
4351 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4352 else if (info.gotSize)
4353 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4354 pos, span, flag, border, data);
4355 return NULL;
4356 }
4357
4358
4359 #ifdef __cplusplus
4360 extern "C" {
4361 #endif
4362 SWIGINTERN int EmptyString_set(PyObject *) {
4363 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4364 return 1;
4365 }
4366
4367
4368 SWIGINTERN PyObject *EmptyString_get(void) {
4369 PyObject *pyobj = 0;
4370
4371 {
4372 #if wxUSE_UNICODE
4373 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4374 #else
4375 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4376 #endif
4377 }
4378 return pyobj;
4379 }
4380
4381
4382 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4383 PyObject *resultobj = 0;
4384 wxObject *arg1 = (wxObject *) 0 ;
4385 wxString result;
4386 void *argp1 = 0 ;
4387 int res1 = 0 ;
4388 PyObject *swig_obj[1] ;
4389
4390 if (!args) SWIG_fail;
4391 swig_obj[0] = args;
4392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4393 if (!SWIG_IsOK(res1)) {
4394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4395 }
4396 arg1 = reinterpret_cast< wxObject * >(argp1);
4397 {
4398 PyThreadState* __tstate = wxPyBeginAllowThreads();
4399 result = wxObject_GetClassName(arg1);
4400 wxPyEndAllowThreads(__tstate);
4401 if (PyErr_Occurred()) SWIG_fail;
4402 }
4403 {
4404 #if wxUSE_UNICODE
4405 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4406 #else
4407 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4408 #endif
4409 }
4410 return resultobj;
4411 fail:
4412 return NULL;
4413 }
4414
4415
4416 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4417 PyObject *resultobj = 0;
4418 wxObject *arg1 = (wxObject *) 0 ;
4419 void *argp1 = 0 ;
4420 int res1 = 0 ;
4421 PyObject *swig_obj[1] ;
4422
4423 if (!args) SWIG_fail;
4424 swig_obj[0] = args;
4425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4426 if (!SWIG_IsOK(res1)) {
4427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4428 }
4429 arg1 = reinterpret_cast< wxObject * >(argp1);
4430 {
4431 PyThreadState* __tstate = wxPyBeginAllowThreads();
4432 wxObject_Destroy(arg1);
4433 wxPyEndAllowThreads(__tstate);
4434 if (PyErr_Occurred()) SWIG_fail;
4435 }
4436 resultobj = SWIG_Py_Void();
4437 return resultobj;
4438 fail:
4439 return NULL;
4440 }
4441
4442
4443 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4444 PyObject *obj;
4445 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4446 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4447 return SWIG_Py_Void();
4448 }
4449
4450 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4451 PyObject *resultobj = 0;
4452 wxSize *arg1 = (wxSize *) 0 ;
4453 int arg2 ;
4454 void *argp1 = 0 ;
4455 int res1 = 0 ;
4456 int val2 ;
4457 int ecode2 = 0 ;
4458 PyObject *swig_obj[2] ;
4459
4460 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4462 if (!SWIG_IsOK(res1)) {
4463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4464 }
4465 arg1 = reinterpret_cast< wxSize * >(argp1);
4466 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4467 if (!SWIG_IsOK(ecode2)) {
4468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4469 }
4470 arg2 = static_cast< int >(val2);
4471 if (arg1) (arg1)->x = arg2;
4472
4473 resultobj = SWIG_Py_Void();
4474 return resultobj;
4475 fail:
4476 return NULL;
4477 }
4478
4479
4480 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4481 PyObject *resultobj = 0;
4482 wxSize *arg1 = (wxSize *) 0 ;
4483 int result;
4484 void *argp1 = 0 ;
4485 int res1 = 0 ;
4486 PyObject *swig_obj[1] ;
4487
4488 if (!args) SWIG_fail;
4489 swig_obj[0] = args;
4490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4491 if (!SWIG_IsOK(res1)) {
4492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4493 }
4494 arg1 = reinterpret_cast< wxSize * >(argp1);
4495 result = (int) ((arg1)->x);
4496 resultobj = SWIG_From_int(static_cast< int >(result));
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4504 PyObject *resultobj = 0;
4505 wxSize *arg1 = (wxSize *) 0 ;
4506 int arg2 ;
4507 void *argp1 = 0 ;
4508 int res1 = 0 ;
4509 int val2 ;
4510 int ecode2 = 0 ;
4511 PyObject *swig_obj[2] ;
4512
4513 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4515 if (!SWIG_IsOK(res1)) {
4516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4517 }
4518 arg1 = reinterpret_cast< wxSize * >(argp1);
4519 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4520 if (!SWIG_IsOK(ecode2)) {
4521 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4522 }
4523 arg2 = static_cast< int >(val2);
4524 if (arg1) (arg1)->y = arg2;
4525
4526 resultobj = SWIG_Py_Void();
4527 return resultobj;
4528 fail:
4529 return NULL;
4530 }
4531
4532
4533 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4534 PyObject *resultobj = 0;
4535 wxSize *arg1 = (wxSize *) 0 ;
4536 int result;
4537 void *argp1 = 0 ;
4538 int res1 = 0 ;
4539 PyObject *swig_obj[1] ;
4540
4541 if (!args) SWIG_fail;
4542 swig_obj[0] = args;
4543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4544 if (!SWIG_IsOK(res1)) {
4545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4546 }
4547 arg1 = reinterpret_cast< wxSize * >(argp1);
4548 result = (int) ((arg1)->y);
4549 resultobj = SWIG_From_int(static_cast< int >(result));
4550 return resultobj;
4551 fail:
4552 return NULL;
4553 }
4554
4555
4556 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4557 PyObject *resultobj = 0;
4558 int arg1 = (int) 0 ;
4559 int arg2 = (int) 0 ;
4560 wxSize *result = 0 ;
4561 int val1 ;
4562 int ecode1 = 0 ;
4563 int val2 ;
4564 int ecode2 = 0 ;
4565 PyObject * obj0 = 0 ;
4566 PyObject * obj1 = 0 ;
4567 char * kwnames[] = {
4568 (char *) "w",(char *) "h", NULL
4569 };
4570
4571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4572 if (obj0) {
4573 ecode1 = SWIG_AsVal_int(obj0, &val1);
4574 if (!SWIG_IsOK(ecode1)) {
4575 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4576 }
4577 arg1 = static_cast< int >(val1);
4578 }
4579 if (obj1) {
4580 ecode2 = SWIG_AsVal_int(obj1, &val2);
4581 if (!SWIG_IsOK(ecode2)) {
4582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4583 }
4584 arg2 = static_cast< int >(val2);
4585 }
4586 {
4587 PyThreadState* __tstate = wxPyBeginAllowThreads();
4588 result = (wxSize *)new wxSize(arg1,arg2);
4589 wxPyEndAllowThreads(__tstate);
4590 if (PyErr_Occurred()) SWIG_fail;
4591 }
4592 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4600 PyObject *resultobj = 0;
4601 wxSize *arg1 = (wxSize *) 0 ;
4602 void *argp1 = 0 ;
4603 int res1 = 0 ;
4604 PyObject *swig_obj[1] ;
4605
4606 if (!args) SWIG_fail;
4607 swig_obj[0] = args;
4608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4609 if (!SWIG_IsOK(res1)) {
4610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4611 }
4612 arg1 = reinterpret_cast< wxSize * >(argp1);
4613 {
4614 PyThreadState* __tstate = wxPyBeginAllowThreads();
4615 delete arg1;
4616
4617 wxPyEndAllowThreads(__tstate);
4618 if (PyErr_Occurred()) SWIG_fail;
4619 }
4620 resultobj = SWIG_Py_Void();
4621 return resultobj;
4622 fail:
4623 return NULL;
4624 }
4625
4626
4627 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4628 PyObject *resultobj = 0;
4629 wxSize *arg1 = (wxSize *) 0 ;
4630 PyObject *arg2 = (PyObject *) 0 ;
4631 bool result;
4632 void *argp1 = 0 ;
4633 int res1 = 0 ;
4634 PyObject * obj0 = 0 ;
4635 PyObject * obj1 = 0 ;
4636 char * kwnames[] = {
4637 (char *) "self",(char *) "other", NULL
4638 };
4639
4640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4642 if (!SWIG_IsOK(res1)) {
4643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4644 }
4645 arg1 = reinterpret_cast< wxSize * >(argp1);
4646 arg2 = obj1;
4647 {
4648 result = (bool)wxSize___eq__(arg1,arg2);
4649 if (PyErr_Occurred()) SWIG_fail;
4650 }
4651 {
4652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4653 }
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = 0;
4662 wxSize *arg1 = (wxSize *) 0 ;
4663 PyObject *arg2 = (PyObject *) 0 ;
4664 bool result;
4665 void *argp1 = 0 ;
4666 int res1 = 0 ;
4667 PyObject * obj0 = 0 ;
4668 PyObject * obj1 = 0 ;
4669 char * kwnames[] = {
4670 (char *) "self",(char *) "other", NULL
4671 };
4672
4673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4675 if (!SWIG_IsOK(res1)) {
4676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4677 }
4678 arg1 = reinterpret_cast< wxSize * >(argp1);
4679 arg2 = obj1;
4680 {
4681 result = (bool)wxSize___ne__(arg1,arg2);
4682 if (PyErr_Occurred()) SWIG_fail;
4683 }
4684 {
4685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4686 }
4687 return resultobj;
4688 fail:
4689 return NULL;
4690 }
4691
4692
4693 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4694 PyObject *resultobj = 0;
4695 wxSize *arg1 = (wxSize *) 0 ;
4696 wxSize *arg2 = 0 ;
4697 wxSize result;
4698 void *argp1 = 0 ;
4699 int res1 = 0 ;
4700 wxSize temp2 ;
4701 PyObject * obj0 = 0 ;
4702 PyObject * obj1 = 0 ;
4703 char * kwnames[] = {
4704 (char *) "self",(char *) "sz", NULL
4705 };
4706
4707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4709 if (!SWIG_IsOK(res1)) {
4710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4711 }
4712 arg1 = reinterpret_cast< wxSize * >(argp1);
4713 {
4714 arg2 = &temp2;
4715 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4716 }
4717 {
4718 PyThreadState* __tstate = wxPyBeginAllowThreads();
4719 result = (arg1)->operator +((wxSize const &)*arg2);
4720 wxPyEndAllowThreads(__tstate);
4721 if (PyErr_Occurred()) SWIG_fail;
4722 }
4723 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4724 return resultobj;
4725 fail:
4726 return NULL;
4727 }
4728
4729
4730 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4731 PyObject *resultobj = 0;
4732 wxSize *arg1 = (wxSize *) 0 ;
4733 wxSize *arg2 = 0 ;
4734 wxSize result;
4735 void *argp1 = 0 ;
4736 int res1 = 0 ;
4737 wxSize temp2 ;
4738 PyObject * obj0 = 0 ;
4739 PyObject * obj1 = 0 ;
4740 char * kwnames[] = {
4741 (char *) "self",(char *) "sz", NULL
4742 };
4743
4744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4746 if (!SWIG_IsOK(res1)) {
4747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4748 }
4749 arg1 = reinterpret_cast< wxSize * >(argp1);
4750 {
4751 arg2 = &temp2;
4752 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4753 }
4754 {
4755 PyThreadState* __tstate = wxPyBeginAllowThreads();
4756 result = (arg1)->operator -((wxSize const &)*arg2);
4757 wxPyEndAllowThreads(__tstate);
4758 if (PyErr_Occurred()) SWIG_fail;
4759 }
4760 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4761 return resultobj;
4762 fail:
4763 return NULL;
4764 }
4765
4766
4767 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4768 PyObject *resultobj = 0;
4769 wxSize *arg1 = (wxSize *) 0 ;
4770 wxSize *arg2 = 0 ;
4771 void *argp1 = 0 ;
4772 int res1 = 0 ;
4773 wxSize temp2 ;
4774 PyObject * obj0 = 0 ;
4775 PyObject * obj1 = 0 ;
4776 char * kwnames[] = {
4777 (char *) "self",(char *) "sz", NULL
4778 };
4779
4780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4782 if (!SWIG_IsOK(res1)) {
4783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4784 }
4785 arg1 = reinterpret_cast< wxSize * >(argp1);
4786 {
4787 arg2 = &temp2;
4788 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4789 }
4790 {
4791 PyThreadState* __tstate = wxPyBeginAllowThreads();
4792 (arg1)->IncTo((wxSize const &)*arg2);
4793 wxPyEndAllowThreads(__tstate);
4794 if (PyErr_Occurred()) SWIG_fail;
4795 }
4796 resultobj = SWIG_Py_Void();
4797 return resultobj;
4798 fail:
4799 return NULL;
4800 }
4801
4802
4803 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4804 PyObject *resultobj = 0;
4805 wxSize *arg1 = (wxSize *) 0 ;
4806 wxSize *arg2 = 0 ;
4807 void *argp1 = 0 ;
4808 int res1 = 0 ;
4809 wxSize temp2 ;
4810 PyObject * obj0 = 0 ;
4811 PyObject * obj1 = 0 ;
4812 char * kwnames[] = {
4813 (char *) "self",(char *) "sz", NULL
4814 };
4815
4816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4818 if (!SWIG_IsOK(res1)) {
4819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4820 }
4821 arg1 = reinterpret_cast< wxSize * >(argp1);
4822 {
4823 arg2 = &temp2;
4824 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4825 }
4826 {
4827 PyThreadState* __tstate = wxPyBeginAllowThreads();
4828 (arg1)->DecTo((wxSize const &)*arg2);
4829 wxPyEndAllowThreads(__tstate);
4830 if (PyErr_Occurred()) SWIG_fail;
4831 }
4832 resultobj = SWIG_Py_Void();
4833 return resultobj;
4834 fail:
4835 return NULL;
4836 }
4837
4838
4839 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4840 PyObject *resultobj = 0;
4841 wxSize *arg1 = (wxSize *) 0 ;
4842 int arg2 ;
4843 int arg3 ;
4844 void *argp1 = 0 ;
4845 int res1 = 0 ;
4846 int val2 ;
4847 int ecode2 = 0 ;
4848 int val3 ;
4849 int ecode3 = 0 ;
4850 PyObject * obj0 = 0 ;
4851 PyObject * obj1 = 0 ;
4852 PyObject * obj2 = 0 ;
4853 char * kwnames[] = {
4854 (char *) "self",(char *) "w",(char *) "h", NULL
4855 };
4856
4857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4859 if (!SWIG_IsOK(res1)) {
4860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4861 }
4862 arg1 = reinterpret_cast< wxSize * >(argp1);
4863 ecode2 = SWIG_AsVal_int(obj1, &val2);
4864 if (!SWIG_IsOK(ecode2)) {
4865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4866 }
4867 arg2 = static_cast< int >(val2);
4868 ecode3 = SWIG_AsVal_int(obj2, &val3);
4869 if (!SWIG_IsOK(ecode3)) {
4870 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4871 }
4872 arg3 = static_cast< int >(val3);
4873 {
4874 PyThreadState* __tstate = wxPyBeginAllowThreads();
4875 (arg1)->Set(arg2,arg3);
4876 wxPyEndAllowThreads(__tstate);
4877 if (PyErr_Occurred()) SWIG_fail;
4878 }
4879 resultobj = SWIG_Py_Void();
4880 return resultobj;
4881 fail:
4882 return NULL;
4883 }
4884
4885
4886 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4887 PyObject *resultobj = 0;
4888 wxSize *arg1 = (wxSize *) 0 ;
4889 int arg2 ;
4890 void *argp1 = 0 ;
4891 int res1 = 0 ;
4892 int val2 ;
4893 int ecode2 = 0 ;
4894 PyObject * obj0 = 0 ;
4895 PyObject * obj1 = 0 ;
4896 char * kwnames[] = {
4897 (char *) "self",(char *) "w", NULL
4898 };
4899
4900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4902 if (!SWIG_IsOK(res1)) {
4903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4904 }
4905 arg1 = reinterpret_cast< wxSize * >(argp1);
4906 ecode2 = SWIG_AsVal_int(obj1, &val2);
4907 if (!SWIG_IsOK(ecode2)) {
4908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4909 }
4910 arg2 = static_cast< int >(val2);
4911 {
4912 PyThreadState* __tstate = wxPyBeginAllowThreads();
4913 (arg1)->SetWidth(arg2);
4914 wxPyEndAllowThreads(__tstate);
4915 if (PyErr_Occurred()) SWIG_fail;
4916 }
4917 resultobj = SWIG_Py_Void();
4918 return resultobj;
4919 fail:
4920 return NULL;
4921 }
4922
4923
4924 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4925 PyObject *resultobj = 0;
4926 wxSize *arg1 = (wxSize *) 0 ;
4927 int arg2 ;
4928 void *argp1 = 0 ;
4929 int res1 = 0 ;
4930 int val2 ;
4931 int ecode2 = 0 ;
4932 PyObject * obj0 = 0 ;
4933 PyObject * obj1 = 0 ;
4934 char * kwnames[] = {
4935 (char *) "self",(char *) "h", NULL
4936 };
4937
4938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4940 if (!SWIG_IsOK(res1)) {
4941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
4942 }
4943 arg1 = reinterpret_cast< wxSize * >(argp1);
4944 ecode2 = SWIG_AsVal_int(obj1, &val2);
4945 if (!SWIG_IsOK(ecode2)) {
4946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
4947 }
4948 arg2 = static_cast< int >(val2);
4949 {
4950 PyThreadState* __tstate = wxPyBeginAllowThreads();
4951 (arg1)->SetHeight(arg2);
4952 wxPyEndAllowThreads(__tstate);
4953 if (PyErr_Occurred()) SWIG_fail;
4954 }
4955 resultobj = SWIG_Py_Void();
4956 return resultobj;
4957 fail:
4958 return NULL;
4959 }
4960
4961
4962 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4963 PyObject *resultobj = 0;
4964 wxSize *arg1 = (wxSize *) 0 ;
4965 int result;
4966 void *argp1 = 0 ;
4967 int res1 = 0 ;
4968 PyObject *swig_obj[1] ;
4969
4970 if (!args) SWIG_fail;
4971 swig_obj[0] = args;
4972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4973 if (!SWIG_IsOK(res1)) {
4974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
4975 }
4976 arg1 = reinterpret_cast< wxSize * >(argp1);
4977 {
4978 PyThreadState* __tstate = wxPyBeginAllowThreads();
4979 result = (int)((wxSize const *)arg1)->GetWidth();
4980 wxPyEndAllowThreads(__tstate);
4981 if (PyErr_Occurred()) SWIG_fail;
4982 }
4983 resultobj = SWIG_From_int(static_cast< int >(result));
4984 return resultobj;
4985 fail:
4986 return NULL;
4987 }
4988
4989
4990 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4991 PyObject *resultobj = 0;
4992 wxSize *arg1 = (wxSize *) 0 ;
4993 int result;
4994 void *argp1 = 0 ;
4995 int res1 = 0 ;
4996 PyObject *swig_obj[1] ;
4997
4998 if (!args) SWIG_fail;
4999 swig_obj[0] = args;
5000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5001 if (!SWIG_IsOK(res1)) {
5002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5003 }
5004 arg1 = reinterpret_cast< wxSize * >(argp1);
5005 {
5006 PyThreadState* __tstate = wxPyBeginAllowThreads();
5007 result = (int)((wxSize const *)arg1)->GetHeight();
5008 wxPyEndAllowThreads(__tstate);
5009 if (PyErr_Occurred()) SWIG_fail;
5010 }
5011 resultobj = SWIG_From_int(static_cast< int >(result));
5012 return resultobj;
5013 fail:
5014 return NULL;
5015 }
5016
5017
5018 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5019 PyObject *resultobj = 0;
5020 wxSize *arg1 = (wxSize *) 0 ;
5021 bool result;
5022 void *argp1 = 0 ;
5023 int res1 = 0 ;
5024 PyObject *swig_obj[1] ;
5025
5026 if (!args) SWIG_fail;
5027 swig_obj[0] = args;
5028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5029 if (!SWIG_IsOK(res1)) {
5030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5031 }
5032 arg1 = reinterpret_cast< wxSize * >(argp1);
5033 {
5034 PyThreadState* __tstate = wxPyBeginAllowThreads();
5035 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5036 wxPyEndAllowThreads(__tstate);
5037 if (PyErr_Occurred()) SWIG_fail;
5038 }
5039 {
5040 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5041 }
5042 return resultobj;
5043 fail:
5044 return NULL;
5045 }
5046
5047
5048 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5049 PyObject *resultobj = 0;
5050 wxSize *arg1 = (wxSize *) 0 ;
5051 wxSize *arg2 = 0 ;
5052 void *argp1 = 0 ;
5053 int res1 = 0 ;
5054 wxSize temp2 ;
5055 PyObject * obj0 = 0 ;
5056 PyObject * obj1 = 0 ;
5057 char * kwnames[] = {
5058 (char *) "self",(char *) "size", NULL
5059 };
5060
5061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5063 if (!SWIG_IsOK(res1)) {
5064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5065 }
5066 arg1 = reinterpret_cast< wxSize * >(argp1);
5067 {
5068 arg2 = &temp2;
5069 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5070 }
5071 {
5072 PyThreadState* __tstate = wxPyBeginAllowThreads();
5073 (arg1)->SetDefaults((wxSize const &)*arg2);
5074 wxPyEndAllowThreads(__tstate);
5075 if (PyErr_Occurred()) SWIG_fail;
5076 }
5077 resultobj = SWIG_Py_Void();
5078 return resultobj;
5079 fail:
5080 return NULL;
5081 }
5082
5083
5084 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5085 PyObject *resultobj = 0;
5086 wxSize *arg1 = (wxSize *) 0 ;
5087 PyObject *result = 0 ;
5088 void *argp1 = 0 ;
5089 int res1 = 0 ;
5090 PyObject *swig_obj[1] ;
5091
5092 if (!args) SWIG_fail;
5093 swig_obj[0] = args;
5094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5095 if (!SWIG_IsOK(res1)) {
5096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5097 }
5098 arg1 = reinterpret_cast< wxSize * >(argp1);
5099 {
5100 PyThreadState* __tstate = wxPyBeginAllowThreads();
5101 result = (PyObject *)wxSize_Get(arg1);
5102 wxPyEndAllowThreads(__tstate);
5103 if (PyErr_Occurred()) SWIG_fail;
5104 }
5105 resultobj = result;
5106 return resultobj;
5107 fail:
5108 return NULL;
5109 }
5110
5111
5112 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5113 PyObject *obj;
5114 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5115 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5116 return SWIG_Py_Void();
5117 }
5118
5119 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5120 return SWIG_Python_InitShadowInstance(args);
5121 }
5122
5123 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5124 PyObject *resultobj = 0;
5125 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5126 double arg2 ;
5127 void *argp1 = 0 ;
5128 int res1 = 0 ;
5129 double val2 ;
5130 int ecode2 = 0 ;
5131 PyObject *swig_obj[2] ;
5132
5133 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5135 if (!SWIG_IsOK(res1)) {
5136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5137 }
5138 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5139 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5140 if (!SWIG_IsOK(ecode2)) {
5141 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5142 }
5143 arg2 = static_cast< double >(val2);
5144 if (arg1) (arg1)->x = arg2;
5145
5146 resultobj = SWIG_Py_Void();
5147 return resultobj;
5148 fail:
5149 return NULL;
5150 }
5151
5152
5153 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5154 PyObject *resultobj = 0;
5155 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5156 double result;
5157 void *argp1 = 0 ;
5158 int res1 = 0 ;
5159 PyObject *swig_obj[1] ;
5160
5161 if (!args) SWIG_fail;
5162 swig_obj[0] = args;
5163 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5164 if (!SWIG_IsOK(res1)) {
5165 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5166 }
5167 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5168 result = (double) ((arg1)->x);
5169 resultobj = SWIG_From_double(static_cast< double >(result));
5170 return resultobj;
5171 fail:
5172 return NULL;
5173 }
5174
5175
5176 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5177 PyObject *resultobj = 0;
5178 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5179 double arg2 ;
5180 void *argp1 = 0 ;
5181 int res1 = 0 ;
5182 double val2 ;
5183 int ecode2 = 0 ;
5184 PyObject *swig_obj[2] ;
5185
5186 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5188 if (!SWIG_IsOK(res1)) {
5189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5190 }
5191 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5192 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5193 if (!SWIG_IsOK(ecode2)) {
5194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5195 }
5196 arg2 = static_cast< double >(val2);
5197 if (arg1) (arg1)->y = arg2;
5198
5199 resultobj = SWIG_Py_Void();
5200 return resultobj;
5201 fail:
5202 return NULL;
5203 }
5204
5205
5206 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5207 PyObject *resultobj = 0;
5208 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5209 double result;
5210 void *argp1 = 0 ;
5211 int res1 = 0 ;
5212 PyObject *swig_obj[1] ;
5213
5214 if (!args) SWIG_fail;
5215 swig_obj[0] = args;
5216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5217 if (!SWIG_IsOK(res1)) {
5218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5219 }
5220 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5221 result = (double) ((arg1)->y);
5222 resultobj = SWIG_From_double(static_cast< double >(result));
5223 return resultobj;
5224 fail:
5225 return NULL;
5226 }
5227
5228
5229 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5230 PyObject *resultobj = 0;
5231 double arg1 = (double) 0.0 ;
5232 double arg2 = (double) 0.0 ;
5233 wxRealPoint *result = 0 ;
5234 double val1 ;
5235 int ecode1 = 0 ;
5236 double val2 ;
5237 int ecode2 = 0 ;
5238 PyObject * obj0 = 0 ;
5239 PyObject * obj1 = 0 ;
5240 char * kwnames[] = {
5241 (char *) "x",(char *) "y", NULL
5242 };
5243
5244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5245 if (obj0) {
5246 ecode1 = SWIG_AsVal_double(obj0, &val1);
5247 if (!SWIG_IsOK(ecode1)) {
5248 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5249 }
5250 arg1 = static_cast< double >(val1);
5251 }
5252 if (obj1) {
5253 ecode2 = SWIG_AsVal_double(obj1, &val2);
5254 if (!SWIG_IsOK(ecode2)) {
5255 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5256 }
5257 arg2 = static_cast< double >(val2);
5258 }
5259 {
5260 PyThreadState* __tstate = wxPyBeginAllowThreads();
5261 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5262 wxPyEndAllowThreads(__tstate);
5263 if (PyErr_Occurred()) SWIG_fail;
5264 }
5265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5266 return resultobj;
5267 fail:
5268 return NULL;
5269 }
5270
5271
5272 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5273 PyObject *resultobj = 0;
5274 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5275 void *argp1 = 0 ;
5276 int res1 = 0 ;
5277 PyObject *swig_obj[1] ;
5278
5279 if (!args) SWIG_fail;
5280 swig_obj[0] = args;
5281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5282 if (!SWIG_IsOK(res1)) {
5283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5284 }
5285 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5286 {
5287 PyThreadState* __tstate = wxPyBeginAllowThreads();
5288 delete arg1;
5289
5290 wxPyEndAllowThreads(__tstate);
5291 if (PyErr_Occurred()) SWIG_fail;
5292 }
5293 resultobj = SWIG_Py_Void();
5294 return resultobj;
5295 fail:
5296 return NULL;
5297 }
5298
5299
5300 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5301 PyObject *resultobj = 0;
5302 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5303 PyObject *arg2 = (PyObject *) 0 ;
5304 bool result;
5305 void *argp1 = 0 ;
5306 int res1 = 0 ;
5307 PyObject * obj0 = 0 ;
5308 PyObject * obj1 = 0 ;
5309 char * kwnames[] = {
5310 (char *) "self",(char *) "other", NULL
5311 };
5312
5313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5315 if (!SWIG_IsOK(res1)) {
5316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5317 }
5318 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5319 arg2 = obj1;
5320 {
5321 result = (bool)wxRealPoint___eq__(arg1,arg2);
5322 if (PyErr_Occurred()) SWIG_fail;
5323 }
5324 {
5325 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5326 }
5327 return resultobj;
5328 fail:
5329 return NULL;
5330 }
5331
5332
5333 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5334 PyObject *resultobj = 0;
5335 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5336 PyObject *arg2 = (PyObject *) 0 ;
5337 bool result;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 PyObject * obj0 = 0 ;
5341 PyObject * obj1 = 0 ;
5342 char * kwnames[] = {
5343 (char *) "self",(char *) "other", NULL
5344 };
5345
5346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5347 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5348 if (!SWIG_IsOK(res1)) {
5349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5350 }
5351 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5352 arg2 = obj1;
5353 {
5354 result = (bool)wxRealPoint___ne__(arg1,arg2);
5355 if (PyErr_Occurred()) SWIG_fail;
5356 }
5357 {
5358 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5359 }
5360 return resultobj;
5361 fail:
5362 return NULL;
5363 }
5364
5365
5366 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5367 PyObject *resultobj = 0;
5368 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5369 wxRealPoint *arg2 = 0 ;
5370 wxRealPoint result;
5371 void *argp1 = 0 ;
5372 int res1 = 0 ;
5373 wxRealPoint temp2 ;
5374 PyObject * obj0 = 0 ;
5375 PyObject * obj1 = 0 ;
5376 char * kwnames[] = {
5377 (char *) "self",(char *) "pt", NULL
5378 };
5379
5380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5382 if (!SWIG_IsOK(res1)) {
5383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5384 }
5385 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5386 {
5387 arg2 = &temp2;
5388 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5389 }
5390 {
5391 PyThreadState* __tstate = wxPyBeginAllowThreads();
5392 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5393 wxPyEndAllowThreads(__tstate);
5394 if (PyErr_Occurred()) SWIG_fail;
5395 }
5396 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5397 return resultobj;
5398 fail:
5399 return NULL;
5400 }
5401
5402
5403 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5404 PyObject *resultobj = 0;
5405 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5406 wxRealPoint *arg2 = 0 ;
5407 wxRealPoint result;
5408 void *argp1 = 0 ;
5409 int res1 = 0 ;
5410 wxRealPoint temp2 ;
5411 PyObject * obj0 = 0 ;
5412 PyObject * obj1 = 0 ;
5413 char * kwnames[] = {
5414 (char *) "self",(char *) "pt", NULL
5415 };
5416
5417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5419 if (!SWIG_IsOK(res1)) {
5420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5421 }
5422 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5423 {
5424 arg2 = &temp2;
5425 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5426 }
5427 {
5428 PyThreadState* __tstate = wxPyBeginAllowThreads();
5429 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5430 wxPyEndAllowThreads(__tstate);
5431 if (PyErr_Occurred()) SWIG_fail;
5432 }
5433 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj = 0;
5442 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5443 double arg2 ;
5444 double arg3 ;
5445 void *argp1 = 0 ;
5446 int res1 = 0 ;
5447 double val2 ;
5448 int ecode2 = 0 ;
5449 double val3 ;
5450 int ecode3 = 0 ;
5451 PyObject * obj0 = 0 ;
5452 PyObject * obj1 = 0 ;
5453 PyObject * obj2 = 0 ;
5454 char * kwnames[] = {
5455 (char *) "self",(char *) "x",(char *) "y", NULL
5456 };
5457
5458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5460 if (!SWIG_IsOK(res1)) {
5461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5462 }
5463 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5464 ecode2 = SWIG_AsVal_double(obj1, &val2);
5465 if (!SWIG_IsOK(ecode2)) {
5466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5467 }
5468 arg2 = static_cast< double >(val2);
5469 ecode3 = SWIG_AsVal_double(obj2, &val3);
5470 if (!SWIG_IsOK(ecode3)) {
5471 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5472 }
5473 arg3 = static_cast< double >(val3);
5474 {
5475 PyThreadState* __tstate = wxPyBeginAllowThreads();
5476 wxRealPoint_Set(arg1,arg2,arg3);
5477 wxPyEndAllowThreads(__tstate);
5478 if (PyErr_Occurred()) SWIG_fail;
5479 }
5480 resultobj = SWIG_Py_Void();
5481 return resultobj;
5482 fail:
5483 return NULL;
5484 }
5485
5486
5487 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5488 PyObject *resultobj = 0;
5489 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5490 PyObject *result = 0 ;
5491 void *argp1 = 0 ;
5492 int res1 = 0 ;
5493 PyObject *swig_obj[1] ;
5494
5495 if (!args) SWIG_fail;
5496 swig_obj[0] = args;
5497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5498 if (!SWIG_IsOK(res1)) {
5499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5500 }
5501 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5502 {
5503 PyThreadState* __tstate = wxPyBeginAllowThreads();
5504 result = (PyObject *)wxRealPoint_Get(arg1);
5505 wxPyEndAllowThreads(__tstate);
5506 if (PyErr_Occurred()) SWIG_fail;
5507 }
5508 resultobj = result;
5509 return resultobj;
5510 fail:
5511 return NULL;
5512 }
5513
5514
5515 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5516 PyObject *obj;
5517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5518 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5519 return SWIG_Py_Void();
5520 }
5521
5522 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5523 return SWIG_Python_InitShadowInstance(args);
5524 }
5525
5526 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5527 PyObject *resultobj = 0;
5528 wxPoint *arg1 = (wxPoint *) 0 ;
5529 int arg2 ;
5530 void *argp1 = 0 ;
5531 int res1 = 0 ;
5532 int val2 ;
5533 int ecode2 = 0 ;
5534 PyObject *swig_obj[2] ;
5535
5536 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5538 if (!SWIG_IsOK(res1)) {
5539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5540 }
5541 arg1 = reinterpret_cast< wxPoint * >(argp1);
5542 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5543 if (!SWIG_IsOK(ecode2)) {
5544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5545 }
5546 arg2 = static_cast< int >(val2);
5547 if (arg1) (arg1)->x = arg2;
5548
5549 resultobj = SWIG_Py_Void();
5550 return resultobj;
5551 fail:
5552 return NULL;
5553 }
5554
5555
5556 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5557 PyObject *resultobj = 0;
5558 wxPoint *arg1 = (wxPoint *) 0 ;
5559 int result;
5560 void *argp1 = 0 ;
5561 int res1 = 0 ;
5562 PyObject *swig_obj[1] ;
5563
5564 if (!args) SWIG_fail;
5565 swig_obj[0] = args;
5566 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5567 if (!SWIG_IsOK(res1)) {
5568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5569 }
5570 arg1 = reinterpret_cast< wxPoint * >(argp1);
5571 result = (int) ((arg1)->x);
5572 resultobj = SWIG_From_int(static_cast< int >(result));
5573 return resultobj;
5574 fail:
5575 return NULL;
5576 }
5577
5578
5579 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5580 PyObject *resultobj = 0;
5581 wxPoint *arg1 = (wxPoint *) 0 ;
5582 int arg2 ;
5583 void *argp1 = 0 ;
5584 int res1 = 0 ;
5585 int val2 ;
5586 int ecode2 = 0 ;
5587 PyObject *swig_obj[2] ;
5588
5589 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5591 if (!SWIG_IsOK(res1)) {
5592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5593 }
5594 arg1 = reinterpret_cast< wxPoint * >(argp1);
5595 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5596 if (!SWIG_IsOK(ecode2)) {
5597 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5598 }
5599 arg2 = static_cast< int >(val2);
5600 if (arg1) (arg1)->y = arg2;
5601
5602 resultobj = SWIG_Py_Void();
5603 return resultobj;
5604 fail:
5605 return NULL;
5606 }
5607
5608
5609 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5610 PyObject *resultobj = 0;
5611 wxPoint *arg1 = (wxPoint *) 0 ;
5612 int result;
5613 void *argp1 = 0 ;
5614 int res1 = 0 ;
5615 PyObject *swig_obj[1] ;
5616
5617 if (!args) SWIG_fail;
5618 swig_obj[0] = args;
5619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5620 if (!SWIG_IsOK(res1)) {
5621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5622 }
5623 arg1 = reinterpret_cast< wxPoint * >(argp1);
5624 result = (int) ((arg1)->y);
5625 resultobj = SWIG_From_int(static_cast< int >(result));
5626 return resultobj;
5627 fail:
5628 return NULL;
5629 }
5630
5631
5632 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5633 PyObject *resultobj = 0;
5634 int arg1 = (int) 0 ;
5635 int arg2 = (int) 0 ;
5636 wxPoint *result = 0 ;
5637 int val1 ;
5638 int ecode1 = 0 ;
5639 int val2 ;
5640 int ecode2 = 0 ;
5641 PyObject * obj0 = 0 ;
5642 PyObject * obj1 = 0 ;
5643 char * kwnames[] = {
5644 (char *) "x",(char *) "y", NULL
5645 };
5646
5647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5648 if (obj0) {
5649 ecode1 = SWIG_AsVal_int(obj0, &val1);
5650 if (!SWIG_IsOK(ecode1)) {
5651 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5652 }
5653 arg1 = static_cast< int >(val1);
5654 }
5655 if (obj1) {
5656 ecode2 = SWIG_AsVal_int(obj1, &val2);
5657 if (!SWIG_IsOK(ecode2)) {
5658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5659 }
5660 arg2 = static_cast< int >(val2);
5661 }
5662 {
5663 PyThreadState* __tstate = wxPyBeginAllowThreads();
5664 result = (wxPoint *)new wxPoint(arg1,arg2);
5665 wxPyEndAllowThreads(__tstate);
5666 if (PyErr_Occurred()) SWIG_fail;
5667 }
5668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5669 return resultobj;
5670 fail:
5671 return NULL;
5672 }
5673
5674
5675 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5676 PyObject *resultobj = 0;
5677 wxPoint *arg1 = (wxPoint *) 0 ;
5678 void *argp1 = 0 ;
5679 int res1 = 0 ;
5680 PyObject *swig_obj[1] ;
5681
5682 if (!args) SWIG_fail;
5683 swig_obj[0] = args;
5684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5685 if (!SWIG_IsOK(res1)) {
5686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5687 }
5688 arg1 = reinterpret_cast< wxPoint * >(argp1);
5689 {
5690 PyThreadState* __tstate = wxPyBeginAllowThreads();
5691 delete arg1;
5692
5693 wxPyEndAllowThreads(__tstate);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 resultobj = SWIG_Py_Void();
5697 return resultobj;
5698 fail:
5699 return NULL;
5700 }
5701
5702
5703 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5704 PyObject *resultobj = 0;
5705 wxPoint *arg1 = (wxPoint *) 0 ;
5706 PyObject *arg2 = (PyObject *) 0 ;
5707 bool result;
5708 void *argp1 = 0 ;
5709 int res1 = 0 ;
5710 PyObject * obj0 = 0 ;
5711 PyObject * obj1 = 0 ;
5712 char * kwnames[] = {
5713 (char *) "self",(char *) "other", NULL
5714 };
5715
5716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5718 if (!SWIG_IsOK(res1)) {
5719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5720 }
5721 arg1 = reinterpret_cast< wxPoint * >(argp1);
5722 arg2 = obj1;
5723 {
5724 result = (bool)wxPoint___eq__(arg1,arg2);
5725 if (PyErr_Occurred()) SWIG_fail;
5726 }
5727 {
5728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5729 }
5730 return resultobj;
5731 fail:
5732 return NULL;
5733 }
5734
5735
5736 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5737 PyObject *resultobj = 0;
5738 wxPoint *arg1 = (wxPoint *) 0 ;
5739 PyObject *arg2 = (PyObject *) 0 ;
5740 bool result;
5741 void *argp1 = 0 ;
5742 int res1 = 0 ;
5743 PyObject * obj0 = 0 ;
5744 PyObject * obj1 = 0 ;
5745 char * kwnames[] = {
5746 (char *) "self",(char *) "other", NULL
5747 };
5748
5749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5751 if (!SWIG_IsOK(res1)) {
5752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5753 }
5754 arg1 = reinterpret_cast< wxPoint * >(argp1);
5755 arg2 = obj1;
5756 {
5757 result = (bool)wxPoint___ne__(arg1,arg2);
5758 if (PyErr_Occurred()) SWIG_fail;
5759 }
5760 {
5761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5762 }
5763 return resultobj;
5764 fail:
5765 return NULL;
5766 }
5767
5768
5769 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5770 PyObject *resultobj = 0;
5771 wxPoint *arg1 = (wxPoint *) 0 ;
5772 wxPoint *arg2 = 0 ;
5773 wxPoint result;
5774 void *argp1 = 0 ;
5775 int res1 = 0 ;
5776 wxPoint temp2 ;
5777 PyObject * obj0 = 0 ;
5778 PyObject * obj1 = 0 ;
5779 char * kwnames[] = {
5780 (char *) "self",(char *) "pt", NULL
5781 };
5782
5783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5785 if (!SWIG_IsOK(res1)) {
5786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5787 }
5788 arg1 = reinterpret_cast< wxPoint * >(argp1);
5789 {
5790 arg2 = &temp2;
5791 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5792 }
5793 {
5794 PyThreadState* __tstate = wxPyBeginAllowThreads();
5795 result = (arg1)->operator +((wxPoint const &)*arg2);
5796 wxPyEndAllowThreads(__tstate);
5797 if (PyErr_Occurred()) SWIG_fail;
5798 }
5799 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5800 return resultobj;
5801 fail:
5802 return NULL;
5803 }
5804
5805
5806 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5807 PyObject *resultobj = 0;
5808 wxPoint *arg1 = (wxPoint *) 0 ;
5809 wxPoint *arg2 = 0 ;
5810 wxPoint result;
5811 void *argp1 = 0 ;
5812 int res1 = 0 ;
5813 wxPoint temp2 ;
5814 PyObject * obj0 = 0 ;
5815 PyObject * obj1 = 0 ;
5816 char * kwnames[] = {
5817 (char *) "self",(char *) "pt", NULL
5818 };
5819
5820 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5821 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5822 if (!SWIG_IsOK(res1)) {
5823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5824 }
5825 arg1 = reinterpret_cast< wxPoint * >(argp1);
5826 {
5827 arg2 = &temp2;
5828 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5829 }
5830 {
5831 PyThreadState* __tstate = wxPyBeginAllowThreads();
5832 result = (arg1)->operator -((wxPoint const &)*arg2);
5833 wxPyEndAllowThreads(__tstate);
5834 if (PyErr_Occurred()) SWIG_fail;
5835 }
5836 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5837 return resultobj;
5838 fail:
5839 return NULL;
5840 }
5841
5842
5843 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5844 PyObject *resultobj = 0;
5845 wxPoint *arg1 = (wxPoint *) 0 ;
5846 wxPoint *arg2 = 0 ;
5847 wxPoint *result = 0 ;
5848 void *argp1 = 0 ;
5849 int res1 = 0 ;
5850 wxPoint temp2 ;
5851 PyObject * obj0 = 0 ;
5852 PyObject * obj1 = 0 ;
5853 char * kwnames[] = {
5854 (char *) "self",(char *) "pt", NULL
5855 };
5856
5857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5859 if (!SWIG_IsOK(res1)) {
5860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5861 }
5862 arg1 = reinterpret_cast< wxPoint * >(argp1);
5863 {
5864 arg2 = &temp2;
5865 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5866 }
5867 {
5868 PyThreadState* __tstate = wxPyBeginAllowThreads();
5869 {
5870 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5871 result = (wxPoint *) &_result_ref;
5872 }
5873 wxPyEndAllowThreads(__tstate);
5874 if (PyErr_Occurred()) SWIG_fail;
5875 }
5876 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5877 return resultobj;
5878 fail:
5879 return NULL;
5880 }
5881
5882
5883 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5884 PyObject *resultobj = 0;
5885 wxPoint *arg1 = (wxPoint *) 0 ;
5886 wxPoint *arg2 = 0 ;
5887 wxPoint *result = 0 ;
5888 void *argp1 = 0 ;
5889 int res1 = 0 ;
5890 wxPoint temp2 ;
5891 PyObject * obj0 = 0 ;
5892 PyObject * obj1 = 0 ;
5893 char * kwnames[] = {
5894 (char *) "self",(char *) "pt", NULL
5895 };
5896
5897 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5898 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5899 if (!SWIG_IsOK(res1)) {
5900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5901 }
5902 arg1 = reinterpret_cast< wxPoint * >(argp1);
5903 {
5904 arg2 = &temp2;
5905 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5906 }
5907 {
5908 PyThreadState* __tstate = wxPyBeginAllowThreads();
5909 {
5910 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5911 result = (wxPoint *) &_result_ref;
5912 }
5913 wxPyEndAllowThreads(__tstate);
5914 if (PyErr_Occurred()) SWIG_fail;
5915 }
5916 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5917 return resultobj;
5918 fail:
5919 return NULL;
5920 }
5921
5922
5923 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5924 PyObject *resultobj = 0;
5925 wxPoint *arg1 = (wxPoint *) 0 ;
5926 long arg2 ;
5927 long arg3 ;
5928 void *argp1 = 0 ;
5929 int res1 = 0 ;
5930 long val2 ;
5931 int ecode2 = 0 ;
5932 long val3 ;
5933 int ecode3 = 0 ;
5934 PyObject * obj0 = 0 ;
5935 PyObject * obj1 = 0 ;
5936 PyObject * obj2 = 0 ;
5937 char * kwnames[] = {
5938 (char *) "self",(char *) "x",(char *) "y", NULL
5939 };
5940
5941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5943 if (!SWIG_IsOK(res1)) {
5944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
5945 }
5946 arg1 = reinterpret_cast< wxPoint * >(argp1);
5947 ecode2 = SWIG_AsVal_long(obj1, &val2);
5948 if (!SWIG_IsOK(ecode2)) {
5949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
5950 }
5951 arg2 = static_cast< long >(val2);
5952 ecode3 = SWIG_AsVal_long(obj2, &val3);
5953 if (!SWIG_IsOK(ecode3)) {
5954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
5955 }
5956 arg3 = static_cast< long >(val3);
5957 {
5958 PyThreadState* __tstate = wxPyBeginAllowThreads();
5959 wxPoint_Set(arg1,arg2,arg3);
5960 wxPyEndAllowThreads(__tstate);
5961 if (PyErr_Occurred()) SWIG_fail;
5962 }
5963 resultobj = SWIG_Py_Void();
5964 return resultobj;
5965 fail:
5966 return NULL;
5967 }
5968
5969
5970 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5971 PyObject *resultobj = 0;
5972 wxPoint *arg1 = (wxPoint *) 0 ;
5973 PyObject *result = 0 ;
5974 void *argp1 = 0 ;
5975 int res1 = 0 ;
5976 PyObject *swig_obj[1] ;
5977
5978 if (!args) SWIG_fail;
5979 swig_obj[0] = args;
5980 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5981 if (!SWIG_IsOK(res1)) {
5982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
5983 }
5984 arg1 = reinterpret_cast< wxPoint * >(argp1);
5985 {
5986 PyThreadState* __tstate = wxPyBeginAllowThreads();
5987 result = (PyObject *)wxPoint_Get(arg1);
5988 wxPyEndAllowThreads(__tstate);
5989 if (PyErr_Occurred()) SWIG_fail;
5990 }
5991 resultobj = result;
5992 return resultobj;
5993 fail:
5994 return NULL;
5995 }
5996
5997
5998 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5999 PyObject *obj;
6000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6001 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6002 return SWIG_Py_Void();
6003 }
6004
6005 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6006 return SWIG_Python_InitShadowInstance(args);
6007 }
6008
6009 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6010 PyObject *resultobj = 0;
6011 int arg1 = (int) 0 ;
6012 int arg2 = (int) 0 ;
6013 int arg3 = (int) 0 ;
6014 int arg4 = (int) 0 ;
6015 wxRect *result = 0 ;
6016 int val1 ;
6017 int ecode1 = 0 ;
6018 int val2 ;
6019 int ecode2 = 0 ;
6020 int val3 ;
6021 int ecode3 = 0 ;
6022 int val4 ;
6023 int ecode4 = 0 ;
6024 PyObject * obj0 = 0 ;
6025 PyObject * obj1 = 0 ;
6026 PyObject * obj2 = 0 ;
6027 PyObject * obj3 = 0 ;
6028 char * kwnames[] = {
6029 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6030 };
6031
6032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6033 if (obj0) {
6034 ecode1 = SWIG_AsVal_int(obj0, &val1);
6035 if (!SWIG_IsOK(ecode1)) {
6036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6037 }
6038 arg1 = static_cast< int >(val1);
6039 }
6040 if (obj1) {
6041 ecode2 = SWIG_AsVal_int(obj1, &val2);
6042 if (!SWIG_IsOK(ecode2)) {
6043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6044 }
6045 arg2 = static_cast< int >(val2);
6046 }
6047 if (obj2) {
6048 ecode3 = SWIG_AsVal_int(obj2, &val3);
6049 if (!SWIG_IsOK(ecode3)) {
6050 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6051 }
6052 arg3 = static_cast< int >(val3);
6053 }
6054 if (obj3) {
6055 ecode4 = SWIG_AsVal_int(obj3, &val4);
6056 if (!SWIG_IsOK(ecode4)) {
6057 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6058 }
6059 arg4 = static_cast< int >(val4);
6060 }
6061 {
6062 PyThreadState* __tstate = wxPyBeginAllowThreads();
6063 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6064 wxPyEndAllowThreads(__tstate);
6065 if (PyErr_Occurred()) SWIG_fail;
6066 }
6067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6068 return resultobj;
6069 fail:
6070 return NULL;
6071 }
6072
6073
6074 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6075 PyObject *resultobj = 0;
6076 wxPoint *arg1 = 0 ;
6077 wxPoint *arg2 = 0 ;
6078 wxRect *result = 0 ;
6079 wxPoint temp1 ;
6080 wxPoint temp2 ;
6081 PyObject * obj0 = 0 ;
6082 PyObject * obj1 = 0 ;
6083 char * kwnames[] = {
6084 (char *) "topLeft",(char *) "bottomRight", NULL
6085 };
6086
6087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6088 {
6089 arg1 = &temp1;
6090 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6091 }
6092 {
6093 arg2 = &temp2;
6094 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6095 }
6096 {
6097 PyThreadState* __tstate = wxPyBeginAllowThreads();
6098 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6099 wxPyEndAllowThreads(__tstate);
6100 if (PyErr_Occurred()) SWIG_fail;
6101 }
6102 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6103 return resultobj;
6104 fail:
6105 return NULL;
6106 }
6107
6108
6109 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6110 PyObject *resultobj = 0;
6111 wxPoint *arg1 = 0 ;
6112 wxSize *arg2 = 0 ;
6113 wxRect *result = 0 ;
6114 wxPoint temp1 ;
6115 wxSize temp2 ;
6116 PyObject * obj0 = 0 ;
6117 PyObject * obj1 = 0 ;
6118 char * kwnames[] = {
6119 (char *) "pos",(char *) "size", NULL
6120 };
6121
6122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6123 {
6124 arg1 = &temp1;
6125 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6126 }
6127 {
6128 arg2 = &temp2;
6129 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6130 }
6131 {
6132 PyThreadState* __tstate = wxPyBeginAllowThreads();
6133 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6134 wxPyEndAllowThreads(__tstate);
6135 if (PyErr_Occurred()) SWIG_fail;
6136 }
6137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6138 return resultobj;
6139 fail:
6140 return NULL;
6141 }
6142
6143
6144 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6145 PyObject *resultobj = 0;
6146 wxSize *arg1 = 0 ;
6147 wxRect *result = 0 ;
6148 wxSize temp1 ;
6149 PyObject * obj0 = 0 ;
6150 char * kwnames[] = {
6151 (char *) "size", NULL
6152 };
6153
6154 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6155 {
6156 arg1 = &temp1;
6157 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6158 }
6159 {
6160 PyThreadState* __tstate = wxPyBeginAllowThreads();
6161 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6162 wxPyEndAllowThreads(__tstate);
6163 if (PyErr_Occurred()) SWIG_fail;
6164 }
6165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6166 return resultobj;
6167 fail:
6168 return NULL;
6169 }
6170
6171
6172 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6173 PyObject *resultobj = 0;
6174 wxRect *arg1 = (wxRect *) 0 ;
6175 void *argp1 = 0 ;
6176 int res1 = 0 ;
6177 PyObject *swig_obj[1] ;
6178
6179 if (!args) SWIG_fail;
6180 swig_obj[0] = args;
6181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6182 if (!SWIG_IsOK(res1)) {
6183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6184 }
6185 arg1 = reinterpret_cast< wxRect * >(argp1);
6186 {
6187 PyThreadState* __tstate = wxPyBeginAllowThreads();
6188 delete arg1;
6189
6190 wxPyEndAllowThreads(__tstate);
6191 if (PyErr_Occurred()) SWIG_fail;
6192 }
6193 resultobj = SWIG_Py_Void();
6194 return resultobj;
6195 fail:
6196 return NULL;
6197 }
6198
6199
6200 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6201 PyObject *resultobj = 0;
6202 wxRect *arg1 = (wxRect *) 0 ;
6203 int result;
6204 void *argp1 = 0 ;
6205 int res1 = 0 ;
6206 PyObject *swig_obj[1] ;
6207
6208 if (!args) SWIG_fail;
6209 swig_obj[0] = args;
6210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6211 if (!SWIG_IsOK(res1)) {
6212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6213 }
6214 arg1 = reinterpret_cast< wxRect * >(argp1);
6215 {
6216 PyThreadState* __tstate = wxPyBeginAllowThreads();
6217 result = (int)((wxRect const *)arg1)->GetX();
6218 wxPyEndAllowThreads(__tstate);
6219 if (PyErr_Occurred()) SWIG_fail;
6220 }
6221 resultobj = SWIG_From_int(static_cast< int >(result));
6222 return resultobj;
6223 fail:
6224 return NULL;
6225 }
6226
6227
6228 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6229 PyObject *resultobj = 0;
6230 wxRect *arg1 = (wxRect *) 0 ;
6231 int arg2 ;
6232 void *argp1 = 0 ;
6233 int res1 = 0 ;
6234 int val2 ;
6235 int ecode2 = 0 ;
6236 PyObject * obj0 = 0 ;
6237 PyObject * obj1 = 0 ;
6238 char * kwnames[] = {
6239 (char *) "self",(char *) "x", NULL
6240 };
6241
6242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6244 if (!SWIG_IsOK(res1)) {
6245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6246 }
6247 arg1 = reinterpret_cast< wxRect * >(argp1);
6248 ecode2 = SWIG_AsVal_int(obj1, &val2);
6249 if (!SWIG_IsOK(ecode2)) {
6250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6251 }
6252 arg2 = static_cast< int >(val2);
6253 {
6254 PyThreadState* __tstate = wxPyBeginAllowThreads();
6255 (arg1)->SetX(arg2);
6256 wxPyEndAllowThreads(__tstate);
6257 if (PyErr_Occurred()) SWIG_fail;
6258 }
6259 resultobj = SWIG_Py_Void();
6260 return resultobj;
6261 fail:
6262 return NULL;
6263 }
6264
6265
6266 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6267 PyObject *resultobj = 0;
6268 wxRect *arg1 = (wxRect *) 0 ;
6269 int result;
6270 void *argp1 = 0 ;
6271 int res1 = 0 ;
6272 PyObject *swig_obj[1] ;
6273
6274 if (!args) SWIG_fail;
6275 swig_obj[0] = args;
6276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6277 if (!SWIG_IsOK(res1)) {
6278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6279 }
6280 arg1 = reinterpret_cast< wxRect * >(argp1);
6281 {
6282 PyThreadState* __tstate = wxPyBeginAllowThreads();
6283 result = (int)(arg1)->GetY();
6284 wxPyEndAllowThreads(__tstate);
6285 if (PyErr_Occurred()) SWIG_fail;
6286 }
6287 resultobj = SWIG_From_int(static_cast< int >(result));
6288 return resultobj;
6289 fail:
6290 return NULL;
6291 }
6292
6293
6294 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6295 PyObject *resultobj = 0;
6296 wxRect *arg1 = (wxRect *) 0 ;
6297 int arg2 ;
6298 void *argp1 = 0 ;
6299 int res1 = 0 ;
6300 int val2 ;
6301 int ecode2 = 0 ;
6302 PyObject * obj0 = 0 ;
6303 PyObject * obj1 = 0 ;
6304 char * kwnames[] = {
6305 (char *) "self",(char *) "y", NULL
6306 };
6307
6308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6310 if (!SWIG_IsOK(res1)) {
6311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6312 }
6313 arg1 = reinterpret_cast< wxRect * >(argp1);
6314 ecode2 = SWIG_AsVal_int(obj1, &val2);
6315 if (!SWIG_IsOK(ecode2)) {
6316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6317 }
6318 arg2 = static_cast< int >(val2);
6319 {
6320 PyThreadState* __tstate = wxPyBeginAllowThreads();
6321 (arg1)->SetY(arg2);
6322 wxPyEndAllowThreads(__tstate);
6323 if (PyErr_Occurred()) SWIG_fail;
6324 }
6325 resultobj = SWIG_Py_Void();
6326 return resultobj;
6327 fail:
6328 return NULL;
6329 }
6330
6331
6332 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6333 PyObject *resultobj = 0;
6334 wxRect *arg1 = (wxRect *) 0 ;
6335 int result;
6336 void *argp1 = 0 ;
6337 int res1 = 0 ;
6338 PyObject *swig_obj[1] ;
6339
6340 if (!args) SWIG_fail;
6341 swig_obj[0] = args;
6342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6343 if (!SWIG_IsOK(res1)) {
6344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6345 }
6346 arg1 = reinterpret_cast< wxRect * >(argp1);
6347 {
6348 PyThreadState* __tstate = wxPyBeginAllowThreads();
6349 result = (int)((wxRect const *)arg1)->GetWidth();
6350 wxPyEndAllowThreads(__tstate);
6351 if (PyErr_Occurred()) SWIG_fail;
6352 }
6353 resultobj = SWIG_From_int(static_cast< int >(result));
6354 return resultobj;
6355 fail:
6356 return NULL;
6357 }
6358
6359
6360 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6361 PyObject *resultobj = 0;
6362 wxRect *arg1 = (wxRect *) 0 ;
6363 int arg2 ;
6364 void *argp1 = 0 ;
6365 int res1 = 0 ;
6366 int val2 ;
6367 int ecode2 = 0 ;
6368 PyObject * obj0 = 0 ;
6369 PyObject * obj1 = 0 ;
6370 char * kwnames[] = {
6371 (char *) "self",(char *) "w", NULL
6372 };
6373
6374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6376 if (!SWIG_IsOK(res1)) {
6377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6378 }
6379 arg1 = reinterpret_cast< wxRect * >(argp1);
6380 ecode2 = SWIG_AsVal_int(obj1, &val2);
6381 if (!SWIG_IsOK(ecode2)) {
6382 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6383 }
6384 arg2 = static_cast< int >(val2);
6385 {
6386 PyThreadState* __tstate = wxPyBeginAllowThreads();
6387 (arg1)->SetWidth(arg2);
6388 wxPyEndAllowThreads(__tstate);
6389 if (PyErr_Occurred()) SWIG_fail;
6390 }
6391 resultobj = SWIG_Py_Void();
6392 return resultobj;
6393 fail:
6394 return NULL;
6395 }
6396
6397
6398 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6399 PyObject *resultobj = 0;
6400 wxRect *arg1 = (wxRect *) 0 ;
6401 int result;
6402 void *argp1 = 0 ;
6403 int res1 = 0 ;
6404 PyObject *swig_obj[1] ;
6405
6406 if (!args) SWIG_fail;
6407 swig_obj[0] = args;
6408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6409 if (!SWIG_IsOK(res1)) {
6410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6411 }
6412 arg1 = reinterpret_cast< wxRect * >(argp1);
6413 {
6414 PyThreadState* __tstate = wxPyBeginAllowThreads();
6415 result = (int)((wxRect const *)arg1)->GetHeight();
6416 wxPyEndAllowThreads(__tstate);
6417 if (PyErr_Occurred()) SWIG_fail;
6418 }
6419 resultobj = SWIG_From_int(static_cast< int >(result));
6420 return resultobj;
6421 fail:
6422 return NULL;
6423 }
6424
6425
6426 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6427 PyObject *resultobj = 0;
6428 wxRect *arg1 = (wxRect *) 0 ;
6429 int arg2 ;
6430 void *argp1 = 0 ;
6431 int res1 = 0 ;
6432 int val2 ;
6433 int ecode2 = 0 ;
6434 PyObject * obj0 = 0 ;
6435 PyObject * obj1 = 0 ;
6436 char * kwnames[] = {
6437 (char *) "self",(char *) "h", NULL
6438 };
6439
6440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6442 if (!SWIG_IsOK(res1)) {
6443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6444 }
6445 arg1 = reinterpret_cast< wxRect * >(argp1);
6446 ecode2 = SWIG_AsVal_int(obj1, &val2);
6447 if (!SWIG_IsOK(ecode2)) {
6448 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6449 }
6450 arg2 = static_cast< int >(val2);
6451 {
6452 PyThreadState* __tstate = wxPyBeginAllowThreads();
6453 (arg1)->SetHeight(arg2);
6454 wxPyEndAllowThreads(__tstate);
6455 if (PyErr_Occurred()) SWIG_fail;
6456 }
6457 resultobj = SWIG_Py_Void();
6458 return resultobj;
6459 fail:
6460 return NULL;
6461 }
6462
6463
6464 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6465 PyObject *resultobj = 0;
6466 wxRect *arg1 = (wxRect *) 0 ;
6467 wxPoint result;
6468 void *argp1 = 0 ;
6469 int res1 = 0 ;
6470 PyObject *swig_obj[1] ;
6471
6472 if (!args) SWIG_fail;
6473 swig_obj[0] = args;
6474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6475 if (!SWIG_IsOK(res1)) {
6476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6477 }
6478 arg1 = reinterpret_cast< wxRect * >(argp1);
6479 {
6480 PyThreadState* __tstate = wxPyBeginAllowThreads();
6481 result = ((wxRect const *)arg1)->GetPosition();
6482 wxPyEndAllowThreads(__tstate);
6483 if (PyErr_Occurred()) SWIG_fail;
6484 }
6485 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6486 return resultobj;
6487 fail:
6488 return NULL;
6489 }
6490
6491
6492 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6493 PyObject *resultobj = 0;
6494 wxRect *arg1 = (wxRect *) 0 ;
6495 wxPoint *arg2 = 0 ;
6496 void *argp1 = 0 ;
6497 int res1 = 0 ;
6498 wxPoint temp2 ;
6499 PyObject * obj0 = 0 ;
6500 PyObject * obj1 = 0 ;
6501 char * kwnames[] = {
6502 (char *) "self",(char *) "p", NULL
6503 };
6504
6505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6507 if (!SWIG_IsOK(res1)) {
6508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6509 }
6510 arg1 = reinterpret_cast< wxRect * >(argp1);
6511 {
6512 arg2 = &temp2;
6513 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6514 }
6515 {
6516 PyThreadState* __tstate = wxPyBeginAllowThreads();
6517 (arg1)->SetPosition((wxPoint const &)*arg2);
6518 wxPyEndAllowThreads(__tstate);
6519 if (PyErr_Occurred()) SWIG_fail;
6520 }
6521 resultobj = SWIG_Py_Void();
6522 return resultobj;
6523 fail:
6524 return NULL;
6525 }
6526
6527
6528 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6529 PyObject *resultobj = 0;
6530 wxRect *arg1 = (wxRect *) 0 ;
6531 wxSize result;
6532 void *argp1 = 0 ;
6533 int res1 = 0 ;
6534 PyObject *swig_obj[1] ;
6535
6536 if (!args) SWIG_fail;
6537 swig_obj[0] = args;
6538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6539 if (!SWIG_IsOK(res1)) {
6540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6541 }
6542 arg1 = reinterpret_cast< wxRect * >(argp1);
6543 {
6544 PyThreadState* __tstate = wxPyBeginAllowThreads();
6545 result = ((wxRect const *)arg1)->GetSize();
6546 wxPyEndAllowThreads(__tstate);
6547 if (PyErr_Occurred()) SWIG_fail;
6548 }
6549 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6550 return resultobj;
6551 fail:
6552 return NULL;
6553 }
6554
6555
6556 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6557 PyObject *resultobj = 0;
6558 wxRect *arg1 = (wxRect *) 0 ;
6559 wxSize *arg2 = 0 ;
6560 void *argp1 = 0 ;
6561 int res1 = 0 ;
6562 wxSize temp2 ;
6563 PyObject * obj0 = 0 ;
6564 PyObject * obj1 = 0 ;
6565 char * kwnames[] = {
6566 (char *) "self",(char *) "s", NULL
6567 };
6568
6569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6571 if (!SWIG_IsOK(res1)) {
6572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6573 }
6574 arg1 = reinterpret_cast< wxRect * >(argp1);
6575 {
6576 arg2 = &temp2;
6577 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6578 }
6579 {
6580 PyThreadState* __tstate = wxPyBeginAllowThreads();
6581 (arg1)->SetSize((wxSize const &)*arg2);
6582 wxPyEndAllowThreads(__tstate);
6583 if (PyErr_Occurred()) SWIG_fail;
6584 }
6585 resultobj = SWIG_Py_Void();
6586 return resultobj;
6587 fail:
6588 return NULL;
6589 }
6590
6591
6592 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6593 PyObject *resultobj = 0;
6594 wxRect *arg1 = (wxRect *) 0 ;
6595 bool result;
6596 void *argp1 = 0 ;
6597 int res1 = 0 ;
6598 PyObject *swig_obj[1] ;
6599
6600 if (!args) SWIG_fail;
6601 swig_obj[0] = args;
6602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6603 if (!SWIG_IsOK(res1)) {
6604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6605 }
6606 arg1 = reinterpret_cast< wxRect * >(argp1);
6607 {
6608 PyThreadState* __tstate = wxPyBeginAllowThreads();
6609 result = (bool)((wxRect const *)arg1)->IsEmpty();
6610 wxPyEndAllowThreads(__tstate);
6611 if (PyErr_Occurred()) SWIG_fail;
6612 }
6613 {
6614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6615 }
6616 return resultobj;
6617 fail:
6618 return NULL;
6619 }
6620
6621
6622 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6623 PyObject *resultobj = 0;
6624 wxRect *arg1 = (wxRect *) 0 ;
6625 wxPoint result;
6626 void *argp1 = 0 ;
6627 int res1 = 0 ;
6628 PyObject *swig_obj[1] ;
6629
6630 if (!args) SWIG_fail;
6631 swig_obj[0] = args;
6632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6633 if (!SWIG_IsOK(res1)) {
6634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6635 }
6636 arg1 = reinterpret_cast< wxRect * >(argp1);
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 result = ((wxRect const *)arg1)->GetTopLeft();
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6651 PyObject *resultobj = 0;
6652 wxRect *arg1 = (wxRect *) 0 ;
6653 wxPoint *arg2 = 0 ;
6654 void *argp1 = 0 ;
6655 int res1 = 0 ;
6656 wxPoint temp2 ;
6657 PyObject * obj0 = 0 ;
6658 PyObject * obj1 = 0 ;
6659 char * kwnames[] = {
6660 (char *) "self",(char *) "p", NULL
6661 };
6662
6663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6665 if (!SWIG_IsOK(res1)) {
6666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6667 }
6668 arg1 = reinterpret_cast< wxRect * >(argp1);
6669 {
6670 arg2 = &temp2;
6671 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6672 }
6673 {
6674 PyThreadState* __tstate = wxPyBeginAllowThreads();
6675 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6676 wxPyEndAllowThreads(__tstate);
6677 if (PyErr_Occurred()) SWIG_fail;
6678 }
6679 resultobj = SWIG_Py_Void();
6680 return resultobj;
6681 fail:
6682 return NULL;
6683 }
6684
6685
6686 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6687 PyObject *resultobj = 0;
6688 wxRect *arg1 = (wxRect *) 0 ;
6689 wxPoint result;
6690 void *argp1 = 0 ;
6691 int res1 = 0 ;
6692 PyObject *swig_obj[1] ;
6693
6694 if (!args) SWIG_fail;
6695 swig_obj[0] = args;
6696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6697 if (!SWIG_IsOK(res1)) {
6698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6699 }
6700 arg1 = reinterpret_cast< wxRect * >(argp1);
6701 {
6702 PyThreadState* __tstate = wxPyBeginAllowThreads();
6703 result = ((wxRect const *)arg1)->GetBottomRight();
6704 wxPyEndAllowThreads(__tstate);
6705 if (PyErr_Occurred()) SWIG_fail;
6706 }
6707 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6708 return resultobj;
6709 fail:
6710 return NULL;
6711 }
6712
6713
6714 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6715 PyObject *resultobj = 0;
6716 wxRect *arg1 = (wxRect *) 0 ;
6717 wxPoint *arg2 = 0 ;
6718 void *argp1 = 0 ;
6719 int res1 = 0 ;
6720 wxPoint temp2 ;
6721 PyObject * obj0 = 0 ;
6722 PyObject * obj1 = 0 ;
6723 char * kwnames[] = {
6724 (char *) "self",(char *) "p", NULL
6725 };
6726
6727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6729 if (!SWIG_IsOK(res1)) {
6730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6731 }
6732 arg1 = reinterpret_cast< wxRect * >(argp1);
6733 {
6734 arg2 = &temp2;
6735 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6736 }
6737 {
6738 PyThreadState* __tstate = wxPyBeginAllowThreads();
6739 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6740 wxPyEndAllowThreads(__tstate);
6741 if (PyErr_Occurred()) SWIG_fail;
6742 }
6743 resultobj = SWIG_Py_Void();
6744 return resultobj;
6745 fail:
6746 return NULL;
6747 }
6748
6749
6750 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6751 PyObject *resultobj = 0;
6752 wxRect *arg1 = (wxRect *) 0 ;
6753 int result;
6754 void *argp1 = 0 ;
6755 int res1 = 0 ;
6756 PyObject *swig_obj[1] ;
6757
6758 if (!args) SWIG_fail;
6759 swig_obj[0] = args;
6760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6761 if (!SWIG_IsOK(res1)) {
6762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6763 }
6764 arg1 = reinterpret_cast< wxRect * >(argp1);
6765 {
6766 PyThreadState* __tstate = wxPyBeginAllowThreads();
6767 result = (int)((wxRect const *)arg1)->GetLeft();
6768 wxPyEndAllowThreads(__tstate);
6769 if (PyErr_Occurred()) SWIG_fail;
6770 }
6771 resultobj = SWIG_From_int(static_cast< int >(result));
6772 return resultobj;
6773 fail:
6774 return NULL;
6775 }
6776
6777
6778 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6779 PyObject *resultobj = 0;
6780 wxRect *arg1 = (wxRect *) 0 ;
6781 int result;
6782 void *argp1 = 0 ;
6783 int res1 = 0 ;
6784 PyObject *swig_obj[1] ;
6785
6786 if (!args) SWIG_fail;
6787 swig_obj[0] = args;
6788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6789 if (!SWIG_IsOK(res1)) {
6790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6791 }
6792 arg1 = reinterpret_cast< wxRect * >(argp1);
6793 {
6794 PyThreadState* __tstate = wxPyBeginAllowThreads();
6795 result = (int)((wxRect const *)arg1)->GetTop();
6796 wxPyEndAllowThreads(__tstate);
6797 if (PyErr_Occurred()) SWIG_fail;
6798 }
6799 resultobj = SWIG_From_int(static_cast< int >(result));
6800 return resultobj;
6801 fail:
6802 return NULL;
6803 }
6804
6805
6806 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6807 PyObject *resultobj = 0;
6808 wxRect *arg1 = (wxRect *) 0 ;
6809 int result;
6810 void *argp1 = 0 ;
6811 int res1 = 0 ;
6812 PyObject *swig_obj[1] ;
6813
6814 if (!args) SWIG_fail;
6815 swig_obj[0] = args;
6816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6817 if (!SWIG_IsOK(res1)) {
6818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6819 }
6820 arg1 = reinterpret_cast< wxRect * >(argp1);
6821 {
6822 PyThreadState* __tstate = wxPyBeginAllowThreads();
6823 result = (int)((wxRect const *)arg1)->GetBottom();
6824 wxPyEndAllowThreads(__tstate);
6825 if (PyErr_Occurred()) SWIG_fail;
6826 }
6827 resultobj = SWIG_From_int(static_cast< int >(result));
6828 return resultobj;
6829 fail:
6830 return NULL;
6831 }
6832
6833
6834 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6835 PyObject *resultobj = 0;
6836 wxRect *arg1 = (wxRect *) 0 ;
6837 int result;
6838 void *argp1 = 0 ;
6839 int res1 = 0 ;
6840 PyObject *swig_obj[1] ;
6841
6842 if (!args) SWIG_fail;
6843 swig_obj[0] = args;
6844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6845 if (!SWIG_IsOK(res1)) {
6846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6847 }
6848 arg1 = reinterpret_cast< wxRect * >(argp1);
6849 {
6850 PyThreadState* __tstate = wxPyBeginAllowThreads();
6851 result = (int)((wxRect const *)arg1)->GetRight();
6852 wxPyEndAllowThreads(__tstate);
6853 if (PyErr_Occurred()) SWIG_fail;
6854 }
6855 resultobj = SWIG_From_int(static_cast< int >(result));
6856 return resultobj;
6857 fail:
6858 return NULL;
6859 }
6860
6861
6862 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6863 PyObject *resultobj = 0;
6864 wxRect *arg1 = (wxRect *) 0 ;
6865 int arg2 ;
6866 void *argp1 = 0 ;
6867 int res1 = 0 ;
6868 int val2 ;
6869 int ecode2 = 0 ;
6870 PyObject * obj0 = 0 ;
6871 PyObject * obj1 = 0 ;
6872 char * kwnames[] = {
6873 (char *) "self",(char *) "left", NULL
6874 };
6875
6876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6878 if (!SWIG_IsOK(res1)) {
6879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6880 }
6881 arg1 = reinterpret_cast< wxRect * >(argp1);
6882 ecode2 = SWIG_AsVal_int(obj1, &val2);
6883 if (!SWIG_IsOK(ecode2)) {
6884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6885 }
6886 arg2 = static_cast< int >(val2);
6887 {
6888 PyThreadState* __tstate = wxPyBeginAllowThreads();
6889 (arg1)->SetLeft(arg2);
6890 wxPyEndAllowThreads(__tstate);
6891 if (PyErr_Occurred()) SWIG_fail;
6892 }
6893 resultobj = SWIG_Py_Void();
6894 return resultobj;
6895 fail:
6896 return NULL;
6897 }
6898
6899
6900 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6901 PyObject *resultobj = 0;
6902 wxRect *arg1 = (wxRect *) 0 ;
6903 int arg2 ;
6904 void *argp1 = 0 ;
6905 int res1 = 0 ;
6906 int val2 ;
6907 int ecode2 = 0 ;
6908 PyObject * obj0 = 0 ;
6909 PyObject * obj1 = 0 ;
6910 char * kwnames[] = {
6911 (char *) "self",(char *) "right", NULL
6912 };
6913
6914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6916 if (!SWIG_IsOK(res1)) {
6917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6918 }
6919 arg1 = reinterpret_cast< wxRect * >(argp1);
6920 ecode2 = SWIG_AsVal_int(obj1, &val2);
6921 if (!SWIG_IsOK(ecode2)) {
6922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6923 }
6924 arg2 = static_cast< int >(val2);
6925 {
6926 PyThreadState* __tstate = wxPyBeginAllowThreads();
6927 (arg1)->SetRight(arg2);
6928 wxPyEndAllowThreads(__tstate);
6929 if (PyErr_Occurred()) SWIG_fail;
6930 }
6931 resultobj = SWIG_Py_Void();
6932 return resultobj;
6933 fail:
6934 return NULL;
6935 }
6936
6937
6938 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6939 PyObject *resultobj = 0;
6940 wxRect *arg1 = (wxRect *) 0 ;
6941 int arg2 ;
6942 void *argp1 = 0 ;
6943 int res1 = 0 ;
6944 int val2 ;
6945 int ecode2 = 0 ;
6946 PyObject * obj0 = 0 ;
6947 PyObject * obj1 = 0 ;
6948 char * kwnames[] = {
6949 (char *) "self",(char *) "top", NULL
6950 };
6951
6952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
6953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6954 if (!SWIG_IsOK(res1)) {
6955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
6956 }
6957 arg1 = reinterpret_cast< wxRect * >(argp1);
6958 ecode2 = SWIG_AsVal_int(obj1, &val2);
6959 if (!SWIG_IsOK(ecode2)) {
6960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
6961 }
6962 arg2 = static_cast< int >(val2);
6963 {
6964 PyThreadState* __tstate = wxPyBeginAllowThreads();
6965 (arg1)->SetTop(arg2);
6966 wxPyEndAllowThreads(__tstate);
6967 if (PyErr_Occurred()) SWIG_fail;
6968 }
6969 resultobj = SWIG_Py_Void();
6970 return resultobj;
6971 fail:
6972 return NULL;
6973 }
6974
6975
6976 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6977 PyObject *resultobj = 0;
6978 wxRect *arg1 = (wxRect *) 0 ;
6979 int arg2 ;
6980 void *argp1 = 0 ;
6981 int res1 = 0 ;
6982 int val2 ;
6983 int ecode2 = 0 ;
6984 PyObject * obj0 = 0 ;
6985 PyObject * obj1 = 0 ;
6986 char * kwnames[] = {
6987 (char *) "self",(char *) "bottom", NULL
6988 };
6989
6990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
6991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6992 if (!SWIG_IsOK(res1)) {
6993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
6994 }
6995 arg1 = reinterpret_cast< wxRect * >(argp1);
6996 ecode2 = SWIG_AsVal_int(obj1, &val2);
6997 if (!SWIG_IsOK(ecode2)) {
6998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
6999 }
7000 arg2 = static_cast< int >(val2);
7001 {
7002 PyThreadState* __tstate = wxPyBeginAllowThreads();
7003 (arg1)->SetBottom(arg2);
7004 wxPyEndAllowThreads(__tstate);
7005 if (PyErr_Occurred()) SWIG_fail;
7006 }
7007 resultobj = SWIG_Py_Void();
7008 return resultobj;
7009 fail:
7010 return NULL;
7011 }
7012
7013
7014 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7015 PyObject *resultobj = 0;
7016 wxRect *arg1 = (wxRect *) 0 ;
7017 int arg2 ;
7018 int arg3 ;
7019 wxRect *result = 0 ;
7020 void *argp1 = 0 ;
7021 int res1 = 0 ;
7022 int val2 ;
7023 int ecode2 = 0 ;
7024 int val3 ;
7025 int ecode3 = 0 ;
7026 PyObject * obj0 = 0 ;
7027 PyObject * obj1 = 0 ;
7028 PyObject * obj2 = 0 ;
7029 char * kwnames[] = {
7030 (char *) "self",(char *) "dx",(char *) "dy", NULL
7031 };
7032
7033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7035 if (!SWIG_IsOK(res1)) {
7036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7037 }
7038 arg1 = reinterpret_cast< wxRect * >(argp1);
7039 ecode2 = SWIG_AsVal_int(obj1, &val2);
7040 if (!SWIG_IsOK(ecode2)) {
7041 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7042 }
7043 arg2 = static_cast< int >(val2);
7044 ecode3 = SWIG_AsVal_int(obj2, &val3);
7045 if (!SWIG_IsOK(ecode3)) {
7046 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7047 }
7048 arg3 = static_cast< int >(val3);
7049 {
7050 PyThreadState* __tstate = wxPyBeginAllowThreads();
7051 {
7052 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7053 result = (wxRect *) &_result_ref;
7054 }
7055 wxPyEndAllowThreads(__tstate);
7056 if (PyErr_Occurred()) SWIG_fail;
7057 }
7058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7059 return resultobj;
7060 fail:
7061 return NULL;
7062 }
7063
7064
7065 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7066 PyObject *resultobj = 0;
7067 wxRect *arg1 = (wxRect *) 0 ;
7068 int arg2 ;
7069 int arg3 ;
7070 wxRect *result = 0 ;
7071 void *argp1 = 0 ;
7072 int res1 = 0 ;
7073 int val2 ;
7074 int ecode2 = 0 ;
7075 int val3 ;
7076 int ecode3 = 0 ;
7077 PyObject * obj0 = 0 ;
7078 PyObject * obj1 = 0 ;
7079 PyObject * obj2 = 0 ;
7080 char * kwnames[] = {
7081 (char *) "self",(char *) "dx",(char *) "dy", NULL
7082 };
7083
7084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7086 if (!SWIG_IsOK(res1)) {
7087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7088 }
7089 arg1 = reinterpret_cast< wxRect * >(argp1);
7090 ecode2 = SWIG_AsVal_int(obj1, &val2);
7091 if (!SWIG_IsOK(ecode2)) {
7092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7093 }
7094 arg2 = static_cast< int >(val2);
7095 ecode3 = SWIG_AsVal_int(obj2, &val3);
7096 if (!SWIG_IsOK(ecode3)) {
7097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7098 }
7099 arg3 = static_cast< int >(val3);
7100 {
7101 PyThreadState* __tstate = wxPyBeginAllowThreads();
7102 {
7103 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7104 result = (wxRect *) &_result_ref;
7105 }
7106 wxPyEndAllowThreads(__tstate);
7107 if (PyErr_Occurred()) SWIG_fail;
7108 }
7109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7110 return resultobj;
7111 fail:
7112 return NULL;
7113 }
7114
7115
7116 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7117 PyObject *resultobj = 0;
7118 wxRect *arg1 = (wxRect *) 0 ;
7119 int arg2 ;
7120 int arg3 ;
7121 void *argp1 = 0 ;
7122 int res1 = 0 ;
7123 int val2 ;
7124 int ecode2 = 0 ;
7125 int val3 ;
7126 int ecode3 = 0 ;
7127 PyObject * obj0 = 0 ;
7128 PyObject * obj1 = 0 ;
7129 PyObject * obj2 = 0 ;
7130 char * kwnames[] = {
7131 (char *) "self",(char *) "dx",(char *) "dy", NULL
7132 };
7133
7134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7136 if (!SWIG_IsOK(res1)) {
7137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7138 }
7139 arg1 = reinterpret_cast< wxRect * >(argp1);
7140 ecode2 = SWIG_AsVal_int(obj1, &val2);
7141 if (!SWIG_IsOK(ecode2)) {
7142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7143 }
7144 arg2 = static_cast< int >(val2);
7145 ecode3 = SWIG_AsVal_int(obj2, &val3);
7146 if (!SWIG_IsOK(ecode3)) {
7147 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7148 }
7149 arg3 = static_cast< int >(val3);
7150 {
7151 PyThreadState* __tstate = wxPyBeginAllowThreads();
7152 (arg1)->Offset(arg2,arg3);
7153 wxPyEndAllowThreads(__tstate);
7154 if (PyErr_Occurred()) SWIG_fail;
7155 }
7156 resultobj = SWIG_Py_Void();
7157 return resultobj;
7158 fail:
7159 return NULL;
7160 }
7161
7162
7163 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7164 PyObject *resultobj = 0;
7165 wxRect *arg1 = (wxRect *) 0 ;
7166 wxPoint *arg2 = 0 ;
7167 void *argp1 = 0 ;
7168 int res1 = 0 ;
7169 wxPoint temp2 ;
7170 PyObject * obj0 = 0 ;
7171 PyObject * obj1 = 0 ;
7172 char * kwnames[] = {
7173 (char *) "self",(char *) "pt", NULL
7174 };
7175
7176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7178 if (!SWIG_IsOK(res1)) {
7179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7180 }
7181 arg1 = reinterpret_cast< wxRect * >(argp1);
7182 {
7183 arg2 = &temp2;
7184 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7185 }
7186 {
7187 PyThreadState* __tstate = wxPyBeginAllowThreads();
7188 (arg1)->Offset((wxPoint const &)*arg2);
7189 wxPyEndAllowThreads(__tstate);
7190 if (PyErr_Occurred()) SWIG_fail;
7191 }
7192 resultobj = SWIG_Py_Void();
7193 return resultobj;
7194 fail:
7195 return NULL;
7196 }
7197
7198
7199 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7200 PyObject *resultobj = 0;
7201 wxRect *arg1 = (wxRect *) 0 ;
7202 wxRect *arg2 = 0 ;
7203 wxRect result;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 wxRect temp2 ;
7207 PyObject * obj0 = 0 ;
7208 PyObject * obj1 = 0 ;
7209 char * kwnames[] = {
7210 (char *) "self",(char *) "rect", NULL
7211 };
7212
7213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7215 if (!SWIG_IsOK(res1)) {
7216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7217 }
7218 arg1 = reinterpret_cast< wxRect * >(argp1);
7219 {
7220 arg2 = &temp2;
7221 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7222 }
7223 {
7224 PyThreadState* __tstate = wxPyBeginAllowThreads();
7225 result = (arg1)->Intersect((wxRect const &)*arg2);
7226 wxPyEndAllowThreads(__tstate);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj = 0;
7238 wxRect *arg1 = (wxRect *) 0 ;
7239 wxRect *arg2 = 0 ;
7240 wxRect result;
7241 void *argp1 = 0 ;
7242 int res1 = 0 ;
7243 wxRect temp2 ;
7244 PyObject * obj0 = 0 ;
7245 PyObject * obj1 = 0 ;
7246 char * kwnames[] = {
7247 (char *) "self",(char *) "rect", NULL
7248 };
7249
7250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7252 if (!SWIG_IsOK(res1)) {
7253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7254 }
7255 arg1 = reinterpret_cast< wxRect * >(argp1);
7256 {
7257 arg2 = &temp2;
7258 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7259 }
7260 {
7261 PyThreadState* __tstate = wxPyBeginAllowThreads();
7262 result = (arg1)->Union((wxRect const &)*arg2);
7263 wxPyEndAllowThreads(__tstate);
7264 if (PyErr_Occurred()) SWIG_fail;
7265 }
7266 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7267 return resultobj;
7268 fail:
7269 return NULL;
7270 }
7271
7272
7273 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7274 PyObject *resultobj = 0;
7275 wxRect *arg1 = (wxRect *) 0 ;
7276 wxRect *arg2 = 0 ;
7277 wxRect result;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 wxRect temp2 ;
7281 PyObject * obj0 = 0 ;
7282 PyObject * obj1 = 0 ;
7283 char * kwnames[] = {
7284 (char *) "self",(char *) "rect", NULL
7285 };
7286
7287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7289 if (!SWIG_IsOK(res1)) {
7290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7291 }
7292 arg1 = reinterpret_cast< wxRect * >(argp1);
7293 {
7294 arg2 = &temp2;
7295 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7296 }
7297 {
7298 PyThreadState* __tstate = wxPyBeginAllowThreads();
7299 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7300 wxPyEndAllowThreads(__tstate);
7301 if (PyErr_Occurred()) SWIG_fail;
7302 }
7303 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7304 return resultobj;
7305 fail:
7306 return NULL;
7307 }
7308
7309
7310 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7311 PyObject *resultobj = 0;
7312 wxRect *arg1 = (wxRect *) 0 ;
7313 wxRect *arg2 = 0 ;
7314 wxRect *result = 0 ;
7315 void *argp1 = 0 ;
7316 int res1 = 0 ;
7317 wxRect temp2 ;
7318 PyObject * obj0 = 0 ;
7319 PyObject * obj1 = 0 ;
7320 char * kwnames[] = {
7321 (char *) "self",(char *) "rect", NULL
7322 };
7323
7324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7326 if (!SWIG_IsOK(res1)) {
7327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7328 }
7329 arg1 = reinterpret_cast< wxRect * >(argp1);
7330 {
7331 arg2 = &temp2;
7332 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7333 }
7334 {
7335 PyThreadState* __tstate = wxPyBeginAllowThreads();
7336 {
7337 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7338 result = (wxRect *) &_result_ref;
7339 }
7340 wxPyEndAllowThreads(__tstate);
7341 if (PyErr_Occurred()) SWIG_fail;
7342 }
7343 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7344 return resultobj;
7345 fail:
7346 return NULL;
7347 }
7348
7349
7350 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7351 PyObject *resultobj = 0;
7352 wxRect *arg1 = (wxRect *) 0 ;
7353 PyObject *arg2 = (PyObject *) 0 ;
7354 bool result;
7355 void *argp1 = 0 ;
7356 int res1 = 0 ;
7357 PyObject * obj0 = 0 ;
7358 PyObject * obj1 = 0 ;
7359 char * kwnames[] = {
7360 (char *) "self",(char *) "other", NULL
7361 };
7362
7363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7365 if (!SWIG_IsOK(res1)) {
7366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7367 }
7368 arg1 = reinterpret_cast< wxRect * >(argp1);
7369 arg2 = obj1;
7370 {
7371 result = (bool)wxRect___eq__(arg1,arg2);
7372 if (PyErr_Occurred()) SWIG_fail;
7373 }
7374 {
7375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7376 }
7377 return resultobj;
7378 fail:
7379 return NULL;
7380 }
7381
7382
7383 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7384 PyObject *resultobj = 0;
7385 wxRect *arg1 = (wxRect *) 0 ;
7386 PyObject *arg2 = (PyObject *) 0 ;
7387 bool result;
7388 void *argp1 = 0 ;
7389 int res1 = 0 ;
7390 PyObject * obj0 = 0 ;
7391 PyObject * obj1 = 0 ;
7392 char * kwnames[] = {
7393 (char *) "self",(char *) "other", NULL
7394 };
7395
7396 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7397 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7398 if (!SWIG_IsOK(res1)) {
7399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7400 }
7401 arg1 = reinterpret_cast< wxRect * >(argp1);
7402 arg2 = obj1;
7403 {
7404 result = (bool)wxRect___ne__(arg1,arg2);
7405 if (PyErr_Occurred()) SWIG_fail;
7406 }
7407 {
7408 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7409 }
7410 return resultobj;
7411 fail:
7412 return NULL;
7413 }
7414
7415
7416 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7417 PyObject *resultobj = 0;
7418 wxRect *arg1 = (wxRect *) 0 ;
7419 int arg2 ;
7420 int arg3 ;
7421 bool result;
7422 void *argp1 = 0 ;
7423 int res1 = 0 ;
7424 int val2 ;
7425 int ecode2 = 0 ;
7426 int val3 ;
7427 int ecode3 = 0 ;
7428 PyObject * obj0 = 0 ;
7429 PyObject * obj1 = 0 ;
7430 PyObject * obj2 = 0 ;
7431 char * kwnames[] = {
7432 (char *) "self",(char *) "x",(char *) "y", NULL
7433 };
7434
7435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7437 if (!SWIG_IsOK(res1)) {
7438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7439 }
7440 arg1 = reinterpret_cast< wxRect * >(argp1);
7441 ecode2 = SWIG_AsVal_int(obj1, &val2);
7442 if (!SWIG_IsOK(ecode2)) {
7443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7444 }
7445 arg2 = static_cast< int >(val2);
7446 ecode3 = SWIG_AsVal_int(obj2, &val3);
7447 if (!SWIG_IsOK(ecode3)) {
7448 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7449 }
7450 arg3 = static_cast< int >(val3);
7451 {
7452 PyThreadState* __tstate = wxPyBeginAllowThreads();
7453 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7454 wxPyEndAllowThreads(__tstate);
7455 if (PyErr_Occurred()) SWIG_fail;
7456 }
7457 {
7458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7459 }
7460 return resultobj;
7461 fail:
7462 return NULL;
7463 }
7464
7465
7466 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7467 PyObject *resultobj = 0;
7468 wxRect *arg1 = (wxRect *) 0 ;
7469 wxPoint *arg2 = 0 ;
7470 bool result;
7471 void *argp1 = 0 ;
7472 int res1 = 0 ;
7473 wxPoint temp2 ;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 char * kwnames[] = {
7477 (char *) "self",(char *) "pt", NULL
7478 };
7479
7480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7482 if (!SWIG_IsOK(res1)) {
7483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7484 }
7485 arg1 = reinterpret_cast< wxRect * >(argp1);
7486 {
7487 arg2 = &temp2;
7488 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7489 }
7490 {
7491 PyThreadState* __tstate = wxPyBeginAllowThreads();
7492 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7493 wxPyEndAllowThreads(__tstate);
7494 if (PyErr_Occurred()) SWIG_fail;
7495 }
7496 {
7497 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7498 }
7499 return resultobj;
7500 fail:
7501 return NULL;
7502 }
7503
7504
7505 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7506 PyObject *resultobj = 0;
7507 wxRect *arg1 = (wxRect *) 0 ;
7508 wxRect *arg2 = 0 ;
7509 bool result;
7510 void *argp1 = 0 ;
7511 int res1 = 0 ;
7512 wxRect temp2 ;
7513 PyObject * obj0 = 0 ;
7514 PyObject * obj1 = 0 ;
7515 char * kwnames[] = {
7516 (char *) "self",(char *) "rect", NULL
7517 };
7518
7519 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7520 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7521 if (!SWIG_IsOK(res1)) {
7522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7523 }
7524 arg1 = reinterpret_cast< wxRect * >(argp1);
7525 {
7526 arg2 = &temp2;
7527 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7528 }
7529 {
7530 PyThreadState* __tstate = wxPyBeginAllowThreads();
7531 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7532 wxPyEndAllowThreads(__tstate);
7533 if (PyErr_Occurred()) SWIG_fail;
7534 }
7535 {
7536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7537 }
7538 return resultobj;
7539 fail:
7540 return NULL;
7541 }
7542
7543
7544 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7545 PyObject *resultobj = 0;
7546 wxRect *arg1 = (wxRect *) 0 ;
7547 wxRect *arg2 = 0 ;
7548 int arg3 = (int) wxBOTH ;
7549 wxRect result;
7550 void *argp1 = 0 ;
7551 int res1 = 0 ;
7552 wxRect temp2 ;
7553 int val3 ;
7554 int ecode3 = 0 ;
7555 PyObject * obj0 = 0 ;
7556 PyObject * obj1 = 0 ;
7557 PyObject * obj2 = 0 ;
7558 char * kwnames[] = {
7559 (char *) "self",(char *) "r",(char *) "dir", NULL
7560 };
7561
7562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7564 if (!SWIG_IsOK(res1)) {
7565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7566 }
7567 arg1 = reinterpret_cast< wxRect * >(argp1);
7568 {
7569 arg2 = &temp2;
7570 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7571 }
7572 if (obj2) {
7573 ecode3 = SWIG_AsVal_int(obj2, &val3);
7574 if (!SWIG_IsOK(ecode3)) {
7575 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7576 }
7577 arg3 = static_cast< int >(val3);
7578 }
7579 {
7580 PyThreadState* __tstate = wxPyBeginAllowThreads();
7581 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7582 wxPyEndAllowThreads(__tstate);
7583 if (PyErr_Occurred()) SWIG_fail;
7584 }
7585 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7586 return resultobj;
7587 fail:
7588 return NULL;
7589 }
7590
7591
7592 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7593 PyObject *resultobj = 0;
7594 wxRect *arg1 = (wxRect *) 0 ;
7595 int arg2 ;
7596 void *argp1 = 0 ;
7597 int res1 = 0 ;
7598 int val2 ;
7599 int ecode2 = 0 ;
7600 PyObject *swig_obj[2] ;
7601
7602 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7604 if (!SWIG_IsOK(res1)) {
7605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7606 }
7607 arg1 = reinterpret_cast< wxRect * >(argp1);
7608 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7609 if (!SWIG_IsOK(ecode2)) {
7610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7611 }
7612 arg2 = static_cast< int >(val2);
7613 if (arg1) (arg1)->x = arg2;
7614
7615 resultobj = SWIG_Py_Void();
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 int result;
7626 void *argp1 = 0 ;
7627 int res1 = 0 ;
7628 PyObject *swig_obj[1] ;
7629
7630 if (!args) SWIG_fail;
7631 swig_obj[0] = args;
7632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7633 if (!SWIG_IsOK(res1)) {
7634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7635 }
7636 arg1 = reinterpret_cast< wxRect * >(argp1);
7637 result = (int) ((arg1)->x);
7638 resultobj = SWIG_From_int(static_cast< int >(result));
7639 return resultobj;
7640 fail:
7641 return NULL;
7642 }
7643
7644
7645 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7646 PyObject *resultobj = 0;
7647 wxRect *arg1 = (wxRect *) 0 ;
7648 int arg2 ;
7649 void *argp1 = 0 ;
7650 int res1 = 0 ;
7651 int val2 ;
7652 int ecode2 = 0 ;
7653 PyObject *swig_obj[2] ;
7654
7655 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7657 if (!SWIG_IsOK(res1)) {
7658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7659 }
7660 arg1 = reinterpret_cast< wxRect * >(argp1);
7661 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7662 if (!SWIG_IsOK(ecode2)) {
7663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7664 }
7665 arg2 = static_cast< int >(val2);
7666 if (arg1) (arg1)->y = arg2;
7667
7668 resultobj = SWIG_Py_Void();
7669 return resultobj;
7670 fail:
7671 return NULL;
7672 }
7673
7674
7675 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7676 PyObject *resultobj = 0;
7677 wxRect *arg1 = (wxRect *) 0 ;
7678 int result;
7679 void *argp1 = 0 ;
7680 int res1 = 0 ;
7681 PyObject *swig_obj[1] ;
7682
7683 if (!args) SWIG_fail;
7684 swig_obj[0] = args;
7685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7686 if (!SWIG_IsOK(res1)) {
7687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7688 }
7689 arg1 = reinterpret_cast< wxRect * >(argp1);
7690 result = (int) ((arg1)->y);
7691 resultobj = SWIG_From_int(static_cast< int >(result));
7692 return resultobj;
7693 fail:
7694 return NULL;
7695 }
7696
7697
7698 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7699 PyObject *resultobj = 0;
7700 wxRect *arg1 = (wxRect *) 0 ;
7701 int arg2 ;
7702 void *argp1 = 0 ;
7703 int res1 = 0 ;
7704 int val2 ;
7705 int ecode2 = 0 ;
7706 PyObject *swig_obj[2] ;
7707
7708 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7710 if (!SWIG_IsOK(res1)) {
7711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7712 }
7713 arg1 = reinterpret_cast< wxRect * >(argp1);
7714 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7715 if (!SWIG_IsOK(ecode2)) {
7716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7717 }
7718 arg2 = static_cast< int >(val2);
7719 if (arg1) (arg1)->width = arg2;
7720
7721 resultobj = SWIG_Py_Void();
7722 return resultobj;
7723 fail:
7724 return NULL;
7725 }
7726
7727
7728 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7729 PyObject *resultobj = 0;
7730 wxRect *arg1 = (wxRect *) 0 ;
7731 int result;
7732 void *argp1 = 0 ;
7733 int res1 = 0 ;
7734 PyObject *swig_obj[1] ;
7735
7736 if (!args) SWIG_fail;
7737 swig_obj[0] = args;
7738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7739 if (!SWIG_IsOK(res1)) {
7740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7741 }
7742 arg1 = reinterpret_cast< wxRect * >(argp1);
7743 result = (int) ((arg1)->width);
7744 resultobj = SWIG_From_int(static_cast< int >(result));
7745 return resultobj;
7746 fail:
7747 return NULL;
7748 }
7749
7750
7751 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7752 PyObject *resultobj = 0;
7753 wxRect *arg1 = (wxRect *) 0 ;
7754 int arg2 ;
7755 void *argp1 = 0 ;
7756 int res1 = 0 ;
7757 int val2 ;
7758 int ecode2 = 0 ;
7759 PyObject *swig_obj[2] ;
7760
7761 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7762 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7763 if (!SWIG_IsOK(res1)) {
7764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7765 }
7766 arg1 = reinterpret_cast< wxRect * >(argp1);
7767 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7768 if (!SWIG_IsOK(ecode2)) {
7769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7770 }
7771 arg2 = static_cast< int >(val2);
7772 if (arg1) (arg1)->height = arg2;
7773
7774 resultobj = SWIG_Py_Void();
7775 return resultobj;
7776 fail:
7777 return NULL;
7778 }
7779
7780
7781 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7782 PyObject *resultobj = 0;
7783 wxRect *arg1 = (wxRect *) 0 ;
7784 int result;
7785 void *argp1 = 0 ;
7786 int res1 = 0 ;
7787 PyObject *swig_obj[1] ;
7788
7789 if (!args) SWIG_fail;
7790 swig_obj[0] = args;
7791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7792 if (!SWIG_IsOK(res1)) {
7793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7794 }
7795 arg1 = reinterpret_cast< wxRect * >(argp1);
7796 result = (int) ((arg1)->height);
7797 resultobj = SWIG_From_int(static_cast< int >(result));
7798 return resultobj;
7799 fail:
7800 return NULL;
7801 }
7802
7803
7804 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7805 PyObject *resultobj = 0;
7806 wxRect *arg1 = (wxRect *) 0 ;
7807 int arg2 = (int) 0 ;
7808 int arg3 = (int) 0 ;
7809 int arg4 = (int) 0 ;
7810 int arg5 = (int) 0 ;
7811 void *argp1 = 0 ;
7812 int res1 = 0 ;
7813 int val2 ;
7814 int ecode2 = 0 ;
7815 int val3 ;
7816 int ecode3 = 0 ;
7817 int val4 ;
7818 int ecode4 = 0 ;
7819 int val5 ;
7820 int ecode5 = 0 ;
7821 PyObject * obj0 = 0 ;
7822 PyObject * obj1 = 0 ;
7823 PyObject * obj2 = 0 ;
7824 PyObject * obj3 = 0 ;
7825 PyObject * obj4 = 0 ;
7826 char * kwnames[] = {
7827 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7828 };
7829
7830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7832 if (!SWIG_IsOK(res1)) {
7833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7834 }
7835 arg1 = reinterpret_cast< wxRect * >(argp1);
7836 if (obj1) {
7837 ecode2 = SWIG_AsVal_int(obj1, &val2);
7838 if (!SWIG_IsOK(ecode2)) {
7839 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7840 }
7841 arg2 = static_cast< int >(val2);
7842 }
7843 if (obj2) {
7844 ecode3 = SWIG_AsVal_int(obj2, &val3);
7845 if (!SWIG_IsOK(ecode3)) {
7846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7847 }
7848 arg3 = static_cast< int >(val3);
7849 }
7850 if (obj3) {
7851 ecode4 = SWIG_AsVal_int(obj3, &val4);
7852 if (!SWIG_IsOK(ecode4)) {
7853 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7854 }
7855 arg4 = static_cast< int >(val4);
7856 }
7857 if (obj4) {
7858 ecode5 = SWIG_AsVal_int(obj4, &val5);
7859 if (!SWIG_IsOK(ecode5)) {
7860 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7861 }
7862 arg5 = static_cast< int >(val5);
7863 }
7864 {
7865 PyThreadState* __tstate = wxPyBeginAllowThreads();
7866 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7867 wxPyEndAllowThreads(__tstate);
7868 if (PyErr_Occurred()) SWIG_fail;
7869 }
7870 resultobj = SWIG_Py_Void();
7871 return resultobj;
7872 fail:
7873 return NULL;
7874 }
7875
7876
7877 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7878 PyObject *resultobj = 0;
7879 wxRect *arg1 = (wxRect *) 0 ;
7880 PyObject *result = 0 ;
7881 void *argp1 = 0 ;
7882 int res1 = 0 ;
7883 PyObject *swig_obj[1] ;
7884
7885 if (!args) SWIG_fail;
7886 swig_obj[0] = args;
7887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7888 if (!SWIG_IsOK(res1)) {
7889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7890 }
7891 arg1 = reinterpret_cast< wxRect * >(argp1);
7892 {
7893 PyThreadState* __tstate = wxPyBeginAllowThreads();
7894 result = (PyObject *)wxRect_Get(arg1);
7895 wxPyEndAllowThreads(__tstate);
7896 if (PyErr_Occurred()) SWIG_fail;
7897 }
7898 resultobj = result;
7899 return resultobj;
7900 fail:
7901 return NULL;
7902 }
7903
7904
7905 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7906 PyObject *obj;
7907 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7908 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7909 return SWIG_Py_Void();
7910 }
7911
7912 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7913 return SWIG_Python_InitShadowInstance(args);
7914 }
7915
7916 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7917 PyObject *resultobj = 0;
7918 wxRect *arg1 = (wxRect *) 0 ;
7919 wxRect *arg2 = (wxRect *) 0 ;
7920 PyObject *result = 0 ;
7921 void *argp1 = 0 ;
7922 int res1 = 0 ;
7923 void *argp2 = 0 ;
7924 int res2 = 0 ;
7925 PyObject * obj0 = 0 ;
7926 PyObject * obj1 = 0 ;
7927 char * kwnames[] = {
7928 (char *) "r1",(char *) "r2", NULL
7929 };
7930
7931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7933 if (!SWIG_IsOK(res1)) {
7934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7935 }
7936 arg1 = reinterpret_cast< wxRect * >(argp1);
7937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7938 if (!SWIG_IsOK(res2)) {
7939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7940 }
7941 arg2 = reinterpret_cast< wxRect * >(argp2);
7942 {
7943 if (!wxPyCheckForApp()) SWIG_fail;
7944 PyThreadState* __tstate = wxPyBeginAllowThreads();
7945 result = (PyObject *)wxIntersectRect(arg1,arg2);
7946 wxPyEndAllowThreads(__tstate);
7947 if (PyErr_Occurred()) SWIG_fail;
7948 }
7949 resultobj = result;
7950 return resultobj;
7951 fail:
7952 return NULL;
7953 }
7954
7955
7956 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7957 PyObject *resultobj = 0;
7958 double arg1 = (double) 0.0 ;
7959 double arg2 = (double) 0.0 ;
7960 wxPoint2D *result = 0 ;
7961 double val1 ;
7962 int ecode1 = 0 ;
7963 double val2 ;
7964 int ecode2 = 0 ;
7965 PyObject * obj0 = 0 ;
7966 PyObject * obj1 = 0 ;
7967 char * kwnames[] = {
7968 (char *) "x",(char *) "y", NULL
7969 };
7970
7971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
7972 if (obj0) {
7973 ecode1 = SWIG_AsVal_double(obj0, &val1);
7974 if (!SWIG_IsOK(ecode1)) {
7975 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
7976 }
7977 arg1 = static_cast< double >(val1);
7978 }
7979 if (obj1) {
7980 ecode2 = SWIG_AsVal_double(obj1, &val2);
7981 if (!SWIG_IsOK(ecode2)) {
7982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
7983 }
7984 arg2 = static_cast< double >(val2);
7985 }
7986 {
7987 PyThreadState* __tstate = wxPyBeginAllowThreads();
7988 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
7989 wxPyEndAllowThreads(__tstate);
7990 if (PyErr_Occurred()) SWIG_fail;
7991 }
7992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
7993 return resultobj;
7994 fail:
7995 return NULL;
7996 }
7997
7998
7999 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8000 PyObject *resultobj = 0;
8001 wxPoint2D *arg1 = 0 ;
8002 wxPoint2D *result = 0 ;
8003 wxPoint2D temp1 ;
8004 PyObject * obj0 = 0 ;
8005 char * kwnames[] = {
8006 (char *) "pt", NULL
8007 };
8008
8009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8010 {
8011 arg1 = &temp1;
8012 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8013 }
8014 {
8015 PyThreadState* __tstate = wxPyBeginAllowThreads();
8016 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8017 wxPyEndAllowThreads(__tstate);
8018 if (PyErr_Occurred()) SWIG_fail;
8019 }
8020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8021 return resultobj;
8022 fail:
8023 return NULL;
8024 }
8025
8026
8027 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8028 PyObject *resultobj = 0;
8029 wxPoint *arg1 = 0 ;
8030 wxPoint2D *result = 0 ;
8031 wxPoint temp1 ;
8032 PyObject * obj0 = 0 ;
8033 char * kwnames[] = {
8034 (char *) "pt", NULL
8035 };
8036
8037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8038 {
8039 arg1 = &temp1;
8040 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8041 }
8042 {
8043 PyThreadState* __tstate = wxPyBeginAllowThreads();
8044 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8045 wxPyEndAllowThreads(__tstate);
8046 if (PyErr_Occurred()) SWIG_fail;
8047 }
8048 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8049 return resultobj;
8050 fail:
8051 return NULL;
8052 }
8053
8054
8055 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8056 PyObject *resultobj = 0;
8057 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8058 int *arg2 = (int *) 0 ;
8059 int *arg3 = (int *) 0 ;
8060 void *argp1 = 0 ;
8061 int res1 = 0 ;
8062 int temp2 ;
8063 int res2 = SWIG_TMPOBJ ;
8064 int temp3 ;
8065 int res3 = SWIG_TMPOBJ ;
8066 PyObject *swig_obj[1] ;
8067
8068 arg2 = &temp2;
8069 arg3 = &temp3;
8070 if (!args) SWIG_fail;
8071 swig_obj[0] = args;
8072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8073 if (!SWIG_IsOK(res1)) {
8074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8075 }
8076 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8077 {
8078 PyThreadState* __tstate = wxPyBeginAllowThreads();
8079 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8080 wxPyEndAllowThreads(__tstate);
8081 if (PyErr_Occurred()) SWIG_fail;
8082 }
8083 resultobj = SWIG_Py_Void();
8084 if (SWIG_IsTmpObj(res2)) {
8085 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8086 } else {
8087 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8088 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8089 }
8090 if (SWIG_IsTmpObj(res3)) {
8091 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8092 } else {
8093 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8094 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8095 }
8096 return resultobj;
8097 fail:
8098 return NULL;
8099 }
8100
8101
8102 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8103 PyObject *resultobj = 0;
8104 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8105 int *arg2 = (int *) 0 ;
8106 int *arg3 = (int *) 0 ;
8107 void *argp1 = 0 ;
8108 int res1 = 0 ;
8109 int temp2 ;
8110 int res2 = SWIG_TMPOBJ ;
8111 int temp3 ;
8112 int res3 = SWIG_TMPOBJ ;
8113 PyObject *swig_obj[1] ;
8114
8115 arg2 = &temp2;
8116 arg3 = &temp3;
8117 if (!args) SWIG_fail;
8118 swig_obj[0] = args;
8119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8120 if (!SWIG_IsOK(res1)) {
8121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8122 }
8123 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8124 {
8125 PyThreadState* __tstate = wxPyBeginAllowThreads();
8126 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8127 wxPyEndAllowThreads(__tstate);
8128 if (PyErr_Occurred()) SWIG_fail;
8129 }
8130 resultobj = SWIG_Py_Void();
8131 if (SWIG_IsTmpObj(res2)) {
8132 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8133 } else {
8134 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8135 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8136 }
8137 if (SWIG_IsTmpObj(res3)) {
8138 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8139 } else {
8140 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8141 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8142 }
8143 return resultobj;
8144 fail:
8145 return NULL;
8146 }
8147
8148
8149 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8150 PyObject *resultobj = 0;
8151 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8152 double result;
8153 void *argp1 = 0 ;
8154 int res1 = 0 ;
8155 PyObject *swig_obj[1] ;
8156
8157 if (!args) SWIG_fail;
8158 swig_obj[0] = args;
8159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8160 if (!SWIG_IsOK(res1)) {
8161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8162 }
8163 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8164 {
8165 PyThreadState* __tstate = wxPyBeginAllowThreads();
8166 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8167 wxPyEndAllowThreads(__tstate);
8168 if (PyErr_Occurred()) SWIG_fail;
8169 }
8170 resultobj = SWIG_From_double(static_cast< double >(result));
8171 return resultobj;
8172 fail:
8173 return NULL;
8174 }
8175
8176
8177 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8178 PyObject *resultobj = 0;
8179 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8180 double result;
8181 void *argp1 = 0 ;
8182 int res1 = 0 ;
8183 PyObject *swig_obj[1] ;
8184
8185 if (!args) SWIG_fail;
8186 swig_obj[0] = args;
8187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8188 if (!SWIG_IsOK(res1)) {
8189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8190 }
8191 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8192 {
8193 PyThreadState* __tstate = wxPyBeginAllowThreads();
8194 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8195 wxPyEndAllowThreads(__tstate);
8196 if (PyErr_Occurred()) SWIG_fail;
8197 }
8198 resultobj = SWIG_From_double(static_cast< double >(result));
8199 return resultobj;
8200 fail:
8201 return NULL;
8202 }
8203
8204
8205 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8206 PyObject *resultobj = 0;
8207 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8208 double arg2 ;
8209 void *argp1 = 0 ;
8210 int res1 = 0 ;
8211 double val2 ;
8212 int ecode2 = 0 ;
8213 PyObject * obj0 = 0 ;
8214 PyObject * obj1 = 0 ;
8215 char * kwnames[] = {
8216 (char *) "self",(char *) "length", NULL
8217 };
8218
8219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8221 if (!SWIG_IsOK(res1)) {
8222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8223 }
8224 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8225 ecode2 = SWIG_AsVal_double(obj1, &val2);
8226 if (!SWIG_IsOK(ecode2)) {
8227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8228 }
8229 arg2 = static_cast< double >(val2);
8230 {
8231 PyThreadState* __tstate = wxPyBeginAllowThreads();
8232 (arg1)->SetVectorLength(arg2);
8233 wxPyEndAllowThreads(__tstate);
8234 if (PyErr_Occurred()) SWIG_fail;
8235 }
8236 resultobj = SWIG_Py_Void();
8237 return resultobj;
8238 fail:
8239 return NULL;
8240 }
8241
8242
8243 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8244 PyObject *resultobj = 0;
8245 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8246 double arg2 ;
8247 void *argp1 = 0 ;
8248 int res1 = 0 ;
8249 double val2 ;
8250 int ecode2 = 0 ;
8251 PyObject * obj0 = 0 ;
8252 PyObject * obj1 = 0 ;
8253 char * kwnames[] = {
8254 (char *) "self",(char *) "degrees", NULL
8255 };
8256
8257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8259 if (!SWIG_IsOK(res1)) {
8260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8261 }
8262 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8263 ecode2 = SWIG_AsVal_double(obj1, &val2);
8264 if (!SWIG_IsOK(ecode2)) {
8265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8266 }
8267 arg2 = static_cast< double >(val2);
8268 {
8269 PyThreadState* __tstate = wxPyBeginAllowThreads();
8270 (arg1)->SetVectorAngle(arg2);
8271 wxPyEndAllowThreads(__tstate);
8272 if (PyErr_Occurred()) SWIG_fail;
8273 }
8274 resultobj = SWIG_Py_Void();
8275 return resultobj;
8276 fail:
8277 return NULL;
8278 }
8279
8280
8281 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8282 PyObject *resultobj = 0;
8283 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8284 wxPoint2D *arg2 = 0 ;
8285 double result;
8286 void *argp1 = 0 ;
8287 int res1 = 0 ;
8288 wxPoint2D temp2 ;
8289 PyObject * obj0 = 0 ;
8290 PyObject * obj1 = 0 ;
8291 char * kwnames[] = {
8292 (char *) "self",(char *) "pt", NULL
8293 };
8294
8295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8297 if (!SWIG_IsOK(res1)) {
8298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8299 }
8300 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8301 {
8302 arg2 = &temp2;
8303 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8304 }
8305 {
8306 PyThreadState* __tstate = wxPyBeginAllowThreads();
8307 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8308 wxPyEndAllowThreads(__tstate);
8309 if (PyErr_Occurred()) SWIG_fail;
8310 }
8311 resultobj = SWIG_From_double(static_cast< double >(result));
8312 return resultobj;
8313 fail:
8314 return NULL;
8315 }
8316
8317
8318 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8319 PyObject *resultobj = 0;
8320 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8321 wxPoint2D *arg2 = 0 ;
8322 double result;
8323 void *argp1 = 0 ;
8324 int res1 = 0 ;
8325 wxPoint2D temp2 ;
8326 PyObject * obj0 = 0 ;
8327 PyObject * obj1 = 0 ;
8328 char * kwnames[] = {
8329 (char *) "self",(char *) "pt", NULL
8330 };
8331
8332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8334 if (!SWIG_IsOK(res1)) {
8335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8336 }
8337 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8338 {
8339 arg2 = &temp2;
8340 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8341 }
8342 {
8343 PyThreadState* __tstate = wxPyBeginAllowThreads();
8344 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8345 wxPyEndAllowThreads(__tstate);
8346 if (PyErr_Occurred()) SWIG_fail;
8347 }
8348 resultobj = SWIG_From_double(static_cast< double >(result));
8349 return resultobj;
8350 fail:
8351 return NULL;
8352 }
8353
8354
8355 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8356 PyObject *resultobj = 0;
8357 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8358 wxPoint2D *arg2 = 0 ;
8359 double result;
8360 void *argp1 = 0 ;
8361 int res1 = 0 ;
8362 wxPoint2D temp2 ;
8363 PyObject * obj0 = 0 ;
8364 PyObject * obj1 = 0 ;
8365 char * kwnames[] = {
8366 (char *) "self",(char *) "vec", NULL
8367 };
8368
8369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8371 if (!SWIG_IsOK(res1)) {
8372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8373 }
8374 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8375 {
8376 arg2 = &temp2;
8377 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8378 }
8379 {
8380 PyThreadState* __tstate = wxPyBeginAllowThreads();
8381 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8382 wxPyEndAllowThreads(__tstate);
8383 if (PyErr_Occurred()) SWIG_fail;
8384 }
8385 resultobj = SWIG_From_double(static_cast< double >(result));
8386 return resultobj;
8387 fail:
8388 return NULL;
8389 }
8390
8391
8392 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8393 PyObject *resultobj = 0;
8394 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8395 wxPoint2D *arg2 = 0 ;
8396 double result;
8397 void *argp1 = 0 ;
8398 int res1 = 0 ;
8399 wxPoint2D temp2 ;
8400 PyObject * obj0 = 0 ;
8401 PyObject * obj1 = 0 ;
8402 char * kwnames[] = {
8403 (char *) "self",(char *) "vec", NULL
8404 };
8405
8406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8408 if (!SWIG_IsOK(res1)) {
8409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8410 }
8411 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8412 {
8413 arg2 = &temp2;
8414 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8415 }
8416 {
8417 PyThreadState* __tstate = wxPyBeginAllowThreads();
8418 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8419 wxPyEndAllowThreads(__tstate);
8420 if (PyErr_Occurred()) SWIG_fail;
8421 }
8422 resultobj = SWIG_From_double(static_cast< double >(result));
8423 return resultobj;
8424 fail:
8425 return NULL;
8426 }
8427
8428
8429 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8430 PyObject *resultobj = 0;
8431 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8432 wxPoint2D result;
8433 void *argp1 = 0 ;
8434 int res1 = 0 ;
8435 PyObject *swig_obj[1] ;
8436
8437 if (!args) SWIG_fail;
8438 swig_obj[0] = args;
8439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8440 if (!SWIG_IsOK(res1)) {
8441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8442 }
8443 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8444 {
8445 PyThreadState* __tstate = wxPyBeginAllowThreads();
8446 result = (arg1)->operator -();
8447 wxPyEndAllowThreads(__tstate);
8448 if (PyErr_Occurred()) SWIG_fail;
8449 }
8450 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8451 return resultobj;
8452 fail:
8453 return NULL;
8454 }
8455
8456
8457 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8458 PyObject *resultobj = 0;
8459 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8460 wxPoint2D *arg2 = 0 ;
8461 wxPoint2D *result = 0 ;
8462 void *argp1 = 0 ;
8463 int res1 = 0 ;
8464 wxPoint2D temp2 ;
8465 PyObject * obj0 = 0 ;
8466 PyObject * obj1 = 0 ;
8467 char * kwnames[] = {
8468 (char *) "self",(char *) "pt", NULL
8469 };
8470
8471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8473 if (!SWIG_IsOK(res1)) {
8474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8475 }
8476 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8477 {
8478 arg2 = &temp2;
8479 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8480 }
8481 {
8482 PyThreadState* __tstate = wxPyBeginAllowThreads();
8483 {
8484 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8485 result = (wxPoint2D *) &_result_ref;
8486 }
8487 wxPyEndAllowThreads(__tstate);
8488 if (PyErr_Occurred()) SWIG_fail;
8489 }
8490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8491 return resultobj;
8492 fail:
8493 return NULL;
8494 }
8495
8496
8497 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8498 PyObject *resultobj = 0;
8499 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8500 wxPoint2D *arg2 = 0 ;
8501 wxPoint2D *result = 0 ;
8502 void *argp1 = 0 ;
8503 int res1 = 0 ;
8504 wxPoint2D temp2 ;
8505 PyObject * obj0 = 0 ;
8506 PyObject * obj1 = 0 ;
8507 char * kwnames[] = {
8508 (char *) "self",(char *) "pt", NULL
8509 };
8510
8511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8513 if (!SWIG_IsOK(res1)) {
8514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8515 }
8516 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8517 {
8518 arg2 = &temp2;
8519 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8520 }
8521 {
8522 PyThreadState* __tstate = wxPyBeginAllowThreads();
8523 {
8524 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8525 result = (wxPoint2D *) &_result_ref;
8526 }
8527 wxPyEndAllowThreads(__tstate);
8528 if (PyErr_Occurred()) SWIG_fail;
8529 }
8530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8531 return resultobj;
8532 fail:
8533 return NULL;
8534 }
8535
8536
8537 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8538 PyObject *resultobj = 0;
8539 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8540 wxPoint2D *arg2 = 0 ;
8541 wxPoint2D *result = 0 ;
8542 void *argp1 = 0 ;
8543 int res1 = 0 ;
8544 wxPoint2D temp2 ;
8545 PyObject * obj0 = 0 ;
8546 PyObject * obj1 = 0 ;
8547 char * kwnames[] = {
8548 (char *) "self",(char *) "pt", NULL
8549 };
8550
8551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8553 if (!SWIG_IsOK(res1)) {
8554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8555 }
8556 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8557 {
8558 arg2 = &temp2;
8559 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8560 }
8561 {
8562 PyThreadState* __tstate = wxPyBeginAllowThreads();
8563 {
8564 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8565 result = (wxPoint2D *) &_result_ref;
8566 }
8567 wxPyEndAllowThreads(__tstate);
8568 if (PyErr_Occurred()) SWIG_fail;
8569 }
8570 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8571 return resultobj;
8572 fail:
8573 return NULL;
8574 }
8575
8576
8577 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8578 PyObject *resultobj = 0;
8579 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8580 wxPoint2D *arg2 = 0 ;
8581 wxPoint2D *result = 0 ;
8582 void *argp1 = 0 ;
8583 int res1 = 0 ;
8584 wxPoint2D temp2 ;
8585 PyObject * obj0 = 0 ;
8586 PyObject * obj1 = 0 ;
8587 char * kwnames[] = {
8588 (char *) "self",(char *) "pt", NULL
8589 };
8590
8591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8593 if (!SWIG_IsOK(res1)) {
8594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8595 }
8596 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8597 {
8598 arg2 = &temp2;
8599 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8600 }
8601 {
8602 PyThreadState* __tstate = wxPyBeginAllowThreads();
8603 {
8604 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8605 result = (wxPoint2D *) &_result_ref;
8606 }
8607 wxPyEndAllowThreads(__tstate);
8608 if (PyErr_Occurred()) SWIG_fail;
8609 }
8610 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8611 return resultobj;
8612 fail:
8613 return NULL;
8614 }
8615
8616
8617 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8618 PyObject *resultobj = 0;
8619 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8620 PyObject *arg2 = (PyObject *) 0 ;
8621 bool result;
8622 void *argp1 = 0 ;
8623 int res1 = 0 ;
8624 PyObject * obj0 = 0 ;
8625 PyObject * obj1 = 0 ;
8626 char * kwnames[] = {
8627 (char *) "self",(char *) "other", NULL
8628 };
8629
8630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8632 if (!SWIG_IsOK(res1)) {
8633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8634 }
8635 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8636 arg2 = obj1;
8637 {
8638 result = (bool)wxPoint2D___eq__(arg1,arg2);
8639 if (PyErr_Occurred()) SWIG_fail;
8640 }
8641 {
8642 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8643 }
8644 return resultobj;
8645 fail:
8646 return NULL;
8647 }
8648
8649
8650 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8651 PyObject *resultobj = 0;
8652 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8653 PyObject *arg2 = (PyObject *) 0 ;
8654 bool result;
8655 void *argp1 = 0 ;
8656 int res1 = 0 ;
8657 PyObject * obj0 = 0 ;
8658 PyObject * obj1 = 0 ;
8659 char * kwnames[] = {
8660 (char *) "self",(char *) "other", NULL
8661 };
8662
8663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8665 if (!SWIG_IsOK(res1)) {
8666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8667 }
8668 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8669 arg2 = obj1;
8670 {
8671 result = (bool)wxPoint2D___ne__(arg1,arg2);
8672 if (PyErr_Occurred()) SWIG_fail;
8673 }
8674 {
8675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8676 }
8677 return resultobj;
8678 fail:
8679 return NULL;
8680 }
8681
8682
8683 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8684 PyObject *resultobj = 0;
8685 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8686 double arg2 ;
8687 void *argp1 = 0 ;
8688 int res1 = 0 ;
8689 double val2 ;
8690 int ecode2 = 0 ;
8691 PyObject *swig_obj[2] ;
8692
8693 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8695 if (!SWIG_IsOK(res1)) {
8696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8697 }
8698 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8699 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8700 if (!SWIG_IsOK(ecode2)) {
8701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8702 }
8703 arg2 = static_cast< double >(val2);
8704 if (arg1) (arg1)->m_x = arg2;
8705
8706 resultobj = SWIG_Py_Void();
8707 return resultobj;
8708 fail:
8709 return NULL;
8710 }
8711
8712
8713 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8714 PyObject *resultobj = 0;
8715 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8716 double result;
8717 void *argp1 = 0 ;
8718 int res1 = 0 ;
8719 PyObject *swig_obj[1] ;
8720
8721 if (!args) SWIG_fail;
8722 swig_obj[0] = args;
8723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8724 if (!SWIG_IsOK(res1)) {
8725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8726 }
8727 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8728 result = (double) ((arg1)->m_x);
8729 resultobj = SWIG_From_double(static_cast< double >(result));
8730 return resultobj;
8731 fail:
8732 return NULL;
8733 }
8734
8735
8736 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8737 PyObject *resultobj = 0;
8738 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8739 double arg2 ;
8740 void *argp1 = 0 ;
8741 int res1 = 0 ;
8742 double val2 ;
8743 int ecode2 = 0 ;
8744 PyObject *swig_obj[2] ;
8745
8746 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8748 if (!SWIG_IsOK(res1)) {
8749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8750 }
8751 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8752 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8753 if (!SWIG_IsOK(ecode2)) {
8754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8755 }
8756 arg2 = static_cast< double >(val2);
8757 if (arg1) (arg1)->m_y = arg2;
8758
8759 resultobj = SWIG_Py_Void();
8760 return resultobj;
8761 fail:
8762 return NULL;
8763 }
8764
8765
8766 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8767 PyObject *resultobj = 0;
8768 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8769 double result;
8770 void *argp1 = 0 ;
8771 int res1 = 0 ;
8772 PyObject *swig_obj[1] ;
8773
8774 if (!args) SWIG_fail;
8775 swig_obj[0] = args;
8776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8777 if (!SWIG_IsOK(res1)) {
8778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8779 }
8780 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8781 result = (double) ((arg1)->m_y);
8782 resultobj = SWIG_From_double(static_cast< double >(result));
8783 return resultobj;
8784 fail:
8785 return NULL;
8786 }
8787
8788
8789 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8790 PyObject *resultobj = 0;
8791 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8792 double arg2 = (double) 0 ;
8793 double arg3 = (double) 0 ;
8794 void *argp1 = 0 ;
8795 int res1 = 0 ;
8796 double val2 ;
8797 int ecode2 = 0 ;
8798 double val3 ;
8799 int ecode3 = 0 ;
8800 PyObject * obj0 = 0 ;
8801 PyObject * obj1 = 0 ;
8802 PyObject * obj2 = 0 ;
8803 char * kwnames[] = {
8804 (char *) "self",(char *) "x",(char *) "y", NULL
8805 };
8806
8807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8809 if (!SWIG_IsOK(res1)) {
8810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8811 }
8812 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8813 if (obj1) {
8814 ecode2 = SWIG_AsVal_double(obj1, &val2);
8815 if (!SWIG_IsOK(ecode2)) {
8816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8817 }
8818 arg2 = static_cast< double >(val2);
8819 }
8820 if (obj2) {
8821 ecode3 = SWIG_AsVal_double(obj2, &val3);
8822 if (!SWIG_IsOK(ecode3)) {
8823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8824 }
8825 arg3 = static_cast< double >(val3);
8826 }
8827 {
8828 PyThreadState* __tstate = wxPyBeginAllowThreads();
8829 wxPoint2D_Set(arg1,arg2,arg3);
8830 wxPyEndAllowThreads(__tstate);
8831 if (PyErr_Occurred()) SWIG_fail;
8832 }
8833 resultobj = SWIG_Py_Void();
8834 return resultobj;
8835 fail:
8836 return NULL;
8837 }
8838
8839
8840 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8841 PyObject *resultobj = 0;
8842 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8843 PyObject *result = 0 ;
8844 void *argp1 = 0 ;
8845 int res1 = 0 ;
8846 PyObject *swig_obj[1] ;
8847
8848 if (!args) SWIG_fail;
8849 swig_obj[0] = args;
8850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8851 if (!SWIG_IsOK(res1)) {
8852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8853 }
8854 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8855 {
8856 PyThreadState* __tstate = wxPyBeginAllowThreads();
8857 result = (PyObject *)wxPoint2D_Get(arg1);
8858 wxPyEndAllowThreads(__tstate);
8859 if (PyErr_Occurred()) SWIG_fail;
8860 }
8861 resultobj = result;
8862 return resultobj;
8863 fail:
8864 return NULL;
8865 }
8866
8867
8868 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8869 PyObject *obj;
8870 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8871 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8872 return SWIG_Py_Void();
8873 }
8874
8875 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8876 return SWIG_Python_InitShadowInstance(args);
8877 }
8878
8879 SWIGINTERN int DefaultPosition_set(PyObject *) {
8880 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8881 return 1;
8882 }
8883
8884
8885 SWIGINTERN PyObject *DefaultPosition_get(void) {
8886 PyObject *pyobj = 0;
8887
8888 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8889 return pyobj;
8890 }
8891
8892
8893 SWIGINTERN int DefaultSize_set(PyObject *) {
8894 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8895 return 1;
8896 }
8897
8898
8899 SWIGINTERN PyObject *DefaultSize_get(void) {
8900 PyObject *pyobj = 0;
8901
8902 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8903 return pyobj;
8904 }
8905
8906
8907 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8908 PyObject *resultobj = 0;
8909 PyObject *arg1 = (PyObject *) 0 ;
8910 wxPyInputStream *result = 0 ;
8911 PyObject * obj0 = 0 ;
8912 char * kwnames[] = {
8913 (char *) "p", NULL
8914 };
8915
8916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8917 arg1 = obj0;
8918 {
8919 PyThreadState* __tstate = wxPyBeginAllowThreads();
8920 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8921 wxPyEndAllowThreads(__tstate);
8922 if (PyErr_Occurred()) SWIG_fail;
8923 }
8924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8925 return resultobj;
8926 fail:
8927 return NULL;
8928 }
8929
8930
8931 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8932 PyObject *resultobj = 0;
8933 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8934 void *argp1 = 0 ;
8935 int res1 = 0 ;
8936 PyObject *swig_obj[1] ;
8937
8938 if (!args) SWIG_fail;
8939 swig_obj[0] = args;
8940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8941 if (!SWIG_IsOK(res1)) {
8942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8943 }
8944 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8945 {
8946 PyThreadState* __tstate = wxPyBeginAllowThreads();
8947 delete arg1;
8948
8949 wxPyEndAllowThreads(__tstate);
8950 if (PyErr_Occurred()) SWIG_fail;
8951 }
8952 resultobj = SWIG_Py_Void();
8953 return resultobj;
8954 fail:
8955 return NULL;
8956 }
8957
8958
8959 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8960 PyObject *resultobj = 0;
8961 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8962 void *argp1 = 0 ;
8963 int res1 = 0 ;
8964 PyObject *swig_obj[1] ;
8965
8966 if (!args) SWIG_fail;
8967 swig_obj[0] = args;
8968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8969 if (!SWIG_IsOK(res1)) {
8970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8971 }
8972 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
8973 {
8974 PyThreadState* __tstate = wxPyBeginAllowThreads();
8975 (arg1)->close();
8976 wxPyEndAllowThreads(__tstate);
8977 if (PyErr_Occurred()) SWIG_fail;
8978 }
8979 resultobj = SWIG_Py_Void();
8980 return resultobj;
8981 fail:
8982 return NULL;
8983 }
8984
8985
8986 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8987 PyObject *resultobj = 0;
8988 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8989 void *argp1 = 0 ;
8990 int res1 = 0 ;
8991 PyObject *swig_obj[1] ;
8992
8993 if (!args) SWIG_fail;
8994 swig_obj[0] = args;
8995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
8996 if (!SWIG_IsOK(res1)) {
8997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
8998 }
8999 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9000 {
9001 PyThreadState* __tstate = wxPyBeginAllowThreads();
9002 (arg1)->flush();
9003 wxPyEndAllowThreads(__tstate);
9004 if (PyErr_Occurred()) SWIG_fail;
9005 }
9006 resultobj = SWIG_Py_Void();
9007 return resultobj;
9008 fail:
9009 return NULL;
9010 }
9011
9012
9013 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9014 PyObject *resultobj = 0;
9015 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9016 bool result;
9017 void *argp1 = 0 ;
9018 int res1 = 0 ;
9019 PyObject *swig_obj[1] ;
9020
9021 if (!args) SWIG_fail;
9022 swig_obj[0] = args;
9023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9024 if (!SWIG_IsOK(res1)) {
9025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9026 }
9027 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9028 {
9029 PyThreadState* __tstate = wxPyBeginAllowThreads();
9030 result = (bool)(arg1)->eof();
9031 wxPyEndAllowThreads(__tstate);
9032 if (PyErr_Occurred()) SWIG_fail;
9033 }
9034 {
9035 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9036 }
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj = 0;
9045 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9046 int arg2 = (int) -1 ;
9047 PyObject *result = 0 ;
9048 void *argp1 = 0 ;
9049 int res1 = 0 ;
9050 int val2 ;
9051 int ecode2 = 0 ;
9052 PyObject * obj0 = 0 ;
9053 PyObject * obj1 = 0 ;
9054 char * kwnames[] = {
9055 (char *) "self",(char *) "size", NULL
9056 };
9057
9058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9060 if (!SWIG_IsOK(res1)) {
9061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9062 }
9063 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9064 if (obj1) {
9065 ecode2 = SWIG_AsVal_int(obj1, &val2);
9066 if (!SWIG_IsOK(ecode2)) {
9067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9068 }
9069 arg2 = static_cast< int >(val2);
9070 }
9071 {
9072 PyThreadState* __tstate = wxPyBeginAllowThreads();
9073 result = (PyObject *)(arg1)->read(arg2);
9074 wxPyEndAllowThreads(__tstate);
9075 if (PyErr_Occurred()) SWIG_fail;
9076 }
9077 resultobj = result;
9078 return resultobj;
9079 fail:
9080 return NULL;
9081 }
9082
9083
9084 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9085 PyObject *resultobj = 0;
9086 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9087 int arg2 = (int) -1 ;
9088 PyObject *result = 0 ;
9089 void *argp1 = 0 ;
9090 int res1 = 0 ;
9091 int val2 ;
9092 int ecode2 = 0 ;
9093 PyObject * obj0 = 0 ;
9094 PyObject * obj1 = 0 ;
9095 char * kwnames[] = {
9096 (char *) "self",(char *) "size", NULL
9097 };
9098
9099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9101 if (!SWIG_IsOK(res1)) {
9102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9103 }
9104 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9105 if (obj1) {
9106 ecode2 = SWIG_AsVal_int(obj1, &val2);
9107 if (!SWIG_IsOK(ecode2)) {
9108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9109 }
9110 arg2 = static_cast< int >(val2);
9111 }
9112 {
9113 PyThreadState* __tstate = wxPyBeginAllowThreads();
9114 result = (PyObject *)(arg1)->readline(arg2);
9115 wxPyEndAllowThreads(__tstate);
9116 if (PyErr_Occurred()) SWIG_fail;
9117 }
9118 resultobj = result;
9119 return resultobj;
9120 fail:
9121 return NULL;
9122 }
9123
9124
9125 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9126 PyObject *resultobj = 0;
9127 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9128 int arg2 = (int) -1 ;
9129 PyObject *result = 0 ;
9130 void *argp1 = 0 ;
9131 int res1 = 0 ;
9132 int val2 ;
9133 int ecode2 = 0 ;
9134 PyObject * obj0 = 0 ;
9135 PyObject * obj1 = 0 ;
9136 char * kwnames[] = {
9137 (char *) "self",(char *) "sizehint", NULL
9138 };
9139
9140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9142 if (!SWIG_IsOK(res1)) {
9143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9144 }
9145 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9146 if (obj1) {
9147 ecode2 = SWIG_AsVal_int(obj1, &val2);
9148 if (!SWIG_IsOK(ecode2)) {
9149 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9150 }
9151 arg2 = static_cast< int >(val2);
9152 }
9153 {
9154 PyThreadState* __tstate = wxPyBeginAllowThreads();
9155 result = (PyObject *)(arg1)->readlines(arg2);
9156 wxPyEndAllowThreads(__tstate);
9157 if (PyErr_Occurred()) SWIG_fail;
9158 }
9159 resultobj = result;
9160 return resultobj;
9161 fail:
9162 return NULL;
9163 }
9164
9165
9166 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9167 PyObject *resultobj = 0;
9168 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9169 int arg2 ;
9170 int arg3 = (int) 0 ;
9171 void *argp1 = 0 ;
9172 int res1 = 0 ;
9173 int val2 ;
9174 int ecode2 = 0 ;
9175 int val3 ;
9176 int ecode3 = 0 ;
9177 PyObject * obj0 = 0 ;
9178 PyObject * obj1 = 0 ;
9179 PyObject * obj2 = 0 ;
9180 char * kwnames[] = {
9181 (char *) "self",(char *) "offset",(char *) "whence", NULL
9182 };
9183
9184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9186 if (!SWIG_IsOK(res1)) {
9187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9188 }
9189 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9190 ecode2 = SWIG_AsVal_int(obj1, &val2);
9191 if (!SWIG_IsOK(ecode2)) {
9192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9193 }
9194 arg2 = static_cast< int >(val2);
9195 if (obj2) {
9196 ecode3 = SWIG_AsVal_int(obj2, &val3);
9197 if (!SWIG_IsOK(ecode3)) {
9198 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9199 }
9200 arg3 = static_cast< int >(val3);
9201 }
9202 {
9203 PyThreadState* __tstate = wxPyBeginAllowThreads();
9204 (arg1)->seek(arg2,arg3);
9205 wxPyEndAllowThreads(__tstate);
9206 if (PyErr_Occurred()) SWIG_fail;
9207 }
9208 resultobj = SWIG_Py_Void();
9209 return resultobj;
9210 fail:
9211 return NULL;
9212 }
9213
9214
9215 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9216 PyObject *resultobj = 0;
9217 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9218 int result;
9219 void *argp1 = 0 ;
9220 int res1 = 0 ;
9221 PyObject *swig_obj[1] ;
9222
9223 if (!args) SWIG_fail;
9224 swig_obj[0] = args;
9225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9226 if (!SWIG_IsOK(res1)) {
9227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9228 }
9229 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9230 {
9231 PyThreadState* __tstate = wxPyBeginAllowThreads();
9232 result = (int)(arg1)->tell();
9233 wxPyEndAllowThreads(__tstate);
9234 if (PyErr_Occurred()) SWIG_fail;
9235 }
9236 resultobj = SWIG_From_int(static_cast< int >(result));
9237 return resultobj;
9238 fail:
9239 return NULL;
9240 }
9241
9242
9243 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9244 PyObject *resultobj = 0;
9245 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9246 char result;
9247 void *argp1 = 0 ;
9248 int res1 = 0 ;
9249 PyObject *swig_obj[1] ;
9250
9251 if (!args) SWIG_fail;
9252 swig_obj[0] = args;
9253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9254 if (!SWIG_IsOK(res1)) {
9255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9256 }
9257 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9258 {
9259 PyThreadState* __tstate = wxPyBeginAllowThreads();
9260 result = (char)(arg1)->Peek();
9261 wxPyEndAllowThreads(__tstate);
9262 if (PyErr_Occurred()) SWIG_fail;
9263 }
9264 resultobj = SWIG_From_char(static_cast< char >(result));
9265 return resultobj;
9266 fail:
9267 return NULL;
9268 }
9269
9270
9271 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9272 PyObject *resultobj = 0;
9273 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9274 char result;
9275 void *argp1 = 0 ;
9276 int res1 = 0 ;
9277 PyObject *swig_obj[1] ;
9278
9279 if (!args) SWIG_fail;
9280 swig_obj[0] = args;
9281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9282 if (!SWIG_IsOK(res1)) {
9283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9284 }
9285 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9286 {
9287 PyThreadState* __tstate = wxPyBeginAllowThreads();
9288 result = (char)(arg1)->GetC();
9289 wxPyEndAllowThreads(__tstate);
9290 if (PyErr_Occurred()) SWIG_fail;
9291 }
9292 resultobj = SWIG_From_char(static_cast< char >(result));
9293 return resultobj;
9294 fail:
9295 return NULL;
9296 }
9297
9298
9299 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9300 PyObject *resultobj = 0;
9301 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9302 size_t result;
9303 void *argp1 = 0 ;
9304 int res1 = 0 ;
9305 PyObject *swig_obj[1] ;
9306
9307 if (!args) SWIG_fail;
9308 swig_obj[0] = args;
9309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9310 if (!SWIG_IsOK(res1)) {
9311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9312 }
9313 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9314 {
9315 PyThreadState* __tstate = wxPyBeginAllowThreads();
9316 result = (size_t)(arg1)->LastRead();
9317 wxPyEndAllowThreads(__tstate);
9318 if (PyErr_Occurred()) SWIG_fail;
9319 }
9320 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9321 return resultobj;
9322 fail:
9323 return NULL;
9324 }
9325
9326
9327 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9328 PyObject *resultobj = 0;
9329 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9330 bool result;
9331 void *argp1 = 0 ;
9332 int res1 = 0 ;
9333 PyObject *swig_obj[1] ;
9334
9335 if (!args) SWIG_fail;
9336 swig_obj[0] = args;
9337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9338 if (!SWIG_IsOK(res1)) {
9339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9340 }
9341 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9342 {
9343 PyThreadState* __tstate = wxPyBeginAllowThreads();
9344 result = (bool)(arg1)->CanRead();
9345 wxPyEndAllowThreads(__tstate);
9346 if (PyErr_Occurred()) SWIG_fail;
9347 }
9348 {
9349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9350 }
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *resultobj = 0;
9359 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9360 bool result;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject *swig_obj[1] ;
9364
9365 if (!args) SWIG_fail;
9366 swig_obj[0] = args;
9367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9368 if (!SWIG_IsOK(res1)) {
9369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9370 }
9371 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (bool)(arg1)->Eof();
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 {
9379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9380 }
9381 return resultobj;
9382 fail:
9383 return NULL;
9384 }
9385
9386
9387 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9388 PyObject *resultobj = 0;
9389 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9390 char arg2 ;
9391 bool result;
9392 void *argp1 = 0 ;
9393 int res1 = 0 ;
9394 char val2 ;
9395 int ecode2 = 0 ;
9396 PyObject * obj0 = 0 ;
9397 PyObject * obj1 = 0 ;
9398 char * kwnames[] = {
9399 (char *) "self",(char *) "c", NULL
9400 };
9401
9402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9404 if (!SWIG_IsOK(res1)) {
9405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9406 }
9407 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9408 ecode2 = SWIG_AsVal_char(obj1, &val2);
9409 if (!SWIG_IsOK(ecode2)) {
9410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9411 }
9412 arg2 = static_cast< char >(val2);
9413 {
9414 PyThreadState* __tstate = wxPyBeginAllowThreads();
9415 result = (bool)(arg1)->Ungetch(arg2);
9416 wxPyEndAllowThreads(__tstate);
9417 if (PyErr_Occurred()) SWIG_fail;
9418 }
9419 {
9420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9421 }
9422 return resultobj;
9423 fail:
9424 return NULL;
9425 }
9426
9427
9428 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9429 PyObject *resultobj = 0;
9430 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9431 long arg2 ;
9432 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9433 long result;
9434 void *argp1 = 0 ;
9435 int res1 = 0 ;
9436 long val2 ;
9437 int ecode2 = 0 ;
9438 int val3 ;
9439 int ecode3 = 0 ;
9440 PyObject * obj0 = 0 ;
9441 PyObject * obj1 = 0 ;
9442 PyObject * obj2 = 0 ;
9443 char * kwnames[] = {
9444 (char *) "self",(char *) "pos",(char *) "mode", NULL
9445 };
9446
9447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9449 if (!SWIG_IsOK(res1)) {
9450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9451 }
9452 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9453 ecode2 = SWIG_AsVal_long(obj1, &val2);
9454 if (!SWIG_IsOK(ecode2)) {
9455 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9456 }
9457 arg2 = static_cast< long >(val2);
9458 if (obj2) {
9459 ecode3 = SWIG_AsVal_int(obj2, &val3);
9460 if (!SWIG_IsOK(ecode3)) {
9461 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9462 }
9463 arg3 = static_cast< wxSeekMode >(val3);
9464 }
9465 {
9466 PyThreadState* __tstate = wxPyBeginAllowThreads();
9467 result = (long)(arg1)->SeekI(arg2,arg3);
9468 wxPyEndAllowThreads(__tstate);
9469 if (PyErr_Occurred()) SWIG_fail;
9470 }
9471 resultobj = SWIG_From_long(static_cast< long >(result));
9472 return resultobj;
9473 fail:
9474 return NULL;
9475 }
9476
9477
9478 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9479 PyObject *resultobj = 0;
9480 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9481 long result;
9482 void *argp1 = 0 ;
9483 int res1 = 0 ;
9484 PyObject *swig_obj[1] ;
9485
9486 if (!args) SWIG_fail;
9487 swig_obj[0] = args;
9488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9489 if (!SWIG_IsOK(res1)) {
9490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9491 }
9492 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9493 {
9494 PyThreadState* __tstate = wxPyBeginAllowThreads();
9495 result = (long)(arg1)->TellI();
9496 wxPyEndAllowThreads(__tstate);
9497 if (PyErr_Occurred()) SWIG_fail;
9498 }
9499 resultobj = SWIG_From_long(static_cast< long >(result));
9500 return resultobj;
9501 fail:
9502 return NULL;
9503 }
9504
9505
9506 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9507 PyObject *obj;
9508 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9509 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9510 return SWIG_Py_Void();
9511 }
9512
9513 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9514 return SWIG_Python_InitShadowInstance(args);
9515 }
9516
9517 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9518 PyObject *resultobj = 0;
9519 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9520 PyObject *arg2 = (PyObject *) 0 ;
9521 void *argp1 = 0 ;
9522 int res1 = 0 ;
9523 PyObject * obj0 = 0 ;
9524 PyObject * obj1 = 0 ;
9525 char * kwnames[] = {
9526 (char *) "self",(char *) "obj", NULL
9527 };
9528
9529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9531 if (!SWIG_IsOK(res1)) {
9532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9533 }
9534 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9535 arg2 = obj1;
9536 {
9537 PyThreadState* __tstate = wxPyBeginAllowThreads();
9538 wxOutputStream_write(arg1,arg2);
9539 wxPyEndAllowThreads(__tstate);
9540 if (PyErr_Occurred()) SWIG_fail;
9541 }
9542 resultobj = SWIG_Py_Void();
9543 return resultobj;
9544 fail:
9545 return NULL;
9546 }
9547
9548
9549 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9550 PyObject *resultobj = 0;
9551 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9552 size_t result;
9553 void *argp1 = 0 ;
9554 int res1 = 0 ;
9555 PyObject *swig_obj[1] ;
9556
9557 if (!args) SWIG_fail;
9558 swig_obj[0] = args;
9559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9560 if (!SWIG_IsOK(res1)) {
9561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9562 }
9563 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9564 {
9565 PyThreadState* __tstate = wxPyBeginAllowThreads();
9566 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9567 wxPyEndAllowThreads(__tstate);
9568 if (PyErr_Occurred()) SWIG_fail;
9569 }
9570 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9571 return resultobj;
9572 fail:
9573 return NULL;
9574 }
9575
9576
9577 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9578 PyObject *obj;
9579 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9580 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9581 return SWIG_Py_Void();
9582 }
9583
9584 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9585 PyObject *resultobj = 0;
9586 wxInputStream *arg1 = (wxInputStream *) 0 ;
9587 wxString *arg2 = 0 ;
9588 wxString *arg3 = 0 ;
9589 wxString *arg4 = 0 ;
9590 wxDateTime arg5 ;
9591 wxFSFile *result = 0 ;
9592 wxPyInputStream *temp1 ;
9593 bool temp2 = false ;
9594 bool temp3 = false ;
9595 bool temp4 = false ;
9596 void *argp5 ;
9597 int res5 = 0 ;
9598 PyObject * obj0 = 0 ;
9599 PyObject * obj1 = 0 ;
9600 PyObject * obj2 = 0 ;
9601 PyObject * obj3 = 0 ;
9602 PyObject * obj4 = 0 ;
9603 char * kwnames[] = {
9604 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9605 };
9606
9607 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9608 {
9609 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9610 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9611 } else {
9612 PyErr_Clear(); // clear the failure of the wxPyConvert above
9613 arg1 = wxPyCBInputStream_create(obj0, true);
9614 if (arg1 == NULL) {
9615 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9616 SWIG_fail;
9617 }
9618 }
9619 }
9620 {
9621 arg2 = wxString_in_helper(obj1);
9622 if (arg2 == NULL) SWIG_fail;
9623 temp2 = true;
9624 }
9625 {
9626 arg3 = wxString_in_helper(obj2);
9627 if (arg3 == NULL) SWIG_fail;
9628 temp3 = true;
9629 }
9630 {
9631 arg4 = wxString_in_helper(obj3);
9632 if (arg4 == NULL) SWIG_fail;
9633 temp4 = true;
9634 }
9635 {
9636 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9637 if (!SWIG_IsOK(res5)) {
9638 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9639 }
9640 if (!argp5) {
9641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9642 } else {
9643 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9644 arg5 = *temp;
9645 if (SWIG_IsNewObj(res5)) delete temp;
9646 }
9647 }
9648 {
9649 PyThreadState* __tstate = wxPyBeginAllowThreads();
9650 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9651 wxPyEndAllowThreads(__tstate);
9652 if (PyErr_Occurred()) SWIG_fail;
9653 }
9654 {
9655 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
9656 }
9657 {
9658 if (temp2)
9659 delete arg2;
9660 }
9661 {
9662 if (temp3)
9663 delete arg3;
9664 }
9665 {
9666 if (temp4)
9667 delete arg4;
9668 }
9669 return resultobj;
9670 fail:
9671 {
9672 if (temp2)
9673 delete arg2;
9674 }
9675 {
9676 if (temp3)
9677 delete arg3;
9678 }
9679 {
9680 if (temp4)
9681 delete arg4;
9682 }
9683 return NULL;
9684 }
9685
9686
9687 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9688 PyObject *resultobj = 0;
9689 wxFSFile *arg1 = (wxFSFile *) 0 ;
9690 void *argp1 = 0 ;
9691 int res1 = 0 ;
9692 PyObject *swig_obj[1] ;
9693
9694 if (!args) SWIG_fail;
9695 swig_obj[0] = args;
9696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9697 if (!SWIG_IsOK(res1)) {
9698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9699 }
9700 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9701 {
9702 PyThreadState* __tstate = wxPyBeginAllowThreads();
9703 delete arg1;
9704
9705 wxPyEndAllowThreads(__tstate);
9706 if (PyErr_Occurred()) SWIG_fail;
9707 }
9708 resultobj = SWIG_Py_Void();
9709 return resultobj;
9710 fail:
9711 return NULL;
9712 }
9713
9714
9715 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9716 PyObject *resultobj = 0;
9717 wxFSFile *arg1 = (wxFSFile *) 0 ;
9718 wxInputStream *result = 0 ;
9719 void *argp1 = 0 ;
9720 int res1 = 0 ;
9721 PyObject *swig_obj[1] ;
9722
9723 if (!args) SWIG_fail;
9724 swig_obj[0] = args;
9725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9726 if (!SWIG_IsOK(res1)) {
9727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9728 }
9729 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9730 {
9731 PyThreadState* __tstate = wxPyBeginAllowThreads();
9732 result = (wxInputStream *)(arg1)->GetStream();
9733 wxPyEndAllowThreads(__tstate);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 {
9737 wxPyInputStream * _ptr = NULL;
9738
9739 if (result) {
9740 _ptr = new wxPyInputStream(result);
9741 }
9742 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9743 }
9744 return resultobj;
9745 fail:
9746 return NULL;
9747 }
9748
9749
9750 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9751 PyObject *resultobj = 0;
9752 wxFSFile *arg1 = (wxFSFile *) 0 ;
9753 wxString *result = 0 ;
9754 void *argp1 = 0 ;
9755 int res1 = 0 ;
9756 PyObject *swig_obj[1] ;
9757
9758 if (!args) SWIG_fail;
9759 swig_obj[0] = args;
9760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9761 if (!SWIG_IsOK(res1)) {
9762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9763 }
9764 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9765 {
9766 PyThreadState* __tstate = wxPyBeginAllowThreads();
9767 {
9768 wxString const &_result_ref = (arg1)->GetMimeType();
9769 result = (wxString *) &_result_ref;
9770 }
9771 wxPyEndAllowThreads(__tstate);
9772 if (PyErr_Occurred()) SWIG_fail;
9773 }
9774 {
9775 #if wxUSE_UNICODE
9776 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9777 #else
9778 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9779 #endif
9780 }
9781 return resultobj;
9782 fail:
9783 return NULL;
9784 }
9785
9786
9787 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9788 PyObject *resultobj = 0;
9789 wxFSFile *arg1 = (wxFSFile *) 0 ;
9790 wxString *result = 0 ;
9791 void *argp1 = 0 ;
9792 int res1 = 0 ;
9793 PyObject *swig_obj[1] ;
9794
9795 if (!args) SWIG_fail;
9796 swig_obj[0] = args;
9797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9798 if (!SWIG_IsOK(res1)) {
9799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9800 }
9801 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9802 {
9803 PyThreadState* __tstate = wxPyBeginAllowThreads();
9804 {
9805 wxString const &_result_ref = (arg1)->GetLocation();
9806 result = (wxString *) &_result_ref;
9807 }
9808 wxPyEndAllowThreads(__tstate);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 {
9812 #if wxUSE_UNICODE
9813 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9814 #else
9815 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9816 #endif
9817 }
9818 return resultobj;
9819 fail:
9820 return NULL;
9821 }
9822
9823
9824 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9825 PyObject *resultobj = 0;
9826 wxFSFile *arg1 = (wxFSFile *) 0 ;
9827 wxString *result = 0 ;
9828 void *argp1 = 0 ;
9829 int res1 = 0 ;
9830 PyObject *swig_obj[1] ;
9831
9832 if (!args) SWIG_fail;
9833 swig_obj[0] = args;
9834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9835 if (!SWIG_IsOK(res1)) {
9836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9837 }
9838 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9839 {
9840 PyThreadState* __tstate = wxPyBeginAllowThreads();
9841 {
9842 wxString const &_result_ref = (arg1)->GetAnchor();
9843 result = (wxString *) &_result_ref;
9844 }
9845 wxPyEndAllowThreads(__tstate);
9846 if (PyErr_Occurred()) SWIG_fail;
9847 }
9848 {
9849 #if wxUSE_UNICODE
9850 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9851 #else
9852 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9853 #endif
9854 }
9855 return resultobj;
9856 fail:
9857 return NULL;
9858 }
9859
9860
9861 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9862 PyObject *resultobj = 0;
9863 wxFSFile *arg1 = (wxFSFile *) 0 ;
9864 wxDateTime result;
9865 void *argp1 = 0 ;
9866 int res1 = 0 ;
9867 PyObject *swig_obj[1] ;
9868
9869 if (!args) SWIG_fail;
9870 swig_obj[0] = args;
9871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9872 if (!SWIG_IsOK(res1)) {
9873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9874 }
9875 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9876 {
9877 PyThreadState* __tstate = wxPyBeginAllowThreads();
9878 result = (arg1)->GetModificationTime();
9879 wxPyEndAllowThreads(__tstate);
9880 if (PyErr_Occurred()) SWIG_fail;
9881 }
9882 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9883 return resultobj;
9884 fail:
9885 return NULL;
9886 }
9887
9888
9889 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9890 PyObject *obj;
9891 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9892 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9893 return SWIG_Py_Void();
9894 }
9895
9896 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9897 return SWIG_Python_InitShadowInstance(args);
9898 }
9899
9900 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9901 PyObject *resultobj = 0;
9902 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9903 void *argp1 = 0 ;
9904 int res1 = 0 ;
9905 PyObject *swig_obj[1] ;
9906
9907 if (!args) SWIG_fail;
9908 swig_obj[0] = args;
9909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9910 if (!SWIG_IsOK(res1)) {
9911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9912 }
9913 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9914 {
9915 PyThreadState* __tstate = wxPyBeginAllowThreads();
9916 delete arg1;
9917
9918 wxPyEndAllowThreads(__tstate);
9919 if (PyErr_Occurred()) SWIG_fail;
9920 }
9921 resultobj = SWIG_Py_Void();
9922 return resultobj;
9923 fail:
9924 return NULL;
9925 }
9926
9927
9928 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9929 PyObject *obj;
9930 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9931 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9932 return SWIG_Py_Void();
9933 }
9934
9935 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9936 PyObject *resultobj = 0;
9937 wxPyFileSystemHandler *result = 0 ;
9938
9939 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9940 {
9941 PyThreadState* __tstate = wxPyBeginAllowThreads();
9942 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9943 wxPyEndAllowThreads(__tstate);
9944 if (PyErr_Occurred()) SWIG_fail;
9945 }
9946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
9947 return resultobj;
9948 fail:
9949 return NULL;
9950 }
9951
9952
9953 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9954 PyObject *resultobj = 0;
9955 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9956 PyObject *arg2 = (PyObject *) 0 ;
9957 PyObject *arg3 = (PyObject *) 0 ;
9958 void *argp1 = 0 ;
9959 int res1 = 0 ;
9960 PyObject * obj0 = 0 ;
9961 PyObject * obj1 = 0 ;
9962 PyObject * obj2 = 0 ;
9963 char * kwnames[] = {
9964 (char *) "self",(char *) "self",(char *) "_class", NULL
9965 };
9966
9967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
9969 if (!SWIG_IsOK(res1)) {
9970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
9971 }
9972 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
9973 arg2 = obj1;
9974 arg3 = obj2;
9975 {
9976 PyThreadState* __tstate = wxPyBeginAllowThreads();
9977 (arg1)->_setCallbackInfo(arg2,arg3);
9978 wxPyEndAllowThreads(__tstate);
9979 if (PyErr_Occurred()) SWIG_fail;
9980 }
9981 resultobj = SWIG_Py_Void();
9982 return resultobj;
9983 fail:
9984 return NULL;
9985 }
9986
9987
9988 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9989 PyObject *resultobj = 0;
9990 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
9991 wxString *arg2 = 0 ;
9992 bool result;
9993 void *argp1 = 0 ;
9994 int res1 = 0 ;
9995 bool temp2 = false ;
9996 PyObject * obj0 = 0 ;
9997 PyObject * obj1 = 0 ;
9998 char * kwnames[] = {
9999 (char *) "self",(char *) "location", NULL
10000 };
10001
10002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10004 if (!SWIG_IsOK(res1)) {
10005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10006 }
10007 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10008 {
10009 arg2 = wxString_in_helper(obj1);
10010 if (arg2 == NULL) SWIG_fail;
10011 temp2 = true;
10012 }
10013 {
10014 PyThreadState* __tstate = wxPyBeginAllowThreads();
10015 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10016 wxPyEndAllowThreads(__tstate);
10017 if (PyErr_Occurred()) SWIG_fail;
10018 }
10019 {
10020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10021 }
10022 {
10023 if (temp2)
10024 delete arg2;
10025 }
10026 return resultobj;
10027 fail:
10028 {
10029 if (temp2)
10030 delete arg2;
10031 }
10032 return NULL;
10033 }
10034
10035
10036 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10037 PyObject *resultobj = 0;
10038 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10039 wxFileSystem *arg2 = 0 ;
10040 wxString *arg3 = 0 ;
10041 wxFSFile *result = 0 ;
10042 void *argp1 = 0 ;
10043 int res1 = 0 ;
10044 void *argp2 = 0 ;
10045 int res2 = 0 ;
10046 bool temp3 = false ;
10047 PyObject * obj0 = 0 ;
10048 PyObject * obj1 = 0 ;
10049 PyObject * obj2 = 0 ;
10050 char * kwnames[] = {
10051 (char *) "self",(char *) "fs",(char *) "location", NULL
10052 };
10053
10054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10056 if (!SWIG_IsOK(res1)) {
10057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10058 }
10059 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10060 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10061 if (!SWIG_IsOK(res2)) {
10062 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10063 }
10064 if (!argp2) {
10065 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10066 }
10067 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10068 {
10069 arg3 = wxString_in_helper(obj2);
10070 if (arg3 == NULL) SWIG_fail;
10071 temp3 = true;
10072 }
10073 {
10074 PyThreadState* __tstate = wxPyBeginAllowThreads();
10075 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10076 wxPyEndAllowThreads(__tstate);
10077 if (PyErr_Occurred()) SWIG_fail;
10078 }
10079 {
10080 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10081 }
10082 {
10083 if (temp3)
10084 delete arg3;
10085 }
10086 return resultobj;
10087 fail:
10088 {
10089 if (temp3)
10090 delete arg3;
10091 }
10092 return NULL;
10093 }
10094
10095
10096 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10097 PyObject *resultobj = 0;
10098 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10099 wxString *arg2 = 0 ;
10100 int arg3 = (int) 0 ;
10101 wxString result;
10102 void *argp1 = 0 ;
10103 int res1 = 0 ;
10104 bool temp2 = false ;
10105 int val3 ;
10106 int ecode3 = 0 ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 PyObject * obj2 = 0 ;
10110 char * kwnames[] = {
10111 (char *) "self",(char *) "spec",(char *) "flags", NULL
10112 };
10113
10114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10116 if (!SWIG_IsOK(res1)) {
10117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10118 }
10119 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10120 {
10121 arg2 = wxString_in_helper(obj1);
10122 if (arg2 == NULL) SWIG_fail;
10123 temp2 = true;
10124 }
10125 if (obj2) {
10126 ecode3 = SWIG_AsVal_int(obj2, &val3);
10127 if (!SWIG_IsOK(ecode3)) {
10128 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10129 }
10130 arg3 = static_cast< int >(val3);
10131 }
10132 {
10133 PyThreadState* __tstate = wxPyBeginAllowThreads();
10134 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10135 wxPyEndAllowThreads(__tstate);
10136 if (PyErr_Occurred()) SWIG_fail;
10137 }
10138 {
10139 #if wxUSE_UNICODE
10140 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10141 #else
10142 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10143 #endif
10144 }
10145 {
10146 if (temp2)
10147 delete arg2;
10148 }
10149 return resultobj;
10150 fail:
10151 {
10152 if (temp2)
10153 delete arg2;
10154 }
10155 return NULL;
10156 }
10157
10158
10159 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10160 PyObject *resultobj = 0;
10161 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10162 wxString result;
10163 void *argp1 = 0 ;
10164 int res1 = 0 ;
10165 PyObject *swig_obj[1] ;
10166
10167 if (!args) SWIG_fail;
10168 swig_obj[0] = args;
10169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10170 if (!SWIG_IsOK(res1)) {
10171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10172 }
10173 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10174 {
10175 PyThreadState* __tstate = wxPyBeginAllowThreads();
10176 result = (arg1)->FindNext();
10177 wxPyEndAllowThreads(__tstate);
10178 if (PyErr_Occurred()) SWIG_fail;
10179 }
10180 {
10181 #if wxUSE_UNICODE
10182 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10183 #else
10184 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10185 #endif
10186 }
10187 return resultobj;
10188 fail:
10189 return NULL;
10190 }
10191
10192
10193 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10194 PyObject *resultobj = 0;
10195 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10196 wxString *arg2 = 0 ;
10197 wxString result;
10198 void *argp1 = 0 ;
10199 int res1 = 0 ;
10200 bool temp2 = false ;
10201 PyObject * obj0 = 0 ;
10202 PyObject * obj1 = 0 ;
10203 char * kwnames[] = {
10204 (char *) "self",(char *) "location", NULL
10205 };
10206
10207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10209 if (!SWIG_IsOK(res1)) {
10210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10211 }
10212 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10213 {
10214 arg2 = wxString_in_helper(obj1);
10215 if (arg2 == NULL) SWIG_fail;
10216 temp2 = true;
10217 }
10218 {
10219 PyThreadState* __tstate = wxPyBeginAllowThreads();
10220 result = (arg1)->GetProtocol((wxString const &)*arg2);
10221 wxPyEndAllowThreads(__tstate);
10222 if (PyErr_Occurred()) SWIG_fail;
10223 }
10224 {
10225 #if wxUSE_UNICODE
10226 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10227 #else
10228 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10229 #endif
10230 }
10231 {
10232 if (temp2)
10233 delete arg2;
10234 }
10235 return resultobj;
10236 fail:
10237 {
10238 if (temp2)
10239 delete arg2;
10240 }
10241 return NULL;
10242 }
10243
10244
10245 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10246 PyObject *resultobj = 0;
10247 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10248 wxString *arg2 = 0 ;
10249 wxString result;
10250 void *argp1 = 0 ;
10251 int res1 = 0 ;
10252 bool temp2 = false ;
10253 PyObject * obj0 = 0 ;
10254 PyObject * obj1 = 0 ;
10255 char * kwnames[] = {
10256 (char *) "self",(char *) "location", NULL
10257 };
10258
10259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10261 if (!SWIG_IsOK(res1)) {
10262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10263 }
10264 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10265 {
10266 arg2 = wxString_in_helper(obj1);
10267 if (arg2 == NULL) SWIG_fail;
10268 temp2 = true;
10269 }
10270 {
10271 PyThreadState* __tstate = wxPyBeginAllowThreads();
10272 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10273 wxPyEndAllowThreads(__tstate);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 {
10277 #if wxUSE_UNICODE
10278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10279 #else
10280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10281 #endif
10282 }
10283 {
10284 if (temp2)
10285 delete arg2;
10286 }
10287 return resultobj;
10288 fail:
10289 {
10290 if (temp2)
10291 delete arg2;
10292 }
10293 return NULL;
10294 }
10295
10296
10297 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10298 PyObject *resultobj = 0;
10299 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10300 wxString *arg2 = 0 ;
10301 wxString result;
10302 void *argp1 = 0 ;
10303 int res1 = 0 ;
10304 bool temp2 = false ;
10305 PyObject * obj0 = 0 ;
10306 PyObject * obj1 = 0 ;
10307 char * kwnames[] = {
10308 (char *) "self",(char *) "location", NULL
10309 };
10310
10311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10313 if (!SWIG_IsOK(res1)) {
10314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10315 }
10316 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10317 {
10318 arg2 = wxString_in_helper(obj1);
10319 if (arg2 == NULL) SWIG_fail;
10320 temp2 = true;
10321 }
10322 {
10323 PyThreadState* __tstate = wxPyBeginAllowThreads();
10324 result = (arg1)->GetAnchor((wxString const &)*arg2);
10325 wxPyEndAllowThreads(__tstate);
10326 if (PyErr_Occurred()) SWIG_fail;
10327 }
10328 {
10329 #if wxUSE_UNICODE
10330 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10331 #else
10332 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10333 #endif
10334 }
10335 {
10336 if (temp2)
10337 delete arg2;
10338 }
10339 return resultobj;
10340 fail:
10341 {
10342 if (temp2)
10343 delete arg2;
10344 }
10345 return NULL;
10346 }
10347
10348
10349 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10350 PyObject *resultobj = 0;
10351 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10352 wxString *arg2 = 0 ;
10353 wxString result;
10354 void *argp1 = 0 ;
10355 int res1 = 0 ;
10356 bool temp2 = false ;
10357 PyObject * obj0 = 0 ;
10358 PyObject * obj1 = 0 ;
10359 char * kwnames[] = {
10360 (char *) "self",(char *) "location", NULL
10361 };
10362
10363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10365 if (!SWIG_IsOK(res1)) {
10366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10367 }
10368 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10369 {
10370 arg2 = wxString_in_helper(obj1);
10371 if (arg2 == NULL) SWIG_fail;
10372 temp2 = true;
10373 }
10374 {
10375 PyThreadState* __tstate = wxPyBeginAllowThreads();
10376 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10377 wxPyEndAllowThreads(__tstate);
10378 if (PyErr_Occurred()) SWIG_fail;
10379 }
10380 {
10381 #if wxUSE_UNICODE
10382 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10383 #else
10384 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10385 #endif
10386 }
10387 {
10388 if (temp2)
10389 delete arg2;
10390 }
10391 return resultobj;
10392 fail:
10393 {
10394 if (temp2)
10395 delete arg2;
10396 }
10397 return NULL;
10398 }
10399
10400
10401 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10402 PyObject *resultobj = 0;
10403 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10404 wxString *arg2 = 0 ;
10405 wxString result;
10406 void *argp1 = 0 ;
10407 int res1 = 0 ;
10408 bool temp2 = false ;
10409 PyObject * obj0 = 0 ;
10410 PyObject * obj1 = 0 ;
10411 char * kwnames[] = {
10412 (char *) "self",(char *) "location", NULL
10413 };
10414
10415 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10416 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10417 if (!SWIG_IsOK(res1)) {
10418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10419 }
10420 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10421 {
10422 arg2 = wxString_in_helper(obj1);
10423 if (arg2 == NULL) SWIG_fail;
10424 temp2 = true;
10425 }
10426 {
10427 PyThreadState* __tstate = wxPyBeginAllowThreads();
10428 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10429 wxPyEndAllowThreads(__tstate);
10430 if (PyErr_Occurred()) SWIG_fail;
10431 }
10432 {
10433 #if wxUSE_UNICODE
10434 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10435 #else
10436 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10437 #endif
10438 }
10439 {
10440 if (temp2)
10441 delete arg2;
10442 }
10443 return resultobj;
10444 fail:
10445 {
10446 if (temp2)
10447 delete arg2;
10448 }
10449 return NULL;
10450 }
10451
10452
10453 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10454 PyObject *obj;
10455 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10456 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10457 return SWIG_Py_Void();
10458 }
10459
10460 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10461 return SWIG_Python_InitShadowInstance(args);
10462 }
10463
10464 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10465 PyObject *resultobj = 0;
10466 wxFileSystem *result = 0 ;
10467
10468 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10469 {
10470 PyThreadState* __tstate = wxPyBeginAllowThreads();
10471 result = (wxFileSystem *)new wxFileSystem();
10472 wxPyEndAllowThreads(__tstate);
10473 if (PyErr_Occurred()) SWIG_fail;
10474 }
10475 {
10476 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10477 }
10478 return resultobj;
10479 fail:
10480 return NULL;
10481 }
10482
10483
10484 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10485 PyObject *resultobj = 0;
10486 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10487 void *argp1 = 0 ;
10488 int res1 = 0 ;
10489 PyObject *swig_obj[1] ;
10490
10491 if (!args) SWIG_fail;
10492 swig_obj[0] = args;
10493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10494 if (!SWIG_IsOK(res1)) {
10495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10496 }
10497 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10498 {
10499 PyThreadState* __tstate = wxPyBeginAllowThreads();
10500 delete arg1;
10501
10502 wxPyEndAllowThreads(__tstate);
10503 if (PyErr_Occurred()) SWIG_fail;
10504 }
10505 resultobj = SWIG_Py_Void();
10506 return resultobj;
10507 fail:
10508 return NULL;
10509 }
10510
10511
10512 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10513 PyObject *resultobj = 0;
10514 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10515 wxString *arg2 = 0 ;
10516 bool arg3 = (bool) false ;
10517 void *argp1 = 0 ;
10518 int res1 = 0 ;
10519 bool temp2 = false ;
10520 bool val3 ;
10521 int ecode3 = 0 ;
10522 PyObject * obj0 = 0 ;
10523 PyObject * obj1 = 0 ;
10524 PyObject * obj2 = 0 ;
10525 char * kwnames[] = {
10526 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10527 };
10528
10529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10531 if (!SWIG_IsOK(res1)) {
10532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10533 }
10534 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10535 {
10536 arg2 = wxString_in_helper(obj1);
10537 if (arg2 == NULL) SWIG_fail;
10538 temp2 = true;
10539 }
10540 if (obj2) {
10541 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10542 if (!SWIG_IsOK(ecode3)) {
10543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10544 }
10545 arg3 = static_cast< bool >(val3);
10546 }
10547 {
10548 PyThreadState* __tstate = wxPyBeginAllowThreads();
10549 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10550 wxPyEndAllowThreads(__tstate);
10551 if (PyErr_Occurred()) SWIG_fail;
10552 }
10553 resultobj = SWIG_Py_Void();
10554 {
10555 if (temp2)
10556 delete arg2;
10557 }
10558 return resultobj;
10559 fail:
10560 {
10561 if (temp2)
10562 delete arg2;
10563 }
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10569 PyObject *resultobj = 0;
10570 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10571 wxString result;
10572 void *argp1 = 0 ;
10573 int res1 = 0 ;
10574 PyObject *swig_obj[1] ;
10575
10576 if (!args) SWIG_fail;
10577 swig_obj[0] = args;
10578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10579 if (!SWIG_IsOK(res1)) {
10580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10581 }
10582 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10583 {
10584 PyThreadState* __tstate = wxPyBeginAllowThreads();
10585 result = (arg1)->GetPath();
10586 wxPyEndAllowThreads(__tstate);
10587 if (PyErr_Occurred()) SWIG_fail;
10588 }
10589 {
10590 #if wxUSE_UNICODE
10591 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10592 #else
10593 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10594 #endif
10595 }
10596 return resultobj;
10597 fail:
10598 return NULL;
10599 }
10600
10601
10602 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10603 PyObject *resultobj = 0;
10604 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10605 wxString *arg2 = 0 ;
10606 wxFSFile *result = 0 ;
10607 void *argp1 = 0 ;
10608 int res1 = 0 ;
10609 bool temp2 = false ;
10610 PyObject * obj0 = 0 ;
10611 PyObject * obj1 = 0 ;
10612 char * kwnames[] = {
10613 (char *) "self",(char *) "location", NULL
10614 };
10615
10616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10617 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10618 if (!SWIG_IsOK(res1)) {
10619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10620 }
10621 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10622 {
10623 arg2 = wxString_in_helper(obj1);
10624 if (arg2 == NULL) SWIG_fail;
10625 temp2 = true;
10626 }
10627 {
10628 PyThreadState* __tstate = wxPyBeginAllowThreads();
10629 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10630 wxPyEndAllowThreads(__tstate);
10631 if (PyErr_Occurred()) SWIG_fail;
10632 }
10633 {
10634 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10635 }
10636 {
10637 if (temp2)
10638 delete arg2;
10639 }
10640 return resultobj;
10641 fail:
10642 {
10643 if (temp2)
10644 delete arg2;
10645 }
10646 return NULL;
10647 }
10648
10649
10650 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10651 PyObject *resultobj = 0;
10652 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10653 wxString *arg2 = 0 ;
10654 int arg3 = (int) 0 ;
10655 wxString result;
10656 void *argp1 = 0 ;
10657 int res1 = 0 ;
10658 bool temp2 = false ;
10659 int val3 ;
10660 int ecode3 = 0 ;
10661 PyObject * obj0 = 0 ;
10662 PyObject * obj1 = 0 ;
10663 PyObject * obj2 = 0 ;
10664 char * kwnames[] = {
10665 (char *) "self",(char *) "spec",(char *) "flags", NULL
10666 };
10667
10668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10670 if (!SWIG_IsOK(res1)) {
10671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10672 }
10673 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10674 {
10675 arg2 = wxString_in_helper(obj1);
10676 if (arg2 == NULL) SWIG_fail;
10677 temp2 = true;
10678 }
10679 if (obj2) {
10680 ecode3 = SWIG_AsVal_int(obj2, &val3);
10681 if (!SWIG_IsOK(ecode3)) {
10682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10683 }
10684 arg3 = static_cast< int >(val3);
10685 }
10686 {
10687 PyThreadState* __tstate = wxPyBeginAllowThreads();
10688 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10689 wxPyEndAllowThreads(__tstate);
10690 if (PyErr_Occurred()) SWIG_fail;
10691 }
10692 {
10693 #if wxUSE_UNICODE
10694 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10695 #else
10696 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10697 #endif
10698 }
10699 {
10700 if (temp2)
10701 delete arg2;
10702 }
10703 return resultobj;
10704 fail:
10705 {
10706 if (temp2)
10707 delete arg2;
10708 }
10709 return NULL;
10710 }
10711
10712
10713 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10714 PyObject *resultobj = 0;
10715 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10716 wxString result;
10717 void *argp1 = 0 ;
10718 int res1 = 0 ;
10719 PyObject *swig_obj[1] ;
10720
10721 if (!args) SWIG_fail;
10722 swig_obj[0] = args;
10723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10724 if (!SWIG_IsOK(res1)) {
10725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10726 }
10727 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10728 {
10729 PyThreadState* __tstate = wxPyBeginAllowThreads();
10730 result = (arg1)->FindNext();
10731 wxPyEndAllowThreads(__tstate);
10732 if (PyErr_Occurred()) SWIG_fail;
10733 }
10734 {
10735 #if wxUSE_UNICODE
10736 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10737 #else
10738 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10739 #endif
10740 }
10741 return resultobj;
10742 fail:
10743 return NULL;
10744 }
10745
10746
10747 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10748 PyObject *resultobj = 0;
10749 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10750 int res1 = 0 ;
10751 PyObject * obj0 = 0 ;
10752 char * kwnames[] = {
10753 (char *) "handler", NULL
10754 };
10755
10756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10757 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10758 if (!SWIG_IsOK(res1)) {
10759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10760 }
10761 {
10762 PyThreadState* __tstate = wxPyBeginAllowThreads();
10763 wxFileSystem::AddHandler(arg1);
10764 wxPyEndAllowThreads(__tstate);
10765 if (PyErr_Occurred()) SWIG_fail;
10766 }
10767 resultobj = SWIG_Py_Void();
10768 return resultobj;
10769 fail:
10770 return NULL;
10771 }
10772
10773
10774 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10775 PyObject *resultobj = 0;
10776
10777 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10778 {
10779 PyThreadState* __tstate = wxPyBeginAllowThreads();
10780 wxFileSystem::CleanUpHandlers();
10781 wxPyEndAllowThreads(__tstate);
10782 if (PyErr_Occurred()) SWIG_fail;
10783 }
10784 resultobj = SWIG_Py_Void();
10785 return resultobj;
10786 fail:
10787 return NULL;
10788 }
10789
10790
10791 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10792 PyObject *resultobj = 0;
10793 wxString *arg1 = 0 ;
10794 wxString result;
10795 bool temp1 = false ;
10796 PyObject * obj0 = 0 ;
10797 char * kwnames[] = {
10798 (char *) "filename", NULL
10799 };
10800
10801 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10802 {
10803 arg1 = wxString_in_helper(obj0);
10804 if (arg1 == NULL) SWIG_fail;
10805 temp1 = true;
10806 }
10807 {
10808 PyThreadState* __tstate = wxPyBeginAllowThreads();
10809 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10810 wxPyEndAllowThreads(__tstate);
10811 if (PyErr_Occurred()) SWIG_fail;
10812 }
10813 {
10814 #if wxUSE_UNICODE
10815 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10816 #else
10817 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10818 #endif
10819 }
10820 {
10821 if (temp1)
10822 delete arg1;
10823 }
10824 return resultobj;
10825 fail:
10826 {
10827 if (temp1)
10828 delete arg1;
10829 }
10830 return NULL;
10831 }
10832
10833
10834 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10835 PyObject *resultobj = 0;
10836 wxString *arg1 = 0 ;
10837 wxString result;
10838 bool temp1 = false ;
10839 PyObject * obj0 = 0 ;
10840 char * kwnames[] = {
10841 (char *) "url", NULL
10842 };
10843
10844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10845 {
10846 arg1 = wxString_in_helper(obj0);
10847 if (arg1 == NULL) SWIG_fail;
10848 temp1 = true;
10849 }
10850 {
10851 PyThreadState* __tstate = wxPyBeginAllowThreads();
10852 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10853 wxPyEndAllowThreads(__tstate);
10854 if (PyErr_Occurred()) SWIG_fail;
10855 }
10856 {
10857 #if wxUSE_UNICODE
10858 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10859 #else
10860 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10861 #endif
10862 }
10863 {
10864 if (temp1)
10865 delete arg1;
10866 }
10867 return resultobj;
10868 fail:
10869 {
10870 if (temp1)
10871 delete arg1;
10872 }
10873 return NULL;
10874 }
10875
10876
10877 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10878 PyObject *obj;
10879 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10880 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10881 return SWIG_Py_Void();
10882 }
10883
10884 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10885 return SWIG_Python_InitShadowInstance(args);
10886 }
10887
10888 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10889 PyObject *resultobj = 0;
10890 wxInternetFSHandler *result = 0 ;
10891
10892 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10893 {
10894 PyThreadState* __tstate = wxPyBeginAllowThreads();
10895 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10896 wxPyEndAllowThreads(__tstate);
10897 if (PyErr_Occurred()) SWIG_fail;
10898 }
10899 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10900 return resultobj;
10901 fail:
10902 return NULL;
10903 }
10904
10905
10906 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10907 PyObject *resultobj = 0;
10908 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10909 wxString *arg2 = 0 ;
10910 bool result;
10911 void *argp1 = 0 ;
10912 int res1 = 0 ;
10913 bool temp2 = false ;
10914 PyObject * obj0 = 0 ;
10915 PyObject * obj1 = 0 ;
10916 char * kwnames[] = {
10917 (char *) "self",(char *) "location", NULL
10918 };
10919
10920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10922 if (!SWIG_IsOK(res1)) {
10923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10924 }
10925 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10926 {
10927 arg2 = wxString_in_helper(obj1);
10928 if (arg2 == NULL) SWIG_fail;
10929 temp2 = true;
10930 }
10931 {
10932 PyThreadState* __tstate = wxPyBeginAllowThreads();
10933 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10934 wxPyEndAllowThreads(__tstate);
10935 if (PyErr_Occurred()) SWIG_fail;
10936 }
10937 {
10938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10939 }
10940 {
10941 if (temp2)
10942 delete arg2;
10943 }
10944 return resultobj;
10945 fail:
10946 {
10947 if (temp2)
10948 delete arg2;
10949 }
10950 return NULL;
10951 }
10952
10953
10954 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10955 PyObject *resultobj = 0;
10956 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10957 wxFileSystem *arg2 = 0 ;
10958 wxString *arg3 = 0 ;
10959 wxFSFile *result = 0 ;
10960 void *argp1 = 0 ;
10961 int res1 = 0 ;
10962 void *argp2 = 0 ;
10963 int res2 = 0 ;
10964 bool temp3 = false ;
10965 PyObject * obj0 = 0 ;
10966 PyObject * obj1 = 0 ;
10967 PyObject * obj2 = 0 ;
10968 char * kwnames[] = {
10969 (char *) "self",(char *) "fs",(char *) "location", NULL
10970 };
10971
10972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10974 if (!SWIG_IsOK(res1)) {
10975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10976 }
10977 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10978 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10979 if (!SWIG_IsOK(res2)) {
10980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10981 }
10982 if (!argp2) {
10983 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10984 }
10985 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10986 {
10987 arg3 = wxString_in_helper(obj2);
10988 if (arg3 == NULL) SWIG_fail;
10989 temp3 = true;
10990 }
10991 {
10992 PyThreadState* __tstate = wxPyBeginAllowThreads();
10993 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10994 wxPyEndAllowThreads(__tstate);
10995 if (PyErr_Occurred()) SWIG_fail;
10996 }
10997 {
10998 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
10999 }
11000 {
11001 if (temp3)
11002 delete arg3;
11003 }
11004 return resultobj;
11005 fail:
11006 {
11007 if (temp3)
11008 delete arg3;
11009 }
11010 return NULL;
11011 }
11012
11013
11014 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11015 PyObject *obj;
11016 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11017 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11018 return SWIG_Py_Void();
11019 }
11020
11021 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11022 return SWIG_Python_InitShadowInstance(args);
11023 }
11024
11025 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11026 PyObject *resultobj = 0;
11027 wxZipFSHandler *result = 0 ;
11028
11029 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11030 {
11031 PyThreadState* __tstate = wxPyBeginAllowThreads();
11032 result = (wxZipFSHandler *)new wxZipFSHandler();
11033 wxPyEndAllowThreads(__tstate);
11034 if (PyErr_Occurred()) SWIG_fail;
11035 }
11036 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11037 return resultobj;
11038 fail:
11039 return NULL;
11040 }
11041
11042
11043 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11044 PyObject *resultobj = 0;
11045 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11046 wxString *arg2 = 0 ;
11047 bool result;
11048 void *argp1 = 0 ;
11049 int res1 = 0 ;
11050 bool temp2 = false ;
11051 PyObject * obj0 = 0 ;
11052 PyObject * obj1 = 0 ;
11053 char * kwnames[] = {
11054 (char *) "self",(char *) "location", NULL
11055 };
11056
11057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11059 if (!SWIG_IsOK(res1)) {
11060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11061 }
11062 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11063 {
11064 arg2 = wxString_in_helper(obj1);
11065 if (arg2 == NULL) SWIG_fail;
11066 temp2 = true;
11067 }
11068 {
11069 PyThreadState* __tstate = wxPyBeginAllowThreads();
11070 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11071 wxPyEndAllowThreads(__tstate);
11072 if (PyErr_Occurred()) SWIG_fail;
11073 }
11074 {
11075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11076 }
11077 {
11078 if (temp2)
11079 delete arg2;
11080 }
11081 return resultobj;
11082 fail:
11083 {
11084 if (temp2)
11085 delete arg2;
11086 }
11087 return NULL;
11088 }
11089
11090
11091 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11092 PyObject *resultobj = 0;
11093 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11094 wxFileSystem *arg2 = 0 ;
11095 wxString *arg3 = 0 ;
11096 wxFSFile *result = 0 ;
11097 void *argp1 = 0 ;
11098 int res1 = 0 ;
11099 void *argp2 = 0 ;
11100 int res2 = 0 ;
11101 bool temp3 = false ;
11102 PyObject * obj0 = 0 ;
11103 PyObject * obj1 = 0 ;
11104 PyObject * obj2 = 0 ;
11105 char * kwnames[] = {
11106 (char *) "self",(char *) "fs",(char *) "location", NULL
11107 };
11108
11109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11111 if (!SWIG_IsOK(res1)) {
11112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11113 }
11114 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11115 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11116 if (!SWIG_IsOK(res2)) {
11117 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11118 }
11119 if (!argp2) {
11120 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11121 }
11122 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11123 {
11124 arg3 = wxString_in_helper(obj2);
11125 if (arg3 == NULL) SWIG_fail;
11126 temp3 = true;
11127 }
11128 {
11129 PyThreadState* __tstate = wxPyBeginAllowThreads();
11130 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11131 wxPyEndAllowThreads(__tstate);
11132 if (PyErr_Occurred()) SWIG_fail;
11133 }
11134 {
11135 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11136 }
11137 {
11138 if (temp3)
11139 delete arg3;
11140 }
11141 return resultobj;
11142 fail:
11143 {
11144 if (temp3)
11145 delete arg3;
11146 }
11147 return NULL;
11148 }
11149
11150
11151 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11152 PyObject *resultobj = 0;
11153 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11154 wxString *arg2 = 0 ;
11155 int arg3 = (int) 0 ;
11156 wxString result;
11157 void *argp1 = 0 ;
11158 int res1 = 0 ;
11159 bool temp2 = false ;
11160 int val3 ;
11161 int ecode3 = 0 ;
11162 PyObject * obj0 = 0 ;
11163 PyObject * obj1 = 0 ;
11164 PyObject * obj2 = 0 ;
11165 char * kwnames[] = {
11166 (char *) "self",(char *) "spec",(char *) "flags", NULL
11167 };
11168
11169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11171 if (!SWIG_IsOK(res1)) {
11172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11173 }
11174 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11175 {
11176 arg2 = wxString_in_helper(obj1);
11177 if (arg2 == NULL) SWIG_fail;
11178 temp2 = true;
11179 }
11180 if (obj2) {
11181 ecode3 = SWIG_AsVal_int(obj2, &val3);
11182 if (!SWIG_IsOK(ecode3)) {
11183 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11184 }
11185 arg3 = static_cast< int >(val3);
11186 }
11187 {
11188 PyThreadState* __tstate = wxPyBeginAllowThreads();
11189 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11190 wxPyEndAllowThreads(__tstate);
11191 if (PyErr_Occurred()) SWIG_fail;
11192 }
11193 {
11194 #if wxUSE_UNICODE
11195 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11196 #else
11197 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11198 #endif
11199 }
11200 {
11201 if (temp2)
11202 delete arg2;
11203 }
11204 return resultobj;
11205 fail:
11206 {
11207 if (temp2)
11208 delete arg2;
11209 }
11210 return NULL;
11211 }
11212
11213
11214 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11215 PyObject *resultobj = 0;
11216 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11217 wxString result;
11218 void *argp1 = 0 ;
11219 int res1 = 0 ;
11220 PyObject *swig_obj[1] ;
11221
11222 if (!args) SWIG_fail;
11223 swig_obj[0] = args;
11224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11225 if (!SWIG_IsOK(res1)) {
11226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11227 }
11228 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11229 {
11230 PyThreadState* __tstate = wxPyBeginAllowThreads();
11231 result = (arg1)->FindNext();
11232 wxPyEndAllowThreads(__tstate);
11233 if (PyErr_Occurred()) SWIG_fail;
11234 }
11235 {
11236 #if wxUSE_UNICODE
11237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11238 #else
11239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11240 #endif
11241 }
11242 return resultobj;
11243 fail:
11244 return NULL;
11245 }
11246
11247
11248 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11249 PyObject *obj;
11250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11251 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11252 return SWIG_Py_Void();
11253 }
11254
11255 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11256 return SWIG_Python_InitShadowInstance(args);
11257 }
11258
11259 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj = 0;
11261 wxString *arg1 = 0 ;
11262 wxImage *arg2 = 0 ;
11263 long arg3 ;
11264 bool temp1 = false ;
11265 void *argp2 = 0 ;
11266 int res2 = 0 ;
11267 long val3 ;
11268 int ecode3 = 0 ;
11269 PyObject * obj0 = 0 ;
11270 PyObject * obj1 = 0 ;
11271 PyObject * obj2 = 0 ;
11272 char * kwnames[] = {
11273 (char *) "filename",(char *) "image",(char *) "type", NULL
11274 };
11275
11276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11277 {
11278 arg1 = wxString_in_helper(obj0);
11279 if (arg1 == NULL) SWIG_fail;
11280 temp1 = true;
11281 }
11282 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11283 if (!SWIG_IsOK(res2)) {
11284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11285 }
11286 if (!argp2) {
11287 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11288 }
11289 arg2 = reinterpret_cast< wxImage * >(argp2);
11290 ecode3 = SWIG_AsVal_long(obj2, &val3);
11291 if (!SWIG_IsOK(ecode3)) {
11292 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11293 }
11294 arg3 = static_cast< long >(val3);
11295 {
11296 PyThreadState* __tstate = wxPyBeginAllowThreads();
11297 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11298 wxPyEndAllowThreads(__tstate);
11299 if (PyErr_Occurred()) SWIG_fail;
11300 }
11301 resultobj = SWIG_Py_Void();
11302 {
11303 if (temp1)
11304 delete arg1;
11305 }
11306 return resultobj;
11307 fail:
11308 {
11309 if (temp1)
11310 delete arg1;
11311 }
11312 return NULL;
11313 }
11314
11315
11316 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11317 PyObject *resultobj = 0;
11318 wxString *arg1 = 0 ;
11319 wxBitmap *arg2 = 0 ;
11320 long arg3 ;
11321 bool temp1 = false ;
11322 void *argp2 = 0 ;
11323 int res2 = 0 ;
11324 long val3 ;
11325 int ecode3 = 0 ;
11326 PyObject * obj0 = 0 ;
11327 PyObject * obj1 = 0 ;
11328 PyObject * obj2 = 0 ;
11329 char * kwnames[] = {
11330 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11331 };
11332
11333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11334 {
11335 arg1 = wxString_in_helper(obj0);
11336 if (arg1 == NULL) SWIG_fail;
11337 temp1 = true;
11338 }
11339 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11340 if (!SWIG_IsOK(res2)) {
11341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11342 }
11343 if (!argp2) {
11344 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11345 }
11346 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11347 ecode3 = SWIG_AsVal_long(obj2, &val3);
11348 if (!SWIG_IsOK(ecode3)) {
11349 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11350 }
11351 arg3 = static_cast< long >(val3);
11352 {
11353 PyThreadState* __tstate = wxPyBeginAllowThreads();
11354 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11355 wxPyEndAllowThreads(__tstate);
11356 if (PyErr_Occurred()) SWIG_fail;
11357 }
11358 resultobj = SWIG_Py_Void();
11359 {
11360 if (temp1)
11361 delete arg1;
11362 }
11363 return resultobj;
11364 fail:
11365 {
11366 if (temp1)
11367 delete arg1;
11368 }
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11374 PyObject *resultobj = 0;
11375 wxString *arg1 = 0 ;
11376 PyObject *arg2 = (PyObject *) 0 ;
11377 bool temp1 = false ;
11378 PyObject * obj0 = 0 ;
11379 PyObject * obj1 = 0 ;
11380 char * kwnames[] = {
11381 (char *) "filename",(char *) "data", NULL
11382 };
11383
11384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11385 {
11386 arg1 = wxString_in_helper(obj0);
11387 if (arg1 == NULL) SWIG_fail;
11388 temp1 = true;
11389 }
11390 arg2 = obj1;
11391 {
11392 PyThreadState* __tstate = wxPyBeginAllowThreads();
11393 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11394 wxPyEndAllowThreads(__tstate);
11395 if (PyErr_Occurred()) SWIG_fail;
11396 }
11397 resultobj = SWIG_Py_Void();
11398 {
11399 if (temp1)
11400 delete arg1;
11401 }
11402 return resultobj;
11403 fail:
11404 {
11405 if (temp1)
11406 delete arg1;
11407 }
11408 return NULL;
11409 }
11410
11411
11412 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11413 PyObject *resultobj = 0;
11414 wxMemoryFSHandler *result = 0 ;
11415
11416 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11417 {
11418 PyThreadState* __tstate = wxPyBeginAllowThreads();
11419 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11420 wxPyEndAllowThreads(__tstate);
11421 if (PyErr_Occurred()) SWIG_fail;
11422 }
11423 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11424 return resultobj;
11425 fail:
11426 return NULL;
11427 }
11428
11429
11430 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11431 PyObject *resultobj = 0;
11432 wxString *arg1 = 0 ;
11433 bool temp1 = false ;
11434 PyObject * obj0 = 0 ;
11435 char * kwnames[] = {
11436 (char *) "filename", NULL
11437 };
11438
11439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11440 {
11441 arg1 = wxString_in_helper(obj0);
11442 if (arg1 == NULL) SWIG_fail;
11443 temp1 = true;
11444 }
11445 {
11446 PyThreadState* __tstate = wxPyBeginAllowThreads();
11447 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11448 wxPyEndAllowThreads(__tstate);
11449 if (PyErr_Occurred()) SWIG_fail;
11450 }
11451 resultobj = SWIG_Py_Void();
11452 {
11453 if (temp1)
11454 delete arg1;
11455 }
11456 return resultobj;
11457 fail:
11458 {
11459 if (temp1)
11460 delete arg1;
11461 }
11462 return NULL;
11463 }
11464
11465
11466 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11467 PyObject *resultobj = 0;
11468 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11469 wxString *arg2 = 0 ;
11470 bool result;
11471 void *argp1 = 0 ;
11472 int res1 = 0 ;
11473 bool temp2 = false ;
11474 PyObject * obj0 = 0 ;
11475 PyObject * obj1 = 0 ;
11476 char * kwnames[] = {
11477 (char *) "self",(char *) "location", NULL
11478 };
11479
11480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11482 if (!SWIG_IsOK(res1)) {
11483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11484 }
11485 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11486 {
11487 arg2 = wxString_in_helper(obj1);
11488 if (arg2 == NULL) SWIG_fail;
11489 temp2 = true;
11490 }
11491 {
11492 PyThreadState* __tstate = wxPyBeginAllowThreads();
11493 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11494 wxPyEndAllowThreads(__tstate);
11495 if (PyErr_Occurred()) SWIG_fail;
11496 }
11497 {
11498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11499 }
11500 {
11501 if (temp2)
11502 delete arg2;
11503 }
11504 return resultobj;
11505 fail:
11506 {
11507 if (temp2)
11508 delete arg2;
11509 }
11510 return NULL;
11511 }
11512
11513
11514 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11515 PyObject *resultobj = 0;
11516 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11517 wxFileSystem *arg2 = 0 ;
11518 wxString *arg3 = 0 ;
11519 wxFSFile *result = 0 ;
11520 void *argp1 = 0 ;
11521 int res1 = 0 ;
11522 void *argp2 = 0 ;
11523 int res2 = 0 ;
11524 bool temp3 = false ;
11525 PyObject * obj0 = 0 ;
11526 PyObject * obj1 = 0 ;
11527 PyObject * obj2 = 0 ;
11528 char * kwnames[] = {
11529 (char *) "self",(char *) "fs",(char *) "location", NULL
11530 };
11531
11532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11534 if (!SWIG_IsOK(res1)) {
11535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11536 }
11537 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11538 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11539 if (!SWIG_IsOK(res2)) {
11540 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11541 }
11542 if (!argp2) {
11543 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11544 }
11545 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11546 {
11547 arg3 = wxString_in_helper(obj2);
11548 if (arg3 == NULL) SWIG_fail;
11549 temp3 = true;
11550 }
11551 {
11552 PyThreadState* __tstate = wxPyBeginAllowThreads();
11553 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11554 wxPyEndAllowThreads(__tstate);
11555 if (PyErr_Occurred()) SWIG_fail;
11556 }
11557 {
11558 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
11559 }
11560 {
11561 if (temp3)
11562 delete arg3;
11563 }
11564 return resultobj;
11565 fail:
11566 {
11567 if (temp3)
11568 delete arg3;
11569 }
11570 return NULL;
11571 }
11572
11573
11574 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11575 PyObject *resultobj = 0;
11576 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11577 wxString *arg2 = 0 ;
11578 int arg3 = (int) 0 ;
11579 wxString result;
11580 void *argp1 = 0 ;
11581 int res1 = 0 ;
11582 bool temp2 = false ;
11583 int val3 ;
11584 int ecode3 = 0 ;
11585 PyObject * obj0 = 0 ;
11586 PyObject * obj1 = 0 ;
11587 PyObject * obj2 = 0 ;
11588 char * kwnames[] = {
11589 (char *) "self",(char *) "spec",(char *) "flags", NULL
11590 };
11591
11592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11594 if (!SWIG_IsOK(res1)) {
11595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11596 }
11597 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11598 {
11599 arg2 = wxString_in_helper(obj1);
11600 if (arg2 == NULL) SWIG_fail;
11601 temp2 = true;
11602 }
11603 if (obj2) {
11604 ecode3 = SWIG_AsVal_int(obj2, &val3);
11605 if (!SWIG_IsOK(ecode3)) {
11606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11607 }
11608 arg3 = static_cast< int >(val3);
11609 }
11610 {
11611 PyThreadState* __tstate = wxPyBeginAllowThreads();
11612 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11613 wxPyEndAllowThreads(__tstate);
11614 if (PyErr_Occurred()) SWIG_fail;
11615 }
11616 {
11617 #if wxUSE_UNICODE
11618 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11619 #else
11620 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11621 #endif
11622 }
11623 {
11624 if (temp2)
11625 delete arg2;
11626 }
11627 return resultobj;
11628 fail:
11629 {
11630 if (temp2)
11631 delete arg2;
11632 }
11633 return NULL;
11634 }
11635
11636
11637 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11638 PyObject *resultobj = 0;
11639 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11640 wxString result;
11641 void *argp1 = 0 ;
11642 int res1 = 0 ;
11643 PyObject *swig_obj[1] ;
11644
11645 if (!args) SWIG_fail;
11646 swig_obj[0] = args;
11647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11648 if (!SWIG_IsOK(res1)) {
11649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11650 }
11651 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11652 {
11653 PyThreadState* __tstate = wxPyBeginAllowThreads();
11654 result = (arg1)->FindNext();
11655 wxPyEndAllowThreads(__tstate);
11656 if (PyErr_Occurred()) SWIG_fail;
11657 }
11658 {
11659 #if wxUSE_UNICODE
11660 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11661 #else
11662 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11663 #endif
11664 }
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11672 PyObject *obj;
11673 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11674 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11675 return SWIG_Py_Void();
11676 }
11677
11678 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11679 return SWIG_Python_InitShadowInstance(args);
11680 }
11681
11682 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11683 PyObject *resultobj = 0;
11684 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11685 wxString result;
11686 void *argp1 = 0 ;
11687 int res1 = 0 ;
11688 PyObject *swig_obj[1] ;
11689
11690 if (!args) SWIG_fail;
11691 swig_obj[0] = args;
11692 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11693 if (!SWIG_IsOK(res1)) {
11694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11695 }
11696 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11697 {
11698 PyThreadState* __tstate = wxPyBeginAllowThreads();
11699 result = (arg1)->GetName();
11700 wxPyEndAllowThreads(__tstate);
11701 if (PyErr_Occurred()) SWIG_fail;
11702 }
11703 {
11704 #if wxUSE_UNICODE
11705 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11706 #else
11707 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11708 #endif
11709 }
11710 return resultobj;
11711 fail:
11712 return NULL;
11713 }
11714
11715
11716 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11717 PyObject *resultobj = 0;
11718 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11719 wxString result;
11720 void *argp1 = 0 ;
11721 int res1 = 0 ;
11722 PyObject *swig_obj[1] ;
11723
11724 if (!args) SWIG_fail;
11725 swig_obj[0] = args;
11726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11727 if (!SWIG_IsOK(res1)) {
11728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11729 }
11730 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11731 {
11732 PyThreadState* __tstate = wxPyBeginAllowThreads();
11733 result = (arg1)->GetExtension();
11734 wxPyEndAllowThreads(__tstate);
11735 if (PyErr_Occurred()) SWIG_fail;
11736 }
11737 {
11738 #if wxUSE_UNICODE
11739 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11740 #else
11741 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11742 #endif
11743 }
11744 return resultobj;
11745 fail:
11746 return NULL;
11747 }
11748
11749
11750 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11751 PyObject *resultobj = 0;
11752 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11753 long result;
11754 void *argp1 = 0 ;
11755 int res1 = 0 ;
11756 PyObject *swig_obj[1] ;
11757
11758 if (!args) SWIG_fail;
11759 swig_obj[0] = args;
11760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11761 if (!SWIG_IsOK(res1)) {
11762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11763 }
11764 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11765 {
11766 PyThreadState* __tstate = wxPyBeginAllowThreads();
11767 result = (long)(arg1)->GetType();
11768 wxPyEndAllowThreads(__tstate);
11769 if (PyErr_Occurred()) SWIG_fail;
11770 }
11771 resultobj = SWIG_From_long(static_cast< long >(result));
11772 return resultobj;
11773 fail:
11774 return NULL;
11775 }
11776
11777
11778 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11779 PyObject *resultobj = 0;
11780 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11781 wxString result;
11782 void *argp1 = 0 ;
11783 int res1 = 0 ;
11784 PyObject *swig_obj[1] ;
11785
11786 if (!args) SWIG_fail;
11787 swig_obj[0] = args;
11788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11789 if (!SWIG_IsOK(res1)) {
11790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11791 }
11792 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11793 {
11794 PyThreadState* __tstate = wxPyBeginAllowThreads();
11795 result = (arg1)->GetMimeType();
11796 wxPyEndAllowThreads(__tstate);
11797 if (PyErr_Occurred()) SWIG_fail;
11798 }
11799 {
11800 #if wxUSE_UNICODE
11801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11802 #else
11803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11804 #endif
11805 }
11806 return resultobj;
11807 fail:
11808 return NULL;
11809 }
11810
11811
11812 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11813 PyObject *resultobj = 0;
11814 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11815 wxString *arg2 = 0 ;
11816 bool result;
11817 void *argp1 = 0 ;
11818 int res1 = 0 ;
11819 bool temp2 = false ;
11820 PyObject * obj0 = 0 ;
11821 PyObject * obj1 = 0 ;
11822 char * kwnames[] = {
11823 (char *) "self",(char *) "name", NULL
11824 };
11825
11826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11827 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11828 if (!SWIG_IsOK(res1)) {
11829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11830 }
11831 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11832 {
11833 arg2 = wxString_in_helper(obj1);
11834 if (arg2 == NULL) SWIG_fail;
11835 temp2 = true;
11836 }
11837 {
11838 PyThreadState* __tstate = wxPyBeginAllowThreads();
11839 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11840 wxPyEndAllowThreads(__tstate);
11841 if (PyErr_Occurred()) SWIG_fail;
11842 }
11843 {
11844 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11845 }
11846 {
11847 if (temp2)
11848 delete arg2;
11849 }
11850 return resultobj;
11851 fail:
11852 {
11853 if (temp2)
11854 delete arg2;
11855 }
11856 return NULL;
11857 }
11858
11859
11860 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11861 PyObject *resultobj = 0;
11862 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11863 wxString *arg2 = 0 ;
11864 void *argp1 = 0 ;
11865 int res1 = 0 ;
11866 bool temp2 = false ;
11867 PyObject * obj0 = 0 ;
11868 PyObject * obj1 = 0 ;
11869 char * kwnames[] = {
11870 (char *) "self",(char *) "name", NULL
11871 };
11872
11873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11875 if (!SWIG_IsOK(res1)) {
11876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11877 }
11878 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11879 {
11880 arg2 = wxString_in_helper(obj1);
11881 if (arg2 == NULL) SWIG_fail;
11882 temp2 = true;
11883 }
11884 {
11885 PyThreadState* __tstate = wxPyBeginAllowThreads();
11886 (arg1)->SetName((wxString const &)*arg2);
11887 wxPyEndAllowThreads(__tstate);
11888 if (PyErr_Occurred()) SWIG_fail;
11889 }
11890 resultobj = SWIG_Py_Void();
11891 {
11892 if (temp2)
11893 delete arg2;
11894 }
11895 return resultobj;
11896 fail:
11897 {
11898 if (temp2)
11899 delete arg2;
11900 }
11901 return NULL;
11902 }
11903
11904
11905 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11906 PyObject *resultobj = 0;
11907 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11908 wxString *arg2 = 0 ;
11909 void *argp1 = 0 ;
11910 int res1 = 0 ;
11911 bool temp2 = false ;
11912 PyObject * obj0 = 0 ;
11913 PyObject * obj1 = 0 ;
11914 char * kwnames[] = {
11915 (char *) "self",(char *) "extension", NULL
11916 };
11917
11918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
11919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11920 if (!SWIG_IsOK(res1)) {
11921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11922 }
11923 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11924 {
11925 arg2 = wxString_in_helper(obj1);
11926 if (arg2 == NULL) SWIG_fail;
11927 temp2 = true;
11928 }
11929 {
11930 PyThreadState* __tstate = wxPyBeginAllowThreads();
11931 (arg1)->SetExtension((wxString const &)*arg2);
11932 wxPyEndAllowThreads(__tstate);
11933 if (PyErr_Occurred()) SWIG_fail;
11934 }
11935 resultobj = SWIG_Py_Void();
11936 {
11937 if (temp2)
11938 delete arg2;
11939 }
11940 return resultobj;
11941 fail:
11942 {
11943 if (temp2)
11944 delete arg2;
11945 }
11946 return NULL;
11947 }
11948
11949
11950 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11951 PyObject *resultobj = 0;
11952 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11953 long arg2 ;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 long val2 ;
11957 int ecode2 = 0 ;
11958 PyObject * obj0 = 0 ;
11959 PyObject * obj1 = 0 ;
11960 char * kwnames[] = {
11961 (char *) "self",(char *) "type", NULL
11962 };
11963
11964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
11965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11966 if (!SWIG_IsOK(res1)) {
11967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11968 }
11969 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11970 ecode2 = SWIG_AsVal_long(obj1, &val2);
11971 if (!SWIG_IsOK(ecode2)) {
11972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
11973 }
11974 arg2 = static_cast< long >(val2);
11975 {
11976 PyThreadState* __tstate = wxPyBeginAllowThreads();
11977 (arg1)->SetType(arg2);
11978 wxPyEndAllowThreads(__tstate);
11979 if (PyErr_Occurred()) SWIG_fail;
11980 }
11981 resultobj = SWIG_Py_Void();
11982 return resultobj;
11983 fail:
11984 return NULL;
11985 }
11986
11987
11988 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11989 PyObject *resultobj = 0;
11990 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11991 wxString *arg2 = 0 ;
11992 void *argp1 = 0 ;
11993 int res1 = 0 ;
11994 bool temp2 = false ;
11995 PyObject * obj0 = 0 ;
11996 PyObject * obj1 = 0 ;
11997 char * kwnames[] = {
11998 (char *) "self",(char *) "mimetype", NULL
11999 };
12000
12001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12003 if (!SWIG_IsOK(res1)) {
12004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12005 }
12006 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12007 {
12008 arg2 = wxString_in_helper(obj1);
12009 if (arg2 == NULL) SWIG_fail;
12010 temp2 = true;
12011 }
12012 {
12013 PyThreadState* __tstate = wxPyBeginAllowThreads();
12014 (arg1)->SetMimeType((wxString const &)*arg2);
12015 wxPyEndAllowThreads(__tstate);
12016 if (PyErr_Occurred()) SWIG_fail;
12017 }
12018 resultobj = SWIG_Py_Void();
12019 {
12020 if (temp2)
12021 delete arg2;
12022 }
12023 return resultobj;
12024 fail:
12025 {
12026 if (temp2)
12027 delete arg2;
12028 }
12029 return NULL;
12030 }
12031
12032
12033 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12034 PyObject *obj;
12035 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12036 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12037 return SWIG_Py_Void();
12038 }
12039
12040 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12041 PyObject *resultobj = 0;
12042 wxPyImageHandler *result = 0 ;
12043
12044 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12045 {
12046 PyThreadState* __tstate = wxPyBeginAllowThreads();
12047 result = (wxPyImageHandler *)new wxPyImageHandler();
12048 wxPyEndAllowThreads(__tstate);
12049 if (PyErr_Occurred()) SWIG_fail;
12050 }
12051 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12052 return resultobj;
12053 fail:
12054 return NULL;
12055 }
12056
12057
12058 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12059 PyObject *resultobj = 0;
12060 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12061 PyObject *arg2 = (PyObject *) 0 ;
12062 void *argp1 = 0 ;
12063 int res1 = 0 ;
12064 PyObject * obj0 = 0 ;
12065 PyObject * obj1 = 0 ;
12066 char * kwnames[] = {
12067 (char *) "self",(char *) "self", NULL
12068 };
12069
12070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12072 if (!SWIG_IsOK(res1)) {
12073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12074 }
12075 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12076 arg2 = obj1;
12077 {
12078 PyThreadState* __tstate = wxPyBeginAllowThreads();
12079 (arg1)->_SetSelf(arg2);
12080 wxPyEndAllowThreads(__tstate);
12081 if (PyErr_Occurred()) SWIG_fail;
12082 }
12083 resultobj = SWIG_Py_Void();
12084 return resultobj;
12085 fail:
12086 return NULL;
12087 }
12088
12089
12090 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12091 PyObject *obj;
12092 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12093 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12094 return SWIG_Py_Void();
12095 }
12096
12097 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12098 return SWIG_Python_InitShadowInstance(args);
12099 }
12100
12101 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12102 PyObject *resultobj = 0;
12103 wxImageHistogram *result = 0 ;
12104
12105 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12106 {
12107 PyThreadState* __tstate = wxPyBeginAllowThreads();
12108 result = (wxImageHistogram *)new wxImageHistogram();
12109 wxPyEndAllowThreads(__tstate);
12110 if (PyErr_Occurred()) SWIG_fail;
12111 }
12112 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12113 return resultobj;
12114 fail:
12115 return NULL;
12116 }
12117
12118
12119 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12120 PyObject *resultobj = 0;
12121 byte arg1 ;
12122 byte arg2 ;
12123 byte arg3 ;
12124 unsigned long result;
12125 unsigned char val1 ;
12126 int ecode1 = 0 ;
12127 unsigned char val2 ;
12128 int ecode2 = 0 ;
12129 unsigned char val3 ;
12130 int ecode3 = 0 ;
12131 PyObject * obj0 = 0 ;
12132 PyObject * obj1 = 0 ;
12133 PyObject * obj2 = 0 ;
12134 char * kwnames[] = {
12135 (char *) "r",(char *) "g",(char *) "b", NULL
12136 };
12137
12138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12139 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12140 if (!SWIG_IsOK(ecode1)) {
12141 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12142 }
12143 arg1 = static_cast< byte >(val1);
12144 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12145 if (!SWIG_IsOK(ecode2)) {
12146 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12147 }
12148 arg2 = static_cast< byte >(val2);
12149 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12150 if (!SWIG_IsOK(ecode3)) {
12151 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12152 }
12153 arg3 = static_cast< byte >(val3);
12154 {
12155 PyThreadState* __tstate = wxPyBeginAllowThreads();
12156 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12157 wxPyEndAllowThreads(__tstate);
12158 if (PyErr_Occurred()) SWIG_fail;
12159 }
12160 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12161 return resultobj;
12162 fail:
12163 return NULL;
12164 }
12165
12166
12167 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12168 PyObject *resultobj = 0;
12169 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12170 byte *arg2 = (byte *) 0 ;
12171 byte *arg3 = (byte *) 0 ;
12172 byte *arg4 = (byte *) 0 ;
12173 byte arg5 = (byte) 1 ;
12174 byte arg6 = (byte) 0 ;
12175 byte arg7 = (byte) 0 ;
12176 bool result;
12177 void *argp1 = 0 ;
12178 int res1 = 0 ;
12179 byte temp2 ;
12180 int res2 = SWIG_TMPOBJ ;
12181 byte temp3 ;
12182 int res3 = SWIG_TMPOBJ ;
12183 byte temp4 ;
12184 int res4 = SWIG_TMPOBJ ;
12185 unsigned char val5 ;
12186 int ecode5 = 0 ;
12187 unsigned char val6 ;
12188 int ecode6 = 0 ;
12189 unsigned char val7 ;
12190 int ecode7 = 0 ;
12191 PyObject * obj0 = 0 ;
12192 PyObject * obj1 = 0 ;
12193 PyObject * obj2 = 0 ;
12194 PyObject * obj3 = 0 ;
12195 char * kwnames[] = {
12196 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12197 };
12198
12199 arg2 = &temp2;
12200 arg3 = &temp3;
12201 arg4 = &temp4;
12202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12204 if (!SWIG_IsOK(res1)) {
12205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12206 }
12207 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12208 if (obj1) {
12209 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12210 if (!SWIG_IsOK(ecode5)) {
12211 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12212 }
12213 arg5 = static_cast< byte >(val5);
12214 }
12215 if (obj2) {
12216 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12217 if (!SWIG_IsOK(ecode6)) {
12218 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12219 }
12220 arg6 = static_cast< byte >(val6);
12221 }
12222 if (obj3) {
12223 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12224 if (!SWIG_IsOK(ecode7)) {
12225 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12226 }
12227 arg7 = static_cast< byte >(val7);
12228 }
12229 {
12230 PyThreadState* __tstate = wxPyBeginAllowThreads();
12231 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12232 wxPyEndAllowThreads(__tstate);
12233 if (PyErr_Occurred()) SWIG_fail;
12234 }
12235 {
12236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12237 }
12238 if (SWIG_IsTmpObj(res2)) {
12239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12240 } else {
12241 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12243 }
12244 if (SWIG_IsTmpObj(res3)) {
12245 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12246 } else {
12247 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12248 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12249 }
12250 if (SWIG_IsTmpObj(res4)) {
12251 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12252 } else {
12253 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12254 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12255 }
12256 return resultobj;
12257 fail:
12258 return NULL;
12259 }
12260
12261
12262 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12263 PyObject *resultobj = 0;
12264 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12265 unsigned long arg2 ;
12266 unsigned long result;
12267 void *argp1 = 0 ;
12268 int res1 = 0 ;
12269 unsigned long val2 ;
12270 int ecode2 = 0 ;
12271 PyObject * obj0 = 0 ;
12272 PyObject * obj1 = 0 ;
12273 char * kwnames[] = {
12274 (char *) "self",(char *) "key", NULL
12275 };
12276
12277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12279 if (!SWIG_IsOK(res1)) {
12280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12281 }
12282 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12283 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12284 if (!SWIG_IsOK(ecode2)) {
12285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12286 }
12287 arg2 = static_cast< unsigned long >(val2);
12288 {
12289 PyThreadState* __tstate = wxPyBeginAllowThreads();
12290 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12291 wxPyEndAllowThreads(__tstate);
12292 if (PyErr_Occurred()) SWIG_fail;
12293 }
12294 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12295 return resultobj;
12296 fail:
12297 return NULL;
12298 }
12299
12300
12301 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12302 PyObject *resultobj = 0;
12303 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12304 byte arg2 ;
12305 byte arg3 ;
12306 byte arg4 ;
12307 unsigned long result;
12308 void *argp1 = 0 ;
12309 int res1 = 0 ;
12310 unsigned char val2 ;
12311 int ecode2 = 0 ;
12312 unsigned char val3 ;
12313 int ecode3 = 0 ;
12314 unsigned char val4 ;
12315 int ecode4 = 0 ;
12316 PyObject * obj0 = 0 ;
12317 PyObject * obj1 = 0 ;
12318 PyObject * obj2 = 0 ;
12319 PyObject * obj3 = 0 ;
12320 char * kwnames[] = {
12321 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12322 };
12323
12324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12326 if (!SWIG_IsOK(res1)) {
12327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12328 }
12329 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12330 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12331 if (!SWIG_IsOK(ecode2)) {
12332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12333 }
12334 arg2 = static_cast< byte >(val2);
12335 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12336 if (!SWIG_IsOK(ecode3)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12338 }
12339 arg3 = static_cast< byte >(val3);
12340 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12341 if (!SWIG_IsOK(ecode4)) {
12342 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12343 }
12344 arg4 = static_cast< byte >(val4);
12345 {
12346 PyThreadState* __tstate = wxPyBeginAllowThreads();
12347 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12348 wxPyEndAllowThreads(__tstate);
12349 if (PyErr_Occurred()) SWIG_fail;
12350 }
12351 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12352 return resultobj;
12353 fail:
12354 return NULL;
12355 }
12356
12357
12358 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12359 PyObject *resultobj = 0;
12360 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12361 wxColour *arg2 = 0 ;
12362 unsigned long result;
12363 void *argp1 = 0 ;
12364 int res1 = 0 ;
12365 wxColour temp2 ;
12366 PyObject * obj0 = 0 ;
12367 PyObject * obj1 = 0 ;
12368 char * kwnames[] = {
12369 (char *) "self",(char *) "colour", NULL
12370 };
12371
12372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12374 if (!SWIG_IsOK(res1)) {
12375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12376 }
12377 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12378 {
12379 arg2 = &temp2;
12380 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12381 }
12382 {
12383 PyThreadState* __tstate = wxPyBeginAllowThreads();
12384 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12385 wxPyEndAllowThreads(__tstate);
12386 if (PyErr_Occurred()) SWIG_fail;
12387 }
12388 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12389 return resultobj;
12390 fail:
12391 return NULL;
12392 }
12393
12394
12395 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12396 PyObject *obj;
12397 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12398 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12399 return SWIG_Py_Void();
12400 }
12401
12402 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12403 return SWIG_Python_InitShadowInstance(args);
12404 }
12405
12406 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12407 PyObject *resultobj = 0;
12408 byte arg1 = (byte) 0 ;
12409 byte arg2 = (byte) 0 ;
12410 byte arg3 = (byte) 0 ;
12411 wxImage_RGBValue *result = 0 ;
12412 unsigned char val1 ;
12413 int ecode1 = 0 ;
12414 unsigned char val2 ;
12415 int ecode2 = 0 ;
12416 unsigned char val3 ;
12417 int ecode3 = 0 ;
12418 PyObject * obj0 = 0 ;
12419 PyObject * obj1 = 0 ;
12420 PyObject * obj2 = 0 ;
12421 char * kwnames[] = {
12422 (char *) "r",(char *) "g",(char *) "b", NULL
12423 };
12424
12425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12426 if (obj0) {
12427 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12428 if (!SWIG_IsOK(ecode1)) {
12429 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12430 }
12431 arg1 = static_cast< byte >(val1);
12432 }
12433 if (obj1) {
12434 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12435 if (!SWIG_IsOK(ecode2)) {
12436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12437 }
12438 arg2 = static_cast< byte >(val2);
12439 }
12440 if (obj2) {
12441 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12442 if (!SWIG_IsOK(ecode3)) {
12443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12444 }
12445 arg3 = static_cast< byte >(val3);
12446 }
12447 {
12448 PyThreadState* __tstate = wxPyBeginAllowThreads();
12449 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12450 wxPyEndAllowThreads(__tstate);
12451 if (PyErr_Occurred()) SWIG_fail;
12452 }
12453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12454 return resultobj;
12455 fail:
12456 return NULL;
12457 }
12458
12459
12460 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12461 PyObject *resultobj = 0;
12462 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12463 byte arg2 ;
12464 void *argp1 = 0 ;
12465 int res1 = 0 ;
12466 unsigned char val2 ;
12467 int ecode2 = 0 ;
12468 PyObject *swig_obj[2] ;
12469
12470 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12472 if (!SWIG_IsOK(res1)) {
12473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12474 }
12475 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12476 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12477 if (!SWIG_IsOK(ecode2)) {
12478 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12479 }
12480 arg2 = static_cast< byte >(val2);
12481 if (arg1) (arg1)->red = arg2;
12482
12483 resultobj = SWIG_Py_Void();
12484 return resultobj;
12485 fail:
12486 return NULL;
12487 }
12488
12489
12490 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12491 PyObject *resultobj = 0;
12492 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12493 byte result;
12494 void *argp1 = 0 ;
12495 int res1 = 0 ;
12496 PyObject *swig_obj[1] ;
12497
12498 if (!args) SWIG_fail;
12499 swig_obj[0] = args;
12500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12501 if (!SWIG_IsOK(res1)) {
12502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12503 }
12504 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12505 result = (byte) ((arg1)->red);
12506 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12507 return resultobj;
12508 fail:
12509 return NULL;
12510 }
12511
12512
12513 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12514 PyObject *resultobj = 0;
12515 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12516 byte arg2 ;
12517 void *argp1 = 0 ;
12518 int res1 = 0 ;
12519 unsigned char val2 ;
12520 int ecode2 = 0 ;
12521 PyObject *swig_obj[2] ;
12522
12523 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12525 if (!SWIG_IsOK(res1)) {
12526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12527 }
12528 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12529 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12530 if (!SWIG_IsOK(ecode2)) {
12531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12532 }
12533 arg2 = static_cast< byte >(val2);
12534 if (arg1) (arg1)->green = arg2;
12535
12536 resultobj = SWIG_Py_Void();
12537 return resultobj;
12538 fail:
12539 return NULL;
12540 }
12541
12542
12543 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12544 PyObject *resultobj = 0;
12545 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12546 byte result;
12547 void *argp1 = 0 ;
12548 int res1 = 0 ;
12549 PyObject *swig_obj[1] ;
12550
12551 if (!args) SWIG_fail;
12552 swig_obj[0] = args;
12553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12554 if (!SWIG_IsOK(res1)) {
12555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12556 }
12557 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12558 result = (byte) ((arg1)->green);
12559 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12560 return resultobj;
12561 fail:
12562 return NULL;
12563 }
12564
12565
12566 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12567 PyObject *resultobj = 0;
12568 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12569 byte arg2 ;
12570 void *argp1 = 0 ;
12571 int res1 = 0 ;
12572 unsigned char val2 ;
12573 int ecode2 = 0 ;
12574 PyObject *swig_obj[2] ;
12575
12576 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12578 if (!SWIG_IsOK(res1)) {
12579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12580 }
12581 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12582 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12583 if (!SWIG_IsOK(ecode2)) {
12584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12585 }
12586 arg2 = static_cast< byte >(val2);
12587 if (arg1) (arg1)->blue = arg2;
12588
12589 resultobj = SWIG_Py_Void();
12590 return resultobj;
12591 fail:
12592 return NULL;
12593 }
12594
12595
12596 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12597 PyObject *resultobj = 0;
12598 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12599 byte result;
12600 void *argp1 = 0 ;
12601 int res1 = 0 ;
12602 PyObject *swig_obj[1] ;
12603
12604 if (!args) SWIG_fail;
12605 swig_obj[0] = args;
12606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12607 if (!SWIG_IsOK(res1)) {
12608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12609 }
12610 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12611 result = (byte) ((arg1)->blue);
12612 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12613 return resultobj;
12614 fail:
12615 return NULL;
12616 }
12617
12618
12619 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12620 PyObject *obj;
12621 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12622 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12623 return SWIG_Py_Void();
12624 }
12625
12626 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12627 return SWIG_Python_InitShadowInstance(args);
12628 }
12629
12630 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12631 PyObject *resultobj = 0;
12632 double arg1 = (double) 0.0 ;
12633 double arg2 = (double) 0.0 ;
12634 double arg3 = (double) 0.0 ;
12635 wxImage_HSVValue *result = 0 ;
12636 double val1 ;
12637 int ecode1 = 0 ;
12638 double val2 ;
12639 int ecode2 = 0 ;
12640 double val3 ;
12641 int ecode3 = 0 ;
12642 PyObject * obj0 = 0 ;
12643 PyObject * obj1 = 0 ;
12644 PyObject * obj2 = 0 ;
12645 char * kwnames[] = {
12646 (char *) "h",(char *) "s",(char *) "v", NULL
12647 };
12648
12649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12650 if (obj0) {
12651 ecode1 = SWIG_AsVal_double(obj0, &val1);
12652 if (!SWIG_IsOK(ecode1)) {
12653 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12654 }
12655 arg1 = static_cast< double >(val1);
12656 }
12657 if (obj1) {
12658 ecode2 = SWIG_AsVal_double(obj1, &val2);
12659 if (!SWIG_IsOK(ecode2)) {
12660 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12661 }
12662 arg2 = static_cast< double >(val2);
12663 }
12664 if (obj2) {
12665 ecode3 = SWIG_AsVal_double(obj2, &val3);
12666 if (!SWIG_IsOK(ecode3)) {
12667 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12668 }
12669 arg3 = static_cast< double >(val3);
12670 }
12671 {
12672 PyThreadState* __tstate = wxPyBeginAllowThreads();
12673 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12674 wxPyEndAllowThreads(__tstate);
12675 if (PyErr_Occurred()) SWIG_fail;
12676 }
12677 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12678 return resultobj;
12679 fail:
12680 return NULL;
12681 }
12682
12683
12684 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12685 PyObject *resultobj = 0;
12686 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12687 double arg2 ;
12688 void *argp1 = 0 ;
12689 int res1 = 0 ;
12690 double val2 ;
12691 int ecode2 = 0 ;
12692 PyObject *swig_obj[2] ;
12693
12694 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12696 if (!SWIG_IsOK(res1)) {
12697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12698 }
12699 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12700 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12701 if (!SWIG_IsOK(ecode2)) {
12702 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12703 }
12704 arg2 = static_cast< double >(val2);
12705 if (arg1) (arg1)->hue = arg2;
12706
12707 resultobj = SWIG_Py_Void();
12708 return resultobj;
12709 fail:
12710 return NULL;
12711 }
12712
12713
12714 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12715 PyObject *resultobj = 0;
12716 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12717 double result;
12718 void *argp1 = 0 ;
12719 int res1 = 0 ;
12720 PyObject *swig_obj[1] ;
12721
12722 if (!args) SWIG_fail;
12723 swig_obj[0] = args;
12724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12725 if (!SWIG_IsOK(res1)) {
12726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12727 }
12728 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12729 result = (double) ((arg1)->hue);
12730 resultobj = SWIG_From_double(static_cast< double >(result));
12731 return resultobj;
12732 fail:
12733 return NULL;
12734 }
12735
12736
12737 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12738 PyObject *resultobj = 0;
12739 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12740 double arg2 ;
12741 void *argp1 = 0 ;
12742 int res1 = 0 ;
12743 double val2 ;
12744 int ecode2 = 0 ;
12745 PyObject *swig_obj[2] ;
12746
12747 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12749 if (!SWIG_IsOK(res1)) {
12750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12751 }
12752 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12753 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12754 if (!SWIG_IsOK(ecode2)) {
12755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12756 }
12757 arg2 = static_cast< double >(val2);
12758 if (arg1) (arg1)->saturation = arg2;
12759
12760 resultobj = SWIG_Py_Void();
12761 return resultobj;
12762 fail:
12763 return NULL;
12764 }
12765
12766
12767 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12768 PyObject *resultobj = 0;
12769 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12770 double result;
12771 void *argp1 = 0 ;
12772 int res1 = 0 ;
12773 PyObject *swig_obj[1] ;
12774
12775 if (!args) SWIG_fail;
12776 swig_obj[0] = args;
12777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12778 if (!SWIG_IsOK(res1)) {
12779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12780 }
12781 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12782 result = (double) ((arg1)->saturation);
12783 resultobj = SWIG_From_double(static_cast< double >(result));
12784 return resultobj;
12785 fail:
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12791 PyObject *resultobj = 0;
12792 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12793 double arg2 ;
12794 void *argp1 = 0 ;
12795 int res1 = 0 ;
12796 double val2 ;
12797 int ecode2 = 0 ;
12798 PyObject *swig_obj[2] ;
12799
12800 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12802 if (!SWIG_IsOK(res1)) {
12803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12804 }
12805 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12806 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12807 if (!SWIG_IsOK(ecode2)) {
12808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12809 }
12810 arg2 = static_cast< double >(val2);
12811 if (arg1) (arg1)->value = arg2;
12812
12813 resultobj = SWIG_Py_Void();
12814 return resultobj;
12815 fail:
12816 return NULL;
12817 }
12818
12819
12820 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12821 PyObject *resultobj = 0;
12822 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12823 double result;
12824 void *argp1 = 0 ;
12825 int res1 = 0 ;
12826 PyObject *swig_obj[1] ;
12827
12828 if (!args) SWIG_fail;
12829 swig_obj[0] = args;
12830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12831 if (!SWIG_IsOK(res1)) {
12832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12833 }
12834 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12835 result = (double) ((arg1)->value);
12836 resultobj = SWIG_From_double(static_cast< double >(result));
12837 return resultobj;
12838 fail:
12839 return NULL;
12840 }
12841
12842
12843 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12844 PyObject *obj;
12845 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12846 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12847 return SWIG_Py_Void();
12848 }
12849
12850 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12851 return SWIG_Python_InitShadowInstance(args);
12852 }
12853
12854 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12855 PyObject *resultobj = 0;
12856 wxString *arg1 = 0 ;
12857 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12858 int arg3 = (int) -1 ;
12859 wxImage *result = 0 ;
12860 bool temp1 = false ;
12861 long val2 ;
12862 int ecode2 = 0 ;
12863 int val3 ;
12864 int ecode3 = 0 ;
12865 PyObject * obj0 = 0 ;
12866 PyObject * obj1 = 0 ;
12867 PyObject * obj2 = 0 ;
12868 char * kwnames[] = {
12869 (char *) "name",(char *) "type",(char *) "index", NULL
12870 };
12871
12872 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12873 {
12874 arg1 = wxString_in_helper(obj0);
12875 if (arg1 == NULL) SWIG_fail;
12876 temp1 = true;
12877 }
12878 if (obj1) {
12879 ecode2 = SWIG_AsVal_long(obj1, &val2);
12880 if (!SWIG_IsOK(ecode2)) {
12881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12882 }
12883 arg2 = static_cast< long >(val2);
12884 }
12885 if (obj2) {
12886 ecode3 = SWIG_AsVal_int(obj2, &val3);
12887 if (!SWIG_IsOK(ecode3)) {
12888 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
12889 }
12890 arg3 = static_cast< int >(val3);
12891 }
12892 {
12893 PyThreadState* __tstate = wxPyBeginAllowThreads();
12894 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
12895 wxPyEndAllowThreads(__tstate);
12896 if (PyErr_Occurred()) SWIG_fail;
12897 }
12898 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
12899 {
12900 if (temp1)
12901 delete arg1;
12902 }
12903 return resultobj;
12904 fail:
12905 {
12906 if (temp1)
12907 delete arg1;
12908 }
12909 return NULL;
12910 }
12911
12912
12913 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12914 PyObject *resultobj = 0;
12915 wxImage *arg1 = (wxImage *) 0 ;
12916 void *argp1 = 0 ;
12917 int res1 = 0 ;
12918 PyObject *swig_obj[1] ;
12919
12920 if (!args) SWIG_fail;
12921 swig_obj[0] = args;
12922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
12923 if (!SWIG_IsOK(res1)) {
12924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
12925 }
12926 arg1 = reinterpret_cast< wxImage * >(argp1);
12927 {
12928 PyThreadState* __tstate = wxPyBeginAllowThreads();
12929 delete arg1;
12930
12931 wxPyEndAllowThreads(__tstate);
12932 if (PyErr_Occurred()) SWIG_fail;
12933 }
12934 resultobj = SWIG_Py_Void();
12935 return resultobj;
12936 fail:
12937 return NULL;
12938 }
12939
12940
12941 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12942 PyObject *resultobj = 0;
12943 wxString *arg1 = 0 ;
12944 wxString *arg2 = 0 ;
12945 int arg3 = (int) -1 ;
12946 wxImage *result = 0 ;
12947 bool temp1 = false ;
12948 bool temp2 = false ;
12949 int val3 ;
12950 int ecode3 = 0 ;
12951 PyObject * obj0 = 0 ;
12952 PyObject * obj1 = 0 ;
12953 PyObject * obj2 = 0 ;
12954 char * kwnames[] = {
12955 (char *) "name",(char *) "mimetype",(char *) "index", NULL
12956 };
12957
12958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12959 {
12960 arg1 = wxString_in_helper(obj0);
12961 if (arg1 == NULL) SWIG_fail;
12962 temp1 = true;
12963 }
12964 {
12965 arg2 = wxString_in_helper(obj1);
12966 if (arg2 == NULL) SWIG_fail;
12967 temp2 = true;
12968 }
12969 if (obj2) {
12970 ecode3 = SWIG_AsVal_int(obj2, &val3);
12971 if (!SWIG_IsOK(ecode3)) {
12972 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
12973 }
12974 arg3 = static_cast< int >(val3);
12975 }
12976 {
12977 PyThreadState* __tstate = wxPyBeginAllowThreads();
12978 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
12979 wxPyEndAllowThreads(__tstate);
12980 if (PyErr_Occurred()) SWIG_fail;
12981 }
12982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
12983 {
12984 if (temp1)
12985 delete arg1;
12986 }
12987 {
12988 if (temp2)
12989 delete arg2;
12990 }
12991 return resultobj;
12992 fail:
12993 {
12994 if (temp1)
12995 delete arg1;
12996 }
12997 {
12998 if (temp2)
12999 delete arg2;
13000 }
13001 return NULL;
13002 }
13003
13004
13005 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13006 PyObject *resultobj = 0;
13007 wxInputStream *arg1 = 0 ;
13008 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13009 int arg3 = (int) -1 ;
13010 wxImage *result = 0 ;
13011 wxPyInputStream *temp1 ;
13012 bool created1 ;
13013 long val2 ;
13014 int ecode2 = 0 ;
13015 int val3 ;
13016 int ecode3 = 0 ;
13017 PyObject * obj0 = 0 ;
13018 PyObject * obj1 = 0 ;
13019 PyObject * obj2 = 0 ;
13020 char * kwnames[] = {
13021 (char *) "stream",(char *) "type",(char *) "index", NULL
13022 };
13023
13024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13025 {
13026 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13027 arg1 = temp1->m_wxis;
13028 created1 = false;
13029 } else {
13030 PyErr_Clear(); // clear the failure of the wxPyConvert above
13031 arg1 = wxPyCBInputStream_create(obj0, false);
13032 if (arg1 == NULL) {
13033 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13034 SWIG_fail;
13035 }
13036 created1 = true;
13037 }
13038 }
13039 if (obj1) {
13040 ecode2 = SWIG_AsVal_long(obj1, &val2);
13041 if (!SWIG_IsOK(ecode2)) {
13042 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13043 }
13044 arg2 = static_cast< long >(val2);
13045 }
13046 if (obj2) {
13047 ecode3 = SWIG_AsVal_int(obj2, &val3);
13048 if (!SWIG_IsOK(ecode3)) {
13049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13050 }
13051 arg3 = static_cast< int >(val3);
13052 }
13053 {
13054 PyThreadState* __tstate = wxPyBeginAllowThreads();
13055 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13056 wxPyEndAllowThreads(__tstate);
13057 if (PyErr_Occurred()) SWIG_fail;
13058 }
13059 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13060 {
13061 if (created1) delete arg1;
13062 }
13063 return resultobj;
13064 fail:
13065 {
13066 if (created1) delete arg1;
13067 }
13068 return NULL;
13069 }
13070
13071
13072 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13073 PyObject *resultobj = 0;
13074 wxInputStream *arg1 = 0 ;
13075 wxString *arg2 = 0 ;
13076 int arg3 = (int) -1 ;
13077 wxImage *result = 0 ;
13078 wxPyInputStream *temp1 ;
13079 bool created1 ;
13080 bool temp2 = false ;
13081 int val3 ;
13082 int ecode3 = 0 ;
13083 PyObject * obj0 = 0 ;
13084 PyObject * obj1 = 0 ;
13085 PyObject * obj2 = 0 ;
13086 char * kwnames[] = {
13087 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13088 };
13089
13090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13091 {
13092 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13093 arg1 = temp1->m_wxis;
13094 created1 = false;
13095 } else {
13096 PyErr_Clear(); // clear the failure of the wxPyConvert above
13097 arg1 = wxPyCBInputStream_create(obj0, false);
13098 if (arg1 == NULL) {
13099 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13100 SWIG_fail;
13101 }
13102 created1 = true;
13103 }
13104 }
13105 {
13106 arg2 = wxString_in_helper(obj1);
13107 if (arg2 == NULL) SWIG_fail;
13108 temp2 = true;
13109 }
13110 if (obj2) {
13111 ecode3 = SWIG_AsVal_int(obj2, &val3);
13112 if (!SWIG_IsOK(ecode3)) {
13113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13114 }
13115 arg3 = static_cast< int >(val3);
13116 }
13117 {
13118 PyThreadState* __tstate = wxPyBeginAllowThreads();
13119 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13120 wxPyEndAllowThreads(__tstate);
13121 if (PyErr_Occurred()) SWIG_fail;
13122 }
13123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13124 {
13125 if (created1) delete arg1;
13126 }
13127 {
13128 if (temp2)
13129 delete arg2;
13130 }
13131 return resultobj;
13132 fail:
13133 {
13134 if (created1) delete arg1;
13135 }
13136 {
13137 if (temp2)
13138 delete arg2;
13139 }
13140 return NULL;
13141 }
13142
13143
13144 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13145 PyObject *resultobj = 0;
13146 int arg1 = (int) 0 ;
13147 int arg2 = (int) 0 ;
13148 bool arg3 = (bool) true ;
13149 wxImage *result = 0 ;
13150 int val1 ;
13151 int ecode1 = 0 ;
13152 int val2 ;
13153 int ecode2 = 0 ;
13154 bool val3 ;
13155 int ecode3 = 0 ;
13156 PyObject * obj0 = 0 ;
13157 PyObject * obj1 = 0 ;
13158 PyObject * obj2 = 0 ;
13159 char * kwnames[] = {
13160 (char *) "width",(char *) "height",(char *) "clear", NULL
13161 };
13162
13163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13164 if (obj0) {
13165 ecode1 = SWIG_AsVal_int(obj0, &val1);
13166 if (!SWIG_IsOK(ecode1)) {
13167 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13168 }
13169 arg1 = static_cast< int >(val1);
13170 }
13171 if (obj1) {
13172 ecode2 = SWIG_AsVal_int(obj1, &val2);
13173 if (!SWIG_IsOK(ecode2)) {
13174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13175 }
13176 arg2 = static_cast< int >(val2);
13177 }
13178 if (obj2) {
13179 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13180 if (!SWIG_IsOK(ecode3)) {
13181 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13182 }
13183 arg3 = static_cast< bool >(val3);
13184 }
13185 {
13186 PyThreadState* __tstate = wxPyBeginAllowThreads();
13187 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13188 wxPyEndAllowThreads(__tstate);
13189 if (PyErr_Occurred()) SWIG_fail;
13190 }
13191 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13192 return resultobj;
13193 fail:
13194 return NULL;
13195 }
13196
13197
13198 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13199 PyObject *resultobj = 0;
13200 wxBitmap *arg1 = 0 ;
13201 wxImage *result = 0 ;
13202 void *argp1 = 0 ;
13203 int res1 = 0 ;
13204 PyObject * obj0 = 0 ;
13205 char * kwnames[] = {
13206 (char *) "bitmap", NULL
13207 };
13208
13209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13210 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13211 if (!SWIG_IsOK(res1)) {
13212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13213 }
13214 if (!argp1) {
13215 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13216 }
13217 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13218 {
13219 if (!wxPyCheckForApp()) SWIG_fail;
13220 PyThreadState* __tstate = wxPyBeginAllowThreads();
13221 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13222 wxPyEndAllowThreads(__tstate);
13223 if (PyErr_Occurred()) SWIG_fail;
13224 }
13225 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13226 return resultobj;
13227 fail:
13228 return NULL;
13229 }
13230
13231
13232 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13233 PyObject *resultobj = 0;
13234 int arg1 ;
13235 int arg2 ;
13236 buffer arg3 ;
13237 int arg4 ;
13238 wxImage *result = 0 ;
13239 int val1 ;
13240 int ecode1 = 0 ;
13241 int val2 ;
13242 int ecode2 = 0 ;
13243 PyObject * obj0 = 0 ;
13244 PyObject * obj1 = 0 ;
13245 PyObject * obj2 = 0 ;
13246 char * kwnames[] = {
13247 (char *) "width",(char *) "height",(char *) "data", NULL
13248 };
13249
13250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13251 ecode1 = SWIG_AsVal_int(obj0, &val1);
13252 if (!SWIG_IsOK(ecode1)) {
13253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13254 }
13255 arg1 = static_cast< int >(val1);
13256 ecode2 = SWIG_AsVal_int(obj1, &val2);
13257 if (!SWIG_IsOK(ecode2)) {
13258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13259 }
13260 arg2 = static_cast< int >(val2);
13261 {
13262 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13263 }
13264 {
13265 PyThreadState* __tstate = wxPyBeginAllowThreads();
13266 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13267 wxPyEndAllowThreads(__tstate);
13268 if (PyErr_Occurred()) SWIG_fail;
13269 }
13270 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13271 return resultobj;
13272 fail:
13273 return NULL;
13274 }
13275
13276
13277 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13278 PyObject *resultobj = 0;
13279 int arg1 ;
13280 int arg2 ;
13281 buffer arg3 ;
13282 int arg4 ;
13283 buffer arg5 ;
13284 int arg6 ;
13285 wxImage *result = 0 ;
13286 int val1 ;
13287 int ecode1 = 0 ;
13288 int val2 ;
13289 int ecode2 = 0 ;
13290 PyObject * obj0 = 0 ;
13291 PyObject * obj1 = 0 ;
13292 PyObject * obj2 = 0 ;
13293 PyObject * obj3 = 0 ;
13294 char * kwnames[] = {
13295 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13296 };
13297
13298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13299 ecode1 = SWIG_AsVal_int(obj0, &val1);
13300 if (!SWIG_IsOK(ecode1)) {
13301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13302 }
13303 arg1 = static_cast< int >(val1);
13304 ecode2 = SWIG_AsVal_int(obj1, &val2);
13305 if (!SWIG_IsOK(ecode2)) {
13306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13307 }
13308 arg2 = static_cast< int >(val2);
13309 {
13310 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13311 }
13312 {
13313 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13314 }
13315 {
13316 PyThreadState* __tstate = wxPyBeginAllowThreads();
13317 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13318 wxPyEndAllowThreads(__tstate);
13319 if (PyErr_Occurred()) SWIG_fail;
13320 }
13321 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13322 return resultobj;
13323 fail:
13324 return NULL;
13325 }
13326
13327
13328 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13329 PyObject *resultobj = 0;
13330 wxImage *arg1 = (wxImage *) 0 ;
13331 int arg2 ;
13332 int arg3 ;
13333 bool arg4 = (bool) true ;
13334 void *argp1 = 0 ;
13335 int res1 = 0 ;
13336 int val2 ;
13337 int ecode2 = 0 ;
13338 int val3 ;
13339 int ecode3 = 0 ;
13340 bool val4 ;
13341 int ecode4 = 0 ;
13342 PyObject * obj0 = 0 ;
13343 PyObject * obj1 = 0 ;
13344 PyObject * obj2 = 0 ;
13345 PyObject * obj3 = 0 ;
13346 char * kwnames[] = {
13347 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13348 };
13349
13350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13352 if (!SWIG_IsOK(res1)) {
13353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13354 }
13355 arg1 = reinterpret_cast< wxImage * >(argp1);
13356 ecode2 = SWIG_AsVal_int(obj1, &val2);
13357 if (!SWIG_IsOK(ecode2)) {
13358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13359 }
13360 arg2 = static_cast< int >(val2);
13361 ecode3 = SWIG_AsVal_int(obj2, &val3);
13362 if (!SWIG_IsOK(ecode3)) {
13363 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13364 }
13365 arg3 = static_cast< int >(val3);
13366 if (obj3) {
13367 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13368 if (!SWIG_IsOK(ecode4)) {
13369 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13370 }
13371 arg4 = static_cast< bool >(val4);
13372 }
13373 {
13374 PyThreadState* __tstate = wxPyBeginAllowThreads();
13375 (arg1)->Create(arg2,arg3,arg4);
13376 wxPyEndAllowThreads(__tstate);
13377 if (PyErr_Occurred()) SWIG_fail;
13378 }
13379 resultobj = SWIG_Py_Void();
13380 return resultobj;
13381 fail:
13382 return NULL;
13383 }
13384
13385
13386 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13387 PyObject *resultobj = 0;
13388 wxImage *arg1 = (wxImage *) 0 ;
13389 void *argp1 = 0 ;
13390 int res1 = 0 ;
13391 PyObject *swig_obj[1] ;
13392
13393 if (!args) SWIG_fail;
13394 swig_obj[0] = args;
13395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13396 if (!SWIG_IsOK(res1)) {
13397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13398 }
13399 arg1 = reinterpret_cast< wxImage * >(argp1);
13400 {
13401 PyThreadState* __tstate = wxPyBeginAllowThreads();
13402 (arg1)->Destroy();
13403 wxPyEndAllowThreads(__tstate);
13404 if (PyErr_Occurred()) SWIG_fail;
13405 }
13406 resultobj = SWIG_Py_Void();
13407 return resultobj;
13408 fail:
13409 return NULL;
13410 }
13411
13412
13413 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13414 PyObject *resultobj = 0;
13415 wxImage *arg1 = (wxImage *) 0 ;
13416 int arg2 ;
13417 int arg3 ;
13418 SwigValueWrapper<wxImage > result;
13419 void *argp1 = 0 ;
13420 int res1 = 0 ;
13421 int val2 ;
13422 int ecode2 = 0 ;
13423 int val3 ;
13424 int ecode3 = 0 ;
13425 PyObject * obj0 = 0 ;
13426 PyObject * obj1 = 0 ;
13427 PyObject * obj2 = 0 ;
13428 char * kwnames[] = {
13429 (char *) "self",(char *) "width",(char *) "height", NULL
13430 };
13431
13432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13434 if (!SWIG_IsOK(res1)) {
13435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13436 }
13437 arg1 = reinterpret_cast< wxImage * >(argp1);
13438 ecode2 = SWIG_AsVal_int(obj1, &val2);
13439 if (!SWIG_IsOK(ecode2)) {
13440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13441 }
13442 arg2 = static_cast< int >(val2);
13443 ecode3 = SWIG_AsVal_int(obj2, &val3);
13444 if (!SWIG_IsOK(ecode3)) {
13445 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13446 }
13447 arg3 = static_cast< int >(val3);
13448 {
13449 PyThreadState* __tstate = wxPyBeginAllowThreads();
13450 result = (arg1)->Scale(arg2,arg3);
13451 wxPyEndAllowThreads(__tstate);
13452 if (PyErr_Occurred()) SWIG_fail;
13453 }
13454 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13455 return resultobj;
13456 fail:
13457 return NULL;
13458 }
13459
13460
13461 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13462 PyObject *resultobj = 0;
13463 wxImage *arg1 = (wxImage *) 0 ;
13464 int arg2 ;
13465 int arg3 ;
13466 SwigValueWrapper<wxImage > result;
13467 void *argp1 = 0 ;
13468 int res1 = 0 ;
13469 int val2 ;
13470 int ecode2 = 0 ;
13471 int val3 ;
13472 int ecode3 = 0 ;
13473 PyObject * obj0 = 0 ;
13474 PyObject * obj1 = 0 ;
13475 PyObject * obj2 = 0 ;
13476 char * kwnames[] = {
13477 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13478 };
13479
13480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13482 if (!SWIG_IsOK(res1)) {
13483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13484 }
13485 arg1 = reinterpret_cast< wxImage * >(argp1);
13486 ecode2 = SWIG_AsVal_int(obj1, &val2);
13487 if (!SWIG_IsOK(ecode2)) {
13488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13489 }
13490 arg2 = static_cast< int >(val2);
13491 ecode3 = SWIG_AsVal_int(obj2, &val3);
13492 if (!SWIG_IsOK(ecode3)) {
13493 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13494 }
13495 arg3 = static_cast< int >(val3);
13496 {
13497 PyThreadState* __tstate = wxPyBeginAllowThreads();
13498 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13499 wxPyEndAllowThreads(__tstate);
13500 if (PyErr_Occurred()) SWIG_fail;
13501 }
13502 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13503 return resultobj;
13504 fail:
13505 return NULL;
13506 }
13507
13508
13509 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13510 PyObject *resultobj = 0;
13511 wxImage *arg1 = (wxImage *) 0 ;
13512 int arg2 ;
13513 int arg3 ;
13514 wxImage *result = 0 ;
13515 void *argp1 = 0 ;
13516 int res1 = 0 ;
13517 int val2 ;
13518 int ecode2 = 0 ;
13519 int val3 ;
13520 int ecode3 = 0 ;
13521 PyObject * obj0 = 0 ;
13522 PyObject * obj1 = 0 ;
13523 PyObject * obj2 = 0 ;
13524 char * kwnames[] = {
13525 (char *) "self",(char *) "width",(char *) "height", NULL
13526 };
13527
13528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13530 if (!SWIG_IsOK(res1)) {
13531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13532 }
13533 arg1 = reinterpret_cast< wxImage * >(argp1);
13534 ecode2 = SWIG_AsVal_int(obj1, &val2);
13535 if (!SWIG_IsOK(ecode2)) {
13536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13537 }
13538 arg2 = static_cast< int >(val2);
13539 ecode3 = SWIG_AsVal_int(obj2, &val3);
13540 if (!SWIG_IsOK(ecode3)) {
13541 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13542 }
13543 arg3 = static_cast< int >(val3);
13544 {
13545 PyThreadState* __tstate = wxPyBeginAllowThreads();
13546 {
13547 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13548 result = (wxImage *) &_result_ref;
13549 }
13550 wxPyEndAllowThreads(__tstate);
13551 if (PyErr_Occurred()) SWIG_fail;
13552 }
13553 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13554 return resultobj;
13555 fail:
13556 return NULL;
13557 }
13558
13559
13560 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13561 PyObject *resultobj = 0;
13562 wxImage *arg1 = (wxImage *) 0 ;
13563 wxSize *arg2 = 0 ;
13564 wxPoint *arg3 = 0 ;
13565 int arg4 = (int) -1 ;
13566 int arg5 = (int) -1 ;
13567 int arg6 = (int) -1 ;
13568 wxImage *result = 0 ;
13569 void *argp1 = 0 ;
13570 int res1 = 0 ;
13571 wxSize temp2 ;
13572 wxPoint temp3 ;
13573 int val4 ;
13574 int ecode4 = 0 ;
13575 int val5 ;
13576 int ecode5 = 0 ;
13577 int val6 ;
13578 int ecode6 = 0 ;
13579 PyObject * obj0 = 0 ;
13580 PyObject * obj1 = 0 ;
13581 PyObject * obj2 = 0 ;
13582 PyObject * obj3 = 0 ;
13583 PyObject * obj4 = 0 ;
13584 PyObject * obj5 = 0 ;
13585 char * kwnames[] = {
13586 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13587 };
13588
13589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13591 if (!SWIG_IsOK(res1)) {
13592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13593 }
13594 arg1 = reinterpret_cast< wxImage * >(argp1);
13595 {
13596 arg2 = &temp2;
13597 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13598 }
13599 {
13600 arg3 = &temp3;
13601 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13602 }
13603 if (obj3) {
13604 ecode4 = SWIG_AsVal_int(obj3, &val4);
13605 if (!SWIG_IsOK(ecode4)) {
13606 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13607 }
13608 arg4 = static_cast< int >(val4);
13609 }
13610 if (obj4) {
13611 ecode5 = SWIG_AsVal_int(obj4, &val5);
13612 if (!SWIG_IsOK(ecode5)) {
13613 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13614 }
13615 arg5 = static_cast< int >(val5);
13616 }
13617 if (obj5) {
13618 ecode6 = SWIG_AsVal_int(obj5, &val6);
13619 if (!SWIG_IsOK(ecode6)) {
13620 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13621 }
13622 arg6 = static_cast< int >(val6);
13623 }
13624 {
13625 PyThreadState* __tstate = wxPyBeginAllowThreads();
13626 {
13627 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13628 result = (wxImage *) &_result_ref;
13629 }
13630 wxPyEndAllowThreads(__tstate);
13631 if (PyErr_Occurred()) SWIG_fail;
13632 }
13633 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13634 return resultobj;
13635 fail:
13636 return NULL;
13637 }
13638
13639
13640 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13641 PyObject *resultobj = 0;
13642 wxImage *arg1 = (wxImage *) 0 ;
13643 int arg2 ;
13644 int arg3 ;
13645 byte arg4 ;
13646 byte arg5 ;
13647 byte arg6 ;
13648 void *argp1 = 0 ;
13649 int res1 = 0 ;
13650 int val2 ;
13651 int ecode2 = 0 ;
13652 int val3 ;
13653 int ecode3 = 0 ;
13654 unsigned char val4 ;
13655 int ecode4 = 0 ;
13656 unsigned char val5 ;
13657 int ecode5 = 0 ;
13658 unsigned char val6 ;
13659 int ecode6 = 0 ;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 PyObject * obj2 = 0 ;
13663 PyObject * obj3 = 0 ;
13664 PyObject * obj4 = 0 ;
13665 PyObject * obj5 = 0 ;
13666 char * kwnames[] = {
13667 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13668 };
13669
13670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13672 if (!SWIG_IsOK(res1)) {
13673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13674 }
13675 arg1 = reinterpret_cast< wxImage * >(argp1);
13676 ecode2 = SWIG_AsVal_int(obj1, &val2);
13677 if (!SWIG_IsOK(ecode2)) {
13678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13679 }
13680 arg2 = static_cast< int >(val2);
13681 ecode3 = SWIG_AsVal_int(obj2, &val3);
13682 if (!SWIG_IsOK(ecode3)) {
13683 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13684 }
13685 arg3 = static_cast< int >(val3);
13686 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13687 if (!SWIG_IsOK(ecode4)) {
13688 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13689 }
13690 arg4 = static_cast< byte >(val4);
13691 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13692 if (!SWIG_IsOK(ecode5)) {
13693 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13694 }
13695 arg5 = static_cast< byte >(val5);
13696 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13697 if (!SWIG_IsOK(ecode6)) {
13698 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13699 }
13700 arg6 = static_cast< byte >(val6);
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13704 wxPyEndAllowThreads(__tstate);
13705 if (PyErr_Occurred()) SWIG_fail;
13706 }
13707 resultobj = SWIG_Py_Void();
13708 return resultobj;
13709 fail:
13710 return NULL;
13711 }
13712
13713
13714 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13715 PyObject *resultobj = 0;
13716 wxImage *arg1 = (wxImage *) 0 ;
13717 wxRect *arg2 = 0 ;
13718 byte arg3 ;
13719 byte arg4 ;
13720 byte arg5 ;
13721 void *argp1 = 0 ;
13722 int res1 = 0 ;
13723 wxRect temp2 ;
13724 unsigned char val3 ;
13725 int ecode3 = 0 ;
13726 unsigned char val4 ;
13727 int ecode4 = 0 ;
13728 unsigned char val5 ;
13729 int ecode5 = 0 ;
13730 PyObject * obj0 = 0 ;
13731 PyObject * obj1 = 0 ;
13732 PyObject * obj2 = 0 ;
13733 PyObject * obj3 = 0 ;
13734 PyObject * obj4 = 0 ;
13735 char * kwnames[] = {
13736 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13737 };
13738
13739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13741 if (!SWIG_IsOK(res1)) {
13742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13743 }
13744 arg1 = reinterpret_cast< wxImage * >(argp1);
13745 {
13746 arg2 = &temp2;
13747 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13748 }
13749 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13750 if (!SWIG_IsOK(ecode3)) {
13751 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13752 }
13753 arg3 = static_cast< byte >(val3);
13754 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13755 if (!SWIG_IsOK(ecode4)) {
13756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13757 }
13758 arg4 = static_cast< byte >(val4);
13759 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13760 if (!SWIG_IsOK(ecode5)) {
13761 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13762 }
13763 arg5 = static_cast< byte >(val5);
13764 {
13765 PyThreadState* __tstate = wxPyBeginAllowThreads();
13766 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13767 wxPyEndAllowThreads(__tstate);
13768 if (PyErr_Occurred()) SWIG_fail;
13769 }
13770 resultobj = SWIG_Py_Void();
13771 return resultobj;
13772 fail:
13773 return NULL;
13774 }
13775
13776
13777 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13778 PyObject *resultobj = 0;
13779 wxImage *arg1 = (wxImage *) 0 ;
13780 int arg2 ;
13781 int arg3 ;
13782 byte result;
13783 void *argp1 = 0 ;
13784 int res1 = 0 ;
13785 int val2 ;
13786 int ecode2 = 0 ;
13787 int val3 ;
13788 int ecode3 = 0 ;
13789 PyObject * obj0 = 0 ;
13790 PyObject * obj1 = 0 ;
13791 PyObject * obj2 = 0 ;
13792 char * kwnames[] = {
13793 (char *) "self",(char *) "x",(char *) "y", NULL
13794 };
13795
13796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13798 if (!SWIG_IsOK(res1)) {
13799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13800 }
13801 arg1 = reinterpret_cast< wxImage * >(argp1);
13802 ecode2 = SWIG_AsVal_int(obj1, &val2);
13803 if (!SWIG_IsOK(ecode2)) {
13804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13805 }
13806 arg2 = static_cast< int >(val2);
13807 ecode3 = SWIG_AsVal_int(obj2, &val3);
13808 if (!SWIG_IsOK(ecode3)) {
13809 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13810 }
13811 arg3 = static_cast< int >(val3);
13812 {
13813 PyThreadState* __tstate = wxPyBeginAllowThreads();
13814 result = (byte)(arg1)->GetRed(arg2,arg3);
13815 wxPyEndAllowThreads(__tstate);
13816 if (PyErr_Occurred()) SWIG_fail;
13817 }
13818 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13819 return resultobj;
13820 fail:
13821 return NULL;
13822 }
13823
13824
13825 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13826 PyObject *resultobj = 0;
13827 wxImage *arg1 = (wxImage *) 0 ;
13828 int arg2 ;
13829 int arg3 ;
13830 byte result;
13831 void *argp1 = 0 ;
13832 int res1 = 0 ;
13833 int val2 ;
13834 int ecode2 = 0 ;
13835 int val3 ;
13836 int ecode3 = 0 ;
13837 PyObject * obj0 = 0 ;
13838 PyObject * obj1 = 0 ;
13839 PyObject * obj2 = 0 ;
13840 char * kwnames[] = {
13841 (char *) "self",(char *) "x",(char *) "y", NULL
13842 };
13843
13844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13846 if (!SWIG_IsOK(res1)) {
13847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13848 }
13849 arg1 = reinterpret_cast< wxImage * >(argp1);
13850 ecode2 = SWIG_AsVal_int(obj1, &val2);
13851 if (!SWIG_IsOK(ecode2)) {
13852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13853 }
13854 arg2 = static_cast< int >(val2);
13855 ecode3 = SWIG_AsVal_int(obj2, &val3);
13856 if (!SWIG_IsOK(ecode3)) {
13857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13858 }
13859 arg3 = static_cast< int >(val3);
13860 {
13861 PyThreadState* __tstate = wxPyBeginAllowThreads();
13862 result = (byte)(arg1)->GetGreen(arg2,arg3);
13863 wxPyEndAllowThreads(__tstate);
13864 if (PyErr_Occurred()) SWIG_fail;
13865 }
13866 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13867 return resultobj;
13868 fail:
13869 return NULL;
13870 }
13871
13872
13873 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13874 PyObject *resultobj = 0;
13875 wxImage *arg1 = (wxImage *) 0 ;
13876 int arg2 ;
13877 int arg3 ;
13878 byte result;
13879 void *argp1 = 0 ;
13880 int res1 = 0 ;
13881 int val2 ;
13882 int ecode2 = 0 ;
13883 int val3 ;
13884 int ecode3 = 0 ;
13885 PyObject * obj0 = 0 ;
13886 PyObject * obj1 = 0 ;
13887 PyObject * obj2 = 0 ;
13888 char * kwnames[] = {
13889 (char *) "self",(char *) "x",(char *) "y", NULL
13890 };
13891
13892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13894 if (!SWIG_IsOK(res1)) {
13895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
13896 }
13897 arg1 = reinterpret_cast< wxImage * >(argp1);
13898 ecode2 = SWIG_AsVal_int(obj1, &val2);
13899 if (!SWIG_IsOK(ecode2)) {
13900 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
13901 }
13902 arg2 = static_cast< int >(val2);
13903 ecode3 = SWIG_AsVal_int(obj2, &val3);
13904 if (!SWIG_IsOK(ecode3)) {
13905 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
13906 }
13907 arg3 = static_cast< int >(val3);
13908 {
13909 PyThreadState* __tstate = wxPyBeginAllowThreads();
13910 result = (byte)(arg1)->GetBlue(arg2,arg3);
13911 wxPyEndAllowThreads(__tstate);
13912 if (PyErr_Occurred()) SWIG_fail;
13913 }
13914 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13915 return resultobj;
13916 fail:
13917 return NULL;
13918 }
13919
13920
13921 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13922 PyObject *resultobj = 0;
13923 wxImage *arg1 = (wxImage *) 0 ;
13924 int arg2 ;
13925 int arg3 ;
13926 byte arg4 ;
13927 void *argp1 = 0 ;
13928 int res1 = 0 ;
13929 int val2 ;
13930 int ecode2 = 0 ;
13931 int val3 ;
13932 int ecode3 = 0 ;
13933 unsigned char val4 ;
13934 int ecode4 = 0 ;
13935 PyObject * obj0 = 0 ;
13936 PyObject * obj1 = 0 ;
13937 PyObject * obj2 = 0 ;
13938 PyObject * obj3 = 0 ;
13939 char * kwnames[] = {
13940 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
13941 };
13942
13943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13945 if (!SWIG_IsOK(res1)) {
13946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
13947 }
13948 arg1 = reinterpret_cast< wxImage * >(argp1);
13949 ecode2 = SWIG_AsVal_int(obj1, &val2);
13950 if (!SWIG_IsOK(ecode2)) {
13951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
13952 }
13953 arg2 = static_cast< int >(val2);
13954 ecode3 = SWIG_AsVal_int(obj2, &val3);
13955 if (!SWIG_IsOK(ecode3)) {
13956 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
13957 }
13958 arg3 = static_cast< int >(val3);
13959 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13960 if (!SWIG_IsOK(ecode4)) {
13961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
13962 }
13963 arg4 = static_cast< byte >(val4);
13964 {
13965 PyThreadState* __tstate = wxPyBeginAllowThreads();
13966 (arg1)->SetAlpha(arg2,arg3,arg4);
13967 wxPyEndAllowThreads(__tstate);
13968 if (PyErr_Occurred()) SWIG_fail;
13969 }
13970 resultobj = SWIG_Py_Void();
13971 return resultobj;
13972 fail:
13973 return NULL;
13974 }
13975
13976
13977 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13978 PyObject *resultobj = 0;
13979 wxImage *arg1 = (wxImage *) 0 ;
13980 int arg2 ;
13981 int arg3 ;
13982 byte result;
13983 void *argp1 = 0 ;
13984 int res1 = 0 ;
13985 int val2 ;
13986 int ecode2 = 0 ;
13987 int val3 ;
13988 int ecode3 = 0 ;
13989 PyObject * obj0 = 0 ;
13990 PyObject * obj1 = 0 ;
13991 PyObject * obj2 = 0 ;
13992 char * kwnames[] = {
13993 (char *) "self",(char *) "x",(char *) "y", NULL
13994 };
13995
13996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13998 if (!SWIG_IsOK(res1)) {
13999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14000 }
14001 arg1 = reinterpret_cast< wxImage * >(argp1);
14002 ecode2 = SWIG_AsVal_int(obj1, &val2);
14003 if (!SWIG_IsOK(ecode2)) {
14004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14005 }
14006 arg2 = static_cast< int >(val2);
14007 ecode3 = SWIG_AsVal_int(obj2, &val3);
14008 if (!SWIG_IsOK(ecode3)) {
14009 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14010 }
14011 arg3 = static_cast< int >(val3);
14012 {
14013 PyThreadState* __tstate = wxPyBeginAllowThreads();
14014 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14015 wxPyEndAllowThreads(__tstate);
14016 if (PyErr_Occurred()) SWIG_fail;
14017 }
14018 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14019 return resultobj;
14020 fail:
14021 return NULL;
14022 }
14023
14024
14025 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14026 PyObject *resultobj = 0;
14027 wxImage *arg1 = (wxImage *) 0 ;
14028 bool result;
14029 void *argp1 = 0 ;
14030 int res1 = 0 ;
14031 PyObject *swig_obj[1] ;
14032
14033 if (!args) SWIG_fail;
14034 swig_obj[0] = args;
14035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14036 if (!SWIG_IsOK(res1)) {
14037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14038 }
14039 arg1 = reinterpret_cast< wxImage * >(argp1);
14040 {
14041 PyThreadState* __tstate = wxPyBeginAllowThreads();
14042 result = (bool)(arg1)->HasAlpha();
14043 wxPyEndAllowThreads(__tstate);
14044 if (PyErr_Occurred()) SWIG_fail;
14045 }
14046 {
14047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14048 }
14049 return resultobj;
14050 fail:
14051 return NULL;
14052 }
14053
14054
14055 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14056 PyObject *resultobj = 0;
14057 wxImage *arg1 = (wxImage *) 0 ;
14058 void *argp1 = 0 ;
14059 int res1 = 0 ;
14060 PyObject *swig_obj[1] ;
14061
14062 if (!args) SWIG_fail;
14063 swig_obj[0] = args;
14064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14065 if (!SWIG_IsOK(res1)) {
14066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14067 }
14068 arg1 = reinterpret_cast< wxImage * >(argp1);
14069 {
14070 PyThreadState* __tstate = wxPyBeginAllowThreads();
14071 (arg1)->InitAlpha();
14072 wxPyEndAllowThreads(__tstate);
14073 if (PyErr_Occurred()) SWIG_fail;
14074 }
14075 resultobj = SWIG_Py_Void();
14076 return resultobj;
14077 fail:
14078 return NULL;
14079 }
14080
14081
14082 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14083 PyObject *resultobj = 0;
14084 wxImage *arg1 = (wxImage *) 0 ;
14085 int arg2 ;
14086 int arg3 ;
14087 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14088 bool result;
14089 void *argp1 = 0 ;
14090 int res1 = 0 ;
14091 int val2 ;
14092 int ecode2 = 0 ;
14093 int val3 ;
14094 int ecode3 = 0 ;
14095 unsigned char val4 ;
14096 int ecode4 = 0 ;
14097 PyObject * obj0 = 0 ;
14098 PyObject * obj1 = 0 ;
14099 PyObject * obj2 = 0 ;
14100 PyObject * obj3 = 0 ;
14101 char * kwnames[] = {
14102 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14103 };
14104
14105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14107 if (!SWIG_IsOK(res1)) {
14108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14109 }
14110 arg1 = reinterpret_cast< wxImage * >(argp1);
14111 ecode2 = SWIG_AsVal_int(obj1, &val2);
14112 if (!SWIG_IsOK(ecode2)) {
14113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14114 }
14115 arg2 = static_cast< int >(val2);
14116 ecode3 = SWIG_AsVal_int(obj2, &val3);
14117 if (!SWIG_IsOK(ecode3)) {
14118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14119 }
14120 arg3 = static_cast< int >(val3);
14121 if (obj3) {
14122 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14123 if (!SWIG_IsOK(ecode4)) {
14124 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14125 }
14126 arg4 = static_cast< byte >(val4);
14127 }
14128 {
14129 PyThreadState* __tstate = wxPyBeginAllowThreads();
14130 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14131 wxPyEndAllowThreads(__tstate);
14132 if (PyErr_Occurred()) SWIG_fail;
14133 }
14134 {
14135 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14136 }
14137 return resultobj;
14138 fail:
14139 return NULL;
14140 }
14141
14142
14143 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14144 PyObject *resultobj = 0;
14145 wxImage *arg1 = (wxImage *) 0 ;
14146 byte *arg2 = (byte *) 0 ;
14147 byte *arg3 = (byte *) 0 ;
14148 byte *arg4 = (byte *) 0 ;
14149 byte arg5 = (byte) 0 ;
14150 byte arg6 = (byte) 0 ;
14151 byte arg7 = (byte) 0 ;
14152 bool result;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 byte temp2 ;
14156 int res2 = SWIG_TMPOBJ ;
14157 byte temp3 ;
14158 int res3 = SWIG_TMPOBJ ;
14159 byte temp4 ;
14160 int res4 = SWIG_TMPOBJ ;
14161 unsigned char val5 ;
14162 int ecode5 = 0 ;
14163 unsigned char val6 ;
14164 int ecode6 = 0 ;
14165 unsigned char val7 ;
14166 int ecode7 = 0 ;
14167 PyObject * obj0 = 0 ;
14168 PyObject * obj1 = 0 ;
14169 PyObject * obj2 = 0 ;
14170 PyObject * obj3 = 0 ;
14171 char * kwnames[] = {
14172 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14173 };
14174
14175 arg2 = &temp2;
14176 arg3 = &temp3;
14177 arg4 = &temp4;
14178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14180 if (!SWIG_IsOK(res1)) {
14181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14182 }
14183 arg1 = reinterpret_cast< wxImage * >(argp1);
14184 if (obj1) {
14185 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14186 if (!SWIG_IsOK(ecode5)) {
14187 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14188 }
14189 arg5 = static_cast< byte >(val5);
14190 }
14191 if (obj2) {
14192 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14193 if (!SWIG_IsOK(ecode6)) {
14194 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14195 }
14196 arg6 = static_cast< byte >(val6);
14197 }
14198 if (obj3) {
14199 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14200 if (!SWIG_IsOK(ecode7)) {
14201 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14202 }
14203 arg7 = static_cast< byte >(val7);
14204 }
14205 {
14206 PyThreadState* __tstate = wxPyBeginAllowThreads();
14207 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14208 wxPyEndAllowThreads(__tstate);
14209 if (PyErr_Occurred()) SWIG_fail;
14210 }
14211 {
14212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14213 }
14214 if (SWIG_IsTmpObj(res2)) {
14215 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14216 } else {
14217 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14218 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14219 }
14220 if (SWIG_IsTmpObj(res3)) {
14221 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14222 } else {
14223 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14224 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14225 }
14226 if (SWIG_IsTmpObj(res4)) {
14227 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14228 } else {
14229 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14230 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14231 }
14232 return resultobj;
14233 fail:
14234 return NULL;
14235 }
14236
14237
14238 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14239 PyObject *resultobj = 0;
14240 wxImage *arg1 = (wxImage *) 0 ;
14241 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14242 bool result;
14243 void *argp1 = 0 ;
14244 int res1 = 0 ;
14245 unsigned char val2 ;
14246 int ecode2 = 0 ;
14247 PyObject * obj0 = 0 ;
14248 PyObject * obj1 = 0 ;
14249 char * kwnames[] = {
14250 (char *) "self",(char *) "threshold", NULL
14251 };
14252
14253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14255 if (!SWIG_IsOK(res1)) {
14256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14257 }
14258 arg1 = reinterpret_cast< wxImage * >(argp1);
14259 if (obj1) {
14260 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14261 if (!SWIG_IsOK(ecode2)) {
14262 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14263 }
14264 arg2 = static_cast< byte >(val2);
14265 }
14266 {
14267 PyThreadState* __tstate = wxPyBeginAllowThreads();
14268 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14269 wxPyEndAllowThreads(__tstate);
14270 if (PyErr_Occurred()) SWIG_fail;
14271 }
14272 {
14273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14274 }
14275 return resultobj;
14276 fail:
14277 return NULL;
14278 }
14279
14280
14281 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14282 PyObject *resultobj = 0;
14283 wxImage *arg1 = (wxImage *) 0 ;
14284 byte arg2 ;
14285 byte arg3 ;
14286 byte arg4 ;
14287 bool result;
14288 void *argp1 = 0 ;
14289 int res1 = 0 ;
14290 unsigned char val2 ;
14291 int ecode2 = 0 ;
14292 unsigned char val3 ;
14293 int ecode3 = 0 ;
14294 unsigned char val4 ;
14295 int ecode4 = 0 ;
14296 PyObject * obj0 = 0 ;
14297 PyObject * obj1 = 0 ;
14298 PyObject * obj2 = 0 ;
14299 PyObject * obj3 = 0 ;
14300 char * kwnames[] = {
14301 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14302 };
14303
14304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14306 if (!SWIG_IsOK(res1)) {
14307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14308 }
14309 arg1 = reinterpret_cast< wxImage * >(argp1);
14310 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14311 if (!SWIG_IsOK(ecode2)) {
14312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14313 }
14314 arg2 = static_cast< byte >(val2);
14315 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14316 if (!SWIG_IsOK(ecode3)) {
14317 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14318 }
14319 arg3 = static_cast< byte >(val3);
14320 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14321 if (!SWIG_IsOK(ecode4)) {
14322 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14323 }
14324 arg4 = static_cast< byte >(val4);
14325 {
14326 PyThreadState* __tstate = wxPyBeginAllowThreads();
14327 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14328 wxPyEndAllowThreads(__tstate);
14329 if (PyErr_Occurred()) SWIG_fail;
14330 }
14331 {
14332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14333 }
14334 return resultobj;
14335 fail:
14336 return NULL;
14337 }
14338
14339
14340 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14341 PyObject *resultobj = 0;
14342 wxImage *arg1 = (wxImage *) 0 ;
14343 wxImage *arg2 = 0 ;
14344 byte arg3 ;
14345 byte arg4 ;
14346 byte arg5 ;
14347 bool result;
14348 void *argp1 = 0 ;
14349 int res1 = 0 ;
14350 void *argp2 = 0 ;
14351 int res2 = 0 ;
14352 unsigned char val3 ;
14353 int ecode3 = 0 ;
14354 unsigned char val4 ;
14355 int ecode4 = 0 ;
14356 unsigned char val5 ;
14357 int ecode5 = 0 ;
14358 PyObject * obj0 = 0 ;
14359 PyObject * obj1 = 0 ;
14360 PyObject * obj2 = 0 ;
14361 PyObject * obj3 = 0 ;
14362 PyObject * obj4 = 0 ;
14363 char * kwnames[] = {
14364 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14365 };
14366
14367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14369 if (!SWIG_IsOK(res1)) {
14370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14371 }
14372 arg1 = reinterpret_cast< wxImage * >(argp1);
14373 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14374 if (!SWIG_IsOK(res2)) {
14375 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14376 }
14377 if (!argp2) {
14378 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14379 }
14380 arg2 = reinterpret_cast< wxImage * >(argp2);
14381 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14382 if (!SWIG_IsOK(ecode3)) {
14383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14384 }
14385 arg3 = static_cast< byte >(val3);
14386 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14387 if (!SWIG_IsOK(ecode4)) {
14388 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14389 }
14390 arg4 = static_cast< byte >(val4);
14391 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14392 if (!SWIG_IsOK(ecode5)) {
14393 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14394 }
14395 arg5 = static_cast< byte >(val5);
14396 {
14397 PyThreadState* __tstate = wxPyBeginAllowThreads();
14398 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14399 wxPyEndAllowThreads(__tstate);
14400 if (PyErr_Occurred()) SWIG_fail;
14401 }
14402 {
14403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14404 }
14405 return resultobj;
14406 fail:
14407 return NULL;
14408 }
14409
14410
14411 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14412 PyObject *resultobj = 0;
14413 wxString *arg1 = 0 ;
14414 bool result;
14415 bool temp1 = false ;
14416 PyObject * obj0 = 0 ;
14417 char * kwnames[] = {
14418 (char *) "filename", NULL
14419 };
14420
14421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14422 {
14423 arg1 = wxString_in_helper(obj0);
14424 if (arg1 == NULL) SWIG_fail;
14425 temp1 = true;
14426 }
14427 {
14428 PyThreadState* __tstate = wxPyBeginAllowThreads();
14429 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14430 wxPyEndAllowThreads(__tstate);
14431 if (PyErr_Occurred()) SWIG_fail;
14432 }
14433 {
14434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14435 }
14436 {
14437 if (temp1)
14438 delete arg1;
14439 }
14440 return resultobj;
14441 fail:
14442 {
14443 if (temp1)
14444 delete arg1;
14445 }
14446 return NULL;
14447 }
14448
14449
14450 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14451 PyObject *resultobj = 0;
14452 wxString *arg1 = 0 ;
14453 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14454 int result;
14455 bool temp1 = false ;
14456 long val2 ;
14457 int ecode2 = 0 ;
14458 PyObject * obj0 = 0 ;
14459 PyObject * obj1 = 0 ;
14460 char * kwnames[] = {
14461 (char *) "filename",(char *) "type", NULL
14462 };
14463
14464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14465 {
14466 arg1 = wxString_in_helper(obj0);
14467 if (arg1 == NULL) SWIG_fail;
14468 temp1 = true;
14469 }
14470 if (obj1) {
14471 ecode2 = SWIG_AsVal_long(obj1, &val2);
14472 if (!SWIG_IsOK(ecode2)) {
14473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14474 }
14475 arg2 = static_cast< long >(val2);
14476 }
14477 {
14478 PyThreadState* __tstate = wxPyBeginAllowThreads();
14479 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14480 wxPyEndAllowThreads(__tstate);
14481 if (PyErr_Occurred()) SWIG_fail;
14482 }
14483 resultobj = SWIG_From_int(static_cast< int >(result));
14484 {
14485 if (temp1)
14486 delete arg1;
14487 }
14488 return resultobj;
14489 fail:
14490 {
14491 if (temp1)
14492 delete arg1;
14493 }
14494 return NULL;
14495 }
14496
14497
14498 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14499 PyObject *resultobj = 0;
14500 wxImage *arg1 = (wxImage *) 0 ;
14501 wxString *arg2 = 0 ;
14502 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14503 int arg4 = (int) -1 ;
14504 bool result;
14505 void *argp1 = 0 ;
14506 int res1 = 0 ;
14507 bool temp2 = false ;
14508 long val3 ;
14509 int ecode3 = 0 ;
14510 int val4 ;
14511 int ecode4 = 0 ;
14512 PyObject * obj0 = 0 ;
14513 PyObject * obj1 = 0 ;
14514 PyObject * obj2 = 0 ;
14515 PyObject * obj3 = 0 ;
14516 char * kwnames[] = {
14517 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14518 };
14519
14520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14522 if (!SWIG_IsOK(res1)) {
14523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14524 }
14525 arg1 = reinterpret_cast< wxImage * >(argp1);
14526 {
14527 arg2 = wxString_in_helper(obj1);
14528 if (arg2 == NULL) SWIG_fail;
14529 temp2 = true;
14530 }
14531 if (obj2) {
14532 ecode3 = SWIG_AsVal_long(obj2, &val3);
14533 if (!SWIG_IsOK(ecode3)) {
14534 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14535 }
14536 arg3 = static_cast< long >(val3);
14537 }
14538 if (obj3) {
14539 ecode4 = SWIG_AsVal_int(obj3, &val4);
14540 if (!SWIG_IsOK(ecode4)) {
14541 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14542 }
14543 arg4 = static_cast< int >(val4);
14544 }
14545 {
14546 PyThreadState* __tstate = wxPyBeginAllowThreads();
14547 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14548 wxPyEndAllowThreads(__tstate);
14549 if (PyErr_Occurred()) SWIG_fail;
14550 }
14551 {
14552 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14553 }
14554 {
14555 if (temp2)
14556 delete arg2;
14557 }
14558 return resultobj;
14559 fail:
14560 {
14561 if (temp2)
14562 delete arg2;
14563 }
14564 return NULL;
14565 }
14566
14567
14568 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14569 PyObject *resultobj = 0;
14570 wxImage *arg1 = (wxImage *) 0 ;
14571 wxString *arg2 = 0 ;
14572 wxString *arg3 = 0 ;
14573 int arg4 = (int) -1 ;
14574 bool result;
14575 void *argp1 = 0 ;
14576 int res1 = 0 ;
14577 bool temp2 = false ;
14578 bool temp3 = false ;
14579 int val4 ;
14580 int ecode4 = 0 ;
14581 PyObject * obj0 = 0 ;
14582 PyObject * obj1 = 0 ;
14583 PyObject * obj2 = 0 ;
14584 PyObject * obj3 = 0 ;
14585 char * kwnames[] = {
14586 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14587 };
14588
14589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14591 if (!SWIG_IsOK(res1)) {
14592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14593 }
14594 arg1 = reinterpret_cast< wxImage * >(argp1);
14595 {
14596 arg2 = wxString_in_helper(obj1);
14597 if (arg2 == NULL) SWIG_fail;
14598 temp2 = true;
14599 }
14600 {
14601 arg3 = wxString_in_helper(obj2);
14602 if (arg3 == NULL) SWIG_fail;
14603 temp3 = true;
14604 }
14605 if (obj3) {
14606 ecode4 = SWIG_AsVal_int(obj3, &val4);
14607 if (!SWIG_IsOK(ecode4)) {
14608 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14609 }
14610 arg4 = static_cast< int >(val4);
14611 }
14612 {
14613 PyThreadState* __tstate = wxPyBeginAllowThreads();
14614 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14615 wxPyEndAllowThreads(__tstate);
14616 if (PyErr_Occurred()) SWIG_fail;
14617 }
14618 {
14619 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14620 }
14621 {
14622 if (temp2)
14623 delete arg2;
14624 }
14625 {
14626 if (temp3)
14627 delete arg3;
14628 }
14629 return resultobj;
14630 fail:
14631 {
14632 if (temp2)
14633 delete arg2;
14634 }
14635 {
14636 if (temp3)
14637 delete arg3;
14638 }
14639 return NULL;
14640 }
14641
14642
14643 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14644 PyObject *resultobj = 0;
14645 wxImage *arg1 = (wxImage *) 0 ;
14646 wxString *arg2 = 0 ;
14647 int arg3 ;
14648 bool result;
14649 void *argp1 = 0 ;
14650 int res1 = 0 ;
14651 bool temp2 = false ;
14652 int val3 ;
14653 int ecode3 = 0 ;
14654 PyObject * obj0 = 0 ;
14655 PyObject * obj1 = 0 ;
14656 PyObject * obj2 = 0 ;
14657 char * kwnames[] = {
14658 (char *) "self",(char *) "name",(char *) "type", NULL
14659 };
14660
14661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14663 if (!SWIG_IsOK(res1)) {
14664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14665 }
14666 arg1 = reinterpret_cast< wxImage * >(argp1);
14667 {
14668 arg2 = wxString_in_helper(obj1);
14669 if (arg2 == NULL) SWIG_fail;
14670 temp2 = true;
14671 }
14672 ecode3 = SWIG_AsVal_int(obj2, &val3);
14673 if (!SWIG_IsOK(ecode3)) {
14674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14675 }
14676 arg3 = static_cast< int >(val3);
14677 {
14678 PyThreadState* __tstate = wxPyBeginAllowThreads();
14679 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14680 wxPyEndAllowThreads(__tstate);
14681 if (PyErr_Occurred()) SWIG_fail;
14682 }
14683 {
14684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14685 }
14686 {
14687 if (temp2)
14688 delete arg2;
14689 }
14690 return resultobj;
14691 fail:
14692 {
14693 if (temp2)
14694 delete arg2;
14695 }
14696 return NULL;
14697 }
14698
14699
14700 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14701 PyObject *resultobj = 0;
14702 wxImage *arg1 = (wxImage *) 0 ;
14703 wxString *arg2 = 0 ;
14704 wxString *arg3 = 0 ;
14705 bool result;
14706 void *argp1 = 0 ;
14707 int res1 = 0 ;
14708 bool temp2 = false ;
14709 bool temp3 = false ;
14710 PyObject * obj0 = 0 ;
14711 PyObject * obj1 = 0 ;
14712 PyObject * obj2 = 0 ;
14713 char * kwnames[] = {
14714 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14715 };
14716
14717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14719 if (!SWIG_IsOK(res1)) {
14720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14721 }
14722 arg1 = reinterpret_cast< wxImage * >(argp1);
14723 {
14724 arg2 = wxString_in_helper(obj1);
14725 if (arg2 == NULL) SWIG_fail;
14726 temp2 = true;
14727 }
14728 {
14729 arg3 = wxString_in_helper(obj2);
14730 if (arg3 == NULL) SWIG_fail;
14731 temp3 = true;
14732 }
14733 {
14734 PyThreadState* __tstate = wxPyBeginAllowThreads();
14735 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14736 wxPyEndAllowThreads(__tstate);
14737 if (PyErr_Occurred()) SWIG_fail;
14738 }
14739 {
14740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14741 }
14742 {
14743 if (temp2)
14744 delete arg2;
14745 }
14746 {
14747 if (temp3)
14748 delete arg3;
14749 }
14750 return resultobj;
14751 fail:
14752 {
14753 if (temp2)
14754 delete arg2;
14755 }
14756 {
14757 if (temp3)
14758 delete arg3;
14759 }
14760 return NULL;
14761 }
14762
14763
14764 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14765 PyObject *resultobj = 0;
14766 wxInputStream *arg1 = 0 ;
14767 bool result;
14768 wxPyInputStream *temp1 ;
14769 bool created1 ;
14770 PyObject * obj0 = 0 ;
14771 char * kwnames[] = {
14772 (char *) "stream", NULL
14773 };
14774
14775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14776 {
14777 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14778 arg1 = temp1->m_wxis;
14779 created1 = false;
14780 } else {
14781 PyErr_Clear(); // clear the failure of the wxPyConvert above
14782 arg1 = wxPyCBInputStream_create(obj0, false);
14783 if (arg1 == NULL) {
14784 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14785 SWIG_fail;
14786 }
14787 created1 = true;
14788 }
14789 }
14790 {
14791 PyThreadState* __tstate = wxPyBeginAllowThreads();
14792 result = (bool)wxImage::CanRead(*arg1);
14793 wxPyEndAllowThreads(__tstate);
14794 if (PyErr_Occurred()) SWIG_fail;
14795 }
14796 {
14797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14798 }
14799 {
14800 if (created1) delete arg1;
14801 }
14802 return resultobj;
14803 fail:
14804 {
14805 if (created1) delete arg1;
14806 }
14807 return NULL;
14808 }
14809
14810
14811 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14812 PyObject *resultobj = 0;
14813 wxImage *arg1 = (wxImage *) 0 ;
14814 wxInputStream *arg2 = 0 ;
14815 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14816 int arg4 = (int) -1 ;
14817 bool result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 wxPyInputStream *temp2 ;
14821 bool created2 ;
14822 long val3 ;
14823 int ecode3 = 0 ;
14824 int val4 ;
14825 int ecode4 = 0 ;
14826 PyObject * obj0 = 0 ;
14827 PyObject * obj1 = 0 ;
14828 PyObject * obj2 = 0 ;
14829 PyObject * obj3 = 0 ;
14830 char * kwnames[] = {
14831 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14832 };
14833
14834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14836 if (!SWIG_IsOK(res1)) {
14837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14838 }
14839 arg1 = reinterpret_cast< wxImage * >(argp1);
14840 {
14841 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14842 arg2 = temp2->m_wxis;
14843 created2 = false;
14844 } else {
14845 PyErr_Clear(); // clear the failure of the wxPyConvert above
14846 arg2 = wxPyCBInputStream_create(obj1, false);
14847 if (arg2 == NULL) {
14848 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14849 SWIG_fail;
14850 }
14851 created2 = true;
14852 }
14853 }
14854 if (obj2) {
14855 ecode3 = SWIG_AsVal_long(obj2, &val3);
14856 if (!SWIG_IsOK(ecode3)) {
14857 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14858 }
14859 arg3 = static_cast< long >(val3);
14860 }
14861 if (obj3) {
14862 ecode4 = SWIG_AsVal_int(obj3, &val4);
14863 if (!SWIG_IsOK(ecode4)) {
14864 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14865 }
14866 arg4 = static_cast< int >(val4);
14867 }
14868 {
14869 PyThreadState* __tstate = wxPyBeginAllowThreads();
14870 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14871 wxPyEndAllowThreads(__tstate);
14872 if (PyErr_Occurred()) SWIG_fail;
14873 }
14874 {
14875 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14876 }
14877 {
14878 if (created2) delete arg2;
14879 }
14880 return resultobj;
14881 fail:
14882 {
14883 if (created2) delete arg2;
14884 }
14885 return NULL;
14886 }
14887
14888
14889 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14890 PyObject *resultobj = 0;
14891 wxImage *arg1 = (wxImage *) 0 ;
14892 wxInputStream *arg2 = 0 ;
14893 wxString *arg3 = 0 ;
14894 int arg4 = (int) -1 ;
14895 bool result;
14896 void *argp1 = 0 ;
14897 int res1 = 0 ;
14898 wxPyInputStream *temp2 ;
14899 bool created2 ;
14900 bool temp3 = false ;
14901 int val4 ;
14902 int ecode4 = 0 ;
14903 PyObject * obj0 = 0 ;
14904 PyObject * obj1 = 0 ;
14905 PyObject * obj2 = 0 ;
14906 PyObject * obj3 = 0 ;
14907 char * kwnames[] = {
14908 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
14909 };
14910
14911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14913 if (!SWIG_IsOK(res1)) {
14914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
14915 }
14916 arg1 = reinterpret_cast< wxImage * >(argp1);
14917 {
14918 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14919 arg2 = temp2->m_wxis;
14920 created2 = false;
14921 } else {
14922 PyErr_Clear(); // clear the failure of the wxPyConvert above
14923 arg2 = wxPyCBInputStream_create(obj1, false);
14924 if (arg2 == NULL) {
14925 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14926 SWIG_fail;
14927 }
14928 created2 = true;
14929 }
14930 }
14931 {
14932 arg3 = wxString_in_helper(obj2);
14933 if (arg3 == NULL) SWIG_fail;
14934 temp3 = true;
14935 }
14936 if (obj3) {
14937 ecode4 = SWIG_AsVal_int(obj3, &val4);
14938 if (!SWIG_IsOK(ecode4)) {
14939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
14940 }
14941 arg4 = static_cast< int >(val4);
14942 }
14943 {
14944 PyThreadState* __tstate = wxPyBeginAllowThreads();
14945 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
14946 wxPyEndAllowThreads(__tstate);
14947 if (PyErr_Occurred()) SWIG_fail;
14948 }
14949 {
14950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14951 }
14952 {
14953 if (created2) delete arg2;
14954 }
14955 {
14956 if (temp3)
14957 delete arg3;
14958 }
14959 return resultobj;
14960 fail:
14961 {
14962 if (created2) delete arg2;
14963 }
14964 {
14965 if (temp3)
14966 delete arg3;
14967 }
14968 return NULL;
14969 }
14970
14971
14972 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14973 PyObject *resultobj = 0;
14974 wxImage *arg1 = (wxImage *) 0 ;
14975 bool result;
14976 void *argp1 = 0 ;
14977 int res1 = 0 ;
14978 PyObject *swig_obj[1] ;
14979
14980 if (!args) SWIG_fail;
14981 swig_obj[0] = args;
14982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14983 if (!SWIG_IsOK(res1)) {
14984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
14985 }
14986 arg1 = reinterpret_cast< wxImage * >(argp1);
14987 {
14988 PyThreadState* __tstate = wxPyBeginAllowThreads();
14989 result = (bool)(arg1)->Ok();
14990 wxPyEndAllowThreads(__tstate);
14991 if (PyErr_Occurred()) SWIG_fail;
14992 }
14993 {
14994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14995 }
14996 return resultobj;
14997 fail:
14998 return NULL;
14999 }
15000
15001
15002 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15003 PyObject *resultobj = 0;
15004 wxImage *arg1 = (wxImage *) 0 ;
15005 int result;
15006 void *argp1 = 0 ;
15007 int res1 = 0 ;
15008 PyObject *swig_obj[1] ;
15009
15010 if (!args) SWIG_fail;
15011 swig_obj[0] = args;
15012 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15013 if (!SWIG_IsOK(res1)) {
15014 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15015 }
15016 arg1 = reinterpret_cast< wxImage * >(argp1);
15017 {
15018 PyThreadState* __tstate = wxPyBeginAllowThreads();
15019 result = (int)(arg1)->GetWidth();
15020 wxPyEndAllowThreads(__tstate);
15021 if (PyErr_Occurred()) SWIG_fail;
15022 }
15023 resultobj = SWIG_From_int(static_cast< int >(result));
15024 return resultobj;
15025 fail:
15026 return NULL;
15027 }
15028
15029
15030 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15031 PyObject *resultobj = 0;
15032 wxImage *arg1 = (wxImage *) 0 ;
15033 int result;
15034 void *argp1 = 0 ;
15035 int res1 = 0 ;
15036 PyObject *swig_obj[1] ;
15037
15038 if (!args) SWIG_fail;
15039 swig_obj[0] = args;
15040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15041 if (!SWIG_IsOK(res1)) {
15042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15043 }
15044 arg1 = reinterpret_cast< wxImage * >(argp1);
15045 {
15046 PyThreadState* __tstate = wxPyBeginAllowThreads();
15047 result = (int)(arg1)->GetHeight();
15048 wxPyEndAllowThreads(__tstate);
15049 if (PyErr_Occurred()) SWIG_fail;
15050 }
15051 resultobj = SWIG_From_int(static_cast< int >(result));
15052 return resultobj;
15053 fail:
15054 return NULL;
15055 }
15056
15057
15058 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15059 PyObject *resultobj = 0;
15060 wxImage *arg1 = (wxImage *) 0 ;
15061 wxSize result;
15062 void *argp1 = 0 ;
15063 int res1 = 0 ;
15064 PyObject *swig_obj[1] ;
15065
15066 if (!args) SWIG_fail;
15067 swig_obj[0] = args;
15068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15069 if (!SWIG_IsOK(res1)) {
15070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15071 }
15072 arg1 = reinterpret_cast< wxImage * >(argp1);
15073 {
15074 PyThreadState* __tstate = wxPyBeginAllowThreads();
15075 result = wxImage_GetSize(arg1);
15076 wxPyEndAllowThreads(__tstate);
15077 if (PyErr_Occurred()) SWIG_fail;
15078 }
15079 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15080 return resultobj;
15081 fail:
15082 return NULL;
15083 }
15084
15085
15086 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15087 PyObject *resultobj = 0;
15088 wxImage *arg1 = (wxImage *) 0 ;
15089 wxRect *arg2 = 0 ;
15090 SwigValueWrapper<wxImage > result;
15091 void *argp1 = 0 ;
15092 int res1 = 0 ;
15093 wxRect temp2 ;
15094 PyObject * obj0 = 0 ;
15095 PyObject * obj1 = 0 ;
15096 char * kwnames[] = {
15097 (char *) "self",(char *) "rect", NULL
15098 };
15099
15100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15102 if (!SWIG_IsOK(res1)) {
15103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15104 }
15105 arg1 = reinterpret_cast< wxImage * >(argp1);
15106 {
15107 arg2 = &temp2;
15108 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15109 }
15110 {
15111 PyThreadState* __tstate = wxPyBeginAllowThreads();
15112 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15113 wxPyEndAllowThreads(__tstate);
15114 if (PyErr_Occurred()) SWIG_fail;
15115 }
15116 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15117 return resultobj;
15118 fail:
15119 return NULL;
15120 }
15121
15122
15123 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15124 PyObject *resultobj = 0;
15125 wxImage *arg1 = (wxImage *) 0 ;
15126 wxSize *arg2 = 0 ;
15127 wxPoint *arg3 = 0 ;
15128 int arg4 = (int) -1 ;
15129 int arg5 = (int) -1 ;
15130 int arg6 = (int) -1 ;
15131 SwigValueWrapper<wxImage > result;
15132 void *argp1 = 0 ;
15133 int res1 = 0 ;
15134 wxSize temp2 ;
15135 wxPoint temp3 ;
15136 int val4 ;
15137 int ecode4 = 0 ;
15138 int val5 ;
15139 int ecode5 = 0 ;
15140 int val6 ;
15141 int ecode6 = 0 ;
15142 PyObject * obj0 = 0 ;
15143 PyObject * obj1 = 0 ;
15144 PyObject * obj2 = 0 ;
15145 PyObject * obj3 = 0 ;
15146 PyObject * obj4 = 0 ;
15147 PyObject * obj5 = 0 ;
15148 char * kwnames[] = {
15149 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15150 };
15151
15152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15154 if (!SWIG_IsOK(res1)) {
15155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15156 }
15157 arg1 = reinterpret_cast< wxImage * >(argp1);
15158 {
15159 arg2 = &temp2;
15160 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15161 }
15162 {
15163 arg3 = &temp3;
15164 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15165 }
15166 if (obj3) {
15167 ecode4 = SWIG_AsVal_int(obj3, &val4);
15168 if (!SWIG_IsOK(ecode4)) {
15169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15170 }
15171 arg4 = static_cast< int >(val4);
15172 }
15173 if (obj4) {
15174 ecode5 = SWIG_AsVal_int(obj4, &val5);
15175 if (!SWIG_IsOK(ecode5)) {
15176 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15177 }
15178 arg5 = static_cast< int >(val5);
15179 }
15180 if (obj5) {
15181 ecode6 = SWIG_AsVal_int(obj5, &val6);
15182 if (!SWIG_IsOK(ecode6)) {
15183 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15184 }
15185 arg6 = static_cast< int >(val6);
15186 }
15187 {
15188 PyThreadState* __tstate = wxPyBeginAllowThreads();
15189 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15190 wxPyEndAllowThreads(__tstate);
15191 if (PyErr_Occurred()) SWIG_fail;
15192 }
15193 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15194 return resultobj;
15195 fail:
15196 return NULL;
15197 }
15198
15199
15200 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15201 PyObject *resultobj = 0;
15202 wxImage *arg1 = (wxImage *) 0 ;
15203 SwigValueWrapper<wxImage > result;
15204 void *argp1 = 0 ;
15205 int res1 = 0 ;
15206 PyObject *swig_obj[1] ;
15207
15208 if (!args) SWIG_fail;
15209 swig_obj[0] = args;
15210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15211 if (!SWIG_IsOK(res1)) {
15212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15213 }
15214 arg1 = reinterpret_cast< wxImage * >(argp1);
15215 {
15216 PyThreadState* __tstate = wxPyBeginAllowThreads();
15217 result = (arg1)->Copy();
15218 wxPyEndAllowThreads(__tstate);
15219 if (PyErr_Occurred()) SWIG_fail;
15220 }
15221 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15222 return resultobj;
15223 fail:
15224 return NULL;
15225 }
15226
15227
15228 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15229 PyObject *resultobj = 0;
15230 wxImage *arg1 = (wxImage *) 0 ;
15231 wxImage *arg2 = 0 ;
15232 int arg3 ;
15233 int arg4 ;
15234 void *argp1 = 0 ;
15235 int res1 = 0 ;
15236 void *argp2 = 0 ;
15237 int res2 = 0 ;
15238 int val3 ;
15239 int ecode3 = 0 ;
15240 int val4 ;
15241 int ecode4 = 0 ;
15242 PyObject * obj0 = 0 ;
15243 PyObject * obj1 = 0 ;
15244 PyObject * obj2 = 0 ;
15245 PyObject * obj3 = 0 ;
15246 char * kwnames[] = {
15247 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15248 };
15249
15250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15252 if (!SWIG_IsOK(res1)) {
15253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15254 }
15255 arg1 = reinterpret_cast< wxImage * >(argp1);
15256 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15257 if (!SWIG_IsOK(res2)) {
15258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15259 }
15260 if (!argp2) {
15261 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15262 }
15263 arg2 = reinterpret_cast< wxImage * >(argp2);
15264 ecode3 = SWIG_AsVal_int(obj2, &val3);
15265 if (!SWIG_IsOK(ecode3)) {
15266 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15267 }
15268 arg3 = static_cast< int >(val3);
15269 ecode4 = SWIG_AsVal_int(obj3, &val4);
15270 if (!SWIG_IsOK(ecode4)) {
15271 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15272 }
15273 arg4 = static_cast< int >(val4);
15274 {
15275 PyThreadState* __tstate = wxPyBeginAllowThreads();
15276 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15277 wxPyEndAllowThreads(__tstate);
15278 if (PyErr_Occurred()) SWIG_fail;
15279 }
15280 resultobj = SWIG_Py_Void();
15281 return resultobj;
15282 fail:
15283 return NULL;
15284 }
15285
15286
15287 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15288 PyObject *resultobj = 0;
15289 wxImage *arg1 = (wxImage *) 0 ;
15290 PyObject *result = 0 ;
15291 void *argp1 = 0 ;
15292 int res1 = 0 ;
15293 PyObject *swig_obj[1] ;
15294
15295 if (!args) SWIG_fail;
15296 swig_obj[0] = args;
15297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15298 if (!SWIG_IsOK(res1)) {
15299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15300 }
15301 arg1 = reinterpret_cast< wxImage * >(argp1);
15302 {
15303 PyThreadState* __tstate = wxPyBeginAllowThreads();
15304 result = (PyObject *)wxImage_GetData(arg1);
15305 wxPyEndAllowThreads(__tstate);
15306 if (PyErr_Occurred()) SWIG_fail;
15307 }
15308 resultobj = result;
15309 return resultobj;
15310 fail:
15311 return NULL;
15312 }
15313
15314
15315 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15316 PyObject *resultobj = 0;
15317 wxImage *arg1 = (wxImage *) 0 ;
15318 buffer arg2 ;
15319 int arg3 ;
15320 void *argp1 = 0 ;
15321 int res1 = 0 ;
15322 PyObject * obj0 = 0 ;
15323 PyObject * obj1 = 0 ;
15324 char * kwnames[] = {
15325 (char *) "self",(char *) "data", NULL
15326 };
15327
15328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15330 if (!SWIG_IsOK(res1)) {
15331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15332 }
15333 arg1 = reinterpret_cast< wxImage * >(argp1);
15334 {
15335 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15336 }
15337 {
15338 PyThreadState* __tstate = wxPyBeginAllowThreads();
15339 wxImage_SetData(arg1,arg2,arg3);
15340 wxPyEndAllowThreads(__tstate);
15341 if (PyErr_Occurred()) SWIG_fail;
15342 }
15343 resultobj = SWIG_Py_Void();
15344 return resultobj;
15345 fail:
15346 return NULL;
15347 }
15348
15349
15350 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15351 PyObject *resultobj = 0;
15352 wxImage *arg1 = (wxImage *) 0 ;
15353 PyObject *result = 0 ;
15354 void *argp1 = 0 ;
15355 int res1 = 0 ;
15356 PyObject *swig_obj[1] ;
15357
15358 if (!args) SWIG_fail;
15359 swig_obj[0] = args;
15360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15361 if (!SWIG_IsOK(res1)) {
15362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15363 }
15364 arg1 = reinterpret_cast< wxImage * >(argp1);
15365 {
15366 PyThreadState* __tstate = wxPyBeginAllowThreads();
15367 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15368 wxPyEndAllowThreads(__tstate);
15369 if (PyErr_Occurred()) SWIG_fail;
15370 }
15371 resultobj = result;
15372 return resultobj;
15373 fail:
15374 return NULL;
15375 }
15376
15377
15378 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15379 PyObject *resultobj = 0;
15380 wxImage *arg1 = (wxImage *) 0 ;
15381 buffer arg2 ;
15382 int arg3 ;
15383 void *argp1 = 0 ;
15384 int res1 = 0 ;
15385 PyObject * obj0 = 0 ;
15386 PyObject * obj1 = 0 ;
15387 char * kwnames[] = {
15388 (char *) "self",(char *) "data", NULL
15389 };
15390
15391 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15392 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15393 if (!SWIG_IsOK(res1)) {
15394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15395 }
15396 arg1 = reinterpret_cast< wxImage * >(argp1);
15397 {
15398 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15399 }
15400 {
15401 PyThreadState* __tstate = wxPyBeginAllowThreads();
15402 wxImage_SetDataBuffer(arg1,arg2,arg3);
15403 wxPyEndAllowThreads(__tstate);
15404 if (PyErr_Occurred()) SWIG_fail;
15405 }
15406 resultobj = SWIG_Py_Void();
15407 return resultobj;
15408 fail:
15409 return NULL;
15410 }
15411
15412
15413 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15414 PyObject *resultobj = 0;
15415 wxImage *arg1 = (wxImage *) 0 ;
15416 PyObject *result = 0 ;
15417 void *argp1 = 0 ;
15418 int res1 = 0 ;
15419 PyObject *swig_obj[1] ;
15420
15421 if (!args) SWIG_fail;
15422 swig_obj[0] = args;
15423 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15424 if (!SWIG_IsOK(res1)) {
15425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15426 }
15427 arg1 = reinterpret_cast< wxImage * >(argp1);
15428 {
15429 PyThreadState* __tstate = wxPyBeginAllowThreads();
15430 result = (PyObject *)wxImage_GetAlphaData(arg1);
15431 wxPyEndAllowThreads(__tstate);
15432 if (PyErr_Occurred()) SWIG_fail;
15433 }
15434 resultobj = result;
15435 return resultobj;
15436 fail:
15437 return NULL;
15438 }
15439
15440
15441 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15442 PyObject *resultobj = 0;
15443 wxImage *arg1 = (wxImage *) 0 ;
15444 buffer arg2 ;
15445 int arg3 ;
15446 void *argp1 = 0 ;
15447 int res1 = 0 ;
15448 PyObject * obj0 = 0 ;
15449 PyObject * obj1 = 0 ;
15450 char * kwnames[] = {
15451 (char *) "self",(char *) "alpha", NULL
15452 };
15453
15454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15456 if (!SWIG_IsOK(res1)) {
15457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15458 }
15459 arg1 = reinterpret_cast< wxImage * >(argp1);
15460 {
15461 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15462 }
15463 {
15464 PyThreadState* __tstate = wxPyBeginAllowThreads();
15465 wxImage_SetAlphaData(arg1,arg2,arg3);
15466 wxPyEndAllowThreads(__tstate);
15467 if (PyErr_Occurred()) SWIG_fail;
15468 }
15469 resultobj = SWIG_Py_Void();
15470 return resultobj;
15471 fail:
15472 return NULL;
15473 }
15474
15475
15476 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15477 PyObject *resultobj = 0;
15478 wxImage *arg1 = (wxImage *) 0 ;
15479 PyObject *result = 0 ;
15480 void *argp1 = 0 ;
15481 int res1 = 0 ;
15482 PyObject *swig_obj[1] ;
15483
15484 if (!args) SWIG_fail;
15485 swig_obj[0] = args;
15486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15487 if (!SWIG_IsOK(res1)) {
15488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15489 }
15490 arg1 = reinterpret_cast< wxImage * >(argp1);
15491 {
15492 PyThreadState* __tstate = wxPyBeginAllowThreads();
15493 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15494 wxPyEndAllowThreads(__tstate);
15495 if (PyErr_Occurred()) SWIG_fail;
15496 }
15497 resultobj = result;
15498 return resultobj;
15499 fail:
15500 return NULL;
15501 }
15502
15503
15504 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15505 PyObject *resultobj = 0;
15506 wxImage *arg1 = (wxImage *) 0 ;
15507 buffer arg2 ;
15508 int arg3 ;
15509 void *argp1 = 0 ;
15510 int res1 = 0 ;
15511 PyObject * obj0 = 0 ;
15512 PyObject * obj1 = 0 ;
15513 char * kwnames[] = {
15514 (char *) "self",(char *) "alpha", NULL
15515 };
15516
15517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15519 if (!SWIG_IsOK(res1)) {
15520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15521 }
15522 arg1 = reinterpret_cast< wxImage * >(argp1);
15523 {
15524 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15525 }
15526 {
15527 PyThreadState* __tstate = wxPyBeginAllowThreads();
15528 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15529 wxPyEndAllowThreads(__tstate);
15530 if (PyErr_Occurred()) SWIG_fail;
15531 }
15532 resultobj = SWIG_Py_Void();
15533 return resultobj;
15534 fail:
15535 return NULL;
15536 }
15537
15538
15539 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15540 PyObject *resultobj = 0;
15541 wxImage *arg1 = (wxImage *) 0 ;
15542 byte arg2 ;
15543 byte arg3 ;
15544 byte arg4 ;
15545 void *argp1 = 0 ;
15546 int res1 = 0 ;
15547 unsigned char val2 ;
15548 int ecode2 = 0 ;
15549 unsigned char val3 ;
15550 int ecode3 = 0 ;
15551 unsigned char val4 ;
15552 int ecode4 = 0 ;
15553 PyObject * obj0 = 0 ;
15554 PyObject * obj1 = 0 ;
15555 PyObject * obj2 = 0 ;
15556 PyObject * obj3 = 0 ;
15557 char * kwnames[] = {
15558 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15559 };
15560
15561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15563 if (!SWIG_IsOK(res1)) {
15564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15565 }
15566 arg1 = reinterpret_cast< wxImage * >(argp1);
15567 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15568 if (!SWIG_IsOK(ecode2)) {
15569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15570 }
15571 arg2 = static_cast< byte >(val2);
15572 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15573 if (!SWIG_IsOK(ecode3)) {
15574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15575 }
15576 arg3 = static_cast< byte >(val3);
15577 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15578 if (!SWIG_IsOK(ecode4)) {
15579 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15580 }
15581 arg4 = static_cast< byte >(val4);
15582 {
15583 PyThreadState* __tstate = wxPyBeginAllowThreads();
15584 (arg1)->SetMaskColour(arg2,arg3,arg4);
15585 wxPyEndAllowThreads(__tstate);
15586 if (PyErr_Occurred()) SWIG_fail;
15587 }
15588 resultobj = SWIG_Py_Void();
15589 return resultobj;
15590 fail:
15591 return NULL;
15592 }
15593
15594
15595 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15596 PyObject *resultobj = 0;
15597 wxImage *arg1 = (wxImage *) 0 ;
15598 byte *arg2 = (byte *) 0 ;
15599 byte *arg3 = (byte *) 0 ;
15600 byte *arg4 = (byte *) 0 ;
15601 void *argp1 = 0 ;
15602 int res1 = 0 ;
15603 byte temp2 ;
15604 int res2 = SWIG_TMPOBJ ;
15605 byte temp3 ;
15606 int res3 = SWIG_TMPOBJ ;
15607 byte temp4 ;
15608 int res4 = SWIG_TMPOBJ ;
15609 PyObject *swig_obj[1] ;
15610
15611 arg2 = &temp2;
15612 arg3 = &temp3;
15613 arg4 = &temp4;
15614 if (!args) SWIG_fail;
15615 swig_obj[0] = args;
15616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15617 if (!SWIG_IsOK(res1)) {
15618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15619 }
15620 arg1 = reinterpret_cast< wxImage * >(argp1);
15621 {
15622 PyThreadState* __tstate = wxPyBeginAllowThreads();
15623 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15624 wxPyEndAllowThreads(__tstate);
15625 if (PyErr_Occurred()) SWIG_fail;
15626 }
15627 resultobj = SWIG_Py_Void();
15628 if (SWIG_IsTmpObj(res2)) {
15629 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15630 } else {
15631 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15632 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15633 }
15634 if (SWIG_IsTmpObj(res3)) {
15635 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15636 } else {
15637 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15638 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15639 }
15640 if (SWIG_IsTmpObj(res4)) {
15641 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15642 } else {
15643 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15645 }
15646 return resultobj;
15647 fail:
15648 return NULL;
15649 }
15650
15651
15652 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15653 PyObject *resultobj = 0;
15654 wxImage *arg1 = (wxImage *) 0 ;
15655 byte result;
15656 void *argp1 = 0 ;
15657 int res1 = 0 ;
15658 PyObject *swig_obj[1] ;
15659
15660 if (!args) SWIG_fail;
15661 swig_obj[0] = args;
15662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15663 if (!SWIG_IsOK(res1)) {
15664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15665 }
15666 arg1 = reinterpret_cast< wxImage * >(argp1);
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 result = (byte)(arg1)->GetMaskRed();
15670 wxPyEndAllowThreads(__tstate);
15671 if (PyErr_Occurred()) SWIG_fail;
15672 }
15673 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15674 return resultobj;
15675 fail:
15676 return NULL;
15677 }
15678
15679
15680 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15681 PyObject *resultobj = 0;
15682 wxImage *arg1 = (wxImage *) 0 ;
15683 byte result;
15684 void *argp1 = 0 ;
15685 int res1 = 0 ;
15686 PyObject *swig_obj[1] ;
15687
15688 if (!args) SWIG_fail;
15689 swig_obj[0] = args;
15690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15691 if (!SWIG_IsOK(res1)) {
15692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15693 }
15694 arg1 = reinterpret_cast< wxImage * >(argp1);
15695 {
15696 PyThreadState* __tstate = wxPyBeginAllowThreads();
15697 result = (byte)(arg1)->GetMaskGreen();
15698 wxPyEndAllowThreads(__tstate);
15699 if (PyErr_Occurred()) SWIG_fail;
15700 }
15701 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15702 return resultobj;
15703 fail:
15704 return NULL;
15705 }
15706
15707
15708 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15709 PyObject *resultobj = 0;
15710 wxImage *arg1 = (wxImage *) 0 ;
15711 byte result;
15712 void *argp1 = 0 ;
15713 int res1 = 0 ;
15714 PyObject *swig_obj[1] ;
15715
15716 if (!args) SWIG_fail;
15717 swig_obj[0] = args;
15718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15719 if (!SWIG_IsOK(res1)) {
15720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15721 }
15722 arg1 = reinterpret_cast< wxImage * >(argp1);
15723 {
15724 PyThreadState* __tstate = wxPyBeginAllowThreads();
15725 result = (byte)(arg1)->GetMaskBlue();
15726 wxPyEndAllowThreads(__tstate);
15727 if (PyErr_Occurred()) SWIG_fail;
15728 }
15729 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15730 return resultobj;
15731 fail:
15732 return NULL;
15733 }
15734
15735
15736 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15737 PyObject *resultobj = 0;
15738 wxImage *arg1 = (wxImage *) 0 ;
15739 bool arg2 = (bool) true ;
15740 void *argp1 = 0 ;
15741 int res1 = 0 ;
15742 bool val2 ;
15743 int ecode2 = 0 ;
15744 PyObject * obj0 = 0 ;
15745 PyObject * obj1 = 0 ;
15746 char * kwnames[] = {
15747 (char *) "self",(char *) "mask", NULL
15748 };
15749
15750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15752 if (!SWIG_IsOK(res1)) {
15753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15754 }
15755 arg1 = reinterpret_cast< wxImage * >(argp1);
15756 if (obj1) {
15757 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15758 if (!SWIG_IsOK(ecode2)) {
15759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15760 }
15761 arg2 = static_cast< bool >(val2);
15762 }
15763 {
15764 PyThreadState* __tstate = wxPyBeginAllowThreads();
15765 (arg1)->SetMask(arg2);
15766 wxPyEndAllowThreads(__tstate);
15767 if (PyErr_Occurred()) SWIG_fail;
15768 }
15769 resultobj = SWIG_Py_Void();
15770 return resultobj;
15771 fail:
15772 return NULL;
15773 }
15774
15775
15776 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15777 PyObject *resultobj = 0;
15778 wxImage *arg1 = (wxImage *) 0 ;
15779 bool result;
15780 void *argp1 = 0 ;
15781 int res1 = 0 ;
15782 PyObject *swig_obj[1] ;
15783
15784 if (!args) SWIG_fail;
15785 swig_obj[0] = args;
15786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15787 if (!SWIG_IsOK(res1)) {
15788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15789 }
15790 arg1 = reinterpret_cast< wxImage * >(argp1);
15791 {
15792 PyThreadState* __tstate = wxPyBeginAllowThreads();
15793 result = (bool)(arg1)->HasMask();
15794 wxPyEndAllowThreads(__tstate);
15795 if (PyErr_Occurred()) SWIG_fail;
15796 }
15797 {
15798 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15799 }
15800 return resultobj;
15801 fail:
15802 return NULL;
15803 }
15804
15805
15806 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15807 PyObject *resultobj = 0;
15808 wxImage *arg1 = (wxImage *) 0 ;
15809 double arg2 ;
15810 wxPoint *arg3 = 0 ;
15811 bool arg4 = (bool) true ;
15812 wxPoint *arg5 = (wxPoint *) NULL ;
15813 SwigValueWrapper<wxImage > result;
15814 void *argp1 = 0 ;
15815 int res1 = 0 ;
15816 double val2 ;
15817 int ecode2 = 0 ;
15818 wxPoint temp3 ;
15819 bool val4 ;
15820 int ecode4 = 0 ;
15821 void *argp5 = 0 ;
15822 int res5 = 0 ;
15823 PyObject * obj0 = 0 ;
15824 PyObject * obj1 = 0 ;
15825 PyObject * obj2 = 0 ;
15826 PyObject * obj3 = 0 ;
15827 PyObject * obj4 = 0 ;
15828 char * kwnames[] = {
15829 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15830 };
15831
15832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15834 if (!SWIG_IsOK(res1)) {
15835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15836 }
15837 arg1 = reinterpret_cast< wxImage * >(argp1);
15838 ecode2 = SWIG_AsVal_double(obj1, &val2);
15839 if (!SWIG_IsOK(ecode2)) {
15840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15841 }
15842 arg2 = static_cast< double >(val2);
15843 {
15844 arg3 = &temp3;
15845 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15846 }
15847 if (obj3) {
15848 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15849 if (!SWIG_IsOK(ecode4)) {
15850 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15851 }
15852 arg4 = static_cast< bool >(val4);
15853 }
15854 if (obj4) {
15855 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15856 if (!SWIG_IsOK(res5)) {
15857 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15858 }
15859 arg5 = reinterpret_cast< wxPoint * >(argp5);
15860 }
15861 {
15862 PyThreadState* __tstate = wxPyBeginAllowThreads();
15863 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15864 wxPyEndAllowThreads(__tstate);
15865 if (PyErr_Occurred()) SWIG_fail;
15866 }
15867 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15868 return resultobj;
15869 fail:
15870 return NULL;
15871 }
15872
15873
15874 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15875 PyObject *resultobj = 0;
15876 wxImage *arg1 = (wxImage *) 0 ;
15877 bool arg2 = (bool) true ;
15878 SwigValueWrapper<wxImage > result;
15879 void *argp1 = 0 ;
15880 int res1 = 0 ;
15881 bool val2 ;
15882 int ecode2 = 0 ;
15883 PyObject * obj0 = 0 ;
15884 PyObject * obj1 = 0 ;
15885 char * kwnames[] = {
15886 (char *) "self",(char *) "clockwise", NULL
15887 };
15888
15889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
15890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15891 if (!SWIG_IsOK(res1)) {
15892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
15893 }
15894 arg1 = reinterpret_cast< wxImage * >(argp1);
15895 if (obj1) {
15896 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15897 if (!SWIG_IsOK(ecode2)) {
15898 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
15899 }
15900 arg2 = static_cast< bool >(val2);
15901 }
15902 {
15903 PyThreadState* __tstate = wxPyBeginAllowThreads();
15904 result = (arg1)->Rotate90(arg2);
15905 wxPyEndAllowThreads(__tstate);
15906 if (PyErr_Occurred()) SWIG_fail;
15907 }
15908 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15909 return resultobj;
15910 fail:
15911 return NULL;
15912 }
15913
15914
15915 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15916 PyObject *resultobj = 0;
15917 wxImage *arg1 = (wxImage *) 0 ;
15918 bool arg2 = (bool) true ;
15919 SwigValueWrapper<wxImage > result;
15920 void *argp1 = 0 ;
15921 int res1 = 0 ;
15922 bool val2 ;
15923 int ecode2 = 0 ;
15924 PyObject * obj0 = 0 ;
15925 PyObject * obj1 = 0 ;
15926 char * kwnames[] = {
15927 (char *) "self",(char *) "horizontally", NULL
15928 };
15929
15930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
15931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15932 if (!SWIG_IsOK(res1)) {
15933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
15934 }
15935 arg1 = reinterpret_cast< wxImage * >(argp1);
15936 if (obj1) {
15937 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15938 if (!SWIG_IsOK(ecode2)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
15940 }
15941 arg2 = static_cast< bool >(val2);
15942 }
15943 {
15944 PyThreadState* __tstate = wxPyBeginAllowThreads();
15945 result = (arg1)->Mirror(arg2);
15946 wxPyEndAllowThreads(__tstate);
15947 if (PyErr_Occurred()) SWIG_fail;
15948 }
15949 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15950 return resultobj;
15951 fail:
15952 return NULL;
15953 }
15954
15955
15956 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15957 PyObject *resultobj = 0;
15958 wxImage *arg1 = (wxImage *) 0 ;
15959 byte arg2 ;
15960 byte arg3 ;
15961 byte arg4 ;
15962 byte arg5 ;
15963 byte arg6 ;
15964 byte arg7 ;
15965 void *argp1 = 0 ;
15966 int res1 = 0 ;
15967 unsigned char val2 ;
15968 int ecode2 = 0 ;
15969 unsigned char val3 ;
15970 int ecode3 = 0 ;
15971 unsigned char val4 ;
15972 int ecode4 = 0 ;
15973 unsigned char val5 ;
15974 int ecode5 = 0 ;
15975 unsigned char val6 ;
15976 int ecode6 = 0 ;
15977 unsigned char val7 ;
15978 int ecode7 = 0 ;
15979 PyObject * obj0 = 0 ;
15980 PyObject * obj1 = 0 ;
15981 PyObject * obj2 = 0 ;
15982 PyObject * obj3 = 0 ;
15983 PyObject * obj4 = 0 ;
15984 PyObject * obj5 = 0 ;
15985 PyObject * obj6 = 0 ;
15986 char * kwnames[] = {
15987 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
15988 };
15989
15990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
15991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15992 if (!SWIG_IsOK(res1)) {
15993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
15994 }
15995 arg1 = reinterpret_cast< wxImage * >(argp1);
15996 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15997 if (!SWIG_IsOK(ecode2)) {
15998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
15999 }
16000 arg2 = static_cast< byte >(val2);
16001 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16002 if (!SWIG_IsOK(ecode3)) {
16003 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16004 }
16005 arg3 = static_cast< byte >(val3);
16006 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16007 if (!SWIG_IsOK(ecode4)) {
16008 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16009 }
16010 arg4 = static_cast< byte >(val4);
16011 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16012 if (!SWIG_IsOK(ecode5)) {
16013 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16014 }
16015 arg5 = static_cast< byte >(val5);
16016 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16017 if (!SWIG_IsOK(ecode6)) {
16018 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16019 }
16020 arg6 = static_cast< byte >(val6);
16021 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16022 if (!SWIG_IsOK(ecode7)) {
16023 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16024 }
16025 arg7 = static_cast< byte >(val7);
16026 {
16027 PyThreadState* __tstate = wxPyBeginAllowThreads();
16028 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16029 wxPyEndAllowThreads(__tstate);
16030 if (PyErr_Occurred()) SWIG_fail;
16031 }
16032 resultobj = SWIG_Py_Void();
16033 return resultobj;
16034 fail:
16035 return NULL;
16036 }
16037
16038
16039 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16040 PyObject *resultobj = 0;
16041 wxImage *arg1 = (wxImage *) 0 ;
16042 double arg2 = (double) 0.299 ;
16043 double arg3 = (double) 0.587 ;
16044 double arg4 = (double) 0.114 ;
16045 SwigValueWrapper<wxImage > result;
16046 void *argp1 = 0 ;
16047 int res1 = 0 ;
16048 double val2 ;
16049 int ecode2 = 0 ;
16050 double val3 ;
16051 int ecode3 = 0 ;
16052 double val4 ;
16053 int ecode4 = 0 ;
16054 PyObject * obj0 = 0 ;
16055 PyObject * obj1 = 0 ;
16056 PyObject * obj2 = 0 ;
16057 PyObject * obj3 = 0 ;
16058 char * kwnames[] = {
16059 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16060 };
16061
16062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16064 if (!SWIG_IsOK(res1)) {
16065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16066 }
16067 arg1 = reinterpret_cast< wxImage * >(argp1);
16068 if (obj1) {
16069 ecode2 = SWIG_AsVal_double(obj1, &val2);
16070 if (!SWIG_IsOK(ecode2)) {
16071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16072 }
16073 arg2 = static_cast< double >(val2);
16074 }
16075 if (obj2) {
16076 ecode3 = SWIG_AsVal_double(obj2, &val3);
16077 if (!SWIG_IsOK(ecode3)) {
16078 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16079 }
16080 arg3 = static_cast< double >(val3);
16081 }
16082 if (obj3) {
16083 ecode4 = SWIG_AsVal_double(obj3, &val4);
16084 if (!SWIG_IsOK(ecode4)) {
16085 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16086 }
16087 arg4 = static_cast< double >(val4);
16088 }
16089 {
16090 PyThreadState* __tstate = wxPyBeginAllowThreads();
16091 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16092 wxPyEndAllowThreads(__tstate);
16093 if (PyErr_Occurred()) SWIG_fail;
16094 }
16095 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16096 return resultobj;
16097 fail:
16098 return NULL;
16099 }
16100
16101
16102 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16103 PyObject *resultobj = 0;
16104 wxImage *arg1 = (wxImage *) 0 ;
16105 byte arg2 ;
16106 byte arg3 ;
16107 byte arg4 ;
16108 SwigValueWrapper<wxImage > result;
16109 void *argp1 = 0 ;
16110 int res1 = 0 ;
16111 unsigned char val2 ;
16112 int ecode2 = 0 ;
16113 unsigned char val3 ;
16114 int ecode3 = 0 ;
16115 unsigned char val4 ;
16116 int ecode4 = 0 ;
16117 PyObject * obj0 = 0 ;
16118 PyObject * obj1 = 0 ;
16119 PyObject * obj2 = 0 ;
16120 PyObject * obj3 = 0 ;
16121 char * kwnames[] = {
16122 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16123 };
16124
16125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16127 if (!SWIG_IsOK(res1)) {
16128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16129 }
16130 arg1 = reinterpret_cast< wxImage * >(argp1);
16131 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16132 if (!SWIG_IsOK(ecode2)) {
16133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16134 }
16135 arg2 = static_cast< byte >(val2);
16136 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16137 if (!SWIG_IsOK(ecode3)) {
16138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16139 }
16140 arg3 = static_cast< byte >(val3);
16141 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16142 if (!SWIG_IsOK(ecode4)) {
16143 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16144 }
16145 arg4 = static_cast< byte >(val4);
16146 {
16147 PyThreadState* __tstate = wxPyBeginAllowThreads();
16148 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16149 wxPyEndAllowThreads(__tstate);
16150 if (PyErr_Occurred()) SWIG_fail;
16151 }
16152 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16153 return resultobj;
16154 fail:
16155 return NULL;
16156 }
16157
16158
16159 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16160 PyObject *resultobj = 0;
16161 wxImage *arg1 = (wxImage *) 0 ;
16162 wxString *arg2 = 0 ;
16163 wxString *arg3 = 0 ;
16164 void *argp1 = 0 ;
16165 int res1 = 0 ;
16166 bool temp2 = false ;
16167 bool temp3 = false ;
16168 PyObject * obj0 = 0 ;
16169 PyObject * obj1 = 0 ;
16170 PyObject * obj2 = 0 ;
16171 char * kwnames[] = {
16172 (char *) "self",(char *) "name",(char *) "value", NULL
16173 };
16174
16175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16177 if (!SWIG_IsOK(res1)) {
16178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16179 }
16180 arg1 = reinterpret_cast< wxImage * >(argp1);
16181 {
16182 arg2 = wxString_in_helper(obj1);
16183 if (arg2 == NULL) SWIG_fail;
16184 temp2 = true;
16185 }
16186 {
16187 arg3 = wxString_in_helper(obj2);
16188 if (arg3 == NULL) SWIG_fail;
16189 temp3 = true;
16190 }
16191 {
16192 PyThreadState* __tstate = wxPyBeginAllowThreads();
16193 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16194 wxPyEndAllowThreads(__tstate);
16195 if (PyErr_Occurred()) SWIG_fail;
16196 }
16197 resultobj = SWIG_Py_Void();
16198 {
16199 if (temp2)
16200 delete arg2;
16201 }
16202 {
16203 if (temp3)
16204 delete arg3;
16205 }
16206 return resultobj;
16207 fail:
16208 {
16209 if (temp2)
16210 delete arg2;
16211 }
16212 {
16213 if (temp3)
16214 delete arg3;
16215 }
16216 return NULL;
16217 }
16218
16219
16220 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16221 PyObject *resultobj = 0;
16222 wxImage *arg1 = (wxImage *) 0 ;
16223 wxString *arg2 = 0 ;
16224 int arg3 ;
16225 void *argp1 = 0 ;
16226 int res1 = 0 ;
16227 bool temp2 = false ;
16228 int val3 ;
16229 int ecode3 = 0 ;
16230 PyObject * obj0 = 0 ;
16231 PyObject * obj1 = 0 ;
16232 PyObject * obj2 = 0 ;
16233 char * kwnames[] = {
16234 (char *) "self",(char *) "name",(char *) "value", NULL
16235 };
16236
16237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16241 }
16242 arg1 = reinterpret_cast< wxImage * >(argp1);
16243 {
16244 arg2 = wxString_in_helper(obj1);
16245 if (arg2 == NULL) SWIG_fail;
16246 temp2 = true;
16247 }
16248 ecode3 = SWIG_AsVal_int(obj2, &val3);
16249 if (!SWIG_IsOK(ecode3)) {
16250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16251 }
16252 arg3 = static_cast< int >(val3);
16253 {
16254 PyThreadState* __tstate = wxPyBeginAllowThreads();
16255 (arg1)->SetOption((wxString const &)*arg2,arg3);
16256 wxPyEndAllowThreads(__tstate);
16257 if (PyErr_Occurred()) SWIG_fail;
16258 }
16259 resultobj = SWIG_Py_Void();
16260 {
16261 if (temp2)
16262 delete arg2;
16263 }
16264 return resultobj;
16265 fail:
16266 {
16267 if (temp2)
16268 delete arg2;
16269 }
16270 return NULL;
16271 }
16272
16273
16274 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16275 PyObject *resultobj = 0;
16276 wxImage *arg1 = (wxImage *) 0 ;
16277 wxString *arg2 = 0 ;
16278 wxString result;
16279 void *argp1 = 0 ;
16280 int res1 = 0 ;
16281 bool temp2 = false ;
16282 PyObject * obj0 = 0 ;
16283 PyObject * obj1 = 0 ;
16284 char * kwnames[] = {
16285 (char *) "self",(char *) "name", NULL
16286 };
16287
16288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16290 if (!SWIG_IsOK(res1)) {
16291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16292 }
16293 arg1 = reinterpret_cast< wxImage * >(argp1);
16294 {
16295 arg2 = wxString_in_helper(obj1);
16296 if (arg2 == NULL) SWIG_fail;
16297 temp2 = true;
16298 }
16299 {
16300 PyThreadState* __tstate = wxPyBeginAllowThreads();
16301 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16302 wxPyEndAllowThreads(__tstate);
16303 if (PyErr_Occurred()) SWIG_fail;
16304 }
16305 {
16306 #if wxUSE_UNICODE
16307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16308 #else
16309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16310 #endif
16311 }
16312 {
16313 if (temp2)
16314 delete arg2;
16315 }
16316 return resultobj;
16317 fail:
16318 {
16319 if (temp2)
16320 delete arg2;
16321 }
16322 return NULL;
16323 }
16324
16325
16326 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16327 PyObject *resultobj = 0;
16328 wxImage *arg1 = (wxImage *) 0 ;
16329 wxString *arg2 = 0 ;
16330 int result;
16331 void *argp1 = 0 ;
16332 int res1 = 0 ;
16333 bool temp2 = false ;
16334 PyObject * obj0 = 0 ;
16335 PyObject * obj1 = 0 ;
16336 char * kwnames[] = {
16337 (char *) "self",(char *) "name", NULL
16338 };
16339
16340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16342 if (!SWIG_IsOK(res1)) {
16343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16344 }
16345 arg1 = reinterpret_cast< wxImage * >(argp1);
16346 {
16347 arg2 = wxString_in_helper(obj1);
16348 if (arg2 == NULL) SWIG_fail;
16349 temp2 = true;
16350 }
16351 {
16352 PyThreadState* __tstate = wxPyBeginAllowThreads();
16353 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16354 wxPyEndAllowThreads(__tstate);
16355 if (PyErr_Occurred()) SWIG_fail;
16356 }
16357 resultobj = SWIG_From_int(static_cast< int >(result));
16358 {
16359 if (temp2)
16360 delete arg2;
16361 }
16362 return resultobj;
16363 fail:
16364 {
16365 if (temp2)
16366 delete arg2;
16367 }
16368 return NULL;
16369 }
16370
16371
16372 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16373 PyObject *resultobj = 0;
16374 wxImage *arg1 = (wxImage *) 0 ;
16375 wxString *arg2 = 0 ;
16376 bool result;
16377 void *argp1 = 0 ;
16378 int res1 = 0 ;
16379 bool temp2 = false ;
16380 PyObject * obj0 = 0 ;
16381 PyObject * obj1 = 0 ;
16382 char * kwnames[] = {
16383 (char *) "self",(char *) "name", NULL
16384 };
16385
16386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16388 if (!SWIG_IsOK(res1)) {
16389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16390 }
16391 arg1 = reinterpret_cast< wxImage * >(argp1);
16392 {
16393 arg2 = wxString_in_helper(obj1);
16394 if (arg2 == NULL) SWIG_fail;
16395 temp2 = true;
16396 }
16397 {
16398 PyThreadState* __tstate = wxPyBeginAllowThreads();
16399 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16400 wxPyEndAllowThreads(__tstate);
16401 if (PyErr_Occurred()) SWIG_fail;
16402 }
16403 {
16404 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16405 }
16406 {
16407 if (temp2)
16408 delete arg2;
16409 }
16410 return resultobj;
16411 fail:
16412 {
16413 if (temp2)
16414 delete arg2;
16415 }
16416 return NULL;
16417 }
16418
16419
16420 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16421 PyObject *resultobj = 0;
16422 wxImage *arg1 = (wxImage *) 0 ;
16423 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16424 unsigned long result;
16425 void *argp1 = 0 ;
16426 int res1 = 0 ;
16427 unsigned long val2 ;
16428 int ecode2 = 0 ;
16429 PyObject * obj0 = 0 ;
16430 PyObject * obj1 = 0 ;
16431 char * kwnames[] = {
16432 (char *) "self",(char *) "stopafter", NULL
16433 };
16434
16435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16437 if (!SWIG_IsOK(res1)) {
16438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16439 }
16440 arg1 = reinterpret_cast< wxImage * >(argp1);
16441 if (obj1) {
16442 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16443 if (!SWIG_IsOK(ecode2)) {
16444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16445 }
16446 arg2 = static_cast< unsigned long >(val2);
16447 }
16448 {
16449 PyThreadState* __tstate = wxPyBeginAllowThreads();
16450 result = (unsigned long)(arg1)->CountColours(arg2);
16451 wxPyEndAllowThreads(__tstate);
16452 if (PyErr_Occurred()) SWIG_fail;
16453 }
16454 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16455 return resultobj;
16456 fail:
16457 return NULL;
16458 }
16459
16460
16461 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16462 PyObject *resultobj = 0;
16463 wxImage *arg1 = (wxImage *) 0 ;
16464 wxImageHistogram *arg2 = 0 ;
16465 unsigned long result;
16466 void *argp1 = 0 ;
16467 int res1 = 0 ;
16468 void *argp2 = 0 ;
16469 int res2 = 0 ;
16470 PyObject * obj0 = 0 ;
16471 PyObject * obj1 = 0 ;
16472 char * kwnames[] = {
16473 (char *) "self",(char *) "h", NULL
16474 };
16475
16476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16478 if (!SWIG_IsOK(res1)) {
16479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16480 }
16481 arg1 = reinterpret_cast< wxImage * >(argp1);
16482 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16483 if (!SWIG_IsOK(res2)) {
16484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16485 }
16486 if (!argp2) {
16487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16488 }
16489 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16490 {
16491 PyThreadState* __tstate = wxPyBeginAllowThreads();
16492 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16493 wxPyEndAllowThreads(__tstate);
16494 if (PyErr_Occurred()) SWIG_fail;
16495 }
16496 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16497 return resultobj;
16498 fail:
16499 return NULL;
16500 }
16501
16502
16503 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16504 PyObject *resultobj = 0;
16505 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16506 void *argp1 = 0 ;
16507 int res1 = 0 ;
16508 PyObject * obj0 = 0 ;
16509 char * kwnames[] = {
16510 (char *) "handler", NULL
16511 };
16512
16513 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16514 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16515 if (!SWIG_IsOK(res1)) {
16516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16517 }
16518 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16519 {
16520 PyThreadState* __tstate = wxPyBeginAllowThreads();
16521 wxImage::AddHandler(arg1);
16522 wxPyEndAllowThreads(__tstate);
16523 if (PyErr_Occurred()) SWIG_fail;
16524 }
16525 resultobj = SWIG_Py_Void();
16526 return resultobj;
16527 fail:
16528 return NULL;
16529 }
16530
16531
16532 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj = 0;
16534 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16535 void *argp1 = 0 ;
16536 int res1 = 0 ;
16537 PyObject * obj0 = 0 ;
16538 char * kwnames[] = {
16539 (char *) "handler", NULL
16540 };
16541
16542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16544 if (!SWIG_IsOK(res1)) {
16545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16546 }
16547 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16548 {
16549 PyThreadState* __tstate = wxPyBeginAllowThreads();
16550 wxImage::InsertHandler(arg1);
16551 wxPyEndAllowThreads(__tstate);
16552 if (PyErr_Occurred()) SWIG_fail;
16553 }
16554 resultobj = SWIG_Py_Void();
16555 return resultobj;
16556 fail:
16557 return NULL;
16558 }
16559
16560
16561 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16562 PyObject *resultobj = 0;
16563 wxString *arg1 = 0 ;
16564 bool result;
16565 bool temp1 = false ;
16566 PyObject * obj0 = 0 ;
16567 char * kwnames[] = {
16568 (char *) "name", NULL
16569 };
16570
16571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16572 {
16573 arg1 = wxString_in_helper(obj0);
16574 if (arg1 == NULL) SWIG_fail;
16575 temp1 = true;
16576 }
16577 {
16578 PyThreadState* __tstate = wxPyBeginAllowThreads();
16579 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16580 wxPyEndAllowThreads(__tstate);
16581 if (PyErr_Occurred()) SWIG_fail;
16582 }
16583 {
16584 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16585 }
16586 {
16587 if (temp1)
16588 delete arg1;
16589 }
16590 return resultobj;
16591 fail:
16592 {
16593 if (temp1)
16594 delete arg1;
16595 }
16596 return NULL;
16597 }
16598
16599
16600 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16601 PyObject *resultobj = 0;
16602 PyObject *result = 0 ;
16603
16604 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16605 {
16606 PyThreadState* __tstate = wxPyBeginAllowThreads();
16607 result = (PyObject *)wxImage_GetHandlers();
16608 wxPyEndAllowThreads(__tstate);
16609 if (PyErr_Occurred()) SWIG_fail;
16610 }
16611 resultobj = result;
16612 return resultobj;
16613 fail:
16614 return NULL;
16615 }
16616
16617
16618 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16619 PyObject *resultobj = 0;
16620 wxString result;
16621
16622 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16623 {
16624 PyThreadState* __tstate = wxPyBeginAllowThreads();
16625 result = wxImage::GetImageExtWildcard();
16626 wxPyEndAllowThreads(__tstate);
16627 if (PyErr_Occurred()) SWIG_fail;
16628 }
16629 {
16630 #if wxUSE_UNICODE
16631 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16632 #else
16633 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16634 #endif
16635 }
16636 return resultobj;
16637 fail:
16638 return NULL;
16639 }
16640
16641
16642 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16643 PyObject *resultobj = 0;
16644 wxImage *arg1 = (wxImage *) 0 ;
16645 int arg2 = (int) -1 ;
16646 wxBitmap result;
16647 void *argp1 = 0 ;
16648 int res1 = 0 ;
16649 int val2 ;
16650 int ecode2 = 0 ;
16651 PyObject * obj0 = 0 ;
16652 PyObject * obj1 = 0 ;
16653 char * kwnames[] = {
16654 (char *) "self",(char *) "depth", NULL
16655 };
16656
16657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16659 if (!SWIG_IsOK(res1)) {
16660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16661 }
16662 arg1 = reinterpret_cast< wxImage * >(argp1);
16663 if (obj1) {
16664 ecode2 = SWIG_AsVal_int(obj1, &val2);
16665 if (!SWIG_IsOK(ecode2)) {
16666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16667 }
16668 arg2 = static_cast< int >(val2);
16669 }
16670 {
16671 if (!wxPyCheckForApp()) SWIG_fail;
16672 PyThreadState* __tstate = wxPyBeginAllowThreads();
16673 result = wxImage_ConvertToBitmap(arg1,arg2);
16674 wxPyEndAllowThreads(__tstate);
16675 if (PyErr_Occurred()) SWIG_fail;
16676 }
16677 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16678 return resultobj;
16679 fail:
16680 return NULL;
16681 }
16682
16683
16684 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16685 PyObject *resultobj = 0;
16686 wxImage *arg1 = (wxImage *) 0 ;
16687 byte arg2 ;
16688 byte arg3 ;
16689 byte arg4 ;
16690 wxBitmap result;
16691 void *argp1 = 0 ;
16692 int res1 = 0 ;
16693 unsigned char val2 ;
16694 int ecode2 = 0 ;
16695 unsigned char val3 ;
16696 int ecode3 = 0 ;
16697 unsigned char val4 ;
16698 int ecode4 = 0 ;
16699 PyObject * obj0 = 0 ;
16700 PyObject * obj1 = 0 ;
16701 PyObject * obj2 = 0 ;
16702 PyObject * obj3 = 0 ;
16703 char * kwnames[] = {
16704 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16705 };
16706
16707 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16708 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16709 if (!SWIG_IsOK(res1)) {
16710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16711 }
16712 arg1 = reinterpret_cast< wxImage * >(argp1);
16713 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16714 if (!SWIG_IsOK(ecode2)) {
16715 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16716 }
16717 arg2 = static_cast< byte >(val2);
16718 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16719 if (!SWIG_IsOK(ecode3)) {
16720 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16721 }
16722 arg3 = static_cast< byte >(val3);
16723 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16724 if (!SWIG_IsOK(ecode4)) {
16725 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16726 }
16727 arg4 = static_cast< byte >(val4);
16728 {
16729 if (!wxPyCheckForApp()) SWIG_fail;
16730 PyThreadState* __tstate = wxPyBeginAllowThreads();
16731 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16732 wxPyEndAllowThreads(__tstate);
16733 if (PyErr_Occurred()) SWIG_fail;
16734 }
16735 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16736 return resultobj;
16737 fail:
16738 return NULL;
16739 }
16740
16741
16742 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16743 PyObject *resultobj = 0;
16744 wxImage *arg1 = (wxImage *) 0 ;
16745 double arg2 ;
16746 void *argp1 = 0 ;
16747 int res1 = 0 ;
16748 double val2 ;
16749 int ecode2 = 0 ;
16750 PyObject * obj0 = 0 ;
16751 PyObject * obj1 = 0 ;
16752 char * kwnames[] = {
16753 (char *) "self",(char *) "angle", NULL
16754 };
16755
16756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
16757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16758 if (!SWIG_IsOK(res1)) {
16759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16760 }
16761 arg1 = reinterpret_cast< wxImage * >(argp1);
16762 ecode2 = SWIG_AsVal_double(obj1, &val2);
16763 if (!SWIG_IsOK(ecode2)) {
16764 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16765 }
16766 arg2 = static_cast< double >(val2);
16767 {
16768 PyThreadState* __tstate = wxPyBeginAllowThreads();
16769 (arg1)->RotateHue(arg2);
16770 wxPyEndAllowThreads(__tstate);
16771 if (PyErr_Occurred()) SWIG_fail;
16772 }
16773 resultobj = SWIG_Py_Void();
16774 return resultobj;
16775 fail:
16776 return NULL;
16777 }
16778
16779
16780 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16781 PyObject *resultobj = 0;
16782 wxImage_RGBValue arg1 ;
16783 wxImage_HSVValue result;
16784 void *argp1 ;
16785 int res1 = 0 ;
16786 PyObject * obj0 = 0 ;
16787 char * kwnames[] = {
16788 (char *) "rgb", NULL
16789 };
16790
16791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16792 {
16793 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16794 if (!SWIG_IsOK(res1)) {
16795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16796 }
16797 if (!argp1) {
16798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16799 } else {
16800 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16801 arg1 = *temp;
16802 if (SWIG_IsNewObj(res1)) delete temp;
16803 }
16804 }
16805 {
16806 PyThreadState* __tstate = wxPyBeginAllowThreads();
16807 result = wxImage::RGBtoHSV(arg1);
16808 wxPyEndAllowThreads(__tstate);
16809 if (PyErr_Occurred()) SWIG_fail;
16810 }
16811 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16812 return resultobj;
16813 fail:
16814 return NULL;
16815 }
16816
16817
16818 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16819 PyObject *resultobj = 0;
16820 wxImage_HSVValue arg1 ;
16821 wxImage_RGBValue result;
16822 void *argp1 ;
16823 int res1 = 0 ;
16824 PyObject * obj0 = 0 ;
16825 char * kwnames[] = {
16826 (char *) "hsv", NULL
16827 };
16828
16829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16830 {
16831 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16832 if (!SWIG_IsOK(res1)) {
16833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16834 }
16835 if (!argp1) {
16836 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16837 } else {
16838 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16839 arg1 = *temp;
16840 if (SWIG_IsNewObj(res1)) delete temp;
16841 }
16842 }
16843 {
16844 PyThreadState* __tstate = wxPyBeginAllowThreads();
16845 result = wxImage::HSVtoRGB(arg1);
16846 wxPyEndAllowThreads(__tstate);
16847 if (PyErr_Occurred()) SWIG_fail;
16848 }
16849 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16850 return resultobj;
16851 fail:
16852 return NULL;
16853 }
16854
16855
16856 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16857 PyObject *obj;
16858 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16859 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16860 return SWIG_Py_Void();
16861 }
16862
16863 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16864 return SWIG_Python_InitShadowInstance(args);
16865 }
16866
16867 SWIGINTERN int NullImage_set(PyObject *) {
16868 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16869 return 1;
16870 }
16871
16872
16873 SWIGINTERN PyObject *NullImage_get(void) {
16874 PyObject *pyobj = 0;
16875
16876 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16877 return pyobj;
16878 }
16879
16880
16881 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16882 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16883 return 1;
16884 }
16885
16886
16887 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
16888 PyObject *pyobj = 0;
16889
16890 {
16891 #if wxUSE_UNICODE
16892 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16893 #else
16894 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
16895 #endif
16896 }
16897 return pyobj;
16898 }
16899
16900
16901 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
16902 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
16903 return 1;
16904 }
16905
16906
16907 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
16908 PyObject *pyobj = 0;
16909
16910 {
16911 #if wxUSE_UNICODE
16912 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16913 #else
16914 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
16915 #endif
16916 }
16917 return pyobj;
16918 }
16919
16920
16921 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
16922 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
16923 return 1;
16924 }
16925
16926
16927 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
16928 PyObject *pyobj = 0;
16929
16930 {
16931 #if wxUSE_UNICODE
16932 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16933 #else
16934 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
16935 #endif
16936 }
16937 return pyobj;
16938 }
16939
16940
16941 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
16942 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
16943 return 1;
16944 }
16945
16946
16947 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
16948 PyObject *pyobj = 0;
16949
16950 {
16951 #if wxUSE_UNICODE
16952 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16953 #else
16954 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
16955 #endif
16956 }
16957 return pyobj;
16958 }
16959
16960
16961 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
16962 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
16963 return 1;
16964 }
16965
16966
16967 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
16968 PyObject *pyobj = 0;
16969
16970 {
16971 #if wxUSE_UNICODE
16972 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16973 #else
16974 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
16975 #endif
16976 }
16977 return pyobj;
16978 }
16979
16980
16981 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
16982 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
16983 return 1;
16984 }
16985
16986
16987 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
16988 PyObject *pyobj = 0;
16989
16990 {
16991 #if wxUSE_UNICODE
16992 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16993 #else
16994 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
16995 #endif
16996 }
16997 return pyobj;
16998 }
16999
17000
17001 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17002 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17003 return 1;
17004 }
17005
17006
17007 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17008 PyObject *pyobj = 0;
17009
17010 {
17011 #if wxUSE_UNICODE
17012 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17013 #else
17014 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17015 #endif
17016 }
17017 return pyobj;
17018 }
17019
17020
17021 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17022 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17023 return 1;
17024 }
17025
17026
17027 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17028 PyObject *pyobj = 0;
17029
17030 {
17031 #if wxUSE_UNICODE
17032 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17033 #else
17034 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17035 #endif
17036 }
17037 return pyobj;
17038 }
17039
17040
17041 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17042 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17043 return 1;
17044 }
17045
17046
17047 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17048 PyObject *pyobj = 0;
17049
17050 {
17051 #if wxUSE_UNICODE
17052 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17053 #else
17054 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17055 #endif
17056 }
17057 return pyobj;
17058 }
17059
17060
17061 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17062 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17063 return 1;
17064 }
17065
17066
17067 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17068 PyObject *pyobj = 0;
17069
17070 {
17071 #if wxUSE_UNICODE
17072 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17073 #else
17074 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17075 #endif
17076 }
17077 return pyobj;
17078 }
17079
17080
17081 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17082 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17083 return 1;
17084 }
17085
17086
17087 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17088 PyObject *pyobj = 0;
17089
17090 {
17091 #if wxUSE_UNICODE
17092 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17093 #else
17094 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17095 #endif
17096 }
17097 return pyobj;
17098 }
17099
17100
17101 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17102 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17103 return 1;
17104 }
17105
17106
17107 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17108 PyObject *pyobj = 0;
17109
17110 {
17111 #if wxUSE_UNICODE
17112 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17113 #else
17114 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17115 #endif
17116 }
17117 return pyobj;
17118 }
17119
17120
17121 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17122 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17123 return 1;
17124 }
17125
17126
17127 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17128 PyObject *pyobj = 0;
17129
17130 {
17131 #if wxUSE_UNICODE
17132 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17133 #else
17134 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17135 #endif
17136 }
17137 return pyobj;
17138 }
17139
17140
17141 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17142 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17143 return 1;
17144 }
17145
17146
17147 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17148 PyObject *pyobj = 0;
17149
17150 {
17151 #if wxUSE_UNICODE
17152 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17153 #else
17154 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17155 #endif
17156 }
17157 return pyobj;
17158 }
17159
17160
17161 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17162 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17163 return 1;
17164 }
17165
17166
17167 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17168 PyObject *pyobj = 0;
17169
17170 {
17171 #if wxUSE_UNICODE
17172 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17173 #else
17174 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17175 #endif
17176 }
17177 return pyobj;
17178 }
17179
17180
17181 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17182 PyObject *resultobj = 0;
17183 wxBMPHandler *result = 0 ;
17184
17185 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17186 {
17187 PyThreadState* __tstate = wxPyBeginAllowThreads();
17188 result = (wxBMPHandler *)new wxBMPHandler();
17189 wxPyEndAllowThreads(__tstate);
17190 if (PyErr_Occurred()) SWIG_fail;
17191 }
17192 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17193 return resultobj;
17194 fail:
17195 return NULL;
17196 }
17197
17198
17199 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17200 PyObject *obj;
17201 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17202 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17203 return SWIG_Py_Void();
17204 }
17205
17206 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17207 return SWIG_Python_InitShadowInstance(args);
17208 }
17209
17210 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17211 PyObject *resultobj = 0;
17212 wxICOHandler *result = 0 ;
17213
17214 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17215 {
17216 PyThreadState* __tstate = wxPyBeginAllowThreads();
17217 result = (wxICOHandler *)new wxICOHandler();
17218 wxPyEndAllowThreads(__tstate);
17219 if (PyErr_Occurred()) SWIG_fail;
17220 }
17221 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17222 return resultobj;
17223 fail:
17224 return NULL;
17225 }
17226
17227
17228 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17229 PyObject *obj;
17230 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17231 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17232 return SWIG_Py_Void();
17233 }
17234
17235 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17236 return SWIG_Python_InitShadowInstance(args);
17237 }
17238
17239 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17240 PyObject *resultobj = 0;
17241 wxCURHandler *result = 0 ;
17242
17243 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17244 {
17245 PyThreadState* __tstate = wxPyBeginAllowThreads();
17246 result = (wxCURHandler *)new wxCURHandler();
17247 wxPyEndAllowThreads(__tstate);
17248 if (PyErr_Occurred()) SWIG_fail;
17249 }
17250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17251 return resultobj;
17252 fail:
17253 return NULL;
17254 }
17255
17256
17257 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17258 PyObject *obj;
17259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17260 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17261 return SWIG_Py_Void();
17262 }
17263
17264 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17265 return SWIG_Python_InitShadowInstance(args);
17266 }
17267
17268 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17269 PyObject *resultobj = 0;
17270 wxANIHandler *result = 0 ;
17271
17272 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17273 {
17274 PyThreadState* __tstate = wxPyBeginAllowThreads();
17275 result = (wxANIHandler *)new wxANIHandler();
17276 wxPyEndAllowThreads(__tstate);
17277 if (PyErr_Occurred()) SWIG_fail;
17278 }
17279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17280 return resultobj;
17281 fail:
17282 return NULL;
17283 }
17284
17285
17286 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17287 PyObject *obj;
17288 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17289 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17290 return SWIG_Py_Void();
17291 }
17292
17293 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17294 return SWIG_Python_InitShadowInstance(args);
17295 }
17296
17297 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17298 PyObject *resultobj = 0;
17299 wxPNGHandler *result = 0 ;
17300
17301 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17302 {
17303 PyThreadState* __tstate = wxPyBeginAllowThreads();
17304 result = (wxPNGHandler *)new wxPNGHandler();
17305 wxPyEndAllowThreads(__tstate);
17306 if (PyErr_Occurred()) SWIG_fail;
17307 }
17308 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17309 return resultobj;
17310 fail:
17311 return NULL;
17312 }
17313
17314
17315 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17316 PyObject *obj;
17317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17318 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17319 return SWIG_Py_Void();
17320 }
17321
17322 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 return SWIG_Python_InitShadowInstance(args);
17324 }
17325
17326 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17327 PyObject *resultobj = 0;
17328 wxGIFHandler *result = 0 ;
17329
17330 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17331 {
17332 PyThreadState* __tstate = wxPyBeginAllowThreads();
17333 result = (wxGIFHandler *)new wxGIFHandler();
17334 wxPyEndAllowThreads(__tstate);
17335 if (PyErr_Occurred()) SWIG_fail;
17336 }
17337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17338 return resultobj;
17339 fail:
17340 return NULL;
17341 }
17342
17343
17344 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17345 PyObject *obj;
17346 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17347 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17348 return SWIG_Py_Void();
17349 }
17350
17351 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17352 return SWIG_Python_InitShadowInstance(args);
17353 }
17354
17355 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17356 PyObject *resultobj = 0;
17357 wxPCXHandler *result = 0 ;
17358
17359 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17360 {
17361 PyThreadState* __tstate = wxPyBeginAllowThreads();
17362 result = (wxPCXHandler *)new wxPCXHandler();
17363 wxPyEndAllowThreads(__tstate);
17364 if (PyErr_Occurred()) SWIG_fail;
17365 }
17366 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17367 return resultobj;
17368 fail:
17369 return NULL;
17370 }
17371
17372
17373 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17374 PyObject *obj;
17375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17376 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17377 return SWIG_Py_Void();
17378 }
17379
17380 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17381 return SWIG_Python_InitShadowInstance(args);
17382 }
17383
17384 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17385 PyObject *resultobj = 0;
17386 wxJPEGHandler *result = 0 ;
17387
17388 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17389 {
17390 PyThreadState* __tstate = wxPyBeginAllowThreads();
17391 result = (wxJPEGHandler *)new wxJPEGHandler();
17392 wxPyEndAllowThreads(__tstate);
17393 if (PyErr_Occurred()) SWIG_fail;
17394 }
17395 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17396 return resultobj;
17397 fail:
17398 return NULL;
17399 }
17400
17401
17402 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17403 PyObject *obj;
17404 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17405 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17406 return SWIG_Py_Void();
17407 }
17408
17409 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17410 return SWIG_Python_InitShadowInstance(args);
17411 }
17412
17413 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17414 PyObject *resultobj = 0;
17415 wxPNMHandler *result = 0 ;
17416
17417 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17418 {
17419 PyThreadState* __tstate = wxPyBeginAllowThreads();
17420 result = (wxPNMHandler *)new wxPNMHandler();
17421 wxPyEndAllowThreads(__tstate);
17422 if (PyErr_Occurred()) SWIG_fail;
17423 }
17424 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17425 return resultobj;
17426 fail:
17427 return NULL;
17428 }
17429
17430
17431 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17432 PyObject *obj;
17433 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17434 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17435 return SWIG_Py_Void();
17436 }
17437
17438 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 return SWIG_Python_InitShadowInstance(args);
17440 }
17441
17442 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17443 PyObject *resultobj = 0;
17444 wxXPMHandler *result = 0 ;
17445
17446 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17447 {
17448 PyThreadState* __tstate = wxPyBeginAllowThreads();
17449 result = (wxXPMHandler *)new wxXPMHandler();
17450 wxPyEndAllowThreads(__tstate);
17451 if (PyErr_Occurred()) SWIG_fail;
17452 }
17453 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17454 return resultobj;
17455 fail:
17456 return NULL;
17457 }
17458
17459
17460 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17461 PyObject *obj;
17462 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17463 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17464 return SWIG_Py_Void();
17465 }
17466
17467 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 return SWIG_Python_InitShadowInstance(args);
17469 }
17470
17471 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17472 PyObject *resultobj = 0;
17473 wxTIFFHandler *result = 0 ;
17474
17475 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17476 {
17477 PyThreadState* __tstate = wxPyBeginAllowThreads();
17478 result = (wxTIFFHandler *)new wxTIFFHandler();
17479 wxPyEndAllowThreads(__tstate);
17480 if (PyErr_Occurred()) SWIG_fail;
17481 }
17482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17483 return resultobj;
17484 fail:
17485 return NULL;
17486 }
17487
17488
17489 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17490 PyObject *obj;
17491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17492 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17493 return SWIG_Py_Void();
17494 }
17495
17496 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17497 return SWIG_Python_InitShadowInstance(args);
17498 }
17499
17500 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17501 PyObject *resultobj = 0;
17502 wxImage *arg1 = 0 ;
17503 wxImage *arg2 = 0 ;
17504 int arg3 = (int) 236 ;
17505 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17506 bool result;
17507 void *argp1 = 0 ;
17508 int res1 = 0 ;
17509 void *argp2 = 0 ;
17510 int res2 = 0 ;
17511 int val3 ;
17512 int ecode3 = 0 ;
17513 int val4 ;
17514 int ecode4 = 0 ;
17515 PyObject * obj0 = 0 ;
17516 PyObject * obj1 = 0 ;
17517 PyObject * obj2 = 0 ;
17518 PyObject * obj3 = 0 ;
17519 char * kwnames[] = {
17520 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17521 };
17522
17523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17524 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17525 if (!SWIG_IsOK(res1)) {
17526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17527 }
17528 if (!argp1) {
17529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17530 }
17531 arg1 = reinterpret_cast< wxImage * >(argp1);
17532 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17533 if (!SWIG_IsOK(res2)) {
17534 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17535 }
17536 if (!argp2) {
17537 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17538 }
17539 arg2 = reinterpret_cast< wxImage * >(argp2);
17540 if (obj2) {
17541 ecode3 = SWIG_AsVal_int(obj2, &val3);
17542 if (!SWIG_IsOK(ecode3)) {
17543 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17544 }
17545 arg3 = static_cast< int >(val3);
17546 }
17547 if (obj3) {
17548 ecode4 = SWIG_AsVal_int(obj3, &val4);
17549 if (!SWIG_IsOK(ecode4)) {
17550 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17551 }
17552 arg4 = static_cast< int >(val4);
17553 }
17554 {
17555 PyThreadState* __tstate = wxPyBeginAllowThreads();
17556 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17557 wxPyEndAllowThreads(__tstate);
17558 if (PyErr_Occurred()) SWIG_fail;
17559 }
17560 {
17561 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17562 }
17563 return resultobj;
17564 fail:
17565 return NULL;
17566 }
17567
17568
17569 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17570 PyObject *obj;
17571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17572 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17573 return SWIG_Py_Void();
17574 }
17575
17576 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17577 PyObject *resultobj = 0;
17578 wxEvtHandler *result = 0 ;
17579
17580 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17581 {
17582 PyThreadState* __tstate = wxPyBeginAllowThreads();
17583 result = (wxEvtHandler *)new wxEvtHandler();
17584 wxPyEndAllowThreads(__tstate);
17585 if (PyErr_Occurred()) SWIG_fail;
17586 }
17587 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17588 return resultobj;
17589 fail:
17590 return NULL;
17591 }
17592
17593
17594 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17595 PyObject *resultobj = 0;
17596 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17597 wxEvtHandler *result = 0 ;
17598 void *argp1 = 0 ;
17599 int res1 = 0 ;
17600 PyObject *swig_obj[1] ;
17601
17602 if (!args) SWIG_fail;
17603 swig_obj[0] = args;
17604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17605 if (!SWIG_IsOK(res1)) {
17606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17607 }
17608 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17609 {
17610 PyThreadState* __tstate = wxPyBeginAllowThreads();
17611 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17612 wxPyEndAllowThreads(__tstate);
17613 if (PyErr_Occurred()) SWIG_fail;
17614 }
17615 {
17616 resultobj = wxPyMake_wxObject(result, 0);
17617 }
17618 return resultobj;
17619 fail:
17620 return NULL;
17621 }
17622
17623
17624 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17625 PyObject *resultobj = 0;
17626 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17627 wxEvtHandler *result = 0 ;
17628 void *argp1 = 0 ;
17629 int res1 = 0 ;
17630 PyObject *swig_obj[1] ;
17631
17632 if (!args) SWIG_fail;
17633 swig_obj[0] = args;
17634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17635 if (!SWIG_IsOK(res1)) {
17636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17637 }
17638 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17639 {
17640 PyThreadState* __tstate = wxPyBeginAllowThreads();
17641 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17642 wxPyEndAllowThreads(__tstate);
17643 if (PyErr_Occurred()) SWIG_fail;
17644 }
17645 {
17646 resultobj = wxPyMake_wxObject(result, 0);
17647 }
17648 return resultobj;
17649 fail:
17650 return NULL;
17651 }
17652
17653
17654 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17655 PyObject *resultobj = 0;
17656 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17657 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17658 void *argp1 = 0 ;
17659 int res1 = 0 ;
17660 void *argp2 = 0 ;
17661 int res2 = 0 ;
17662 PyObject * obj0 = 0 ;
17663 PyObject * obj1 = 0 ;
17664 char * kwnames[] = {
17665 (char *) "self",(char *) "handler", NULL
17666 };
17667
17668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17670 if (!SWIG_IsOK(res1)) {
17671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17672 }
17673 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17675 if (!SWIG_IsOK(res2)) {
17676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17677 }
17678 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17679 {
17680 PyThreadState* __tstate = wxPyBeginAllowThreads();
17681 (arg1)->SetNextHandler(arg2);
17682 wxPyEndAllowThreads(__tstate);
17683 if (PyErr_Occurred()) SWIG_fail;
17684 }
17685 resultobj = SWIG_Py_Void();
17686 return resultobj;
17687 fail:
17688 return NULL;
17689 }
17690
17691
17692 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17693 PyObject *resultobj = 0;
17694 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17695 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17696 void *argp1 = 0 ;
17697 int res1 = 0 ;
17698 void *argp2 = 0 ;
17699 int res2 = 0 ;
17700 PyObject * obj0 = 0 ;
17701 PyObject * obj1 = 0 ;
17702 char * kwnames[] = {
17703 (char *) "self",(char *) "handler", NULL
17704 };
17705
17706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17708 if (!SWIG_IsOK(res1)) {
17709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17710 }
17711 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17712 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17713 if (!SWIG_IsOK(res2)) {
17714 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17715 }
17716 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17717 {
17718 PyThreadState* __tstate = wxPyBeginAllowThreads();
17719 (arg1)->SetPreviousHandler(arg2);
17720 wxPyEndAllowThreads(__tstate);
17721 if (PyErr_Occurred()) SWIG_fail;
17722 }
17723 resultobj = SWIG_Py_Void();
17724 return resultobj;
17725 fail:
17726 return NULL;
17727 }
17728
17729
17730 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17731 PyObject *resultobj = 0;
17732 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17733 bool result;
17734 void *argp1 = 0 ;
17735 int res1 = 0 ;
17736 PyObject *swig_obj[1] ;
17737
17738 if (!args) SWIG_fail;
17739 swig_obj[0] = args;
17740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17741 if (!SWIG_IsOK(res1)) {
17742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17743 }
17744 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17745 {
17746 PyThreadState* __tstate = wxPyBeginAllowThreads();
17747 result = (bool)(arg1)->GetEvtHandlerEnabled();
17748 wxPyEndAllowThreads(__tstate);
17749 if (PyErr_Occurred()) SWIG_fail;
17750 }
17751 {
17752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17753 }
17754 return resultobj;
17755 fail:
17756 return NULL;
17757 }
17758
17759
17760 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17761 PyObject *resultobj = 0;
17762 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17763 bool arg2 ;
17764 void *argp1 = 0 ;
17765 int res1 = 0 ;
17766 bool val2 ;
17767 int ecode2 = 0 ;
17768 PyObject * obj0 = 0 ;
17769 PyObject * obj1 = 0 ;
17770 char * kwnames[] = {
17771 (char *) "self",(char *) "enabled", NULL
17772 };
17773
17774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17776 if (!SWIG_IsOK(res1)) {
17777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17778 }
17779 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17781 if (!SWIG_IsOK(ecode2)) {
17782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17783 }
17784 arg2 = static_cast< bool >(val2);
17785 {
17786 PyThreadState* __tstate = wxPyBeginAllowThreads();
17787 (arg1)->SetEvtHandlerEnabled(arg2);
17788 wxPyEndAllowThreads(__tstate);
17789 if (PyErr_Occurred()) SWIG_fail;
17790 }
17791 resultobj = SWIG_Py_Void();
17792 return resultobj;
17793 fail:
17794 return NULL;
17795 }
17796
17797
17798 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17799 PyObject *resultobj = 0;
17800 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17801 wxEvent *arg2 = 0 ;
17802 bool result;
17803 void *argp1 = 0 ;
17804 int res1 = 0 ;
17805 void *argp2 = 0 ;
17806 int res2 = 0 ;
17807 PyObject * obj0 = 0 ;
17808 PyObject * obj1 = 0 ;
17809 char * kwnames[] = {
17810 (char *) "self",(char *) "event", NULL
17811 };
17812
17813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17814 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17815 if (!SWIG_IsOK(res1)) {
17816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17817 }
17818 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17819 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17820 if (!SWIG_IsOK(res2)) {
17821 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17822 }
17823 if (!argp2) {
17824 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17825 }
17826 arg2 = reinterpret_cast< wxEvent * >(argp2);
17827 {
17828 PyThreadState* __tstate = wxPyBeginAllowThreads();
17829 result = (bool)(arg1)->ProcessEvent(*arg2);
17830 wxPyEndAllowThreads(__tstate);
17831 if (PyErr_Occurred()) SWIG_fail;
17832 }
17833 {
17834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17835 }
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17843 PyObject *resultobj = 0;
17844 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17845 wxEvent *arg2 = 0 ;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 void *argp2 = 0 ;
17849 int res2 = 0 ;
17850 PyObject * obj0 = 0 ;
17851 PyObject * obj1 = 0 ;
17852 char * kwnames[] = {
17853 (char *) "self",(char *) "event", NULL
17854 };
17855
17856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17858 if (!SWIG_IsOK(res1)) {
17859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17860 }
17861 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17862 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17863 if (!SWIG_IsOK(res2)) {
17864 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17865 }
17866 if (!argp2) {
17867 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17868 }
17869 arg2 = reinterpret_cast< wxEvent * >(argp2);
17870 {
17871 PyThreadState* __tstate = wxPyBeginAllowThreads();
17872 (arg1)->AddPendingEvent(*arg2);
17873 wxPyEndAllowThreads(__tstate);
17874 if (PyErr_Occurred()) SWIG_fail;
17875 }
17876 resultobj = SWIG_Py_Void();
17877 return resultobj;
17878 fail:
17879 return NULL;
17880 }
17881
17882
17883 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17884 PyObject *resultobj = 0;
17885 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17886 void *argp1 = 0 ;
17887 int res1 = 0 ;
17888 PyObject *swig_obj[1] ;
17889
17890 if (!args) SWIG_fail;
17891 swig_obj[0] = args;
17892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17893 if (!SWIG_IsOK(res1)) {
17894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17895 }
17896 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 (arg1)->ProcessPendingEvents();
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_Py_Void();
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj = 0;
17912 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17913 int arg2 ;
17914 int arg3 ;
17915 int arg4 ;
17916 PyObject *arg5 = (PyObject *) 0 ;
17917 void *argp1 = 0 ;
17918 int res1 = 0 ;
17919 int val2 ;
17920 int ecode2 = 0 ;
17921 int val3 ;
17922 int ecode3 = 0 ;
17923 int val4 ;
17924 int ecode4 = 0 ;
17925 PyObject * obj0 = 0 ;
17926 PyObject * obj1 = 0 ;
17927 PyObject * obj2 = 0 ;
17928 PyObject * obj3 = 0 ;
17929 PyObject * obj4 = 0 ;
17930 char * kwnames[] = {
17931 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
17932 };
17933
17934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17936 if (!SWIG_IsOK(res1)) {
17937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17938 }
17939 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17940 ecode2 = SWIG_AsVal_int(obj1, &val2);
17941 if (!SWIG_IsOK(ecode2)) {
17942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
17943 }
17944 arg2 = static_cast< int >(val2);
17945 ecode3 = SWIG_AsVal_int(obj2, &val3);
17946 if (!SWIG_IsOK(ecode3)) {
17947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
17948 }
17949 arg3 = static_cast< int >(val3);
17950 ecode4 = SWIG_AsVal_int(obj3, &val4);
17951 if (!SWIG_IsOK(ecode4)) {
17952 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
17953 }
17954 arg4 = static_cast< int >(val4);
17955 arg5 = obj4;
17956 {
17957 PyThreadState* __tstate = wxPyBeginAllowThreads();
17958 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
17959 wxPyEndAllowThreads(__tstate);
17960 if (PyErr_Occurred()) SWIG_fail;
17961 }
17962 resultobj = SWIG_Py_Void();
17963 return resultobj;
17964 fail:
17965 return NULL;
17966 }
17967
17968
17969 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17970 PyObject *resultobj = 0;
17971 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17972 int arg2 ;
17973 int arg3 = (int) -1 ;
17974 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
17975 bool result;
17976 void *argp1 = 0 ;
17977 int res1 = 0 ;
17978 int val2 ;
17979 int ecode2 = 0 ;
17980 int val3 ;
17981 int ecode3 = 0 ;
17982 int val4 ;
17983 int ecode4 = 0 ;
17984 PyObject * obj0 = 0 ;
17985 PyObject * obj1 = 0 ;
17986 PyObject * obj2 = 0 ;
17987 PyObject * obj3 = 0 ;
17988 char * kwnames[] = {
17989 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
17990 };
17991
17992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17994 if (!SWIG_IsOK(res1)) {
17995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17996 }
17997 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17998 ecode2 = SWIG_AsVal_int(obj1, &val2);
17999 if (!SWIG_IsOK(ecode2)) {
18000 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18001 }
18002 arg2 = static_cast< int >(val2);
18003 if (obj2) {
18004 ecode3 = SWIG_AsVal_int(obj2, &val3);
18005 if (!SWIG_IsOK(ecode3)) {
18006 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18007 }
18008 arg3 = static_cast< int >(val3);
18009 }
18010 if (obj3) {
18011 ecode4 = SWIG_AsVal_int(obj3, &val4);
18012 if (!SWIG_IsOK(ecode4)) {
18013 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18014 }
18015 arg4 = static_cast< wxEventType >(val4);
18016 }
18017 {
18018 PyThreadState* __tstate = wxPyBeginAllowThreads();
18019 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18020 wxPyEndAllowThreads(__tstate);
18021 if (PyErr_Occurred()) SWIG_fail;
18022 }
18023 {
18024 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18025 }
18026 return resultobj;
18027 fail:
18028 return NULL;
18029 }
18030
18031
18032 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18033 PyObject *resultobj = 0;
18034 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18035 PyObject *arg2 = (PyObject *) 0 ;
18036 bool arg3 = (bool) true ;
18037 void *argp1 = 0 ;
18038 int res1 = 0 ;
18039 bool val3 ;
18040 int ecode3 = 0 ;
18041 PyObject * obj0 = 0 ;
18042 PyObject * obj1 = 0 ;
18043 PyObject * obj2 = 0 ;
18044 char * kwnames[] = {
18045 (char *) "self",(char *) "_self",(char *) "incref", NULL
18046 };
18047
18048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18050 if (!SWIG_IsOK(res1)) {
18051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18052 }
18053 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18054 arg2 = obj1;
18055 if (obj2) {
18056 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18057 if (!SWIG_IsOK(ecode3)) {
18058 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18059 }
18060 arg3 = static_cast< bool >(val3);
18061 }
18062 {
18063 PyThreadState* __tstate = wxPyBeginAllowThreads();
18064 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18065 wxPyEndAllowThreads(__tstate);
18066 if (PyErr_Occurred()) SWIG_fail;
18067 }
18068 resultobj = SWIG_Py_Void();
18069 return resultobj;
18070 fail:
18071 return NULL;
18072 }
18073
18074
18075 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18076 PyObject *obj;
18077 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18078 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18079 return SWIG_Py_Void();
18080 }
18081
18082 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18083 return SWIG_Python_InitShadowInstance(args);
18084 }
18085
18086 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18087 PyObject *resultobj = 0;
18088 wxEventType result;
18089
18090 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18091 {
18092 PyThreadState* __tstate = wxPyBeginAllowThreads();
18093 result = (wxEventType)wxNewEventType();
18094 wxPyEndAllowThreads(__tstate);
18095 if (PyErr_Occurred()) SWIG_fail;
18096 }
18097 resultobj = SWIG_From_int(static_cast< int >(result));
18098 return resultobj;
18099 fail:
18100 return NULL;
18101 }
18102
18103
18104 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18105 PyObject *resultobj = 0;
18106 wxEvent *arg1 = (wxEvent *) 0 ;
18107 void *argp1 = 0 ;
18108 int res1 = 0 ;
18109 PyObject *swig_obj[1] ;
18110
18111 if (!args) SWIG_fail;
18112 swig_obj[0] = args;
18113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18114 if (!SWIG_IsOK(res1)) {
18115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18116 }
18117 arg1 = reinterpret_cast< wxEvent * >(argp1);
18118 {
18119 PyThreadState* __tstate = wxPyBeginAllowThreads();
18120 delete arg1;
18121
18122 wxPyEndAllowThreads(__tstate);
18123 if (PyErr_Occurred()) SWIG_fail;
18124 }
18125 resultobj = SWIG_Py_Void();
18126 return resultobj;
18127 fail:
18128 return NULL;
18129 }
18130
18131
18132 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18133 PyObject *resultobj = 0;
18134 wxEvent *arg1 = (wxEvent *) 0 ;
18135 wxEventType arg2 ;
18136 void *argp1 = 0 ;
18137 int res1 = 0 ;
18138 int val2 ;
18139 int ecode2 = 0 ;
18140 PyObject * obj0 = 0 ;
18141 PyObject * obj1 = 0 ;
18142 char * kwnames[] = {
18143 (char *) "self",(char *) "typ", NULL
18144 };
18145
18146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18148 if (!SWIG_IsOK(res1)) {
18149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18150 }
18151 arg1 = reinterpret_cast< wxEvent * >(argp1);
18152 ecode2 = SWIG_AsVal_int(obj1, &val2);
18153 if (!SWIG_IsOK(ecode2)) {
18154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18155 }
18156 arg2 = static_cast< wxEventType >(val2);
18157 {
18158 PyThreadState* __tstate = wxPyBeginAllowThreads();
18159 (arg1)->SetEventType(arg2);
18160 wxPyEndAllowThreads(__tstate);
18161 if (PyErr_Occurred()) SWIG_fail;
18162 }
18163 resultobj = SWIG_Py_Void();
18164 return resultobj;
18165 fail:
18166 return NULL;
18167 }
18168
18169
18170 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18171 PyObject *resultobj = 0;
18172 wxEvent *arg1 = (wxEvent *) 0 ;
18173 wxEventType result;
18174 void *argp1 = 0 ;
18175 int res1 = 0 ;
18176 PyObject *swig_obj[1] ;
18177
18178 if (!args) SWIG_fail;
18179 swig_obj[0] = args;
18180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18181 if (!SWIG_IsOK(res1)) {
18182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18183 }
18184 arg1 = reinterpret_cast< wxEvent * >(argp1);
18185 {
18186 PyThreadState* __tstate = wxPyBeginAllowThreads();
18187 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18188 wxPyEndAllowThreads(__tstate);
18189 if (PyErr_Occurred()) SWIG_fail;
18190 }
18191 resultobj = SWIG_From_int(static_cast< int >(result));
18192 return resultobj;
18193 fail:
18194 return NULL;
18195 }
18196
18197
18198 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *resultobj = 0;
18200 wxEvent *arg1 = (wxEvent *) 0 ;
18201 wxObject *result = 0 ;
18202 void *argp1 = 0 ;
18203 int res1 = 0 ;
18204 PyObject *swig_obj[1] ;
18205
18206 if (!args) SWIG_fail;
18207 swig_obj[0] = args;
18208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18209 if (!SWIG_IsOK(res1)) {
18210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18211 }
18212 arg1 = reinterpret_cast< wxEvent * >(argp1);
18213 {
18214 PyThreadState* __tstate = wxPyBeginAllowThreads();
18215 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18216 wxPyEndAllowThreads(__tstate);
18217 if (PyErr_Occurred()) SWIG_fail;
18218 }
18219 {
18220 resultobj = wxPyMake_wxObject(result, (bool)0);
18221 }
18222 return resultobj;
18223 fail:
18224 return NULL;
18225 }
18226
18227
18228 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18229 PyObject *resultobj = 0;
18230 wxEvent *arg1 = (wxEvent *) 0 ;
18231 wxObject *arg2 = (wxObject *) 0 ;
18232 void *argp1 = 0 ;
18233 int res1 = 0 ;
18234 void *argp2 = 0 ;
18235 int res2 = 0 ;
18236 PyObject * obj0 = 0 ;
18237 PyObject * obj1 = 0 ;
18238 char * kwnames[] = {
18239 (char *) "self",(char *) "obj", NULL
18240 };
18241
18242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18244 if (!SWIG_IsOK(res1)) {
18245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18246 }
18247 arg1 = reinterpret_cast< wxEvent * >(argp1);
18248 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18249 if (!SWIG_IsOK(res2)) {
18250 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18251 }
18252 arg2 = reinterpret_cast< wxObject * >(argp2);
18253 {
18254 PyThreadState* __tstate = wxPyBeginAllowThreads();
18255 (arg1)->SetEventObject(arg2);
18256 wxPyEndAllowThreads(__tstate);
18257 if (PyErr_Occurred()) SWIG_fail;
18258 }
18259 resultobj = SWIG_Py_Void();
18260 return resultobj;
18261 fail:
18262 return NULL;
18263 }
18264
18265
18266 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18267 PyObject *resultobj = 0;
18268 wxEvent *arg1 = (wxEvent *) 0 ;
18269 long result;
18270 void *argp1 = 0 ;
18271 int res1 = 0 ;
18272 PyObject *swig_obj[1] ;
18273
18274 if (!args) SWIG_fail;
18275 swig_obj[0] = args;
18276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18277 if (!SWIG_IsOK(res1)) {
18278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18279 }
18280 arg1 = reinterpret_cast< wxEvent * >(argp1);
18281 {
18282 PyThreadState* __tstate = wxPyBeginAllowThreads();
18283 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18284 wxPyEndAllowThreads(__tstate);
18285 if (PyErr_Occurred()) SWIG_fail;
18286 }
18287 resultobj = SWIG_From_long(static_cast< long >(result));
18288 return resultobj;
18289 fail:
18290 return NULL;
18291 }
18292
18293
18294 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18295 PyObject *resultobj = 0;
18296 wxEvent *arg1 = (wxEvent *) 0 ;
18297 long arg2 = (long) 0 ;
18298 void *argp1 = 0 ;
18299 int res1 = 0 ;
18300 long val2 ;
18301 int ecode2 = 0 ;
18302 PyObject * obj0 = 0 ;
18303 PyObject * obj1 = 0 ;
18304 char * kwnames[] = {
18305 (char *) "self",(char *) "ts", NULL
18306 };
18307
18308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18310 if (!SWIG_IsOK(res1)) {
18311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18312 }
18313 arg1 = reinterpret_cast< wxEvent * >(argp1);
18314 if (obj1) {
18315 ecode2 = SWIG_AsVal_long(obj1, &val2);
18316 if (!SWIG_IsOK(ecode2)) {
18317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18318 }
18319 arg2 = static_cast< long >(val2);
18320 }
18321 {
18322 PyThreadState* __tstate = wxPyBeginAllowThreads();
18323 (arg1)->SetTimestamp(arg2);
18324 wxPyEndAllowThreads(__tstate);
18325 if (PyErr_Occurred()) SWIG_fail;
18326 }
18327 resultobj = SWIG_Py_Void();
18328 return resultobj;
18329 fail:
18330 return NULL;
18331 }
18332
18333
18334 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18335 PyObject *resultobj = 0;
18336 wxEvent *arg1 = (wxEvent *) 0 ;
18337 int result;
18338 void *argp1 = 0 ;
18339 int res1 = 0 ;
18340 PyObject *swig_obj[1] ;
18341
18342 if (!args) SWIG_fail;
18343 swig_obj[0] = args;
18344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18345 if (!SWIG_IsOK(res1)) {
18346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18347 }
18348 arg1 = reinterpret_cast< wxEvent * >(argp1);
18349 {
18350 PyThreadState* __tstate = wxPyBeginAllowThreads();
18351 result = (int)((wxEvent const *)arg1)->GetId();
18352 wxPyEndAllowThreads(__tstate);
18353 if (PyErr_Occurred()) SWIG_fail;
18354 }
18355 resultobj = SWIG_From_int(static_cast< int >(result));
18356 return resultobj;
18357 fail:
18358 return NULL;
18359 }
18360
18361
18362 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18363 PyObject *resultobj = 0;
18364 wxEvent *arg1 = (wxEvent *) 0 ;
18365 int arg2 ;
18366 void *argp1 = 0 ;
18367 int res1 = 0 ;
18368 int val2 ;
18369 int ecode2 = 0 ;
18370 PyObject * obj0 = 0 ;
18371 PyObject * obj1 = 0 ;
18372 char * kwnames[] = {
18373 (char *) "self",(char *) "Id", NULL
18374 };
18375
18376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18378 if (!SWIG_IsOK(res1)) {
18379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18380 }
18381 arg1 = reinterpret_cast< wxEvent * >(argp1);
18382 ecode2 = SWIG_AsVal_int(obj1, &val2);
18383 if (!SWIG_IsOK(ecode2)) {
18384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18385 }
18386 arg2 = static_cast< int >(val2);
18387 {
18388 PyThreadState* __tstate = wxPyBeginAllowThreads();
18389 (arg1)->SetId(arg2);
18390 wxPyEndAllowThreads(__tstate);
18391 if (PyErr_Occurred()) SWIG_fail;
18392 }
18393 resultobj = SWIG_Py_Void();
18394 return resultobj;
18395 fail:
18396 return NULL;
18397 }
18398
18399
18400 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18401 PyObject *resultobj = 0;
18402 wxEvent *arg1 = (wxEvent *) 0 ;
18403 bool result;
18404 void *argp1 = 0 ;
18405 int res1 = 0 ;
18406 PyObject *swig_obj[1] ;
18407
18408 if (!args) SWIG_fail;
18409 swig_obj[0] = args;
18410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18411 if (!SWIG_IsOK(res1)) {
18412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18413 }
18414 arg1 = reinterpret_cast< wxEvent * >(argp1);
18415 {
18416 PyThreadState* __tstate = wxPyBeginAllowThreads();
18417 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18418 wxPyEndAllowThreads(__tstate);
18419 if (PyErr_Occurred()) SWIG_fail;
18420 }
18421 {
18422 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18423 }
18424 return resultobj;
18425 fail:
18426 return NULL;
18427 }
18428
18429
18430 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18431 PyObject *resultobj = 0;
18432 wxEvent *arg1 = (wxEvent *) 0 ;
18433 bool arg2 = (bool) true ;
18434 void *argp1 = 0 ;
18435 int res1 = 0 ;
18436 bool val2 ;
18437 int ecode2 = 0 ;
18438 PyObject * obj0 = 0 ;
18439 PyObject * obj1 = 0 ;
18440 char * kwnames[] = {
18441 (char *) "self",(char *) "skip", NULL
18442 };
18443
18444 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18445 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18446 if (!SWIG_IsOK(res1)) {
18447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18448 }
18449 arg1 = reinterpret_cast< wxEvent * >(argp1);
18450 if (obj1) {
18451 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18452 if (!SWIG_IsOK(ecode2)) {
18453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18454 }
18455 arg2 = static_cast< bool >(val2);
18456 }
18457 {
18458 PyThreadState* __tstate = wxPyBeginAllowThreads();
18459 (arg1)->Skip(arg2);
18460 wxPyEndAllowThreads(__tstate);
18461 if (PyErr_Occurred()) SWIG_fail;
18462 }
18463 resultobj = SWIG_Py_Void();
18464 return resultobj;
18465 fail:
18466 return NULL;
18467 }
18468
18469
18470 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18471 PyObject *resultobj = 0;
18472 wxEvent *arg1 = (wxEvent *) 0 ;
18473 bool result;
18474 void *argp1 = 0 ;
18475 int res1 = 0 ;
18476 PyObject *swig_obj[1] ;
18477
18478 if (!args) SWIG_fail;
18479 swig_obj[0] = args;
18480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18481 if (!SWIG_IsOK(res1)) {
18482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18483 }
18484 arg1 = reinterpret_cast< wxEvent * >(argp1);
18485 {
18486 PyThreadState* __tstate = wxPyBeginAllowThreads();
18487 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18488 wxPyEndAllowThreads(__tstate);
18489 if (PyErr_Occurred()) SWIG_fail;
18490 }
18491 {
18492 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18493 }
18494 return resultobj;
18495 fail:
18496 return NULL;
18497 }
18498
18499
18500 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18501 PyObject *resultobj = 0;
18502 wxEvent *arg1 = (wxEvent *) 0 ;
18503 bool result;
18504 void *argp1 = 0 ;
18505 int res1 = 0 ;
18506 PyObject *swig_obj[1] ;
18507
18508 if (!args) SWIG_fail;
18509 swig_obj[0] = args;
18510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18511 if (!SWIG_IsOK(res1)) {
18512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18513 }
18514 arg1 = reinterpret_cast< wxEvent * >(argp1);
18515 {
18516 PyThreadState* __tstate = wxPyBeginAllowThreads();
18517 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18518 wxPyEndAllowThreads(__tstate);
18519 if (PyErr_Occurred()) SWIG_fail;
18520 }
18521 {
18522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18523 }
18524 return resultobj;
18525 fail:
18526 return NULL;
18527 }
18528
18529
18530 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18531 PyObject *resultobj = 0;
18532 wxEvent *arg1 = (wxEvent *) 0 ;
18533 int result;
18534 void *argp1 = 0 ;
18535 int res1 = 0 ;
18536 PyObject *swig_obj[1] ;
18537
18538 if (!args) SWIG_fail;
18539 swig_obj[0] = args;
18540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18541 if (!SWIG_IsOK(res1)) {
18542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18543 }
18544 arg1 = reinterpret_cast< wxEvent * >(argp1);
18545 {
18546 PyThreadState* __tstate = wxPyBeginAllowThreads();
18547 result = (int)(arg1)->StopPropagation();
18548 wxPyEndAllowThreads(__tstate);
18549 if (PyErr_Occurred()) SWIG_fail;
18550 }
18551 resultobj = SWIG_From_int(static_cast< int >(result));
18552 return resultobj;
18553 fail:
18554 return NULL;
18555 }
18556
18557
18558 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18559 PyObject *resultobj = 0;
18560 wxEvent *arg1 = (wxEvent *) 0 ;
18561 int arg2 ;
18562 void *argp1 = 0 ;
18563 int res1 = 0 ;
18564 int val2 ;
18565 int ecode2 = 0 ;
18566 PyObject * obj0 = 0 ;
18567 PyObject * obj1 = 0 ;
18568 char * kwnames[] = {
18569 (char *) "self",(char *) "propagationLevel", NULL
18570 };
18571
18572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18574 if (!SWIG_IsOK(res1)) {
18575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18576 }
18577 arg1 = reinterpret_cast< wxEvent * >(argp1);
18578 ecode2 = SWIG_AsVal_int(obj1, &val2);
18579 if (!SWIG_IsOK(ecode2)) {
18580 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18581 }
18582 arg2 = static_cast< int >(val2);
18583 {
18584 PyThreadState* __tstate = wxPyBeginAllowThreads();
18585 (arg1)->ResumePropagation(arg2);
18586 wxPyEndAllowThreads(__tstate);
18587 if (PyErr_Occurred()) SWIG_fail;
18588 }
18589 resultobj = SWIG_Py_Void();
18590 return resultobj;
18591 fail:
18592 return NULL;
18593 }
18594
18595
18596 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18597 PyObject *resultobj = 0;
18598 wxEvent *arg1 = (wxEvent *) 0 ;
18599 wxEvent *result = 0 ;
18600 void *argp1 = 0 ;
18601 int res1 = 0 ;
18602 PyObject *swig_obj[1] ;
18603
18604 if (!args) SWIG_fail;
18605 swig_obj[0] = args;
18606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18607 if (!SWIG_IsOK(res1)) {
18608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18609 }
18610 arg1 = reinterpret_cast< wxEvent * >(argp1);
18611 {
18612 PyThreadState* __tstate = wxPyBeginAllowThreads();
18613 result = (wxEvent *)(arg1)->Clone();
18614 wxPyEndAllowThreads(__tstate);
18615 if (PyErr_Occurred()) SWIG_fail;
18616 }
18617 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18618 return resultobj;
18619 fail:
18620 return NULL;
18621 }
18622
18623
18624 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18625 PyObject *obj;
18626 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18627 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18628 return SWIG_Py_Void();
18629 }
18630
18631 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18632 PyObject *resultobj = 0;
18633 wxEvent *arg1 = 0 ;
18634 wxPropagationDisabler *result = 0 ;
18635 void *argp1 = 0 ;
18636 int res1 = 0 ;
18637 PyObject * obj0 = 0 ;
18638 char * kwnames[] = {
18639 (char *) "event", NULL
18640 };
18641
18642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18643 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18644 if (!SWIG_IsOK(res1)) {
18645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18646 }
18647 if (!argp1) {
18648 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18649 }
18650 arg1 = reinterpret_cast< wxEvent * >(argp1);
18651 {
18652 PyThreadState* __tstate = wxPyBeginAllowThreads();
18653 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18654 wxPyEndAllowThreads(__tstate);
18655 if (PyErr_Occurred()) SWIG_fail;
18656 }
18657 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18658 return resultobj;
18659 fail:
18660 return NULL;
18661 }
18662
18663
18664 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18665 PyObject *resultobj = 0;
18666 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18667 void *argp1 = 0 ;
18668 int res1 = 0 ;
18669 PyObject *swig_obj[1] ;
18670
18671 if (!args) SWIG_fail;
18672 swig_obj[0] = args;
18673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18674 if (!SWIG_IsOK(res1)) {
18675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18676 }
18677 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18678 {
18679 PyThreadState* __tstate = wxPyBeginAllowThreads();
18680 delete arg1;
18681
18682 wxPyEndAllowThreads(__tstate);
18683 if (PyErr_Occurred()) SWIG_fail;
18684 }
18685 resultobj = SWIG_Py_Void();
18686 return resultobj;
18687 fail:
18688 return NULL;
18689 }
18690
18691
18692 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18693 PyObject *obj;
18694 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18695 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18696 return SWIG_Py_Void();
18697 }
18698
18699 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18700 return SWIG_Python_InitShadowInstance(args);
18701 }
18702
18703 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18704 PyObject *resultobj = 0;
18705 wxEvent *arg1 = 0 ;
18706 wxPropagateOnce *result = 0 ;
18707 void *argp1 = 0 ;
18708 int res1 = 0 ;
18709 PyObject * obj0 = 0 ;
18710 char * kwnames[] = {
18711 (char *) "event", NULL
18712 };
18713
18714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18715 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18716 if (!SWIG_IsOK(res1)) {
18717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18718 }
18719 if (!argp1) {
18720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18721 }
18722 arg1 = reinterpret_cast< wxEvent * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18737 PyObject *resultobj = 0;
18738 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18739 void *argp1 = 0 ;
18740 int res1 = 0 ;
18741 PyObject *swig_obj[1] ;
18742
18743 if (!args) SWIG_fail;
18744 swig_obj[0] = args;
18745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18746 if (!SWIG_IsOK(res1)) {
18747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18748 }
18749 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18750 {
18751 PyThreadState* __tstate = wxPyBeginAllowThreads();
18752 delete arg1;
18753
18754 wxPyEndAllowThreads(__tstate);
18755 if (PyErr_Occurred()) SWIG_fail;
18756 }
18757 resultobj = SWIG_Py_Void();
18758 return resultobj;
18759 fail:
18760 return NULL;
18761 }
18762
18763
18764 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18765 PyObject *obj;
18766 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18767 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18768 return SWIG_Py_Void();
18769 }
18770
18771 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18772 return SWIG_Python_InitShadowInstance(args);
18773 }
18774
18775 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18776 PyObject *resultobj = 0;
18777 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18778 int arg2 = (int) 0 ;
18779 wxCommandEvent *result = 0 ;
18780 int val1 ;
18781 int ecode1 = 0 ;
18782 int val2 ;
18783 int ecode2 = 0 ;
18784 PyObject * obj0 = 0 ;
18785 PyObject * obj1 = 0 ;
18786 char * kwnames[] = {
18787 (char *) "commandType",(char *) "winid", NULL
18788 };
18789
18790 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18791 if (obj0) {
18792 ecode1 = SWIG_AsVal_int(obj0, &val1);
18793 if (!SWIG_IsOK(ecode1)) {
18794 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18795 }
18796 arg1 = static_cast< wxEventType >(val1);
18797 }
18798 if (obj1) {
18799 ecode2 = SWIG_AsVal_int(obj1, &val2);
18800 if (!SWIG_IsOK(ecode2)) {
18801 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18802 }
18803 arg2 = static_cast< int >(val2);
18804 }
18805 {
18806 PyThreadState* __tstate = wxPyBeginAllowThreads();
18807 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18808 wxPyEndAllowThreads(__tstate);
18809 if (PyErr_Occurred()) SWIG_fail;
18810 }
18811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18812 return resultobj;
18813 fail:
18814 return NULL;
18815 }
18816
18817
18818 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18819 PyObject *resultobj = 0;
18820 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18821 int result;
18822 void *argp1 = 0 ;
18823 int res1 = 0 ;
18824 PyObject *swig_obj[1] ;
18825
18826 if (!args) SWIG_fail;
18827 swig_obj[0] = args;
18828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18829 if (!SWIG_IsOK(res1)) {
18830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18831 }
18832 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18833 {
18834 PyThreadState* __tstate = wxPyBeginAllowThreads();
18835 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18836 wxPyEndAllowThreads(__tstate);
18837 if (PyErr_Occurred()) SWIG_fail;
18838 }
18839 resultobj = SWIG_From_int(static_cast< int >(result));
18840 return resultobj;
18841 fail:
18842 return NULL;
18843 }
18844
18845
18846 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18847 PyObject *resultobj = 0;
18848 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18849 wxString *arg2 = 0 ;
18850 void *argp1 = 0 ;
18851 int res1 = 0 ;
18852 bool temp2 = false ;
18853 PyObject * obj0 = 0 ;
18854 PyObject * obj1 = 0 ;
18855 char * kwnames[] = {
18856 (char *) "self",(char *) "s", NULL
18857 };
18858
18859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18861 if (!SWIG_IsOK(res1)) {
18862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18863 }
18864 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18865 {
18866 arg2 = wxString_in_helper(obj1);
18867 if (arg2 == NULL) SWIG_fail;
18868 temp2 = true;
18869 }
18870 {
18871 PyThreadState* __tstate = wxPyBeginAllowThreads();
18872 (arg1)->SetString((wxString const &)*arg2);
18873 wxPyEndAllowThreads(__tstate);
18874 if (PyErr_Occurred()) SWIG_fail;
18875 }
18876 resultobj = SWIG_Py_Void();
18877 {
18878 if (temp2)
18879 delete arg2;
18880 }
18881 return resultobj;
18882 fail:
18883 {
18884 if (temp2)
18885 delete arg2;
18886 }
18887 return NULL;
18888 }
18889
18890
18891 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18892 PyObject *resultobj = 0;
18893 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18894 wxString result;
18895 void *argp1 = 0 ;
18896 int res1 = 0 ;
18897 PyObject *swig_obj[1] ;
18898
18899 if (!args) SWIG_fail;
18900 swig_obj[0] = args;
18901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18902 if (!SWIG_IsOK(res1)) {
18903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18904 }
18905 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18906 {
18907 PyThreadState* __tstate = wxPyBeginAllowThreads();
18908 result = ((wxCommandEvent const *)arg1)->GetString();
18909 wxPyEndAllowThreads(__tstate);
18910 if (PyErr_Occurred()) SWIG_fail;
18911 }
18912 {
18913 #if wxUSE_UNICODE
18914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
18915 #else
18916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
18917 #endif
18918 }
18919 return resultobj;
18920 fail:
18921 return NULL;
18922 }
18923
18924
18925 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18926 PyObject *resultobj = 0;
18927 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18928 bool result;
18929 void *argp1 = 0 ;
18930 int res1 = 0 ;
18931 PyObject *swig_obj[1] ;
18932
18933 if (!args) SWIG_fail;
18934 swig_obj[0] = args;
18935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18936 if (!SWIG_IsOK(res1)) {
18937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18938 }
18939 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18940 {
18941 PyThreadState* __tstate = wxPyBeginAllowThreads();
18942 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
18943 wxPyEndAllowThreads(__tstate);
18944 if (PyErr_Occurred()) SWIG_fail;
18945 }
18946 {
18947 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18948 }
18949 return resultobj;
18950 fail:
18951 return NULL;
18952 }
18953
18954
18955 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18956 PyObject *resultobj = 0;
18957 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18958 bool result;
18959 void *argp1 = 0 ;
18960 int res1 = 0 ;
18961 PyObject *swig_obj[1] ;
18962
18963 if (!args) SWIG_fail;
18964 swig_obj[0] = args;
18965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18966 if (!SWIG_IsOK(res1)) {
18967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18968 }
18969 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18970 {
18971 PyThreadState* __tstate = wxPyBeginAllowThreads();
18972 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
18973 wxPyEndAllowThreads(__tstate);
18974 if (PyErr_Occurred()) SWIG_fail;
18975 }
18976 {
18977 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18978 }
18979 return resultobj;
18980 fail:
18981 return NULL;
18982 }
18983
18984
18985 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18986 PyObject *resultobj = 0;
18987 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18988 long arg2 ;
18989 void *argp1 = 0 ;
18990 int res1 = 0 ;
18991 long val2 ;
18992 int ecode2 = 0 ;
18993 PyObject * obj0 = 0 ;
18994 PyObject * obj1 = 0 ;
18995 char * kwnames[] = {
18996 (char *) "self",(char *) "extraLong", NULL
18997 };
18998
18999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19001 if (!SWIG_IsOK(res1)) {
19002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19003 }
19004 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19005 ecode2 = SWIG_AsVal_long(obj1, &val2);
19006 if (!SWIG_IsOK(ecode2)) {
19007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19008 }
19009 arg2 = static_cast< long >(val2);
19010 {
19011 PyThreadState* __tstate = wxPyBeginAllowThreads();
19012 (arg1)->SetExtraLong(arg2);
19013 wxPyEndAllowThreads(__tstate);
19014 if (PyErr_Occurred()) SWIG_fail;
19015 }
19016 resultobj = SWIG_Py_Void();
19017 return resultobj;
19018 fail:
19019 return NULL;
19020 }
19021
19022
19023 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19024 PyObject *resultobj = 0;
19025 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19026 long result;
19027 void *argp1 = 0 ;
19028 int res1 = 0 ;
19029 PyObject *swig_obj[1] ;
19030
19031 if (!args) SWIG_fail;
19032 swig_obj[0] = args;
19033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19034 if (!SWIG_IsOK(res1)) {
19035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19036 }
19037 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19038 {
19039 PyThreadState* __tstate = wxPyBeginAllowThreads();
19040 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19041 wxPyEndAllowThreads(__tstate);
19042 if (PyErr_Occurred()) SWIG_fail;
19043 }
19044 resultobj = SWIG_From_long(static_cast< long >(result));
19045 return resultobj;
19046 fail:
19047 return NULL;
19048 }
19049
19050
19051 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19052 PyObject *resultobj = 0;
19053 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19054 int arg2 ;
19055 void *argp1 = 0 ;
19056 int res1 = 0 ;
19057 int val2 ;
19058 int ecode2 = 0 ;
19059 PyObject * obj0 = 0 ;
19060 PyObject * obj1 = 0 ;
19061 char * kwnames[] = {
19062 (char *) "self",(char *) "i", NULL
19063 };
19064
19065 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19066 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19067 if (!SWIG_IsOK(res1)) {
19068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19069 }
19070 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19071 ecode2 = SWIG_AsVal_int(obj1, &val2);
19072 if (!SWIG_IsOK(ecode2)) {
19073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19074 }
19075 arg2 = static_cast< int >(val2);
19076 {
19077 PyThreadState* __tstate = wxPyBeginAllowThreads();
19078 (arg1)->SetInt(arg2);
19079 wxPyEndAllowThreads(__tstate);
19080 if (PyErr_Occurred()) SWIG_fail;
19081 }
19082 resultobj = SWIG_Py_Void();
19083 return resultobj;
19084 fail:
19085 return NULL;
19086 }
19087
19088
19089 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19090 PyObject *resultobj = 0;
19091 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19092 int result;
19093 void *argp1 = 0 ;
19094 int res1 = 0 ;
19095 PyObject *swig_obj[1] ;
19096
19097 if (!args) SWIG_fail;
19098 swig_obj[0] = args;
19099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19100 if (!SWIG_IsOK(res1)) {
19101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19102 }
19103 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19104 {
19105 PyThreadState* __tstate = wxPyBeginAllowThreads();
19106 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19107 wxPyEndAllowThreads(__tstate);
19108 if (PyErr_Occurred()) SWIG_fail;
19109 }
19110 resultobj = SWIG_From_int(static_cast< int >(result));
19111 return resultobj;
19112 fail:
19113 return NULL;
19114 }
19115
19116
19117 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19118 PyObject *resultobj = 0;
19119 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19120 PyObject *result = 0 ;
19121 void *argp1 = 0 ;
19122 int res1 = 0 ;
19123 PyObject *swig_obj[1] ;
19124
19125 if (!args) SWIG_fail;
19126 swig_obj[0] = args;
19127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19128 if (!SWIG_IsOK(res1)) {
19129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19130 }
19131 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19132 {
19133 PyThreadState* __tstate = wxPyBeginAllowThreads();
19134 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19135 wxPyEndAllowThreads(__tstate);
19136 if (PyErr_Occurred()) SWIG_fail;
19137 }
19138 resultobj = result;
19139 return resultobj;
19140 fail:
19141 return NULL;
19142 }
19143
19144
19145 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19146 PyObject *resultobj = 0;
19147 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19148 PyObject *arg2 = (PyObject *) 0 ;
19149 void *argp1 = 0 ;
19150 int res1 = 0 ;
19151 PyObject * obj0 = 0 ;
19152 PyObject * obj1 = 0 ;
19153 char * kwnames[] = {
19154 (char *) "self",(char *) "clientData", NULL
19155 };
19156
19157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19159 if (!SWIG_IsOK(res1)) {
19160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19161 }
19162 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19163 arg2 = obj1;
19164 {
19165 PyThreadState* __tstate = wxPyBeginAllowThreads();
19166 wxCommandEvent_SetClientData(arg1,arg2);
19167 wxPyEndAllowThreads(__tstate);
19168 if (PyErr_Occurred()) SWIG_fail;
19169 }
19170 resultobj = SWIG_Py_Void();
19171 return resultobj;
19172 fail:
19173 return NULL;
19174 }
19175
19176
19177 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19178 PyObject *resultobj = 0;
19179 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19180 wxEvent *result = 0 ;
19181 void *argp1 = 0 ;
19182 int res1 = 0 ;
19183 PyObject *swig_obj[1] ;
19184
19185 if (!args) SWIG_fail;
19186 swig_obj[0] = args;
19187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19188 if (!SWIG_IsOK(res1)) {
19189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19190 }
19191 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19192 {
19193 PyThreadState* __tstate = wxPyBeginAllowThreads();
19194 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19195 wxPyEndAllowThreads(__tstate);
19196 if (PyErr_Occurred()) SWIG_fail;
19197 }
19198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19199 return resultobj;
19200 fail:
19201 return NULL;
19202 }
19203
19204
19205 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19206 PyObject *obj;
19207 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19208 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19209 return SWIG_Py_Void();
19210 }
19211
19212 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19213 return SWIG_Python_InitShadowInstance(args);
19214 }
19215
19216 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19217 PyObject *resultobj = 0;
19218 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19219 int arg2 = (int) 0 ;
19220 wxNotifyEvent *result = 0 ;
19221 int val1 ;
19222 int ecode1 = 0 ;
19223 int val2 ;
19224 int ecode2 = 0 ;
19225 PyObject * obj0 = 0 ;
19226 PyObject * obj1 = 0 ;
19227 char * kwnames[] = {
19228 (char *) "commandType",(char *) "winid", NULL
19229 };
19230
19231 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19232 if (obj0) {
19233 ecode1 = SWIG_AsVal_int(obj0, &val1);
19234 if (!SWIG_IsOK(ecode1)) {
19235 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19236 }
19237 arg1 = static_cast< wxEventType >(val1);
19238 }
19239 if (obj1) {
19240 ecode2 = SWIG_AsVal_int(obj1, &val2);
19241 if (!SWIG_IsOK(ecode2)) {
19242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19243 }
19244 arg2 = static_cast< int >(val2);
19245 }
19246 {
19247 PyThreadState* __tstate = wxPyBeginAllowThreads();
19248 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19249 wxPyEndAllowThreads(__tstate);
19250 if (PyErr_Occurred()) SWIG_fail;
19251 }
19252 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19253 return resultobj;
19254 fail:
19255 return NULL;
19256 }
19257
19258
19259 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19260 PyObject *resultobj = 0;
19261 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19262 void *argp1 = 0 ;
19263 int res1 = 0 ;
19264 PyObject *swig_obj[1] ;
19265
19266 if (!args) SWIG_fail;
19267 swig_obj[0] = args;
19268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19269 if (!SWIG_IsOK(res1)) {
19270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19271 }
19272 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19273 {
19274 PyThreadState* __tstate = wxPyBeginAllowThreads();
19275 (arg1)->Veto();
19276 wxPyEndAllowThreads(__tstate);
19277 if (PyErr_Occurred()) SWIG_fail;
19278 }
19279 resultobj = SWIG_Py_Void();
19280 return resultobj;
19281 fail:
19282 return NULL;
19283 }
19284
19285
19286 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19287 PyObject *resultobj = 0;
19288 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19289 void *argp1 = 0 ;
19290 int res1 = 0 ;
19291 PyObject *swig_obj[1] ;
19292
19293 if (!args) SWIG_fail;
19294 swig_obj[0] = args;
19295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19296 if (!SWIG_IsOK(res1)) {
19297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19298 }
19299 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19300 {
19301 PyThreadState* __tstate = wxPyBeginAllowThreads();
19302 (arg1)->Allow();
19303 wxPyEndAllowThreads(__tstate);
19304 if (PyErr_Occurred()) SWIG_fail;
19305 }
19306 resultobj = SWIG_Py_Void();
19307 return resultobj;
19308 fail:
19309 return NULL;
19310 }
19311
19312
19313 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19314 PyObject *resultobj = 0;
19315 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19316 bool result;
19317 void *argp1 = 0 ;
19318 int res1 = 0 ;
19319 PyObject *swig_obj[1] ;
19320
19321 if (!args) SWIG_fail;
19322 swig_obj[0] = args;
19323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19324 if (!SWIG_IsOK(res1)) {
19325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19326 }
19327 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19328 {
19329 PyThreadState* __tstate = wxPyBeginAllowThreads();
19330 result = (bool)(arg1)->IsAllowed();
19331 wxPyEndAllowThreads(__tstate);
19332 if (PyErr_Occurred()) SWIG_fail;
19333 }
19334 {
19335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19336 }
19337 return resultobj;
19338 fail:
19339 return NULL;
19340 }
19341
19342
19343 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19344 PyObject *obj;
19345 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19346 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19347 return SWIG_Py_Void();
19348 }
19349
19350 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19351 return SWIG_Python_InitShadowInstance(args);
19352 }
19353
19354 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19355 PyObject *resultobj = 0;
19356 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19357 int arg2 = (int) 0 ;
19358 int arg3 = (int) 0 ;
19359 int arg4 = (int) 0 ;
19360 wxScrollEvent *result = 0 ;
19361 int val1 ;
19362 int ecode1 = 0 ;
19363 int val2 ;
19364 int ecode2 = 0 ;
19365 int val3 ;
19366 int ecode3 = 0 ;
19367 int val4 ;
19368 int ecode4 = 0 ;
19369 PyObject * obj0 = 0 ;
19370 PyObject * obj1 = 0 ;
19371 PyObject * obj2 = 0 ;
19372 PyObject * obj3 = 0 ;
19373 char * kwnames[] = {
19374 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19375 };
19376
19377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19378 if (obj0) {
19379 ecode1 = SWIG_AsVal_int(obj0, &val1);
19380 if (!SWIG_IsOK(ecode1)) {
19381 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19382 }
19383 arg1 = static_cast< wxEventType >(val1);
19384 }
19385 if (obj1) {
19386 ecode2 = SWIG_AsVal_int(obj1, &val2);
19387 if (!SWIG_IsOK(ecode2)) {
19388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19389 }
19390 arg2 = static_cast< int >(val2);
19391 }
19392 if (obj2) {
19393 ecode3 = SWIG_AsVal_int(obj2, &val3);
19394 if (!SWIG_IsOK(ecode3)) {
19395 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19396 }
19397 arg3 = static_cast< int >(val3);
19398 }
19399 if (obj3) {
19400 ecode4 = SWIG_AsVal_int(obj3, &val4);
19401 if (!SWIG_IsOK(ecode4)) {
19402 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19403 }
19404 arg4 = static_cast< int >(val4);
19405 }
19406 {
19407 PyThreadState* __tstate = wxPyBeginAllowThreads();
19408 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19409 wxPyEndAllowThreads(__tstate);
19410 if (PyErr_Occurred()) SWIG_fail;
19411 }
19412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19413 return resultobj;
19414 fail:
19415 return NULL;
19416 }
19417
19418
19419 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19420 PyObject *resultobj = 0;
19421 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19422 int result;
19423 void *argp1 = 0 ;
19424 int res1 = 0 ;
19425 PyObject *swig_obj[1] ;
19426
19427 if (!args) SWIG_fail;
19428 swig_obj[0] = args;
19429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19430 if (!SWIG_IsOK(res1)) {
19431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19432 }
19433 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19434 {
19435 PyThreadState* __tstate = wxPyBeginAllowThreads();
19436 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19437 wxPyEndAllowThreads(__tstate);
19438 if (PyErr_Occurred()) SWIG_fail;
19439 }
19440 resultobj = SWIG_From_int(static_cast< int >(result));
19441 return resultobj;
19442 fail:
19443 return NULL;
19444 }
19445
19446
19447 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19448 PyObject *resultobj = 0;
19449 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19450 int result;
19451 void *argp1 = 0 ;
19452 int res1 = 0 ;
19453 PyObject *swig_obj[1] ;
19454
19455 if (!args) SWIG_fail;
19456 swig_obj[0] = args;
19457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19458 if (!SWIG_IsOK(res1)) {
19459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19460 }
19461 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19462 {
19463 PyThreadState* __tstate = wxPyBeginAllowThreads();
19464 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19465 wxPyEndAllowThreads(__tstate);
19466 if (PyErr_Occurred()) SWIG_fail;
19467 }
19468 resultobj = SWIG_From_int(static_cast< int >(result));
19469 return resultobj;
19470 fail:
19471 return NULL;
19472 }
19473
19474
19475 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19476 PyObject *resultobj = 0;
19477 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19478 int arg2 ;
19479 void *argp1 = 0 ;
19480 int res1 = 0 ;
19481 int val2 ;
19482 int ecode2 = 0 ;
19483 PyObject * obj0 = 0 ;
19484 PyObject * obj1 = 0 ;
19485 char * kwnames[] = {
19486 (char *) "self",(char *) "orient", NULL
19487 };
19488
19489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19491 if (!SWIG_IsOK(res1)) {
19492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19493 }
19494 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19495 ecode2 = SWIG_AsVal_int(obj1, &val2);
19496 if (!SWIG_IsOK(ecode2)) {
19497 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19498 }
19499 arg2 = static_cast< int >(val2);
19500 {
19501 PyThreadState* __tstate = wxPyBeginAllowThreads();
19502 (arg1)->SetOrientation(arg2);
19503 wxPyEndAllowThreads(__tstate);
19504 if (PyErr_Occurred()) SWIG_fail;
19505 }
19506 resultobj = SWIG_Py_Void();
19507 return resultobj;
19508 fail:
19509 return NULL;
19510 }
19511
19512
19513 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19514 PyObject *resultobj = 0;
19515 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19516 int arg2 ;
19517 void *argp1 = 0 ;
19518 int res1 = 0 ;
19519 int val2 ;
19520 int ecode2 = 0 ;
19521 PyObject * obj0 = 0 ;
19522 PyObject * obj1 = 0 ;
19523 char * kwnames[] = {
19524 (char *) "self",(char *) "pos", NULL
19525 };
19526
19527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19529 if (!SWIG_IsOK(res1)) {
19530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19531 }
19532 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19533 ecode2 = SWIG_AsVal_int(obj1, &val2);
19534 if (!SWIG_IsOK(ecode2)) {
19535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19536 }
19537 arg2 = static_cast< int >(val2);
19538 {
19539 PyThreadState* __tstate = wxPyBeginAllowThreads();
19540 (arg1)->SetPosition(arg2);
19541 wxPyEndAllowThreads(__tstate);
19542 if (PyErr_Occurred()) SWIG_fail;
19543 }
19544 resultobj = SWIG_Py_Void();
19545 return resultobj;
19546 fail:
19547 return NULL;
19548 }
19549
19550
19551 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19552 PyObject *obj;
19553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19554 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19555 return SWIG_Py_Void();
19556 }
19557
19558 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19559 return SWIG_Python_InitShadowInstance(args);
19560 }
19561
19562 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19563 PyObject *resultobj = 0;
19564 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19565 int arg2 = (int) 0 ;
19566 int arg3 = (int) 0 ;
19567 wxScrollWinEvent *result = 0 ;
19568 int val1 ;
19569 int ecode1 = 0 ;
19570 int val2 ;
19571 int ecode2 = 0 ;
19572 int val3 ;
19573 int ecode3 = 0 ;
19574 PyObject * obj0 = 0 ;
19575 PyObject * obj1 = 0 ;
19576 PyObject * obj2 = 0 ;
19577 char * kwnames[] = {
19578 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19579 };
19580
19581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19582 if (obj0) {
19583 ecode1 = SWIG_AsVal_int(obj0, &val1);
19584 if (!SWIG_IsOK(ecode1)) {
19585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19586 }
19587 arg1 = static_cast< wxEventType >(val1);
19588 }
19589 if (obj1) {
19590 ecode2 = SWIG_AsVal_int(obj1, &val2);
19591 if (!SWIG_IsOK(ecode2)) {
19592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19593 }
19594 arg2 = static_cast< int >(val2);
19595 }
19596 if (obj2) {
19597 ecode3 = SWIG_AsVal_int(obj2, &val3);
19598 if (!SWIG_IsOK(ecode3)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19600 }
19601 arg3 = static_cast< int >(val3);
19602 }
19603 {
19604 PyThreadState* __tstate = wxPyBeginAllowThreads();
19605 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19606 wxPyEndAllowThreads(__tstate);
19607 if (PyErr_Occurred()) SWIG_fail;
19608 }
19609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19610 return resultobj;
19611 fail:
19612 return NULL;
19613 }
19614
19615
19616 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19617 PyObject *resultobj = 0;
19618 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19619 int result;
19620 void *argp1 = 0 ;
19621 int res1 = 0 ;
19622 PyObject *swig_obj[1] ;
19623
19624 if (!args) SWIG_fail;
19625 swig_obj[0] = args;
19626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19627 if (!SWIG_IsOK(res1)) {
19628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19629 }
19630 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19631 {
19632 PyThreadState* __tstate = wxPyBeginAllowThreads();
19633 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19634 wxPyEndAllowThreads(__tstate);
19635 if (PyErr_Occurred()) SWIG_fail;
19636 }
19637 resultobj = SWIG_From_int(static_cast< int >(result));
19638 return resultobj;
19639 fail:
19640 return NULL;
19641 }
19642
19643
19644 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19645 PyObject *resultobj = 0;
19646 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19647 int result;
19648 void *argp1 = 0 ;
19649 int res1 = 0 ;
19650 PyObject *swig_obj[1] ;
19651
19652 if (!args) SWIG_fail;
19653 swig_obj[0] = args;
19654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19655 if (!SWIG_IsOK(res1)) {
19656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19657 }
19658 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19659 {
19660 PyThreadState* __tstate = wxPyBeginAllowThreads();
19661 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19662 wxPyEndAllowThreads(__tstate);
19663 if (PyErr_Occurred()) SWIG_fail;
19664 }
19665 resultobj = SWIG_From_int(static_cast< int >(result));
19666 return resultobj;
19667 fail:
19668 return NULL;
19669 }
19670
19671
19672 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19673 PyObject *resultobj = 0;
19674 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19675 int arg2 ;
19676 void *argp1 = 0 ;
19677 int res1 = 0 ;
19678 int val2 ;
19679 int ecode2 = 0 ;
19680 PyObject * obj0 = 0 ;
19681 PyObject * obj1 = 0 ;
19682 char * kwnames[] = {
19683 (char *) "self",(char *) "orient", NULL
19684 };
19685
19686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19688 if (!SWIG_IsOK(res1)) {
19689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19690 }
19691 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19692 ecode2 = SWIG_AsVal_int(obj1, &val2);
19693 if (!SWIG_IsOK(ecode2)) {
19694 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19695 }
19696 arg2 = static_cast< int >(val2);
19697 {
19698 PyThreadState* __tstate = wxPyBeginAllowThreads();
19699 (arg1)->SetOrientation(arg2);
19700 wxPyEndAllowThreads(__tstate);
19701 if (PyErr_Occurred()) SWIG_fail;
19702 }
19703 resultobj = SWIG_Py_Void();
19704 return resultobj;
19705 fail:
19706 return NULL;
19707 }
19708
19709
19710 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19711 PyObject *resultobj = 0;
19712 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19713 int arg2 ;
19714 void *argp1 = 0 ;
19715 int res1 = 0 ;
19716 int val2 ;
19717 int ecode2 = 0 ;
19718 PyObject * obj0 = 0 ;
19719 PyObject * obj1 = 0 ;
19720 char * kwnames[] = {
19721 (char *) "self",(char *) "pos", NULL
19722 };
19723
19724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19726 if (!SWIG_IsOK(res1)) {
19727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19728 }
19729 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19730 ecode2 = SWIG_AsVal_int(obj1, &val2);
19731 if (!SWIG_IsOK(ecode2)) {
19732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19733 }
19734 arg2 = static_cast< int >(val2);
19735 {
19736 PyThreadState* __tstate = wxPyBeginAllowThreads();
19737 (arg1)->SetPosition(arg2);
19738 wxPyEndAllowThreads(__tstate);
19739 if (PyErr_Occurred()) SWIG_fail;
19740 }
19741 resultobj = SWIG_Py_Void();
19742 return resultobj;
19743 fail:
19744 return NULL;
19745 }
19746
19747
19748 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19749 PyObject *obj;
19750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19751 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19752 return SWIG_Py_Void();
19753 }
19754
19755 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19756 return SWIG_Python_InitShadowInstance(args);
19757 }
19758
19759 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19760 PyObject *resultobj = 0;
19761 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19762 wxMouseEvent *result = 0 ;
19763 int val1 ;
19764 int ecode1 = 0 ;
19765 PyObject * obj0 = 0 ;
19766 char * kwnames[] = {
19767 (char *) "mouseType", NULL
19768 };
19769
19770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19771 if (obj0) {
19772 ecode1 = SWIG_AsVal_int(obj0, &val1);
19773 if (!SWIG_IsOK(ecode1)) {
19774 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19775 }
19776 arg1 = static_cast< wxEventType >(val1);
19777 }
19778 {
19779 PyThreadState* __tstate = wxPyBeginAllowThreads();
19780 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19781 wxPyEndAllowThreads(__tstate);
19782 if (PyErr_Occurred()) SWIG_fail;
19783 }
19784 {
19785 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19786 }
19787 return resultobj;
19788 fail:
19789 return NULL;
19790 }
19791
19792
19793 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19794 PyObject *resultobj = 0;
19795 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19796 bool result;
19797 void *argp1 = 0 ;
19798 int res1 = 0 ;
19799 PyObject *swig_obj[1] ;
19800
19801 if (!args) SWIG_fail;
19802 swig_obj[0] = args;
19803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19804 if (!SWIG_IsOK(res1)) {
19805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19806 }
19807 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19808 {
19809 PyThreadState* __tstate = wxPyBeginAllowThreads();
19810 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19811 wxPyEndAllowThreads(__tstate);
19812 if (PyErr_Occurred()) SWIG_fail;
19813 }
19814 {
19815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19816 }
19817 return resultobj;
19818 fail:
19819 return NULL;
19820 }
19821
19822
19823 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19824 PyObject *resultobj = 0;
19825 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19826 int arg2 = (int) wxMOUSE_BTN_ANY ;
19827 bool result;
19828 void *argp1 = 0 ;
19829 int res1 = 0 ;
19830 int val2 ;
19831 int ecode2 = 0 ;
19832 PyObject * obj0 = 0 ;
19833 PyObject * obj1 = 0 ;
19834 char * kwnames[] = {
19835 (char *) "self",(char *) "but", NULL
19836 };
19837
19838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19840 if (!SWIG_IsOK(res1)) {
19841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19842 }
19843 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19844 if (obj1) {
19845 ecode2 = SWIG_AsVal_int(obj1, &val2);
19846 if (!SWIG_IsOK(ecode2)) {
19847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19848 }
19849 arg2 = static_cast< int >(val2);
19850 }
19851 {
19852 PyThreadState* __tstate = wxPyBeginAllowThreads();
19853 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19854 wxPyEndAllowThreads(__tstate);
19855 if (PyErr_Occurred()) SWIG_fail;
19856 }
19857 {
19858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19859 }
19860 return resultobj;
19861 fail:
19862 return NULL;
19863 }
19864
19865
19866 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19867 PyObject *resultobj = 0;
19868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19869 int arg2 = (int) wxMOUSE_BTN_ANY ;
19870 bool result;
19871 void *argp1 = 0 ;
19872 int res1 = 0 ;
19873 int val2 ;
19874 int ecode2 = 0 ;
19875 PyObject * obj0 = 0 ;
19876 PyObject * obj1 = 0 ;
19877 char * kwnames[] = {
19878 (char *) "self",(char *) "but", NULL
19879 };
19880
19881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19883 if (!SWIG_IsOK(res1)) {
19884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19885 }
19886 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19887 if (obj1) {
19888 ecode2 = SWIG_AsVal_int(obj1, &val2);
19889 if (!SWIG_IsOK(ecode2)) {
19890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
19891 }
19892 arg2 = static_cast< int >(val2);
19893 }
19894 {
19895 PyThreadState* __tstate = wxPyBeginAllowThreads();
19896 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
19897 wxPyEndAllowThreads(__tstate);
19898 if (PyErr_Occurred()) SWIG_fail;
19899 }
19900 {
19901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19902 }
19903 return resultobj;
19904 fail:
19905 return NULL;
19906 }
19907
19908
19909 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19910 PyObject *resultobj = 0;
19911 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19912 int arg2 = (int) wxMOUSE_BTN_ANY ;
19913 bool result;
19914 void *argp1 = 0 ;
19915 int res1 = 0 ;
19916 int val2 ;
19917 int ecode2 = 0 ;
19918 PyObject * obj0 = 0 ;
19919 PyObject * obj1 = 0 ;
19920 char * kwnames[] = {
19921 (char *) "self",(char *) "but", NULL
19922 };
19923
19924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
19925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19926 if (!SWIG_IsOK(res1)) {
19927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19928 }
19929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19930 if (obj1) {
19931 ecode2 = SWIG_AsVal_int(obj1, &val2);
19932 if (!SWIG_IsOK(ecode2)) {
19933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
19934 }
19935 arg2 = static_cast< int >(val2);
19936 }
19937 {
19938 PyThreadState* __tstate = wxPyBeginAllowThreads();
19939 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
19940 wxPyEndAllowThreads(__tstate);
19941 if (PyErr_Occurred()) SWIG_fail;
19942 }
19943 {
19944 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19945 }
19946 return resultobj;
19947 fail:
19948 return NULL;
19949 }
19950
19951
19952 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19953 PyObject *resultobj = 0;
19954 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19955 int arg2 ;
19956 bool result;
19957 void *argp1 = 0 ;
19958 int res1 = 0 ;
19959 int val2 ;
19960 int ecode2 = 0 ;
19961 PyObject * obj0 = 0 ;
19962 PyObject * obj1 = 0 ;
19963 char * kwnames[] = {
19964 (char *) "self",(char *) "button", NULL
19965 };
19966
19967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
19968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19969 if (!SWIG_IsOK(res1)) {
19970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19971 }
19972 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19973 ecode2 = SWIG_AsVal_int(obj1, &val2);
19974 if (!SWIG_IsOK(ecode2)) {
19975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
19976 }
19977 arg2 = static_cast< int >(val2);
19978 {
19979 PyThreadState* __tstate = wxPyBeginAllowThreads();
19980 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
19981 wxPyEndAllowThreads(__tstate);
19982 if (PyErr_Occurred()) SWIG_fail;
19983 }
19984 {
19985 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19986 }
19987 return resultobj;
19988 fail:
19989 return NULL;
19990 }
19991
19992
19993 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19994 PyObject *resultobj = 0;
19995 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19996 int arg2 ;
19997 bool result;
19998 void *argp1 = 0 ;
19999 int res1 = 0 ;
20000 int val2 ;
20001 int ecode2 = 0 ;
20002 PyObject * obj0 = 0 ;
20003 PyObject * obj1 = 0 ;
20004 char * kwnames[] = {
20005 (char *) "self",(char *) "but", NULL
20006 };
20007
20008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20010 if (!SWIG_IsOK(res1)) {
20011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20012 }
20013 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20014 ecode2 = SWIG_AsVal_int(obj1, &val2);
20015 if (!SWIG_IsOK(ecode2)) {
20016 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20017 }
20018 arg2 = static_cast< int >(val2);
20019 {
20020 PyThreadState* __tstate = wxPyBeginAllowThreads();
20021 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20022 wxPyEndAllowThreads(__tstate);
20023 if (PyErr_Occurred()) SWIG_fail;
20024 }
20025 {
20026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20027 }
20028 return resultobj;
20029 fail:
20030 return NULL;
20031 }
20032
20033
20034 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20035 PyObject *resultobj = 0;
20036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20037 int result;
20038 void *argp1 = 0 ;
20039 int res1 = 0 ;
20040 PyObject *swig_obj[1] ;
20041
20042 if (!args) SWIG_fail;
20043 swig_obj[0] = args;
20044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20045 if (!SWIG_IsOK(res1)) {
20046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20047 }
20048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 resultobj = SWIG_From_int(static_cast< int >(result));
20056 return resultobj;
20057 fail:
20058 return NULL;
20059 }
20060
20061
20062 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20063 PyObject *resultobj = 0;
20064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20065 bool result;
20066 void *argp1 = 0 ;
20067 int res1 = 0 ;
20068 PyObject *swig_obj[1] ;
20069
20070 if (!args) SWIG_fail;
20071 swig_obj[0] = args;
20072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20073 if (!SWIG_IsOK(res1)) {
20074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20075 }
20076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20077 {
20078 PyThreadState* __tstate = wxPyBeginAllowThreads();
20079 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20080 wxPyEndAllowThreads(__tstate);
20081 if (PyErr_Occurred()) SWIG_fail;
20082 }
20083 {
20084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20085 }
20086 return resultobj;
20087 fail:
20088 return NULL;
20089 }
20090
20091
20092 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20093 PyObject *resultobj = 0;
20094 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20095 bool result;
20096 void *argp1 = 0 ;
20097 int res1 = 0 ;
20098 PyObject *swig_obj[1] ;
20099
20100 if (!args) SWIG_fail;
20101 swig_obj[0] = args;
20102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20103 if (!SWIG_IsOK(res1)) {
20104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20105 }
20106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20107 {
20108 PyThreadState* __tstate = wxPyBeginAllowThreads();
20109 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20110 wxPyEndAllowThreads(__tstate);
20111 if (PyErr_Occurred()) SWIG_fail;
20112 }
20113 {
20114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20115 }
20116 return resultobj;
20117 fail:
20118 return NULL;
20119 }
20120
20121
20122 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20123 PyObject *resultobj = 0;
20124 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20125 bool result;
20126 void *argp1 = 0 ;
20127 int res1 = 0 ;
20128 PyObject *swig_obj[1] ;
20129
20130 if (!args) SWIG_fail;
20131 swig_obj[0] = args;
20132 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20133 if (!SWIG_IsOK(res1)) {
20134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20135 }
20136 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20137 {
20138 PyThreadState* __tstate = wxPyBeginAllowThreads();
20139 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20140 wxPyEndAllowThreads(__tstate);
20141 if (PyErr_Occurred()) SWIG_fail;
20142 }
20143 {
20144 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20145 }
20146 return resultobj;
20147 fail:
20148 return NULL;
20149 }
20150
20151
20152 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20153 PyObject *resultobj = 0;
20154 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20155 bool result;
20156 void *argp1 = 0 ;
20157 int res1 = 0 ;
20158 PyObject *swig_obj[1] ;
20159
20160 if (!args) SWIG_fail;
20161 swig_obj[0] = args;
20162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20163 if (!SWIG_IsOK(res1)) {
20164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20165 }
20166 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20167 {
20168 PyThreadState* __tstate = wxPyBeginAllowThreads();
20169 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20170 wxPyEndAllowThreads(__tstate);
20171 if (PyErr_Occurred()) SWIG_fail;
20172 }
20173 {
20174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20175 }
20176 return resultobj;
20177 fail:
20178 return NULL;
20179 }
20180
20181
20182 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20183 PyObject *resultobj = 0;
20184 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20185 bool result;
20186 void *argp1 = 0 ;
20187 int res1 = 0 ;
20188 PyObject *swig_obj[1] ;
20189
20190 if (!args) SWIG_fail;
20191 swig_obj[0] = args;
20192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20193 if (!SWIG_IsOK(res1)) {
20194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20195 }
20196 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20197 {
20198 PyThreadState* __tstate = wxPyBeginAllowThreads();
20199 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20200 wxPyEndAllowThreads(__tstate);
20201 if (PyErr_Occurred()) SWIG_fail;
20202 }
20203 {
20204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20205 }
20206 return resultobj;
20207 fail:
20208 return NULL;
20209 }
20210
20211
20212 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20213 PyObject *resultobj = 0;
20214 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20215 bool result;
20216 void *argp1 = 0 ;
20217 int res1 = 0 ;
20218 PyObject *swig_obj[1] ;
20219
20220 if (!args) SWIG_fail;
20221 swig_obj[0] = args;
20222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20223 if (!SWIG_IsOK(res1)) {
20224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20225 }
20226 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20227 {
20228 PyThreadState* __tstate = wxPyBeginAllowThreads();
20229 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20230 wxPyEndAllowThreads(__tstate);
20231 if (PyErr_Occurred()) SWIG_fail;
20232 }
20233 {
20234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20235 }
20236 return resultobj;
20237 fail:
20238 return NULL;
20239 }
20240
20241
20242 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20243 PyObject *resultobj = 0;
20244 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20245 bool result;
20246 void *argp1 = 0 ;
20247 int res1 = 0 ;
20248 PyObject *swig_obj[1] ;
20249
20250 if (!args) SWIG_fail;
20251 swig_obj[0] = args;
20252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20253 if (!SWIG_IsOK(res1)) {
20254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20255 }
20256 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20257 {
20258 PyThreadState* __tstate = wxPyBeginAllowThreads();
20259 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20260 wxPyEndAllowThreads(__tstate);
20261 if (PyErr_Occurred()) SWIG_fail;
20262 }
20263 {
20264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20265 }
20266 return resultobj;
20267 fail:
20268 return NULL;
20269 }
20270
20271
20272 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20273 PyObject *resultobj = 0;
20274 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20275 bool result;
20276 void *argp1 = 0 ;
20277 int res1 = 0 ;
20278 PyObject *swig_obj[1] ;
20279
20280 if (!args) SWIG_fail;
20281 swig_obj[0] = args;
20282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20283 if (!SWIG_IsOK(res1)) {
20284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20285 }
20286 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20287 {
20288 PyThreadState* __tstate = wxPyBeginAllowThreads();
20289 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20290 wxPyEndAllowThreads(__tstate);
20291 if (PyErr_Occurred()) SWIG_fail;
20292 }
20293 {
20294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20295 }
20296 return resultobj;
20297 fail:
20298 return NULL;
20299 }
20300
20301
20302 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20303 PyObject *resultobj = 0;
20304 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20305 bool result;
20306 void *argp1 = 0 ;
20307 int res1 = 0 ;
20308 PyObject *swig_obj[1] ;
20309
20310 if (!args) SWIG_fail;
20311 swig_obj[0] = args;
20312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20313 if (!SWIG_IsOK(res1)) {
20314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20315 }
20316 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20317 {
20318 PyThreadState* __tstate = wxPyBeginAllowThreads();
20319 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20320 wxPyEndAllowThreads(__tstate);
20321 if (PyErr_Occurred()) SWIG_fail;
20322 }
20323 {
20324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20325 }
20326 return resultobj;
20327 fail:
20328 return NULL;
20329 }
20330
20331
20332 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20333 PyObject *resultobj = 0;
20334 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20335 bool result;
20336 void *argp1 = 0 ;
20337 int res1 = 0 ;
20338 PyObject *swig_obj[1] ;
20339
20340 if (!args) SWIG_fail;
20341 swig_obj[0] = args;
20342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20343 if (!SWIG_IsOK(res1)) {
20344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20345 }
20346 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20347 {
20348 PyThreadState* __tstate = wxPyBeginAllowThreads();
20349 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20350 wxPyEndAllowThreads(__tstate);
20351 if (PyErr_Occurred()) SWIG_fail;
20352 }
20353 {
20354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20355 }
20356 return resultobj;
20357 fail:
20358 return NULL;
20359 }
20360
20361
20362 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20363 PyObject *resultobj = 0;
20364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20365 bool result;
20366 void *argp1 = 0 ;
20367 int res1 = 0 ;
20368 PyObject *swig_obj[1] ;
20369
20370 if (!args) SWIG_fail;
20371 swig_obj[0] = args;
20372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20373 if (!SWIG_IsOK(res1)) {
20374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20375 }
20376 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20380 wxPyEndAllowThreads(__tstate);
20381 if (PyErr_Occurred()) SWIG_fail;
20382 }
20383 {
20384 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20385 }
20386 return resultobj;
20387 fail:
20388 return NULL;
20389 }
20390
20391
20392 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20393 PyObject *resultobj = 0;
20394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20395 bool result;
20396 void *argp1 = 0 ;
20397 int res1 = 0 ;
20398 PyObject *swig_obj[1] ;
20399
20400 if (!args) SWIG_fail;
20401 swig_obj[0] = args;
20402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20403 if (!SWIG_IsOK(res1)) {
20404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20405 }
20406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20407 {
20408 PyThreadState* __tstate = wxPyBeginAllowThreads();
20409 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20410 wxPyEndAllowThreads(__tstate);
20411 if (PyErr_Occurred()) SWIG_fail;
20412 }
20413 {
20414 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20415 }
20416 return resultobj;
20417 fail:
20418 return NULL;
20419 }
20420
20421
20422 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20423 PyObject *resultobj = 0;
20424 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20425 bool result;
20426 void *argp1 = 0 ;
20427 int res1 = 0 ;
20428 PyObject *swig_obj[1] ;
20429
20430 if (!args) SWIG_fail;
20431 swig_obj[0] = args;
20432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20433 if (!SWIG_IsOK(res1)) {
20434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20435 }
20436 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20437 {
20438 PyThreadState* __tstate = wxPyBeginAllowThreads();
20439 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20440 wxPyEndAllowThreads(__tstate);
20441 if (PyErr_Occurred()) SWIG_fail;
20442 }
20443 {
20444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20445 }
20446 return resultobj;
20447 fail:
20448 return NULL;
20449 }
20450
20451
20452 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20453 PyObject *resultobj = 0;
20454 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20455 bool result;
20456 void *argp1 = 0 ;
20457 int res1 = 0 ;
20458 PyObject *swig_obj[1] ;
20459
20460 if (!args) SWIG_fail;
20461 swig_obj[0] = args;
20462 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20463 if (!SWIG_IsOK(res1)) {
20464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20465 }
20466 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20467 {
20468 PyThreadState* __tstate = wxPyBeginAllowThreads();
20469 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20470 wxPyEndAllowThreads(__tstate);
20471 if (PyErr_Occurred()) SWIG_fail;
20472 }
20473 {
20474 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20475 }
20476 return resultobj;
20477 fail:
20478 return NULL;
20479 }
20480
20481
20482 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20483 PyObject *resultobj = 0;
20484 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20485 bool result;
20486 void *argp1 = 0 ;
20487 int res1 = 0 ;
20488 PyObject *swig_obj[1] ;
20489
20490 if (!args) SWIG_fail;
20491 swig_obj[0] = args;
20492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20493 if (!SWIG_IsOK(res1)) {
20494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20495 }
20496 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20497 {
20498 PyThreadState* __tstate = wxPyBeginAllowThreads();
20499 result = (bool)(arg1)->LeftIsDown();
20500 wxPyEndAllowThreads(__tstate);
20501 if (PyErr_Occurred()) SWIG_fail;
20502 }
20503 {
20504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20505 }
20506 return resultobj;
20507 fail:
20508 return NULL;
20509 }
20510
20511
20512 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20513 PyObject *resultobj = 0;
20514 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20515 bool result;
20516 void *argp1 = 0 ;
20517 int res1 = 0 ;
20518 PyObject *swig_obj[1] ;
20519
20520 if (!args) SWIG_fail;
20521 swig_obj[0] = args;
20522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20523 if (!SWIG_IsOK(res1)) {
20524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20525 }
20526 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20527 {
20528 PyThreadState* __tstate = wxPyBeginAllowThreads();
20529 result = (bool)(arg1)->MiddleIsDown();
20530 wxPyEndAllowThreads(__tstate);
20531 if (PyErr_Occurred()) SWIG_fail;
20532 }
20533 {
20534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20535 }
20536 return resultobj;
20537 fail:
20538 return NULL;
20539 }
20540
20541
20542 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20543 PyObject *resultobj = 0;
20544 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20545 bool result;
20546 void *argp1 = 0 ;
20547 int res1 = 0 ;
20548 PyObject *swig_obj[1] ;
20549
20550 if (!args) SWIG_fail;
20551 swig_obj[0] = args;
20552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20553 if (!SWIG_IsOK(res1)) {
20554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20555 }
20556 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20557 {
20558 PyThreadState* __tstate = wxPyBeginAllowThreads();
20559 result = (bool)(arg1)->RightIsDown();
20560 wxPyEndAllowThreads(__tstate);
20561 if (PyErr_Occurred()) SWIG_fail;
20562 }
20563 {
20564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20565 }
20566 return resultobj;
20567 fail:
20568 return NULL;
20569 }
20570
20571
20572 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20573 PyObject *resultobj = 0;
20574 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20575 bool result;
20576 void *argp1 = 0 ;
20577 int res1 = 0 ;
20578 PyObject *swig_obj[1] ;
20579
20580 if (!args) SWIG_fail;
20581 swig_obj[0] = args;
20582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20583 if (!SWIG_IsOK(res1)) {
20584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20585 }
20586 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20587 {
20588 PyThreadState* __tstate = wxPyBeginAllowThreads();
20589 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20590 wxPyEndAllowThreads(__tstate);
20591 if (PyErr_Occurred()) SWIG_fail;
20592 }
20593 {
20594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20595 }
20596 return resultobj;
20597 fail:
20598 return NULL;
20599 }
20600
20601
20602 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20603 PyObject *resultobj = 0;
20604 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20605 bool result;
20606 void *argp1 = 0 ;
20607 int res1 = 0 ;
20608 PyObject *swig_obj[1] ;
20609
20610 if (!args) SWIG_fail;
20611 swig_obj[0] = args;
20612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20613 if (!SWIG_IsOK(res1)) {
20614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20615 }
20616 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20617 {
20618 PyThreadState* __tstate = wxPyBeginAllowThreads();
20619 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20620 wxPyEndAllowThreads(__tstate);
20621 if (PyErr_Occurred()) SWIG_fail;
20622 }
20623 {
20624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20625 }
20626 return resultobj;
20627 fail:
20628 return NULL;
20629 }
20630
20631
20632 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20633 PyObject *resultobj = 0;
20634 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20635 bool result;
20636 void *argp1 = 0 ;
20637 int res1 = 0 ;
20638 PyObject *swig_obj[1] ;
20639
20640 if (!args) SWIG_fail;
20641 swig_obj[0] = args;
20642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20643 if (!SWIG_IsOK(res1)) {
20644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20645 }
20646 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20647 {
20648 PyThreadState* __tstate = wxPyBeginAllowThreads();
20649 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20650 wxPyEndAllowThreads(__tstate);
20651 if (PyErr_Occurred()) SWIG_fail;
20652 }
20653 {
20654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20655 }
20656 return resultobj;
20657 fail:
20658 return NULL;
20659 }
20660
20661
20662 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20663 PyObject *resultobj = 0;
20664 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20665 bool result;
20666 void *argp1 = 0 ;
20667 int res1 = 0 ;
20668 PyObject *swig_obj[1] ;
20669
20670 if (!args) SWIG_fail;
20671 swig_obj[0] = args;
20672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20673 if (!SWIG_IsOK(res1)) {
20674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20675 }
20676 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20677 {
20678 PyThreadState* __tstate = wxPyBeginAllowThreads();
20679 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20680 wxPyEndAllowThreads(__tstate);
20681 if (PyErr_Occurred()) SWIG_fail;
20682 }
20683 {
20684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20685 }
20686 return resultobj;
20687 fail:
20688 return NULL;
20689 }
20690
20691
20692 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20693 PyObject *resultobj = 0;
20694 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20695 wxPoint result;
20696 void *argp1 = 0 ;
20697 int res1 = 0 ;
20698 PyObject *swig_obj[1] ;
20699
20700 if (!args) SWIG_fail;
20701 swig_obj[0] = args;
20702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20703 if (!SWIG_IsOK(res1)) {
20704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20705 }
20706 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20707 {
20708 PyThreadState* __tstate = wxPyBeginAllowThreads();
20709 result = (arg1)->GetPosition();
20710 wxPyEndAllowThreads(__tstate);
20711 if (PyErr_Occurred()) SWIG_fail;
20712 }
20713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20714 return resultobj;
20715 fail:
20716 return NULL;
20717 }
20718
20719
20720 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20721 PyObject *resultobj = 0;
20722 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20723 long *arg2 = (long *) 0 ;
20724 long *arg3 = (long *) 0 ;
20725 void *argp1 = 0 ;
20726 int res1 = 0 ;
20727 long temp2 ;
20728 int res2 = SWIG_TMPOBJ ;
20729 long temp3 ;
20730 int res3 = SWIG_TMPOBJ ;
20731 PyObject *swig_obj[1] ;
20732
20733 arg2 = &temp2;
20734 arg3 = &temp3;
20735 if (!args) SWIG_fail;
20736 swig_obj[0] = args;
20737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20738 if (!SWIG_IsOK(res1)) {
20739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20740 }
20741 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20742 {
20743 PyThreadState* __tstate = wxPyBeginAllowThreads();
20744 (arg1)->GetPosition(arg2,arg3);
20745 wxPyEndAllowThreads(__tstate);
20746 if (PyErr_Occurred()) SWIG_fail;
20747 }
20748 resultobj = SWIG_Py_Void();
20749 if (SWIG_IsTmpObj(res2)) {
20750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20751 } else {
20752 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20754 }
20755 if (SWIG_IsTmpObj(res3)) {
20756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20757 } else {
20758 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20759 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20760 }
20761 return resultobj;
20762 fail:
20763 return NULL;
20764 }
20765
20766
20767 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20768 PyObject *resultobj = 0;
20769 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20770 wxDC *arg2 = 0 ;
20771 wxPoint result;
20772 void *argp1 = 0 ;
20773 int res1 = 0 ;
20774 void *argp2 = 0 ;
20775 int res2 = 0 ;
20776 PyObject * obj0 = 0 ;
20777 PyObject * obj1 = 0 ;
20778 char * kwnames[] = {
20779 (char *) "self",(char *) "dc", NULL
20780 };
20781
20782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20784 if (!SWIG_IsOK(res1)) {
20785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20786 }
20787 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20788 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20789 if (!SWIG_IsOK(res2)) {
20790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20791 }
20792 if (!argp2) {
20793 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20794 }
20795 arg2 = reinterpret_cast< wxDC * >(argp2);
20796 {
20797 PyThreadState* __tstate = wxPyBeginAllowThreads();
20798 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20799 wxPyEndAllowThreads(__tstate);
20800 if (PyErr_Occurred()) SWIG_fail;
20801 }
20802 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20803 return resultobj;
20804 fail:
20805 return NULL;
20806 }
20807
20808
20809 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20810 PyObject *resultobj = 0;
20811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20812 int result;
20813 void *argp1 = 0 ;
20814 int res1 = 0 ;
20815 PyObject *swig_obj[1] ;
20816
20817 if (!args) SWIG_fail;
20818 swig_obj[0] = args;
20819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20820 if (!SWIG_IsOK(res1)) {
20821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20822 }
20823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20824 {
20825 PyThreadState* __tstate = wxPyBeginAllowThreads();
20826 result = (int)((wxMouseEvent const *)arg1)->GetX();
20827 wxPyEndAllowThreads(__tstate);
20828 if (PyErr_Occurred()) SWIG_fail;
20829 }
20830 resultobj = SWIG_From_int(static_cast< int >(result));
20831 return resultobj;
20832 fail:
20833 return NULL;
20834 }
20835
20836
20837 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20838 PyObject *resultobj = 0;
20839 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20840 int result;
20841 void *argp1 = 0 ;
20842 int res1 = 0 ;
20843 PyObject *swig_obj[1] ;
20844
20845 if (!args) SWIG_fail;
20846 swig_obj[0] = args;
20847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20848 if (!SWIG_IsOK(res1)) {
20849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20850 }
20851 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20852 {
20853 PyThreadState* __tstate = wxPyBeginAllowThreads();
20854 result = (int)((wxMouseEvent const *)arg1)->GetY();
20855 wxPyEndAllowThreads(__tstate);
20856 if (PyErr_Occurred()) SWIG_fail;
20857 }
20858 resultobj = SWIG_From_int(static_cast< int >(result));
20859 return resultobj;
20860 fail:
20861 return NULL;
20862 }
20863
20864
20865 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20866 PyObject *resultobj = 0;
20867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20868 int result;
20869 void *argp1 = 0 ;
20870 int res1 = 0 ;
20871 PyObject *swig_obj[1] ;
20872
20873 if (!args) SWIG_fail;
20874 swig_obj[0] = args;
20875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20876 if (!SWIG_IsOK(res1)) {
20877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20878 }
20879 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20880 {
20881 PyThreadState* __tstate = wxPyBeginAllowThreads();
20882 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20883 wxPyEndAllowThreads(__tstate);
20884 if (PyErr_Occurred()) SWIG_fail;
20885 }
20886 resultobj = SWIG_From_int(static_cast< int >(result));
20887 return resultobj;
20888 fail:
20889 return NULL;
20890 }
20891
20892
20893 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20894 PyObject *resultobj = 0;
20895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20896 int result;
20897 void *argp1 = 0 ;
20898 int res1 = 0 ;
20899 PyObject *swig_obj[1] ;
20900
20901 if (!args) SWIG_fail;
20902 swig_obj[0] = args;
20903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20904 if (!SWIG_IsOK(res1)) {
20905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20906 }
20907 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
20911 wxPyEndAllowThreads(__tstate);
20912 if (PyErr_Occurred()) SWIG_fail;
20913 }
20914 resultobj = SWIG_From_int(static_cast< int >(result));
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20922 PyObject *resultobj = 0;
20923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20924 int result;
20925 void *argp1 = 0 ;
20926 int res1 = 0 ;
20927 PyObject *swig_obj[1] ;
20928
20929 if (!args) SWIG_fail;
20930 swig_obj[0] = args;
20931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20932 if (!SWIG_IsOK(res1)) {
20933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20934 }
20935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_From_int(static_cast< int >(result));
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 PyObject *resultobj = 0;
20951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20952 bool result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 PyObject *swig_obj[1] ;
20956
20957 if (!args) SWIG_fail;
20958 swig_obj[0] = args;
20959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20960 if (!SWIG_IsOK(res1)) {
20961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20962 }
20963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 {
20971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20972 }
20973 return resultobj;
20974 fail:
20975 return NULL;
20976 }
20977
20978
20979 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20980 PyObject *resultobj = 0;
20981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20982 int arg2 ;
20983 void *argp1 = 0 ;
20984 int res1 = 0 ;
20985 int val2 ;
20986 int ecode2 = 0 ;
20987 PyObject *swig_obj[2] ;
20988
20989 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
20990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20991 if (!SWIG_IsOK(res1)) {
20992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20993 }
20994 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20995 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
20996 if (!SWIG_IsOK(ecode2)) {
20997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
20998 }
20999 arg2 = static_cast< int >(val2);
21000 if (arg1) (arg1)->m_x = arg2;
21001
21002 resultobj = SWIG_Py_Void();
21003 return resultobj;
21004 fail:
21005 return NULL;
21006 }
21007
21008
21009 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21010 PyObject *resultobj = 0;
21011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21012 int result;
21013 void *argp1 = 0 ;
21014 int res1 = 0 ;
21015 PyObject *swig_obj[1] ;
21016
21017 if (!args) SWIG_fail;
21018 swig_obj[0] = args;
21019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21020 if (!SWIG_IsOK(res1)) {
21021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21022 }
21023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21024 result = (int) ((arg1)->m_x);
21025 resultobj = SWIG_From_int(static_cast< int >(result));
21026 return resultobj;
21027 fail:
21028 return NULL;
21029 }
21030
21031
21032 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21033 PyObject *resultobj = 0;
21034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21035 int arg2 ;
21036 void *argp1 = 0 ;
21037 int res1 = 0 ;
21038 int val2 ;
21039 int ecode2 = 0 ;
21040 PyObject *swig_obj[2] ;
21041
21042 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21044 if (!SWIG_IsOK(res1)) {
21045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21046 }
21047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21048 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21049 if (!SWIG_IsOK(ecode2)) {
21050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21051 }
21052 arg2 = static_cast< int >(val2);
21053 if (arg1) (arg1)->m_y = arg2;
21054
21055 resultobj = SWIG_Py_Void();
21056 return resultobj;
21057 fail:
21058 return NULL;
21059 }
21060
21061
21062 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21063 PyObject *resultobj = 0;
21064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21065 int result;
21066 void *argp1 = 0 ;
21067 int res1 = 0 ;
21068 PyObject *swig_obj[1] ;
21069
21070 if (!args) SWIG_fail;
21071 swig_obj[0] = args;
21072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21073 if (!SWIG_IsOK(res1)) {
21074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21075 }
21076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21077 result = (int) ((arg1)->m_y);
21078 resultobj = SWIG_From_int(static_cast< int >(result));
21079 return resultobj;
21080 fail:
21081 return NULL;
21082 }
21083
21084
21085 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21086 PyObject *resultobj = 0;
21087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21088 bool arg2 ;
21089 void *argp1 = 0 ;
21090 int res1 = 0 ;
21091 bool val2 ;
21092 int ecode2 = 0 ;
21093 PyObject *swig_obj[2] ;
21094
21095 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21097 if (!SWIG_IsOK(res1)) {
21098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21099 }
21100 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21101 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21102 if (!SWIG_IsOK(ecode2)) {
21103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21104 }
21105 arg2 = static_cast< bool >(val2);
21106 if (arg1) (arg1)->m_leftDown = arg2;
21107
21108 resultobj = SWIG_Py_Void();
21109 return resultobj;
21110 fail:
21111 return NULL;
21112 }
21113
21114
21115 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21116 PyObject *resultobj = 0;
21117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21118 bool result;
21119 void *argp1 = 0 ;
21120 int res1 = 0 ;
21121 PyObject *swig_obj[1] ;
21122
21123 if (!args) SWIG_fail;
21124 swig_obj[0] = args;
21125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21126 if (!SWIG_IsOK(res1)) {
21127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21128 }
21129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21130 result = (bool) ((arg1)->m_leftDown);
21131 {
21132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21133 }
21134 return resultobj;
21135 fail:
21136 return NULL;
21137 }
21138
21139
21140 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21141 PyObject *resultobj = 0;
21142 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21143 bool arg2 ;
21144 void *argp1 = 0 ;
21145 int res1 = 0 ;
21146 bool val2 ;
21147 int ecode2 = 0 ;
21148 PyObject *swig_obj[2] ;
21149
21150 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21152 if (!SWIG_IsOK(res1)) {
21153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21154 }
21155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21156 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21157 if (!SWIG_IsOK(ecode2)) {
21158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21159 }
21160 arg2 = static_cast< bool >(val2);
21161 if (arg1) (arg1)->m_middleDown = arg2;
21162
21163 resultobj = SWIG_Py_Void();
21164 return resultobj;
21165 fail:
21166 return NULL;
21167 }
21168
21169
21170 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21171 PyObject *resultobj = 0;
21172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21173 bool result;
21174 void *argp1 = 0 ;
21175 int res1 = 0 ;
21176 PyObject *swig_obj[1] ;
21177
21178 if (!args) SWIG_fail;
21179 swig_obj[0] = args;
21180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21181 if (!SWIG_IsOK(res1)) {
21182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21183 }
21184 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21185 result = (bool) ((arg1)->m_middleDown);
21186 {
21187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21188 }
21189 return resultobj;
21190 fail:
21191 return NULL;
21192 }
21193
21194
21195 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21196 PyObject *resultobj = 0;
21197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21198 bool arg2 ;
21199 void *argp1 = 0 ;
21200 int res1 = 0 ;
21201 bool val2 ;
21202 int ecode2 = 0 ;
21203 PyObject *swig_obj[2] ;
21204
21205 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21207 if (!SWIG_IsOK(res1)) {
21208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21209 }
21210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21211 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21212 if (!SWIG_IsOK(ecode2)) {
21213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21214 }
21215 arg2 = static_cast< bool >(val2);
21216 if (arg1) (arg1)->m_rightDown = arg2;
21217
21218 resultobj = SWIG_Py_Void();
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21226 PyObject *resultobj = 0;
21227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21228 bool result;
21229 void *argp1 = 0 ;
21230 int res1 = 0 ;
21231 PyObject *swig_obj[1] ;
21232
21233 if (!args) SWIG_fail;
21234 swig_obj[0] = args;
21235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21236 if (!SWIG_IsOK(res1)) {
21237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21238 }
21239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21240 result = (bool) ((arg1)->m_rightDown);
21241 {
21242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21243 }
21244 return resultobj;
21245 fail:
21246 return NULL;
21247 }
21248
21249
21250 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21251 PyObject *resultobj = 0;
21252 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21253 bool arg2 ;
21254 void *argp1 = 0 ;
21255 int res1 = 0 ;
21256 bool val2 ;
21257 int ecode2 = 0 ;
21258 PyObject *swig_obj[2] ;
21259
21260 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21262 if (!SWIG_IsOK(res1)) {
21263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21264 }
21265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21266 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21267 if (!SWIG_IsOK(ecode2)) {
21268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21269 }
21270 arg2 = static_cast< bool >(val2);
21271 if (arg1) (arg1)->m_controlDown = arg2;
21272
21273 resultobj = SWIG_Py_Void();
21274 return resultobj;
21275 fail:
21276 return NULL;
21277 }
21278
21279
21280 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21281 PyObject *resultobj = 0;
21282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21283 bool result;
21284 void *argp1 = 0 ;
21285 int res1 = 0 ;
21286 PyObject *swig_obj[1] ;
21287
21288 if (!args) SWIG_fail;
21289 swig_obj[0] = args;
21290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21291 if (!SWIG_IsOK(res1)) {
21292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21293 }
21294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21295 result = (bool) ((arg1)->m_controlDown);
21296 {
21297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21298 }
21299 return resultobj;
21300 fail:
21301 return NULL;
21302 }
21303
21304
21305 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21306 PyObject *resultobj = 0;
21307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21308 bool arg2 ;
21309 void *argp1 = 0 ;
21310 int res1 = 0 ;
21311 bool val2 ;
21312 int ecode2 = 0 ;
21313 PyObject *swig_obj[2] ;
21314
21315 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21317 if (!SWIG_IsOK(res1)) {
21318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21319 }
21320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21321 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21322 if (!SWIG_IsOK(ecode2)) {
21323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21324 }
21325 arg2 = static_cast< bool >(val2);
21326 if (arg1) (arg1)->m_shiftDown = arg2;
21327
21328 resultobj = SWIG_Py_Void();
21329 return resultobj;
21330 fail:
21331 return NULL;
21332 }
21333
21334
21335 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21336 PyObject *resultobj = 0;
21337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21338 bool result;
21339 void *argp1 = 0 ;
21340 int res1 = 0 ;
21341 PyObject *swig_obj[1] ;
21342
21343 if (!args) SWIG_fail;
21344 swig_obj[0] = args;
21345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21346 if (!SWIG_IsOK(res1)) {
21347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21348 }
21349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21350 result = (bool) ((arg1)->m_shiftDown);
21351 {
21352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21353 }
21354 return resultobj;
21355 fail:
21356 return NULL;
21357 }
21358
21359
21360 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21361 PyObject *resultobj = 0;
21362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21363 bool arg2 ;
21364 void *argp1 = 0 ;
21365 int res1 = 0 ;
21366 bool val2 ;
21367 int ecode2 = 0 ;
21368 PyObject *swig_obj[2] ;
21369
21370 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21372 if (!SWIG_IsOK(res1)) {
21373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21374 }
21375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21376 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21377 if (!SWIG_IsOK(ecode2)) {
21378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21379 }
21380 arg2 = static_cast< bool >(val2);
21381 if (arg1) (arg1)->m_altDown = arg2;
21382
21383 resultobj = SWIG_Py_Void();
21384 return resultobj;
21385 fail:
21386 return NULL;
21387 }
21388
21389
21390 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21391 PyObject *resultobj = 0;
21392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21393 bool result;
21394 void *argp1 = 0 ;
21395 int res1 = 0 ;
21396 PyObject *swig_obj[1] ;
21397
21398 if (!args) SWIG_fail;
21399 swig_obj[0] = args;
21400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21401 if (!SWIG_IsOK(res1)) {
21402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21403 }
21404 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21405 result = (bool) ((arg1)->m_altDown);
21406 {
21407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21408 }
21409 return resultobj;
21410 fail:
21411 return NULL;
21412 }
21413
21414
21415 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21416 PyObject *resultobj = 0;
21417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21418 bool arg2 ;
21419 void *argp1 = 0 ;
21420 int res1 = 0 ;
21421 bool val2 ;
21422 int ecode2 = 0 ;
21423 PyObject *swig_obj[2] ;
21424
21425 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21427 if (!SWIG_IsOK(res1)) {
21428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21429 }
21430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21431 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21432 if (!SWIG_IsOK(ecode2)) {
21433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21434 }
21435 arg2 = static_cast< bool >(val2);
21436 if (arg1) (arg1)->m_metaDown = arg2;
21437
21438 resultobj = SWIG_Py_Void();
21439 return resultobj;
21440 fail:
21441 return NULL;
21442 }
21443
21444
21445 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21446 PyObject *resultobj = 0;
21447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21448 bool result;
21449 void *argp1 = 0 ;
21450 int res1 = 0 ;
21451 PyObject *swig_obj[1] ;
21452
21453 if (!args) SWIG_fail;
21454 swig_obj[0] = args;
21455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21456 if (!SWIG_IsOK(res1)) {
21457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21458 }
21459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21460 result = (bool) ((arg1)->m_metaDown);
21461 {
21462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21463 }
21464 return resultobj;
21465 fail:
21466 return NULL;
21467 }
21468
21469
21470 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21471 PyObject *resultobj = 0;
21472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21473 int arg2 ;
21474 void *argp1 = 0 ;
21475 int res1 = 0 ;
21476 int val2 ;
21477 int ecode2 = 0 ;
21478 PyObject *swig_obj[2] ;
21479
21480 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21482 if (!SWIG_IsOK(res1)) {
21483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21484 }
21485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21486 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21487 if (!SWIG_IsOK(ecode2)) {
21488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21489 }
21490 arg2 = static_cast< int >(val2);
21491 if (arg1) (arg1)->m_wheelRotation = arg2;
21492
21493 resultobj = SWIG_Py_Void();
21494 return resultobj;
21495 fail:
21496 return NULL;
21497 }
21498
21499
21500 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21501 PyObject *resultobj = 0;
21502 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21503 int result;
21504 void *argp1 = 0 ;
21505 int res1 = 0 ;
21506 PyObject *swig_obj[1] ;
21507
21508 if (!args) SWIG_fail;
21509 swig_obj[0] = args;
21510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21511 if (!SWIG_IsOK(res1)) {
21512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21513 }
21514 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21515 result = (int) ((arg1)->m_wheelRotation);
21516 resultobj = SWIG_From_int(static_cast< int >(result));
21517 return resultobj;
21518 fail:
21519 return NULL;
21520 }
21521
21522
21523 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21524 PyObject *resultobj = 0;
21525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21526 int arg2 ;
21527 void *argp1 = 0 ;
21528 int res1 = 0 ;
21529 int val2 ;
21530 int ecode2 = 0 ;
21531 PyObject *swig_obj[2] ;
21532
21533 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21535 if (!SWIG_IsOK(res1)) {
21536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21537 }
21538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21539 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21540 if (!SWIG_IsOK(ecode2)) {
21541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21542 }
21543 arg2 = static_cast< int >(val2);
21544 if (arg1) (arg1)->m_wheelDelta = arg2;
21545
21546 resultobj = SWIG_Py_Void();
21547 return resultobj;
21548 fail:
21549 return NULL;
21550 }
21551
21552
21553 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21554 PyObject *resultobj = 0;
21555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21556 int result;
21557 void *argp1 = 0 ;
21558 int res1 = 0 ;
21559 PyObject *swig_obj[1] ;
21560
21561 if (!args) SWIG_fail;
21562 swig_obj[0] = args;
21563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21564 if (!SWIG_IsOK(res1)) {
21565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21566 }
21567 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21568 result = (int) ((arg1)->m_wheelDelta);
21569 resultobj = SWIG_From_int(static_cast< int >(result));
21570 return resultobj;
21571 fail:
21572 return NULL;
21573 }
21574
21575
21576 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21577 PyObject *resultobj = 0;
21578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21579 int arg2 ;
21580 void *argp1 = 0 ;
21581 int res1 = 0 ;
21582 int val2 ;
21583 int ecode2 = 0 ;
21584 PyObject *swig_obj[2] ;
21585
21586 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21588 if (!SWIG_IsOK(res1)) {
21589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21590 }
21591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21592 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21593 if (!SWIG_IsOK(ecode2)) {
21594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21595 }
21596 arg2 = static_cast< int >(val2);
21597 if (arg1) (arg1)->m_linesPerAction = arg2;
21598
21599 resultobj = SWIG_Py_Void();
21600 return resultobj;
21601 fail:
21602 return NULL;
21603 }
21604
21605
21606 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21607 PyObject *resultobj = 0;
21608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21609 int result;
21610 void *argp1 = 0 ;
21611 int res1 = 0 ;
21612 PyObject *swig_obj[1] ;
21613
21614 if (!args) SWIG_fail;
21615 swig_obj[0] = args;
21616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21617 if (!SWIG_IsOK(res1)) {
21618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21619 }
21620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21621 result = (int) ((arg1)->m_linesPerAction);
21622 resultobj = SWIG_From_int(static_cast< int >(result));
21623 return resultobj;
21624 fail:
21625 return NULL;
21626 }
21627
21628
21629 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21630 PyObject *obj;
21631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21632 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21633 return SWIG_Py_Void();
21634 }
21635
21636 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21637 return SWIG_Python_InitShadowInstance(args);
21638 }
21639
21640 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21641 PyObject *resultobj = 0;
21642 int arg1 = (int) 0 ;
21643 int arg2 = (int) 0 ;
21644 wxSetCursorEvent *result = 0 ;
21645 int val1 ;
21646 int ecode1 = 0 ;
21647 int val2 ;
21648 int ecode2 = 0 ;
21649 PyObject * obj0 = 0 ;
21650 PyObject * obj1 = 0 ;
21651 char * kwnames[] = {
21652 (char *) "x",(char *) "y", NULL
21653 };
21654
21655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21656 if (obj0) {
21657 ecode1 = SWIG_AsVal_int(obj0, &val1);
21658 if (!SWIG_IsOK(ecode1)) {
21659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21660 }
21661 arg1 = static_cast< int >(val1);
21662 }
21663 if (obj1) {
21664 ecode2 = SWIG_AsVal_int(obj1, &val2);
21665 if (!SWIG_IsOK(ecode2)) {
21666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21667 }
21668 arg2 = static_cast< int >(val2);
21669 }
21670 {
21671 PyThreadState* __tstate = wxPyBeginAllowThreads();
21672 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21673 wxPyEndAllowThreads(__tstate);
21674 if (PyErr_Occurred()) SWIG_fail;
21675 }
21676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21677 return resultobj;
21678 fail:
21679 return NULL;
21680 }
21681
21682
21683 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21684 PyObject *resultobj = 0;
21685 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21686 int result;
21687 void *argp1 = 0 ;
21688 int res1 = 0 ;
21689 PyObject *swig_obj[1] ;
21690
21691 if (!args) SWIG_fail;
21692 swig_obj[0] = args;
21693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21694 if (!SWIG_IsOK(res1)) {
21695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21696 }
21697 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21698 {
21699 PyThreadState* __tstate = wxPyBeginAllowThreads();
21700 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21701 wxPyEndAllowThreads(__tstate);
21702 if (PyErr_Occurred()) SWIG_fail;
21703 }
21704 resultobj = SWIG_From_int(static_cast< int >(result));
21705 return resultobj;
21706 fail:
21707 return NULL;
21708 }
21709
21710
21711 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21712 PyObject *resultobj = 0;
21713 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21714 int result;
21715 void *argp1 = 0 ;
21716 int res1 = 0 ;
21717 PyObject *swig_obj[1] ;
21718
21719 if (!args) SWIG_fail;
21720 swig_obj[0] = args;
21721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21722 if (!SWIG_IsOK(res1)) {
21723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21724 }
21725 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21726 {
21727 PyThreadState* __tstate = wxPyBeginAllowThreads();
21728 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21729 wxPyEndAllowThreads(__tstate);
21730 if (PyErr_Occurred()) SWIG_fail;
21731 }
21732 resultobj = SWIG_From_int(static_cast< int >(result));
21733 return resultobj;
21734 fail:
21735 return NULL;
21736 }
21737
21738
21739 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21740 PyObject *resultobj = 0;
21741 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21742 wxCursor *arg2 = 0 ;
21743 void *argp1 = 0 ;
21744 int res1 = 0 ;
21745 void *argp2 = 0 ;
21746 int res2 = 0 ;
21747 PyObject * obj0 = 0 ;
21748 PyObject * obj1 = 0 ;
21749 char * kwnames[] = {
21750 (char *) "self",(char *) "cursor", NULL
21751 };
21752
21753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21755 if (!SWIG_IsOK(res1)) {
21756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21757 }
21758 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21760 if (!SWIG_IsOK(res2)) {
21761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21762 }
21763 if (!argp2) {
21764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21765 }
21766 arg2 = reinterpret_cast< wxCursor * >(argp2);
21767 {
21768 PyThreadState* __tstate = wxPyBeginAllowThreads();
21769 (arg1)->SetCursor((wxCursor const &)*arg2);
21770 wxPyEndAllowThreads(__tstate);
21771 if (PyErr_Occurred()) SWIG_fail;
21772 }
21773 resultobj = SWIG_Py_Void();
21774 return resultobj;
21775 fail:
21776 return NULL;
21777 }
21778
21779
21780 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21781 PyObject *resultobj = 0;
21782 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21783 wxCursor *result = 0 ;
21784 void *argp1 = 0 ;
21785 int res1 = 0 ;
21786 PyObject *swig_obj[1] ;
21787
21788 if (!args) SWIG_fail;
21789 swig_obj[0] = args;
21790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21791 if (!SWIG_IsOK(res1)) {
21792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21793 }
21794 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21795 {
21796 PyThreadState* __tstate = wxPyBeginAllowThreads();
21797 {
21798 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21799 result = (wxCursor *) &_result_ref;
21800 }
21801 wxPyEndAllowThreads(__tstate);
21802 if (PyErr_Occurred()) SWIG_fail;
21803 }
21804 {
21805 wxCursor* resultptr = new wxCursor(*result);
21806 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21807 }
21808 return resultobj;
21809 fail:
21810 return NULL;
21811 }
21812
21813
21814 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21815 PyObject *resultobj = 0;
21816 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21817 bool result;
21818 void *argp1 = 0 ;
21819 int res1 = 0 ;
21820 PyObject *swig_obj[1] ;
21821
21822 if (!args) SWIG_fail;
21823 swig_obj[0] = args;
21824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21825 if (!SWIG_IsOK(res1)) {
21826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21827 }
21828 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21829 {
21830 PyThreadState* __tstate = wxPyBeginAllowThreads();
21831 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21832 wxPyEndAllowThreads(__tstate);
21833 if (PyErr_Occurred()) SWIG_fail;
21834 }
21835 {
21836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21837 }
21838 return resultobj;
21839 fail:
21840 return NULL;
21841 }
21842
21843
21844 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21845 PyObject *obj;
21846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21847 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21848 return SWIG_Py_Void();
21849 }
21850
21851 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21852 return SWIG_Python_InitShadowInstance(args);
21853 }
21854
21855 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21856 PyObject *resultobj = 0;
21857 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21858 wxKeyEvent *result = 0 ;
21859 int val1 ;
21860 int ecode1 = 0 ;
21861 PyObject * obj0 = 0 ;
21862 char * kwnames[] = {
21863 (char *) "eventType", NULL
21864 };
21865
21866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21867 if (obj0) {
21868 ecode1 = SWIG_AsVal_int(obj0, &val1);
21869 if (!SWIG_IsOK(ecode1)) {
21870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21871 }
21872 arg1 = static_cast< wxEventType >(val1);
21873 }
21874 {
21875 PyThreadState* __tstate = wxPyBeginAllowThreads();
21876 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21877 wxPyEndAllowThreads(__tstate);
21878 if (PyErr_Occurred()) SWIG_fail;
21879 }
21880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21881 return resultobj;
21882 fail:
21883 return NULL;
21884 }
21885
21886
21887 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21888 PyObject *resultobj = 0;
21889 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21890 int result;
21891 void *argp1 = 0 ;
21892 int res1 = 0 ;
21893 PyObject *swig_obj[1] ;
21894
21895 if (!args) SWIG_fail;
21896 swig_obj[0] = args;
21897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21898 if (!SWIG_IsOK(res1)) {
21899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21900 }
21901 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21902 {
21903 PyThreadState* __tstate = wxPyBeginAllowThreads();
21904 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
21905 wxPyEndAllowThreads(__tstate);
21906 if (PyErr_Occurred()) SWIG_fail;
21907 }
21908 resultobj = SWIG_From_int(static_cast< int >(result));
21909 return resultobj;
21910 fail:
21911 return NULL;
21912 }
21913
21914
21915 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21916 PyObject *resultobj = 0;
21917 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21918 bool result;
21919 void *argp1 = 0 ;
21920 int res1 = 0 ;
21921 PyObject *swig_obj[1] ;
21922
21923 if (!args) SWIG_fail;
21924 swig_obj[0] = args;
21925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21926 if (!SWIG_IsOK(res1)) {
21927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21928 }
21929 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21930 {
21931 PyThreadState* __tstate = wxPyBeginAllowThreads();
21932 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
21933 wxPyEndAllowThreads(__tstate);
21934 if (PyErr_Occurred()) SWIG_fail;
21935 }
21936 {
21937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21938 }
21939 return resultobj;
21940 fail:
21941 return NULL;
21942 }
21943
21944
21945 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21946 PyObject *resultobj = 0;
21947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21948 bool result;
21949 void *argp1 = 0 ;
21950 int res1 = 0 ;
21951 PyObject *swig_obj[1] ;
21952
21953 if (!args) SWIG_fail;
21954 swig_obj[0] = args;
21955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21956 if (!SWIG_IsOK(res1)) {
21957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21958 }
21959 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21960 {
21961 PyThreadState* __tstate = wxPyBeginAllowThreads();
21962 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
21963 wxPyEndAllowThreads(__tstate);
21964 if (PyErr_Occurred()) SWIG_fail;
21965 }
21966 {
21967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21968 }
21969 return resultobj;
21970 fail:
21971 return NULL;
21972 }
21973
21974
21975 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21976 PyObject *resultobj = 0;
21977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
21978 bool result;
21979 void *argp1 = 0 ;
21980 int res1 = 0 ;
21981 PyObject *swig_obj[1] ;
21982
21983 if (!args) SWIG_fail;
21984 swig_obj[0] = args;
21985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
21986 if (!SWIG_IsOK(res1)) {
21987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
21988 }
21989 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
21990 {
21991 PyThreadState* __tstate = wxPyBeginAllowThreads();
21992 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
21993 wxPyEndAllowThreads(__tstate);
21994 if (PyErr_Occurred()) SWIG_fail;
21995 }
21996 {
21997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21998 }
21999 return resultobj;
22000 fail:
22001 return NULL;
22002 }
22003
22004
22005 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22006 PyObject *resultobj = 0;
22007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22008 bool result;
22009 void *argp1 = 0 ;
22010 int res1 = 0 ;
22011 PyObject *swig_obj[1] ;
22012
22013 if (!args) SWIG_fail;
22014 swig_obj[0] = args;
22015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22016 if (!SWIG_IsOK(res1)) {
22017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22018 }
22019 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22020 {
22021 PyThreadState* __tstate = wxPyBeginAllowThreads();
22022 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22023 wxPyEndAllowThreads(__tstate);
22024 if (PyErr_Occurred()) SWIG_fail;
22025 }
22026 {
22027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22028 }
22029 return resultobj;
22030 fail:
22031 return NULL;
22032 }
22033
22034
22035 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22036 PyObject *resultobj = 0;
22037 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22038 bool result;
22039 void *argp1 = 0 ;
22040 int res1 = 0 ;
22041 PyObject *swig_obj[1] ;
22042
22043 if (!args) SWIG_fail;
22044 swig_obj[0] = args;
22045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22046 if (!SWIG_IsOK(res1)) {
22047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22048 }
22049 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22050 {
22051 PyThreadState* __tstate = wxPyBeginAllowThreads();
22052 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22053 wxPyEndAllowThreads(__tstate);
22054 if (PyErr_Occurred()) SWIG_fail;
22055 }
22056 {
22057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22058 }
22059 return resultobj;
22060 fail:
22061 return NULL;
22062 }
22063
22064
22065 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22066 PyObject *resultobj = 0;
22067 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22068 bool result;
22069 void *argp1 = 0 ;
22070 int res1 = 0 ;
22071 PyObject *swig_obj[1] ;
22072
22073 if (!args) SWIG_fail;
22074 swig_obj[0] = args;
22075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22076 if (!SWIG_IsOK(res1)) {
22077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22078 }
22079 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22080 {
22081 PyThreadState* __tstate = wxPyBeginAllowThreads();
22082 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22083 wxPyEndAllowThreads(__tstate);
22084 if (PyErr_Occurred()) SWIG_fail;
22085 }
22086 {
22087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22088 }
22089 return resultobj;
22090 fail:
22091 return NULL;
22092 }
22093
22094
22095 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22096 PyObject *resultobj = 0;
22097 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22098 int result;
22099 void *argp1 = 0 ;
22100 int res1 = 0 ;
22101 PyObject *swig_obj[1] ;
22102
22103 if (!args) SWIG_fail;
22104 swig_obj[0] = args;
22105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22106 if (!SWIG_IsOK(res1)) {
22107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22108 }
22109 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22110 {
22111 PyThreadState* __tstate = wxPyBeginAllowThreads();
22112 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22113 wxPyEndAllowThreads(__tstate);
22114 if (PyErr_Occurred()) SWIG_fail;
22115 }
22116 resultobj = SWIG_From_int(static_cast< int >(result));
22117 return resultobj;
22118 fail:
22119 return NULL;
22120 }
22121
22122
22123 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22124 PyObject *resultobj = 0;
22125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22126 int result;
22127 void *argp1 = 0 ;
22128 int res1 = 0 ;
22129 PyObject *swig_obj[1] ;
22130
22131 if (!args) SWIG_fail;
22132 swig_obj[0] = args;
22133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22134 if (!SWIG_IsOK(res1)) {
22135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22136 }
22137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22141 wxPyEndAllowThreads(__tstate);
22142 if (PyErr_Occurred()) SWIG_fail;
22143 }
22144 resultobj = SWIG_From_int(static_cast< int >(result));
22145 return resultobj;
22146 fail:
22147 return NULL;
22148 }
22149
22150
22151 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22152 PyObject *resultobj = 0;
22153 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22154 unsigned int result;
22155 void *argp1 = 0 ;
22156 int res1 = 0 ;
22157 PyObject *swig_obj[1] ;
22158
22159 if (!args) SWIG_fail;
22160 swig_obj[0] = args;
22161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22162 if (!SWIG_IsOK(res1)) {
22163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22164 }
22165 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22166 {
22167 PyThreadState* __tstate = wxPyBeginAllowThreads();
22168 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22169 wxPyEndAllowThreads(__tstate);
22170 if (PyErr_Occurred()) SWIG_fail;
22171 }
22172 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22173 return resultobj;
22174 fail:
22175 return NULL;
22176 }
22177
22178
22179 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22180 PyObject *resultobj = 0;
22181 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22182 unsigned int result;
22183 void *argp1 = 0 ;
22184 int res1 = 0 ;
22185 PyObject *swig_obj[1] ;
22186
22187 if (!args) SWIG_fail;
22188 swig_obj[0] = args;
22189 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22190 if (!SWIG_IsOK(res1)) {
22191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22192 }
22193 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22194 {
22195 PyThreadState* __tstate = wxPyBeginAllowThreads();
22196 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22197 wxPyEndAllowThreads(__tstate);
22198 if (PyErr_Occurred()) SWIG_fail;
22199 }
22200 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22208 PyObject *resultobj = 0;
22209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22210 wxPoint result;
22211 void *argp1 = 0 ;
22212 int res1 = 0 ;
22213 PyObject *swig_obj[1] ;
22214
22215 if (!args) SWIG_fail;
22216 swig_obj[0] = args;
22217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22218 if (!SWIG_IsOK(res1)) {
22219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22220 }
22221 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (arg1)->GetPosition();
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22238 long *arg2 = (long *) 0 ;
22239 long *arg3 = (long *) 0 ;
22240 void *argp1 = 0 ;
22241 int res1 = 0 ;
22242 long temp2 ;
22243 int res2 = SWIG_TMPOBJ ;
22244 long temp3 ;
22245 int res3 = SWIG_TMPOBJ ;
22246 PyObject *swig_obj[1] ;
22247
22248 arg2 = &temp2;
22249 arg3 = &temp3;
22250 if (!args) SWIG_fail;
22251 swig_obj[0] = args;
22252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22253 if (!SWIG_IsOK(res1)) {
22254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22255 }
22256 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22257 {
22258 PyThreadState* __tstate = wxPyBeginAllowThreads();
22259 (arg1)->GetPosition(arg2,arg3);
22260 wxPyEndAllowThreads(__tstate);
22261 if (PyErr_Occurred()) SWIG_fail;
22262 }
22263 resultobj = SWIG_Py_Void();
22264 if (SWIG_IsTmpObj(res2)) {
22265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22266 } else {
22267 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22268 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22269 }
22270 if (SWIG_IsTmpObj(res3)) {
22271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22272 } else {
22273 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22275 }
22276 return resultobj;
22277 fail:
22278 return NULL;
22279 }
22280
22281
22282 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22283 PyObject *resultobj = 0;
22284 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22285 int result;
22286 void *argp1 = 0 ;
22287 int res1 = 0 ;
22288 PyObject *swig_obj[1] ;
22289
22290 if (!args) SWIG_fail;
22291 swig_obj[0] = args;
22292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22293 if (!SWIG_IsOK(res1)) {
22294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22295 }
22296 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22297 {
22298 PyThreadState* __tstate = wxPyBeginAllowThreads();
22299 result = (int)((wxKeyEvent const *)arg1)->GetX();
22300 wxPyEndAllowThreads(__tstate);
22301 if (PyErr_Occurred()) SWIG_fail;
22302 }
22303 resultobj = SWIG_From_int(static_cast< int >(result));
22304 return resultobj;
22305 fail:
22306 return NULL;
22307 }
22308
22309
22310 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22311 PyObject *resultobj = 0;
22312 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22313 int result;
22314 void *argp1 = 0 ;
22315 int res1 = 0 ;
22316 PyObject *swig_obj[1] ;
22317
22318 if (!args) SWIG_fail;
22319 swig_obj[0] = args;
22320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22321 if (!SWIG_IsOK(res1)) {
22322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22323 }
22324 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22325 {
22326 PyThreadState* __tstate = wxPyBeginAllowThreads();
22327 result = (int)((wxKeyEvent const *)arg1)->GetY();
22328 wxPyEndAllowThreads(__tstate);
22329 if (PyErr_Occurred()) SWIG_fail;
22330 }
22331 resultobj = SWIG_From_int(static_cast< int >(result));
22332 return resultobj;
22333 fail:
22334 return NULL;
22335 }
22336
22337
22338 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22339 PyObject *resultobj = 0;
22340 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22341 int arg2 ;
22342 void *argp1 = 0 ;
22343 int res1 = 0 ;
22344 int val2 ;
22345 int ecode2 = 0 ;
22346 PyObject *swig_obj[2] ;
22347
22348 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22350 if (!SWIG_IsOK(res1)) {
22351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22352 }
22353 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22354 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22355 if (!SWIG_IsOK(ecode2)) {
22356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22357 }
22358 arg2 = static_cast< int >(val2);
22359 if (arg1) (arg1)->m_x = arg2;
22360
22361 resultobj = SWIG_Py_Void();
22362 return resultobj;
22363 fail:
22364 return NULL;
22365 }
22366
22367
22368 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22369 PyObject *resultobj = 0;
22370 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22371 int result;
22372 void *argp1 = 0 ;
22373 int res1 = 0 ;
22374 PyObject *swig_obj[1] ;
22375
22376 if (!args) SWIG_fail;
22377 swig_obj[0] = args;
22378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22379 if (!SWIG_IsOK(res1)) {
22380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22381 }
22382 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22383 result = (int) ((arg1)->m_x);
22384 resultobj = SWIG_From_int(static_cast< int >(result));
22385 return resultobj;
22386 fail:
22387 return NULL;
22388 }
22389
22390
22391 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22392 PyObject *resultobj = 0;
22393 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22394 int arg2 ;
22395 void *argp1 = 0 ;
22396 int res1 = 0 ;
22397 int val2 ;
22398 int ecode2 = 0 ;
22399 PyObject *swig_obj[2] ;
22400
22401 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22403 if (!SWIG_IsOK(res1)) {
22404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22405 }
22406 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22407 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22408 if (!SWIG_IsOK(ecode2)) {
22409 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22410 }
22411 arg2 = static_cast< int >(val2);
22412 if (arg1) (arg1)->m_y = arg2;
22413
22414 resultobj = SWIG_Py_Void();
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22422 PyObject *resultobj = 0;
22423 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22424 int result;
22425 void *argp1 = 0 ;
22426 int res1 = 0 ;
22427 PyObject *swig_obj[1] ;
22428
22429 if (!args) SWIG_fail;
22430 swig_obj[0] = args;
22431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22432 if (!SWIG_IsOK(res1)) {
22433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22434 }
22435 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22436 result = (int) ((arg1)->m_y);
22437 resultobj = SWIG_From_int(static_cast< int >(result));
22438 return resultobj;
22439 fail:
22440 return NULL;
22441 }
22442
22443
22444 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22445 PyObject *resultobj = 0;
22446 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22447 long arg2 ;
22448 void *argp1 = 0 ;
22449 int res1 = 0 ;
22450 long val2 ;
22451 int ecode2 = 0 ;
22452 PyObject *swig_obj[2] ;
22453
22454 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22456 if (!SWIG_IsOK(res1)) {
22457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22458 }
22459 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22460 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22461 if (!SWIG_IsOK(ecode2)) {
22462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22463 }
22464 arg2 = static_cast< long >(val2);
22465 if (arg1) (arg1)->m_keyCode = arg2;
22466
22467 resultobj = SWIG_Py_Void();
22468 return resultobj;
22469 fail:
22470 return NULL;
22471 }
22472
22473
22474 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22475 PyObject *resultobj = 0;
22476 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22477 long result;
22478 void *argp1 = 0 ;
22479 int res1 = 0 ;
22480 PyObject *swig_obj[1] ;
22481
22482 if (!args) SWIG_fail;
22483 swig_obj[0] = args;
22484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22485 if (!SWIG_IsOK(res1)) {
22486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22487 }
22488 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22489 result = (long) ((arg1)->m_keyCode);
22490 resultobj = SWIG_From_long(static_cast< long >(result));
22491 return resultobj;
22492 fail:
22493 return NULL;
22494 }
22495
22496
22497 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22498 PyObject *resultobj = 0;
22499 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22500 bool arg2 ;
22501 void *argp1 = 0 ;
22502 int res1 = 0 ;
22503 bool val2 ;
22504 int ecode2 = 0 ;
22505 PyObject *swig_obj[2] ;
22506
22507 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22509 if (!SWIG_IsOK(res1)) {
22510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22511 }
22512 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22513 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22514 if (!SWIG_IsOK(ecode2)) {
22515 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22516 }
22517 arg2 = static_cast< bool >(val2);
22518 if (arg1) (arg1)->m_controlDown = arg2;
22519
22520 resultobj = SWIG_Py_Void();
22521 return resultobj;
22522 fail:
22523 return NULL;
22524 }
22525
22526
22527 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22528 PyObject *resultobj = 0;
22529 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22530 bool result;
22531 void *argp1 = 0 ;
22532 int res1 = 0 ;
22533 PyObject *swig_obj[1] ;
22534
22535 if (!args) SWIG_fail;
22536 swig_obj[0] = args;
22537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22538 if (!SWIG_IsOK(res1)) {
22539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22540 }
22541 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22542 result = (bool) ((arg1)->m_controlDown);
22543 {
22544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22545 }
22546 return resultobj;
22547 fail:
22548 return NULL;
22549 }
22550
22551
22552 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22553 PyObject *resultobj = 0;
22554 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22555 bool arg2 ;
22556 void *argp1 = 0 ;
22557 int res1 = 0 ;
22558 bool val2 ;
22559 int ecode2 = 0 ;
22560 PyObject *swig_obj[2] ;
22561
22562 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22564 if (!SWIG_IsOK(res1)) {
22565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22566 }
22567 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22568 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22569 if (!SWIG_IsOK(ecode2)) {
22570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22571 }
22572 arg2 = static_cast< bool >(val2);
22573 if (arg1) (arg1)->m_shiftDown = arg2;
22574
22575 resultobj = SWIG_Py_Void();
22576 return resultobj;
22577 fail:
22578 return NULL;
22579 }
22580
22581
22582 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22583 PyObject *resultobj = 0;
22584 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22585 bool result;
22586 void *argp1 = 0 ;
22587 int res1 = 0 ;
22588 PyObject *swig_obj[1] ;
22589
22590 if (!args) SWIG_fail;
22591 swig_obj[0] = args;
22592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22593 if (!SWIG_IsOK(res1)) {
22594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22595 }
22596 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22597 result = (bool) ((arg1)->m_shiftDown);
22598 {
22599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22600 }
22601 return resultobj;
22602 fail:
22603 return NULL;
22604 }
22605
22606
22607 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22608 PyObject *resultobj = 0;
22609 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22610 bool arg2 ;
22611 void *argp1 = 0 ;
22612 int res1 = 0 ;
22613 bool val2 ;
22614 int ecode2 = 0 ;
22615 PyObject *swig_obj[2] ;
22616
22617 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22619 if (!SWIG_IsOK(res1)) {
22620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22621 }
22622 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22623 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22624 if (!SWIG_IsOK(ecode2)) {
22625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22626 }
22627 arg2 = static_cast< bool >(val2);
22628 if (arg1) (arg1)->m_altDown = arg2;
22629
22630 resultobj = SWIG_Py_Void();
22631 return resultobj;
22632 fail:
22633 return NULL;
22634 }
22635
22636
22637 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22638 PyObject *resultobj = 0;
22639 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22640 bool result;
22641 void *argp1 = 0 ;
22642 int res1 = 0 ;
22643 PyObject *swig_obj[1] ;
22644
22645 if (!args) SWIG_fail;
22646 swig_obj[0] = args;
22647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22648 if (!SWIG_IsOK(res1)) {
22649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22650 }
22651 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22652 result = (bool) ((arg1)->m_altDown);
22653 {
22654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22655 }
22656 return resultobj;
22657 fail:
22658 return NULL;
22659 }
22660
22661
22662 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22663 PyObject *resultobj = 0;
22664 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22665 bool arg2 ;
22666 void *argp1 = 0 ;
22667 int res1 = 0 ;
22668 bool val2 ;
22669 int ecode2 = 0 ;
22670 PyObject *swig_obj[2] ;
22671
22672 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22674 if (!SWIG_IsOK(res1)) {
22675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22676 }
22677 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22678 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22679 if (!SWIG_IsOK(ecode2)) {
22680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22681 }
22682 arg2 = static_cast< bool >(val2);
22683 if (arg1) (arg1)->m_metaDown = arg2;
22684
22685 resultobj = SWIG_Py_Void();
22686 return resultobj;
22687 fail:
22688 return NULL;
22689 }
22690
22691
22692 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22693 PyObject *resultobj = 0;
22694 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22695 bool result;
22696 void *argp1 = 0 ;
22697 int res1 = 0 ;
22698 PyObject *swig_obj[1] ;
22699
22700 if (!args) SWIG_fail;
22701 swig_obj[0] = args;
22702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22703 if (!SWIG_IsOK(res1)) {
22704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22705 }
22706 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22707 result = (bool) ((arg1)->m_metaDown);
22708 {
22709 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22710 }
22711 return resultobj;
22712 fail:
22713 return NULL;
22714 }
22715
22716
22717 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22718 PyObject *resultobj = 0;
22719 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22720 bool arg2 ;
22721 void *argp1 = 0 ;
22722 int res1 = 0 ;
22723 bool val2 ;
22724 int ecode2 = 0 ;
22725 PyObject *swig_obj[2] ;
22726
22727 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22729 if (!SWIG_IsOK(res1)) {
22730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22731 }
22732 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22733 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22734 if (!SWIG_IsOK(ecode2)) {
22735 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22736 }
22737 arg2 = static_cast< bool >(val2);
22738 if (arg1) (arg1)->m_scanCode = arg2;
22739
22740 resultobj = SWIG_Py_Void();
22741 return resultobj;
22742 fail:
22743 return NULL;
22744 }
22745
22746
22747 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22748 PyObject *resultobj = 0;
22749 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22750 bool result;
22751 void *argp1 = 0 ;
22752 int res1 = 0 ;
22753 PyObject *swig_obj[1] ;
22754
22755 if (!args) SWIG_fail;
22756 swig_obj[0] = args;
22757 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22758 if (!SWIG_IsOK(res1)) {
22759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22760 }
22761 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22762 result = (bool) ((arg1)->m_scanCode);
22763 {
22764 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22765 }
22766 return resultobj;
22767 fail:
22768 return NULL;
22769 }
22770
22771
22772 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22773 PyObject *resultobj = 0;
22774 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22775 unsigned int arg2 ;
22776 void *argp1 = 0 ;
22777 int res1 = 0 ;
22778 unsigned int val2 ;
22779 int ecode2 = 0 ;
22780 PyObject *swig_obj[2] ;
22781
22782 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22784 if (!SWIG_IsOK(res1)) {
22785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22786 }
22787 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22788 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22789 if (!SWIG_IsOK(ecode2)) {
22790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22791 }
22792 arg2 = static_cast< unsigned int >(val2);
22793 if (arg1) (arg1)->m_rawCode = arg2;
22794
22795 resultobj = SWIG_Py_Void();
22796 return resultobj;
22797 fail:
22798 return NULL;
22799 }
22800
22801
22802 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22803 PyObject *resultobj = 0;
22804 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22805 unsigned int result;
22806 void *argp1 = 0 ;
22807 int res1 = 0 ;
22808 PyObject *swig_obj[1] ;
22809
22810 if (!args) SWIG_fail;
22811 swig_obj[0] = args;
22812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22813 if (!SWIG_IsOK(res1)) {
22814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22815 }
22816 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22817 result = (unsigned int) ((arg1)->m_rawCode);
22818 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22819 return resultobj;
22820 fail:
22821 return NULL;
22822 }
22823
22824
22825 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22826 PyObject *resultobj = 0;
22827 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22828 unsigned int arg2 ;
22829 void *argp1 = 0 ;
22830 int res1 = 0 ;
22831 unsigned int val2 ;
22832 int ecode2 = 0 ;
22833 PyObject *swig_obj[2] ;
22834
22835 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22837 if (!SWIG_IsOK(res1)) {
22838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22839 }
22840 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22841 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22842 if (!SWIG_IsOK(ecode2)) {
22843 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22844 }
22845 arg2 = static_cast< unsigned int >(val2);
22846 if (arg1) (arg1)->m_rawFlags = arg2;
22847
22848 resultobj = SWIG_Py_Void();
22849 return resultobj;
22850 fail:
22851 return NULL;
22852 }
22853
22854
22855 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22856 PyObject *resultobj = 0;
22857 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22858 unsigned int result;
22859 void *argp1 = 0 ;
22860 int res1 = 0 ;
22861 PyObject *swig_obj[1] ;
22862
22863 if (!args) SWIG_fail;
22864 swig_obj[0] = args;
22865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22866 if (!SWIG_IsOK(res1)) {
22867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22868 }
22869 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22870 result = (unsigned int) ((arg1)->m_rawFlags);
22871 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22872 return resultobj;
22873 fail:
22874 return NULL;
22875 }
22876
22877
22878 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22879 PyObject *obj;
22880 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22881 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
22882 return SWIG_Py_Void();
22883 }
22884
22885 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22886 return SWIG_Python_InitShadowInstance(args);
22887 }
22888
22889 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22890 PyObject *resultobj = 0;
22891 wxSize const &arg1_defvalue = wxDefaultSize ;
22892 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
22893 int arg2 = (int) 0 ;
22894 wxSizeEvent *result = 0 ;
22895 wxSize temp1 ;
22896 int val2 ;
22897 int ecode2 = 0 ;
22898 PyObject * obj0 = 0 ;
22899 PyObject * obj1 = 0 ;
22900 char * kwnames[] = {
22901 (char *) "sz",(char *) "winid", NULL
22902 };
22903
22904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22905 if (obj0) {
22906 {
22907 arg1 = &temp1;
22908 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
22909 }
22910 }
22911 if (obj1) {
22912 ecode2 = SWIG_AsVal_int(obj1, &val2);
22913 if (!SWIG_IsOK(ecode2)) {
22914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
22915 }
22916 arg2 = static_cast< int >(val2);
22917 }
22918 {
22919 PyThreadState* __tstate = wxPyBeginAllowThreads();
22920 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
22921 wxPyEndAllowThreads(__tstate);
22922 if (PyErr_Occurred()) SWIG_fail;
22923 }
22924 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
22925 return resultobj;
22926 fail:
22927 return NULL;
22928 }
22929
22930
22931 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22932 PyObject *resultobj = 0;
22933 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22934 wxSize result;
22935 void *argp1 = 0 ;
22936 int res1 = 0 ;
22937 PyObject *swig_obj[1] ;
22938
22939 if (!args) SWIG_fail;
22940 swig_obj[0] = args;
22941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22942 if (!SWIG_IsOK(res1)) {
22943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22944 }
22945 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22946 {
22947 PyThreadState* __tstate = wxPyBeginAllowThreads();
22948 result = ((wxSizeEvent const *)arg1)->GetSize();
22949 wxPyEndAllowThreads(__tstate);
22950 if (PyErr_Occurred()) SWIG_fail;
22951 }
22952 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
22953 return resultobj;
22954 fail:
22955 return NULL;
22956 }
22957
22958
22959 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22960 PyObject *resultobj = 0;
22961 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22962 wxRect result;
22963 void *argp1 = 0 ;
22964 int res1 = 0 ;
22965 PyObject *swig_obj[1] ;
22966
22967 if (!args) SWIG_fail;
22968 swig_obj[0] = args;
22969 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
22970 if (!SWIG_IsOK(res1)) {
22971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
22972 }
22973 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
22974 {
22975 PyThreadState* __tstate = wxPyBeginAllowThreads();
22976 result = ((wxSizeEvent const *)arg1)->GetRect();
22977 wxPyEndAllowThreads(__tstate);
22978 if (PyErr_Occurred()) SWIG_fail;
22979 }
22980 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
22981 return resultobj;
22982 fail:
22983 return NULL;
22984 }
22985
22986
22987 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22988 PyObject *resultobj = 0;
22989 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
22990 wxRect arg2 ;
22991 void *argp1 = 0 ;
22992 int res1 = 0 ;
22993 void *argp2 ;
22994 int res2 = 0 ;
22995 PyObject * obj0 = 0 ;
22996 PyObject * obj1 = 0 ;
22997 char * kwnames[] = {
22998 (char *) "self",(char *) "rect", NULL
22999 };
23000
23001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23003 if (!SWIG_IsOK(res1)) {
23004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23005 }
23006 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23007 {
23008 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23009 if (!SWIG_IsOK(res2)) {
23010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23011 }
23012 if (!argp2) {
23013 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23014 } else {
23015 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23016 arg2 = *temp;
23017 if (SWIG_IsNewObj(res2)) delete temp;
23018 }
23019 }
23020 {
23021 PyThreadState* __tstate = wxPyBeginAllowThreads();
23022 (arg1)->SetRect(arg2);
23023 wxPyEndAllowThreads(__tstate);
23024 if (PyErr_Occurred()) SWIG_fail;
23025 }
23026 resultobj = SWIG_Py_Void();
23027 return resultobj;
23028 fail:
23029 return NULL;
23030 }
23031
23032
23033 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23034 PyObject *resultobj = 0;
23035 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23036 wxSize arg2 ;
23037 void *argp1 = 0 ;
23038 int res1 = 0 ;
23039 void *argp2 ;
23040 int res2 = 0 ;
23041 PyObject * obj0 = 0 ;
23042 PyObject * obj1 = 0 ;
23043 char * kwnames[] = {
23044 (char *) "self",(char *) "size", NULL
23045 };
23046
23047 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23048 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23049 if (!SWIG_IsOK(res1)) {
23050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23051 }
23052 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23053 {
23054 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23055 if (!SWIG_IsOK(res2)) {
23056 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23057 }
23058 if (!argp2) {
23059 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23060 } else {
23061 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23062 arg2 = *temp;
23063 if (SWIG_IsNewObj(res2)) delete temp;
23064 }
23065 }
23066 {
23067 PyThreadState* __tstate = wxPyBeginAllowThreads();
23068 wxSizeEvent_SetSize(arg1,arg2);
23069 wxPyEndAllowThreads(__tstate);
23070 if (PyErr_Occurred()) SWIG_fail;
23071 }
23072 resultobj = SWIG_Py_Void();
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *resultobj = 0;
23081 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23082 wxSize *arg2 = (wxSize *) 0 ;
23083 void *argp1 = 0 ;
23084 int res1 = 0 ;
23085 void *argp2 = 0 ;
23086 int res2 = 0 ;
23087 PyObject *swig_obj[2] ;
23088
23089 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23091 if (!SWIG_IsOK(res1)) {
23092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23093 }
23094 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23095 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23096 if (!SWIG_IsOK(res2)) {
23097 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23098 }
23099 arg2 = reinterpret_cast< wxSize * >(argp2);
23100 if (arg1) (arg1)->m_size = *arg2;
23101
23102 resultobj = SWIG_Py_Void();
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 PyObject *resultobj = 0;
23111 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23112 wxSize *result = 0 ;
23113 void *argp1 = 0 ;
23114 int res1 = 0 ;
23115 PyObject *swig_obj[1] ;
23116
23117 if (!args) SWIG_fail;
23118 swig_obj[0] = args;
23119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23122 }
23123 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23124 result = (wxSize *)& ((arg1)->m_size);
23125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23126 return resultobj;
23127 fail:
23128 return NULL;
23129 }
23130
23131
23132 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23133 PyObject *resultobj = 0;
23134 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23135 wxRect *arg2 = (wxRect *) 0 ;
23136 void *argp1 = 0 ;
23137 int res1 = 0 ;
23138 void *argp2 = 0 ;
23139 int res2 = 0 ;
23140 PyObject *swig_obj[2] ;
23141
23142 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23144 if (!SWIG_IsOK(res1)) {
23145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23146 }
23147 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23148 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23149 if (!SWIG_IsOK(res2)) {
23150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23151 }
23152 arg2 = reinterpret_cast< wxRect * >(argp2);
23153 if (arg1) (arg1)->m_rect = *arg2;
23154
23155 resultobj = SWIG_Py_Void();
23156 return resultobj;
23157 fail:
23158 return NULL;
23159 }
23160
23161
23162 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23163 PyObject *resultobj = 0;
23164 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23165 wxRect *result = 0 ;
23166 void *argp1 = 0 ;
23167 int res1 = 0 ;
23168 PyObject *swig_obj[1] ;
23169
23170 if (!args) SWIG_fail;
23171 swig_obj[0] = args;
23172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23173 if (!SWIG_IsOK(res1)) {
23174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23175 }
23176 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23177 result = (wxRect *)& ((arg1)->m_rect);
23178 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23179 return resultobj;
23180 fail:
23181 return NULL;
23182 }
23183
23184
23185 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23186 PyObject *obj;
23187 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23188 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23189 return SWIG_Py_Void();
23190 }
23191
23192 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23193 return SWIG_Python_InitShadowInstance(args);
23194 }
23195
23196 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23197 PyObject *resultobj = 0;
23198 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23199 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23200 int arg2 = (int) 0 ;
23201 wxMoveEvent *result = 0 ;
23202 wxPoint temp1 ;
23203 int val2 ;
23204 int ecode2 = 0 ;
23205 PyObject * obj0 = 0 ;
23206 PyObject * obj1 = 0 ;
23207 char * kwnames[] = {
23208 (char *) "pos",(char *) "winid", NULL
23209 };
23210
23211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23212 if (obj0) {
23213 {
23214 arg1 = &temp1;
23215 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23216 }
23217 }
23218 if (obj1) {
23219 ecode2 = SWIG_AsVal_int(obj1, &val2);
23220 if (!SWIG_IsOK(ecode2)) {
23221 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23222 }
23223 arg2 = static_cast< int >(val2);
23224 }
23225 {
23226 PyThreadState* __tstate = wxPyBeginAllowThreads();
23227 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23228 wxPyEndAllowThreads(__tstate);
23229 if (PyErr_Occurred()) SWIG_fail;
23230 }
23231 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23232 return resultobj;
23233 fail:
23234 return NULL;
23235 }
23236
23237
23238 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23239 PyObject *resultobj = 0;
23240 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23241 wxPoint result;
23242 void *argp1 = 0 ;
23243 int res1 = 0 ;
23244 PyObject *swig_obj[1] ;
23245
23246 if (!args) SWIG_fail;
23247 swig_obj[0] = args;
23248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23249 if (!SWIG_IsOK(res1)) {
23250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23251 }
23252 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23253 {
23254 PyThreadState* __tstate = wxPyBeginAllowThreads();
23255 result = ((wxMoveEvent const *)arg1)->GetPosition();
23256 wxPyEndAllowThreads(__tstate);
23257 if (PyErr_Occurred()) SWIG_fail;
23258 }
23259 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23260 return resultobj;
23261 fail:
23262 return NULL;
23263 }
23264
23265
23266 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23267 PyObject *resultobj = 0;
23268 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23269 wxRect result;
23270 void *argp1 = 0 ;
23271 int res1 = 0 ;
23272 PyObject *swig_obj[1] ;
23273
23274 if (!args) SWIG_fail;
23275 swig_obj[0] = args;
23276 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23277 if (!SWIG_IsOK(res1)) {
23278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23279 }
23280 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23281 {
23282 PyThreadState* __tstate = wxPyBeginAllowThreads();
23283 result = ((wxMoveEvent const *)arg1)->GetRect();
23284 wxPyEndAllowThreads(__tstate);
23285 if (PyErr_Occurred()) SWIG_fail;
23286 }
23287 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23288 return resultobj;
23289 fail:
23290 return NULL;
23291 }
23292
23293
23294 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23295 PyObject *resultobj = 0;
23296 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23297 wxRect *arg2 = 0 ;
23298 void *argp1 = 0 ;
23299 int res1 = 0 ;
23300 wxRect temp2 ;
23301 PyObject * obj0 = 0 ;
23302 PyObject * obj1 = 0 ;
23303 char * kwnames[] = {
23304 (char *) "self",(char *) "rect", NULL
23305 };
23306
23307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23309 if (!SWIG_IsOK(res1)) {
23310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23311 }
23312 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23313 {
23314 arg2 = &temp2;
23315 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23316 }
23317 {
23318 PyThreadState* __tstate = wxPyBeginAllowThreads();
23319 (arg1)->SetRect((wxRect const &)*arg2);
23320 wxPyEndAllowThreads(__tstate);
23321 if (PyErr_Occurred()) SWIG_fail;
23322 }
23323 resultobj = SWIG_Py_Void();
23324 return resultobj;
23325 fail:
23326 return NULL;
23327 }
23328
23329
23330 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23331 PyObject *resultobj = 0;
23332 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23333 wxPoint *arg2 = 0 ;
23334 void *argp1 = 0 ;
23335 int res1 = 0 ;
23336 wxPoint temp2 ;
23337 PyObject * obj0 = 0 ;
23338 PyObject * obj1 = 0 ;
23339 char * kwnames[] = {
23340 (char *) "self",(char *) "pos", NULL
23341 };
23342
23343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23345 if (!SWIG_IsOK(res1)) {
23346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23347 }
23348 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23349 {
23350 arg2 = &temp2;
23351 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23352 }
23353 {
23354 PyThreadState* __tstate = wxPyBeginAllowThreads();
23355 (arg1)->SetPosition((wxPoint const &)*arg2);
23356 wxPyEndAllowThreads(__tstate);
23357 if (PyErr_Occurred()) SWIG_fail;
23358 }
23359 resultobj = SWIG_Py_Void();
23360 return resultobj;
23361 fail:
23362 return NULL;
23363 }
23364
23365
23366 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23367 PyObject *obj;
23368 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23369 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23370 return SWIG_Py_Void();
23371 }
23372
23373 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23374 return SWIG_Python_InitShadowInstance(args);
23375 }
23376
23377 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23378 PyObject *resultobj = 0;
23379 int arg1 = (int) 0 ;
23380 wxPaintEvent *result = 0 ;
23381 int val1 ;
23382 int ecode1 = 0 ;
23383 PyObject * obj0 = 0 ;
23384 char * kwnames[] = {
23385 (char *) "Id", NULL
23386 };
23387
23388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23389 if (obj0) {
23390 ecode1 = SWIG_AsVal_int(obj0, &val1);
23391 if (!SWIG_IsOK(ecode1)) {
23392 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23393 }
23394 arg1 = static_cast< int >(val1);
23395 }
23396 {
23397 PyThreadState* __tstate = wxPyBeginAllowThreads();
23398 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23399 wxPyEndAllowThreads(__tstate);
23400 if (PyErr_Occurred()) SWIG_fail;
23401 }
23402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23403 return resultobj;
23404 fail:
23405 return NULL;
23406 }
23407
23408
23409 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23410 PyObject *obj;
23411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23412 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23413 return SWIG_Py_Void();
23414 }
23415
23416 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23417 return SWIG_Python_InitShadowInstance(args);
23418 }
23419
23420 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23421 PyObject *resultobj = 0;
23422 int arg1 = (int) 0 ;
23423 wxNcPaintEvent *result = 0 ;
23424 int val1 ;
23425 int ecode1 = 0 ;
23426 PyObject * obj0 = 0 ;
23427 char * kwnames[] = {
23428 (char *) "winid", NULL
23429 };
23430
23431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23432 if (obj0) {
23433 ecode1 = SWIG_AsVal_int(obj0, &val1);
23434 if (!SWIG_IsOK(ecode1)) {
23435 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23436 }
23437 arg1 = static_cast< int >(val1);
23438 }
23439 {
23440 PyThreadState* __tstate = wxPyBeginAllowThreads();
23441 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23446 return resultobj;
23447 fail:
23448 return NULL;
23449 }
23450
23451
23452 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23453 PyObject *obj;
23454 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23455 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23456 return SWIG_Py_Void();
23457 }
23458
23459 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23460 return SWIG_Python_InitShadowInstance(args);
23461 }
23462
23463 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23464 PyObject *resultobj = 0;
23465 int arg1 = (int) 0 ;
23466 wxDC *arg2 = (wxDC *) NULL ;
23467 wxEraseEvent *result = 0 ;
23468 int val1 ;
23469 int ecode1 = 0 ;
23470 void *argp2 = 0 ;
23471 int res2 = 0 ;
23472 PyObject * obj0 = 0 ;
23473 PyObject * obj1 = 0 ;
23474 char * kwnames[] = {
23475 (char *) "Id",(char *) "dc", NULL
23476 };
23477
23478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23479 if (obj0) {
23480 ecode1 = SWIG_AsVal_int(obj0, &val1);
23481 if (!SWIG_IsOK(ecode1)) {
23482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23483 }
23484 arg1 = static_cast< int >(val1);
23485 }
23486 if (obj1) {
23487 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23488 if (!SWIG_IsOK(res2)) {
23489 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23490 }
23491 arg2 = reinterpret_cast< wxDC * >(argp2);
23492 }
23493 {
23494 PyThreadState* __tstate = wxPyBeginAllowThreads();
23495 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23496 wxPyEndAllowThreads(__tstate);
23497 if (PyErr_Occurred()) SWIG_fail;
23498 }
23499 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23500 return resultobj;
23501 fail:
23502 return NULL;
23503 }
23504
23505
23506 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23507 PyObject *resultobj = 0;
23508 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23509 wxDC *result = 0 ;
23510 void *argp1 = 0 ;
23511 int res1 = 0 ;
23512 PyObject *swig_obj[1] ;
23513
23514 if (!args) SWIG_fail;
23515 swig_obj[0] = args;
23516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23517 if (!SWIG_IsOK(res1)) {
23518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23519 }
23520 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23521 {
23522 PyThreadState* __tstate = wxPyBeginAllowThreads();
23523 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23524 wxPyEndAllowThreads(__tstate);
23525 if (PyErr_Occurred()) SWIG_fail;
23526 }
23527 {
23528 resultobj = wxPyMake_wxObject(result, (bool)0);
23529 }
23530 return resultobj;
23531 fail:
23532 return NULL;
23533 }
23534
23535
23536 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23537 PyObject *obj;
23538 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23539 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23540 return SWIG_Py_Void();
23541 }
23542
23543 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23544 return SWIG_Python_InitShadowInstance(args);
23545 }
23546
23547 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23548 PyObject *resultobj = 0;
23549 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23550 int arg2 = (int) 0 ;
23551 wxFocusEvent *result = 0 ;
23552 int val1 ;
23553 int ecode1 = 0 ;
23554 int val2 ;
23555 int ecode2 = 0 ;
23556 PyObject * obj0 = 0 ;
23557 PyObject * obj1 = 0 ;
23558 char * kwnames[] = {
23559 (char *) "type",(char *) "winid", NULL
23560 };
23561
23562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23563 if (obj0) {
23564 ecode1 = SWIG_AsVal_int(obj0, &val1);
23565 if (!SWIG_IsOK(ecode1)) {
23566 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23567 }
23568 arg1 = static_cast< wxEventType >(val1);
23569 }
23570 if (obj1) {
23571 ecode2 = SWIG_AsVal_int(obj1, &val2);
23572 if (!SWIG_IsOK(ecode2)) {
23573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23574 }
23575 arg2 = static_cast< int >(val2);
23576 }
23577 {
23578 PyThreadState* __tstate = wxPyBeginAllowThreads();
23579 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23580 wxPyEndAllowThreads(__tstate);
23581 if (PyErr_Occurred()) SWIG_fail;
23582 }
23583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23584 return resultobj;
23585 fail:
23586 return NULL;
23587 }
23588
23589
23590 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23591 PyObject *resultobj = 0;
23592 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23593 wxWindow *result = 0 ;
23594 void *argp1 = 0 ;
23595 int res1 = 0 ;
23596 PyObject *swig_obj[1] ;
23597
23598 if (!args) SWIG_fail;
23599 swig_obj[0] = args;
23600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23601 if (!SWIG_IsOK(res1)) {
23602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23603 }
23604 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23605 {
23606 PyThreadState* __tstate = wxPyBeginAllowThreads();
23607 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23608 wxPyEndAllowThreads(__tstate);
23609 if (PyErr_Occurred()) SWIG_fail;
23610 }
23611 {
23612 resultobj = wxPyMake_wxObject(result, (bool)0);
23613 }
23614 return resultobj;
23615 fail:
23616 return NULL;
23617 }
23618
23619
23620 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23621 PyObject *resultobj = 0;
23622 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23623 wxWindow *arg2 = (wxWindow *) 0 ;
23624 void *argp1 = 0 ;
23625 int res1 = 0 ;
23626 void *argp2 = 0 ;
23627 int res2 = 0 ;
23628 PyObject * obj0 = 0 ;
23629 PyObject * obj1 = 0 ;
23630 char * kwnames[] = {
23631 (char *) "self",(char *) "win", NULL
23632 };
23633
23634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23636 if (!SWIG_IsOK(res1)) {
23637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23638 }
23639 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23640 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23641 if (!SWIG_IsOK(res2)) {
23642 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23643 }
23644 arg2 = reinterpret_cast< wxWindow * >(argp2);
23645 {
23646 PyThreadState* __tstate = wxPyBeginAllowThreads();
23647 (arg1)->SetWindow(arg2);
23648 wxPyEndAllowThreads(__tstate);
23649 if (PyErr_Occurred()) SWIG_fail;
23650 }
23651 resultobj = SWIG_Py_Void();
23652 return resultobj;
23653 fail:
23654 return NULL;
23655 }
23656
23657
23658 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23659 PyObject *obj;
23660 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23661 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23662 return SWIG_Py_Void();
23663 }
23664
23665 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23666 return SWIG_Python_InitShadowInstance(args);
23667 }
23668
23669 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23670 PyObject *resultobj = 0;
23671 wxWindow *arg1 = (wxWindow *) NULL ;
23672 wxChildFocusEvent *result = 0 ;
23673 void *argp1 = 0 ;
23674 int res1 = 0 ;
23675 PyObject * obj0 = 0 ;
23676 char * kwnames[] = {
23677 (char *) "win", NULL
23678 };
23679
23680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23681 if (obj0) {
23682 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23683 if (!SWIG_IsOK(res1)) {
23684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23685 }
23686 arg1 = reinterpret_cast< wxWindow * >(argp1);
23687 }
23688 {
23689 PyThreadState* __tstate = wxPyBeginAllowThreads();
23690 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23691 wxPyEndAllowThreads(__tstate);
23692 if (PyErr_Occurred()) SWIG_fail;
23693 }
23694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23695 return resultobj;
23696 fail:
23697 return NULL;
23698 }
23699
23700
23701 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23702 PyObject *resultobj = 0;
23703 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23704 wxWindow *result = 0 ;
23705 void *argp1 = 0 ;
23706 int res1 = 0 ;
23707 PyObject *swig_obj[1] ;
23708
23709 if (!args) SWIG_fail;
23710 swig_obj[0] = args;
23711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23712 if (!SWIG_IsOK(res1)) {
23713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23714 }
23715 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23716 {
23717 PyThreadState* __tstate = wxPyBeginAllowThreads();
23718 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23719 wxPyEndAllowThreads(__tstate);
23720 if (PyErr_Occurred()) SWIG_fail;
23721 }
23722 {
23723 resultobj = wxPyMake_wxObject(result, (bool)0);
23724 }
23725 return resultobj;
23726 fail:
23727 return NULL;
23728 }
23729
23730
23731 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23732 PyObject *obj;
23733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23734 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23735 return SWIG_Py_Void();
23736 }
23737
23738 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23739 return SWIG_Python_InitShadowInstance(args);
23740 }
23741
23742 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23743 PyObject *resultobj = 0;
23744 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23745 bool arg2 = (bool) true ;
23746 int arg3 = (int) 0 ;
23747 wxActivateEvent *result = 0 ;
23748 int val1 ;
23749 int ecode1 = 0 ;
23750 bool val2 ;
23751 int ecode2 = 0 ;
23752 int val3 ;
23753 int ecode3 = 0 ;
23754 PyObject * obj0 = 0 ;
23755 PyObject * obj1 = 0 ;
23756 PyObject * obj2 = 0 ;
23757 char * kwnames[] = {
23758 (char *) "type",(char *) "active",(char *) "Id", NULL
23759 };
23760
23761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23762 if (obj0) {
23763 ecode1 = SWIG_AsVal_int(obj0, &val1);
23764 if (!SWIG_IsOK(ecode1)) {
23765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23766 }
23767 arg1 = static_cast< wxEventType >(val1);
23768 }
23769 if (obj1) {
23770 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23771 if (!SWIG_IsOK(ecode2)) {
23772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23773 }
23774 arg2 = static_cast< bool >(val2);
23775 }
23776 if (obj2) {
23777 ecode3 = SWIG_AsVal_int(obj2, &val3);
23778 if (!SWIG_IsOK(ecode3)) {
23779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23780 }
23781 arg3 = static_cast< int >(val3);
23782 }
23783 {
23784 PyThreadState* __tstate = wxPyBeginAllowThreads();
23785 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23786 wxPyEndAllowThreads(__tstate);
23787 if (PyErr_Occurred()) SWIG_fail;
23788 }
23789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23790 return resultobj;
23791 fail:
23792 return NULL;
23793 }
23794
23795
23796 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23797 PyObject *resultobj = 0;
23798 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23799 bool result;
23800 void *argp1 = 0 ;
23801 int res1 = 0 ;
23802 PyObject *swig_obj[1] ;
23803
23804 if (!args) SWIG_fail;
23805 swig_obj[0] = args;
23806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23807 if (!SWIG_IsOK(res1)) {
23808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23809 }
23810 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23811 {
23812 PyThreadState* __tstate = wxPyBeginAllowThreads();
23813 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23814 wxPyEndAllowThreads(__tstate);
23815 if (PyErr_Occurred()) SWIG_fail;
23816 }
23817 {
23818 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23819 }
23820 return resultobj;
23821 fail:
23822 return NULL;
23823 }
23824
23825
23826 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23827 PyObject *obj;
23828 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23829 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23830 return SWIG_Py_Void();
23831 }
23832
23833 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23834 return SWIG_Python_InitShadowInstance(args);
23835 }
23836
23837 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23838 PyObject *resultobj = 0;
23839 int arg1 = (int) 0 ;
23840 wxInitDialogEvent *result = 0 ;
23841 int val1 ;
23842 int ecode1 = 0 ;
23843 PyObject * obj0 = 0 ;
23844 char * kwnames[] = {
23845 (char *) "Id", NULL
23846 };
23847
23848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23849 if (obj0) {
23850 ecode1 = SWIG_AsVal_int(obj0, &val1);
23851 if (!SWIG_IsOK(ecode1)) {
23852 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
23853 }
23854 arg1 = static_cast< int >(val1);
23855 }
23856 {
23857 PyThreadState* __tstate = wxPyBeginAllowThreads();
23858 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
23859 wxPyEndAllowThreads(__tstate);
23860 if (PyErr_Occurred()) SWIG_fail;
23861 }
23862 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
23863 return resultobj;
23864 fail:
23865 return NULL;
23866 }
23867
23868
23869 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23870 PyObject *obj;
23871 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23872 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
23873 return SWIG_Py_Void();
23874 }
23875
23876 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23877 return SWIG_Python_InitShadowInstance(args);
23878 }
23879
23880 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23881 PyObject *resultobj = 0;
23882 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23883 int arg2 = (int) 0 ;
23884 wxMenu *arg3 = (wxMenu *) NULL ;
23885 wxMenuEvent *result = 0 ;
23886 int val1 ;
23887 int ecode1 = 0 ;
23888 int val2 ;
23889 int ecode2 = 0 ;
23890 void *argp3 = 0 ;
23891 int res3 = 0 ;
23892 PyObject * obj0 = 0 ;
23893 PyObject * obj1 = 0 ;
23894 PyObject * obj2 = 0 ;
23895 char * kwnames[] = {
23896 (char *) "type",(char *) "winid",(char *) "menu", NULL
23897 };
23898
23899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23900 if (obj0) {
23901 ecode1 = SWIG_AsVal_int(obj0, &val1);
23902 if (!SWIG_IsOK(ecode1)) {
23903 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23904 }
23905 arg1 = static_cast< wxEventType >(val1);
23906 }
23907 if (obj1) {
23908 ecode2 = SWIG_AsVal_int(obj1, &val2);
23909 if (!SWIG_IsOK(ecode2)) {
23910 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
23911 }
23912 arg2 = static_cast< int >(val2);
23913 }
23914 if (obj2) {
23915 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
23916 if (!SWIG_IsOK(res3)) {
23917 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
23918 }
23919 arg3 = reinterpret_cast< wxMenu * >(argp3);
23920 }
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
23924 wxPyEndAllowThreads(__tstate);
23925 if (PyErr_Occurred()) SWIG_fail;
23926 }
23927 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23935 PyObject *resultobj = 0;
23936 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23937 int result;
23938 void *argp1 = 0 ;
23939 int res1 = 0 ;
23940 PyObject *swig_obj[1] ;
23941
23942 if (!args) SWIG_fail;
23943 swig_obj[0] = args;
23944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23945 if (!SWIG_IsOK(res1)) {
23946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23947 }
23948 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23949 {
23950 PyThreadState* __tstate = wxPyBeginAllowThreads();
23951 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
23952 wxPyEndAllowThreads(__tstate);
23953 if (PyErr_Occurred()) SWIG_fail;
23954 }
23955 resultobj = SWIG_From_int(static_cast< int >(result));
23956 return resultobj;
23957 fail:
23958 return NULL;
23959 }
23960
23961
23962 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23963 PyObject *resultobj = 0;
23964 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23965 bool result;
23966 void *argp1 = 0 ;
23967 int res1 = 0 ;
23968 PyObject *swig_obj[1] ;
23969
23970 if (!args) SWIG_fail;
23971 swig_obj[0] = args;
23972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
23973 if (!SWIG_IsOK(res1)) {
23974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
23975 }
23976 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
23977 {
23978 PyThreadState* __tstate = wxPyBeginAllowThreads();
23979 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
23980 wxPyEndAllowThreads(__tstate);
23981 if (PyErr_Occurred()) SWIG_fail;
23982 }
23983 {
23984 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23985 }
23986 return resultobj;
23987 fail:
23988 return NULL;
23989 }
23990
23991
23992 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23993 PyObject *resultobj = 0;
23994 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
23995 wxMenu *result = 0 ;
23996 void *argp1 = 0 ;
23997 int res1 = 0 ;
23998 PyObject *swig_obj[1] ;
23999
24000 if (!args) SWIG_fail;
24001 swig_obj[0] = args;
24002 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24003 if (!SWIG_IsOK(res1)) {
24004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24005 }
24006 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24007 {
24008 PyThreadState* __tstate = wxPyBeginAllowThreads();
24009 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24010 wxPyEndAllowThreads(__tstate);
24011 if (PyErr_Occurred()) SWIG_fail;
24012 }
24013 {
24014 resultobj = wxPyMake_wxObject(result, (bool)0);
24015 }
24016 return resultobj;
24017 fail:
24018 return NULL;
24019 }
24020
24021
24022 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24023 PyObject *obj;
24024 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24025 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24026 return SWIG_Py_Void();
24027 }
24028
24029 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24030 return SWIG_Python_InitShadowInstance(args);
24031 }
24032
24033 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24034 PyObject *resultobj = 0;
24035 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24036 int arg2 = (int) 0 ;
24037 wxCloseEvent *result = 0 ;
24038 int val1 ;
24039 int ecode1 = 0 ;
24040 int val2 ;
24041 int ecode2 = 0 ;
24042 PyObject * obj0 = 0 ;
24043 PyObject * obj1 = 0 ;
24044 char * kwnames[] = {
24045 (char *) "type",(char *) "winid", NULL
24046 };
24047
24048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24049 if (obj0) {
24050 ecode1 = SWIG_AsVal_int(obj0, &val1);
24051 if (!SWIG_IsOK(ecode1)) {
24052 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24053 }
24054 arg1 = static_cast< wxEventType >(val1);
24055 }
24056 if (obj1) {
24057 ecode2 = SWIG_AsVal_int(obj1, &val2);
24058 if (!SWIG_IsOK(ecode2)) {
24059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24060 }
24061 arg2 = static_cast< int >(val2);
24062 }
24063 {
24064 PyThreadState* __tstate = wxPyBeginAllowThreads();
24065 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24066 wxPyEndAllowThreads(__tstate);
24067 if (PyErr_Occurred()) SWIG_fail;
24068 }
24069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24070 return resultobj;
24071 fail:
24072 return NULL;
24073 }
24074
24075
24076 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24077 PyObject *resultobj = 0;
24078 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24079 bool arg2 ;
24080 void *argp1 = 0 ;
24081 int res1 = 0 ;
24082 bool val2 ;
24083 int ecode2 = 0 ;
24084 PyObject * obj0 = 0 ;
24085 PyObject * obj1 = 0 ;
24086 char * kwnames[] = {
24087 (char *) "self",(char *) "logOff", NULL
24088 };
24089
24090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24092 if (!SWIG_IsOK(res1)) {
24093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24094 }
24095 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24096 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24097 if (!SWIG_IsOK(ecode2)) {
24098 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24099 }
24100 arg2 = static_cast< bool >(val2);
24101 {
24102 PyThreadState* __tstate = wxPyBeginAllowThreads();
24103 (arg1)->SetLoggingOff(arg2);
24104 wxPyEndAllowThreads(__tstate);
24105 if (PyErr_Occurred()) SWIG_fail;
24106 }
24107 resultobj = SWIG_Py_Void();
24108 return resultobj;
24109 fail:
24110 return NULL;
24111 }
24112
24113
24114 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24115 PyObject *resultobj = 0;
24116 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24117 bool result;
24118 void *argp1 = 0 ;
24119 int res1 = 0 ;
24120 PyObject *swig_obj[1] ;
24121
24122 if (!args) SWIG_fail;
24123 swig_obj[0] = args;
24124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24125 if (!SWIG_IsOK(res1)) {
24126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24127 }
24128 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24129 {
24130 PyThreadState* __tstate = wxPyBeginAllowThreads();
24131 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24132 wxPyEndAllowThreads(__tstate);
24133 if (PyErr_Occurred()) SWIG_fail;
24134 }
24135 {
24136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24137 }
24138 return resultobj;
24139 fail:
24140 return NULL;
24141 }
24142
24143
24144 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24145 PyObject *resultobj = 0;
24146 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24147 bool arg2 = (bool) true ;
24148 void *argp1 = 0 ;
24149 int res1 = 0 ;
24150 bool val2 ;
24151 int ecode2 = 0 ;
24152 PyObject * obj0 = 0 ;
24153 PyObject * obj1 = 0 ;
24154 char * kwnames[] = {
24155 (char *) "self",(char *) "veto", NULL
24156 };
24157
24158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24160 if (!SWIG_IsOK(res1)) {
24161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24162 }
24163 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24164 if (obj1) {
24165 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24166 if (!SWIG_IsOK(ecode2)) {
24167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24168 }
24169 arg2 = static_cast< bool >(val2);
24170 }
24171 {
24172 PyThreadState* __tstate = wxPyBeginAllowThreads();
24173 (arg1)->Veto(arg2);
24174 wxPyEndAllowThreads(__tstate);
24175 if (PyErr_Occurred()) SWIG_fail;
24176 }
24177 resultobj = SWIG_Py_Void();
24178 return resultobj;
24179 fail:
24180 return NULL;
24181 }
24182
24183
24184 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24185 PyObject *resultobj = 0;
24186 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24187 bool result;
24188 void *argp1 = 0 ;
24189 int res1 = 0 ;
24190 PyObject *swig_obj[1] ;
24191
24192 if (!args) SWIG_fail;
24193 swig_obj[0] = args;
24194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24195 if (!SWIG_IsOK(res1)) {
24196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24197 }
24198 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24199 {
24200 PyThreadState* __tstate = wxPyBeginAllowThreads();
24201 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24202 wxPyEndAllowThreads(__tstate);
24203 if (PyErr_Occurred()) SWIG_fail;
24204 }
24205 {
24206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24207 }
24208 return resultobj;
24209 fail:
24210 return NULL;
24211 }
24212
24213
24214 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24215 PyObject *resultobj = 0;
24216 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24217 bool arg2 ;
24218 void *argp1 = 0 ;
24219 int res1 = 0 ;
24220 bool val2 ;
24221 int ecode2 = 0 ;
24222 PyObject * obj0 = 0 ;
24223 PyObject * obj1 = 0 ;
24224 char * kwnames[] = {
24225 (char *) "self",(char *) "canVeto", NULL
24226 };
24227
24228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24230 if (!SWIG_IsOK(res1)) {
24231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24232 }
24233 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24234 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24235 if (!SWIG_IsOK(ecode2)) {
24236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24237 }
24238 arg2 = static_cast< bool >(val2);
24239 {
24240 PyThreadState* __tstate = wxPyBeginAllowThreads();
24241 (arg1)->SetCanVeto(arg2);
24242 wxPyEndAllowThreads(__tstate);
24243 if (PyErr_Occurred()) SWIG_fail;
24244 }
24245 resultobj = SWIG_Py_Void();
24246 return resultobj;
24247 fail:
24248 return NULL;
24249 }
24250
24251
24252 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24253 PyObject *resultobj = 0;
24254 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24255 bool result;
24256 void *argp1 = 0 ;
24257 int res1 = 0 ;
24258 PyObject *swig_obj[1] ;
24259
24260 if (!args) SWIG_fail;
24261 swig_obj[0] = args;
24262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24263 if (!SWIG_IsOK(res1)) {
24264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24265 }
24266 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24267 {
24268 PyThreadState* __tstate = wxPyBeginAllowThreads();
24269 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24270 wxPyEndAllowThreads(__tstate);
24271 if (PyErr_Occurred()) SWIG_fail;
24272 }
24273 {
24274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24275 }
24276 return resultobj;
24277 fail:
24278 return NULL;
24279 }
24280
24281
24282 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24283 PyObject *obj;
24284 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24285 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24286 return SWIG_Py_Void();
24287 }
24288
24289 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24290 return SWIG_Python_InitShadowInstance(args);
24291 }
24292
24293 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24294 PyObject *resultobj = 0;
24295 int arg1 = (int) 0 ;
24296 bool arg2 = (bool) false ;
24297 wxShowEvent *result = 0 ;
24298 int val1 ;
24299 int ecode1 = 0 ;
24300 bool val2 ;
24301 int ecode2 = 0 ;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304 char * kwnames[] = {
24305 (char *) "winid",(char *) "show", NULL
24306 };
24307
24308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24309 if (obj0) {
24310 ecode1 = SWIG_AsVal_int(obj0, &val1);
24311 if (!SWIG_IsOK(ecode1)) {
24312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24313 }
24314 arg1 = static_cast< int >(val1);
24315 }
24316 if (obj1) {
24317 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24318 if (!SWIG_IsOK(ecode2)) {
24319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24320 }
24321 arg2 = static_cast< bool >(val2);
24322 }
24323 {
24324 PyThreadState* __tstate = wxPyBeginAllowThreads();
24325 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24326 wxPyEndAllowThreads(__tstate);
24327 if (PyErr_Occurred()) SWIG_fail;
24328 }
24329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24330 return resultobj;
24331 fail:
24332 return NULL;
24333 }
24334
24335
24336 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24337 PyObject *resultobj = 0;
24338 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24339 bool arg2 ;
24340 void *argp1 = 0 ;
24341 int res1 = 0 ;
24342 bool val2 ;
24343 int ecode2 = 0 ;
24344 PyObject * obj0 = 0 ;
24345 PyObject * obj1 = 0 ;
24346 char * kwnames[] = {
24347 (char *) "self",(char *) "show", NULL
24348 };
24349
24350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24352 if (!SWIG_IsOK(res1)) {
24353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24354 }
24355 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24356 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24357 if (!SWIG_IsOK(ecode2)) {
24358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24359 }
24360 arg2 = static_cast< bool >(val2);
24361 {
24362 PyThreadState* __tstate = wxPyBeginAllowThreads();
24363 (arg1)->SetShow(arg2);
24364 wxPyEndAllowThreads(__tstate);
24365 if (PyErr_Occurred()) SWIG_fail;
24366 }
24367 resultobj = SWIG_Py_Void();
24368 return resultobj;
24369 fail:
24370 return NULL;
24371 }
24372
24373
24374 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24375 PyObject *resultobj = 0;
24376 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24377 bool result;
24378 void *argp1 = 0 ;
24379 int res1 = 0 ;
24380 PyObject *swig_obj[1] ;
24381
24382 if (!args) SWIG_fail;
24383 swig_obj[0] = args;
24384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24385 if (!SWIG_IsOK(res1)) {
24386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24387 }
24388 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 {
24396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24397 }
24398 return resultobj;
24399 fail:
24400 return NULL;
24401 }
24402
24403
24404 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24405 PyObject *obj;
24406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24407 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24408 return SWIG_Py_Void();
24409 }
24410
24411 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24412 return SWIG_Python_InitShadowInstance(args);
24413 }
24414
24415 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24416 PyObject *resultobj = 0;
24417 int arg1 = (int) 0 ;
24418 bool arg2 = (bool) true ;
24419 wxIconizeEvent *result = 0 ;
24420 int val1 ;
24421 int ecode1 = 0 ;
24422 bool val2 ;
24423 int ecode2 = 0 ;
24424 PyObject * obj0 = 0 ;
24425 PyObject * obj1 = 0 ;
24426 char * kwnames[] = {
24427 (char *) "id",(char *) "iconized", NULL
24428 };
24429
24430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24431 if (obj0) {
24432 ecode1 = SWIG_AsVal_int(obj0, &val1);
24433 if (!SWIG_IsOK(ecode1)) {
24434 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24435 }
24436 arg1 = static_cast< int >(val1);
24437 }
24438 if (obj1) {
24439 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24440 if (!SWIG_IsOK(ecode2)) {
24441 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24442 }
24443 arg2 = static_cast< bool >(val2);
24444 }
24445 {
24446 PyThreadState* __tstate = wxPyBeginAllowThreads();
24447 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24448 wxPyEndAllowThreads(__tstate);
24449 if (PyErr_Occurred()) SWIG_fail;
24450 }
24451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24452 return resultobj;
24453 fail:
24454 return NULL;
24455 }
24456
24457
24458 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24459 PyObject *resultobj = 0;
24460 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24461 bool result;
24462 void *argp1 = 0 ;
24463 int res1 = 0 ;
24464 PyObject *swig_obj[1] ;
24465
24466 if (!args) SWIG_fail;
24467 swig_obj[0] = args;
24468 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24469 if (!SWIG_IsOK(res1)) {
24470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24471 }
24472 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = (bool)(arg1)->Iconized();
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 {
24480 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24481 }
24482 return resultobj;
24483 fail:
24484 return NULL;
24485 }
24486
24487
24488 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24489 PyObject *obj;
24490 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24491 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24492 return SWIG_Py_Void();
24493 }
24494
24495 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24496 return SWIG_Python_InitShadowInstance(args);
24497 }
24498
24499 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24500 PyObject *resultobj = 0;
24501 int arg1 = (int) 0 ;
24502 wxMaximizeEvent *result = 0 ;
24503 int val1 ;
24504 int ecode1 = 0 ;
24505 PyObject * obj0 = 0 ;
24506 char * kwnames[] = {
24507 (char *) "id", NULL
24508 };
24509
24510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24511 if (obj0) {
24512 ecode1 = SWIG_AsVal_int(obj0, &val1);
24513 if (!SWIG_IsOK(ecode1)) {
24514 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24515 }
24516 arg1 = static_cast< int >(val1);
24517 }
24518 {
24519 PyThreadState* __tstate = wxPyBeginAllowThreads();
24520 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24521 wxPyEndAllowThreads(__tstate);
24522 if (PyErr_Occurred()) SWIG_fail;
24523 }
24524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24525 return resultobj;
24526 fail:
24527 return NULL;
24528 }
24529
24530
24531 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24532 PyObject *obj;
24533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24534 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24535 return SWIG_Py_Void();
24536 }
24537
24538 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24539 return SWIG_Python_InitShadowInstance(args);
24540 }
24541
24542 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24543 PyObject *resultobj = 0;
24544 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24545 wxPoint result;
24546 void *argp1 = 0 ;
24547 int res1 = 0 ;
24548 PyObject *swig_obj[1] ;
24549
24550 if (!args) SWIG_fail;
24551 swig_obj[0] = args;
24552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24553 if (!SWIG_IsOK(res1)) {
24554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24555 }
24556 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24557 {
24558 PyThreadState* __tstate = wxPyBeginAllowThreads();
24559 result = (arg1)->GetPosition();
24560 wxPyEndAllowThreads(__tstate);
24561 if (PyErr_Occurred()) SWIG_fail;
24562 }
24563 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24564 return resultobj;
24565 fail:
24566 return NULL;
24567 }
24568
24569
24570 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24571 PyObject *resultobj = 0;
24572 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24573 int result;
24574 void *argp1 = 0 ;
24575 int res1 = 0 ;
24576 PyObject *swig_obj[1] ;
24577
24578 if (!args) SWIG_fail;
24579 swig_obj[0] = args;
24580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24581 if (!SWIG_IsOK(res1)) {
24582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24583 }
24584 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24585 {
24586 PyThreadState* __tstate = wxPyBeginAllowThreads();
24587 result = (int)(arg1)->GetNumberOfFiles();
24588 wxPyEndAllowThreads(__tstate);
24589 if (PyErr_Occurred()) SWIG_fail;
24590 }
24591 resultobj = SWIG_From_int(static_cast< int >(result));
24592 return resultobj;
24593 fail:
24594 return NULL;
24595 }
24596
24597
24598 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24599 PyObject *resultobj = 0;
24600 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24601 PyObject *result = 0 ;
24602 void *argp1 = 0 ;
24603 int res1 = 0 ;
24604 PyObject *swig_obj[1] ;
24605
24606 if (!args) SWIG_fail;
24607 swig_obj[0] = args;
24608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24609 if (!SWIG_IsOK(res1)) {
24610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24611 }
24612 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24613 {
24614 PyThreadState* __tstate = wxPyBeginAllowThreads();
24615 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24616 wxPyEndAllowThreads(__tstate);
24617 if (PyErr_Occurred()) SWIG_fail;
24618 }
24619 resultobj = result;
24620 return resultobj;
24621 fail:
24622 return NULL;
24623 }
24624
24625
24626 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24627 PyObject *obj;
24628 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24629 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24630 return SWIG_Py_Void();
24631 }
24632
24633 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24634 PyObject *resultobj = 0;
24635 int arg1 = (int) 0 ;
24636 wxUpdateUIEvent *result = 0 ;
24637 int val1 ;
24638 int ecode1 = 0 ;
24639 PyObject * obj0 = 0 ;
24640 char * kwnames[] = {
24641 (char *) "commandId", NULL
24642 };
24643
24644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24645 if (obj0) {
24646 ecode1 = SWIG_AsVal_int(obj0, &val1);
24647 if (!SWIG_IsOK(ecode1)) {
24648 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24649 }
24650 arg1 = static_cast< int >(val1);
24651 }
24652 {
24653 PyThreadState* __tstate = wxPyBeginAllowThreads();
24654 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24655 wxPyEndAllowThreads(__tstate);
24656 if (PyErr_Occurred()) SWIG_fail;
24657 }
24658 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24659 return resultobj;
24660 fail:
24661 return NULL;
24662 }
24663
24664
24665 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24666 PyObject *resultobj = 0;
24667 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24668 bool result;
24669 void *argp1 = 0 ;
24670 int res1 = 0 ;
24671 PyObject *swig_obj[1] ;
24672
24673 if (!args) SWIG_fail;
24674 swig_obj[0] = args;
24675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24676 if (!SWIG_IsOK(res1)) {
24677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24678 }
24679 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24680 {
24681 PyThreadState* __tstate = wxPyBeginAllowThreads();
24682 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24683 wxPyEndAllowThreads(__tstate);
24684 if (PyErr_Occurred()) SWIG_fail;
24685 }
24686 {
24687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24688 }
24689 return resultobj;
24690 fail:
24691 return NULL;
24692 }
24693
24694
24695 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24696 PyObject *resultobj = 0;
24697 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24698 bool result;
24699 void *argp1 = 0 ;
24700 int res1 = 0 ;
24701 PyObject *swig_obj[1] ;
24702
24703 if (!args) SWIG_fail;
24704 swig_obj[0] = args;
24705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24706 if (!SWIG_IsOK(res1)) {
24707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24708 }
24709 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24710 {
24711 PyThreadState* __tstate = wxPyBeginAllowThreads();
24712 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24713 wxPyEndAllowThreads(__tstate);
24714 if (PyErr_Occurred()) SWIG_fail;
24715 }
24716 {
24717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24718 }
24719 return resultobj;
24720 fail:
24721 return NULL;
24722 }
24723
24724
24725 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24726 PyObject *resultobj = 0;
24727 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24728 bool result;
24729 void *argp1 = 0 ;
24730 int res1 = 0 ;
24731 PyObject *swig_obj[1] ;
24732
24733 if (!args) SWIG_fail;
24734 swig_obj[0] = args;
24735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24736 if (!SWIG_IsOK(res1)) {
24737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24738 }
24739 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24740 {
24741 PyThreadState* __tstate = wxPyBeginAllowThreads();
24742 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24743 wxPyEndAllowThreads(__tstate);
24744 if (PyErr_Occurred()) SWIG_fail;
24745 }
24746 {
24747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24748 }
24749 return resultobj;
24750 fail:
24751 return NULL;
24752 }
24753
24754
24755 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24756 PyObject *resultobj = 0;
24757 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24758 wxString result;
24759 void *argp1 = 0 ;
24760 int res1 = 0 ;
24761 PyObject *swig_obj[1] ;
24762
24763 if (!args) SWIG_fail;
24764 swig_obj[0] = args;
24765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24766 if (!SWIG_IsOK(res1)) {
24767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24768 }
24769 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24770 {
24771 PyThreadState* __tstate = wxPyBeginAllowThreads();
24772 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24773 wxPyEndAllowThreads(__tstate);
24774 if (PyErr_Occurred()) SWIG_fail;
24775 }
24776 {
24777 #if wxUSE_UNICODE
24778 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24779 #else
24780 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24781 #endif
24782 }
24783 return resultobj;
24784 fail:
24785 return NULL;
24786 }
24787
24788
24789 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24790 PyObject *resultobj = 0;
24791 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24792 bool result;
24793 void *argp1 = 0 ;
24794 int res1 = 0 ;
24795 PyObject *swig_obj[1] ;
24796
24797 if (!args) SWIG_fail;
24798 swig_obj[0] = args;
24799 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24800 if (!SWIG_IsOK(res1)) {
24801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24802 }
24803 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24804 {
24805 PyThreadState* __tstate = wxPyBeginAllowThreads();
24806 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24807 wxPyEndAllowThreads(__tstate);
24808 if (PyErr_Occurred()) SWIG_fail;
24809 }
24810 {
24811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24812 }
24813 return resultobj;
24814 fail:
24815 return NULL;
24816 }
24817
24818
24819 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24820 PyObject *resultobj = 0;
24821 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24822 bool result;
24823 void *argp1 = 0 ;
24824 int res1 = 0 ;
24825 PyObject *swig_obj[1] ;
24826
24827 if (!args) SWIG_fail;
24828 swig_obj[0] = args;
24829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24830 if (!SWIG_IsOK(res1)) {
24831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24832 }
24833 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24834 {
24835 PyThreadState* __tstate = wxPyBeginAllowThreads();
24836 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24837 wxPyEndAllowThreads(__tstate);
24838 if (PyErr_Occurred()) SWIG_fail;
24839 }
24840 {
24841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24842 }
24843 return resultobj;
24844 fail:
24845 return NULL;
24846 }
24847
24848
24849 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24850 PyObject *resultobj = 0;
24851 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24852 bool result;
24853 void *argp1 = 0 ;
24854 int res1 = 0 ;
24855 PyObject *swig_obj[1] ;
24856
24857 if (!args) SWIG_fail;
24858 swig_obj[0] = args;
24859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24860 if (!SWIG_IsOK(res1)) {
24861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24862 }
24863 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24864 {
24865 PyThreadState* __tstate = wxPyBeginAllowThreads();
24866 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
24867 wxPyEndAllowThreads(__tstate);
24868 if (PyErr_Occurred()) SWIG_fail;
24869 }
24870 {
24871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24872 }
24873 return resultobj;
24874 fail:
24875 return NULL;
24876 }
24877
24878
24879 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24880 PyObject *resultobj = 0;
24881 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24882 bool result;
24883 void *argp1 = 0 ;
24884 int res1 = 0 ;
24885 PyObject *swig_obj[1] ;
24886
24887 if (!args) SWIG_fail;
24888 swig_obj[0] = args;
24889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24890 if (!SWIG_IsOK(res1)) {
24891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24892 }
24893 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24894 {
24895 PyThreadState* __tstate = wxPyBeginAllowThreads();
24896 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
24897 wxPyEndAllowThreads(__tstate);
24898 if (PyErr_Occurred()) SWIG_fail;
24899 }
24900 {
24901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24902 }
24903 return resultobj;
24904 fail:
24905 return NULL;
24906 }
24907
24908
24909 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24910 PyObject *resultobj = 0;
24911 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24912 bool arg2 ;
24913 void *argp1 = 0 ;
24914 int res1 = 0 ;
24915 bool val2 ;
24916 int ecode2 = 0 ;
24917 PyObject * obj0 = 0 ;
24918 PyObject * obj1 = 0 ;
24919 char * kwnames[] = {
24920 (char *) "self",(char *) "check", NULL
24921 };
24922
24923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
24924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24925 if (!SWIG_IsOK(res1)) {
24926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24927 }
24928 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24929 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24930 if (!SWIG_IsOK(ecode2)) {
24931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
24932 }
24933 arg2 = static_cast< bool >(val2);
24934 {
24935 PyThreadState* __tstate = wxPyBeginAllowThreads();
24936 (arg1)->Check(arg2);
24937 wxPyEndAllowThreads(__tstate);
24938 if (PyErr_Occurred()) SWIG_fail;
24939 }
24940 resultobj = SWIG_Py_Void();
24941 return resultobj;
24942 fail:
24943 return NULL;
24944 }
24945
24946
24947 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24948 PyObject *resultobj = 0;
24949 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24950 bool arg2 ;
24951 void *argp1 = 0 ;
24952 int res1 = 0 ;
24953 bool val2 ;
24954 int ecode2 = 0 ;
24955 PyObject * obj0 = 0 ;
24956 PyObject * obj1 = 0 ;
24957 char * kwnames[] = {
24958 (char *) "self",(char *) "enable", NULL
24959 };
24960
24961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
24962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24963 if (!SWIG_IsOK(res1)) {
24964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
24965 }
24966 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24967 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24968 if (!SWIG_IsOK(ecode2)) {
24969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
24970 }
24971 arg2 = static_cast< bool >(val2);
24972 {
24973 PyThreadState* __tstate = wxPyBeginAllowThreads();
24974 (arg1)->Enable(arg2);
24975 wxPyEndAllowThreads(__tstate);
24976 if (PyErr_Occurred()) SWIG_fail;
24977 }
24978 resultobj = SWIG_Py_Void();
24979 return resultobj;
24980 fail:
24981 return NULL;
24982 }
24983
24984
24985 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24986 PyObject *resultobj = 0;
24987 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24988 bool arg2 ;
24989 void *argp1 = 0 ;
24990 int res1 = 0 ;
24991 bool val2 ;
24992 int ecode2 = 0 ;
24993 PyObject * obj0 = 0 ;
24994 PyObject * obj1 = 0 ;
24995 char * kwnames[] = {
24996 (char *) "self",(char *) "show", NULL
24997 };
24998
24999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25001 if (!SWIG_IsOK(res1)) {
25002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25003 }
25004 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25006 if (!SWIG_IsOK(ecode2)) {
25007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25008 }
25009 arg2 = static_cast< bool >(val2);
25010 {
25011 PyThreadState* __tstate = wxPyBeginAllowThreads();
25012 (arg1)->Show(arg2);
25013 wxPyEndAllowThreads(__tstate);
25014 if (PyErr_Occurred()) SWIG_fail;
25015 }
25016 resultobj = SWIG_Py_Void();
25017 return resultobj;
25018 fail:
25019 return NULL;
25020 }
25021
25022
25023 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25024 PyObject *resultobj = 0;
25025 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25026 wxString *arg2 = 0 ;
25027 void *argp1 = 0 ;
25028 int res1 = 0 ;
25029 bool temp2 = false ;
25030 PyObject * obj0 = 0 ;
25031 PyObject * obj1 = 0 ;
25032 char * kwnames[] = {
25033 (char *) "self",(char *) "text", NULL
25034 };
25035
25036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25038 if (!SWIG_IsOK(res1)) {
25039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25040 }
25041 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25042 {
25043 arg2 = wxString_in_helper(obj1);
25044 if (arg2 == NULL) SWIG_fail;
25045 temp2 = true;
25046 }
25047 {
25048 PyThreadState* __tstate = wxPyBeginAllowThreads();
25049 (arg1)->SetText((wxString const &)*arg2);
25050 wxPyEndAllowThreads(__tstate);
25051 if (PyErr_Occurred()) SWIG_fail;
25052 }
25053 resultobj = SWIG_Py_Void();
25054 {
25055 if (temp2)
25056 delete arg2;
25057 }
25058 return resultobj;
25059 fail:
25060 {
25061 if (temp2)
25062 delete arg2;
25063 }
25064 return NULL;
25065 }
25066
25067
25068 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25069 PyObject *resultobj = 0;
25070 long arg1 ;
25071 long val1 ;
25072 int ecode1 = 0 ;
25073 PyObject * obj0 = 0 ;
25074 char * kwnames[] = {
25075 (char *) "updateInterval", NULL
25076 };
25077
25078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25079 ecode1 = SWIG_AsVal_long(obj0, &val1);
25080 if (!SWIG_IsOK(ecode1)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25082 }
25083 arg1 = static_cast< long >(val1);
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 wxUpdateUIEvent::SetUpdateInterval(arg1);
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_Py_Void();
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25098 PyObject *resultobj = 0;
25099 long result;
25100
25101 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25102 {
25103 PyThreadState* __tstate = wxPyBeginAllowThreads();
25104 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25105 wxPyEndAllowThreads(__tstate);
25106 if (PyErr_Occurred()) SWIG_fail;
25107 }
25108 resultobj = SWIG_From_long(static_cast< long >(result));
25109 return resultobj;
25110 fail:
25111 return NULL;
25112 }
25113
25114
25115 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25116 PyObject *resultobj = 0;
25117 wxWindow *arg1 = (wxWindow *) 0 ;
25118 bool result;
25119 void *argp1 = 0 ;
25120 int res1 = 0 ;
25121 PyObject * obj0 = 0 ;
25122 char * kwnames[] = {
25123 (char *) "win", NULL
25124 };
25125
25126 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25127 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25128 if (!SWIG_IsOK(res1)) {
25129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25130 }
25131 arg1 = reinterpret_cast< wxWindow * >(argp1);
25132 {
25133 PyThreadState* __tstate = wxPyBeginAllowThreads();
25134 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25135 wxPyEndAllowThreads(__tstate);
25136 if (PyErr_Occurred()) SWIG_fail;
25137 }
25138 {
25139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25140 }
25141 return resultobj;
25142 fail:
25143 return NULL;
25144 }
25145
25146
25147 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25148 PyObject *resultobj = 0;
25149
25150 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25151 {
25152 PyThreadState* __tstate = wxPyBeginAllowThreads();
25153 wxUpdateUIEvent::ResetUpdateTime();
25154 wxPyEndAllowThreads(__tstate);
25155 if (PyErr_Occurred()) SWIG_fail;
25156 }
25157 resultobj = SWIG_Py_Void();
25158 return resultobj;
25159 fail:
25160 return NULL;
25161 }
25162
25163
25164 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25165 PyObject *resultobj = 0;
25166 wxUpdateUIMode arg1 ;
25167 int val1 ;
25168 int ecode1 = 0 ;
25169 PyObject * obj0 = 0 ;
25170 char * kwnames[] = {
25171 (char *) "mode", NULL
25172 };
25173
25174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25175 ecode1 = SWIG_AsVal_int(obj0, &val1);
25176 if (!SWIG_IsOK(ecode1)) {
25177 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25178 }
25179 arg1 = static_cast< wxUpdateUIMode >(val1);
25180 {
25181 PyThreadState* __tstate = wxPyBeginAllowThreads();
25182 wxUpdateUIEvent::SetMode(arg1);
25183 wxPyEndAllowThreads(__tstate);
25184 if (PyErr_Occurred()) SWIG_fail;
25185 }
25186 resultobj = SWIG_Py_Void();
25187 return resultobj;
25188 fail:
25189 return NULL;
25190 }
25191
25192
25193 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25194 PyObject *resultobj = 0;
25195 wxUpdateUIMode result;
25196
25197 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25198 {
25199 PyThreadState* __tstate = wxPyBeginAllowThreads();
25200 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25201 wxPyEndAllowThreads(__tstate);
25202 if (PyErr_Occurred()) SWIG_fail;
25203 }
25204 resultobj = SWIG_From_int(static_cast< int >(result));
25205 return resultobj;
25206 fail:
25207 return NULL;
25208 }
25209
25210
25211 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25212 PyObject *obj;
25213 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25214 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25215 return SWIG_Py_Void();
25216 }
25217
25218 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25219 return SWIG_Python_InitShadowInstance(args);
25220 }
25221
25222 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25223 PyObject *resultobj = 0;
25224 wxSysColourChangedEvent *result = 0 ;
25225
25226 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25227 {
25228 PyThreadState* __tstate = wxPyBeginAllowThreads();
25229 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25230 wxPyEndAllowThreads(__tstate);
25231 if (PyErr_Occurred()) SWIG_fail;
25232 }
25233 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25234 return resultobj;
25235 fail:
25236 return NULL;
25237 }
25238
25239
25240 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25241 PyObject *obj;
25242 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25243 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25244 return SWIG_Py_Void();
25245 }
25246
25247 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 return SWIG_Python_InitShadowInstance(args);
25249 }
25250
25251 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25252 PyObject *resultobj = 0;
25253 int arg1 = (int) 0 ;
25254 wxWindow *arg2 = (wxWindow *) NULL ;
25255 wxMouseCaptureChangedEvent *result = 0 ;
25256 int val1 ;
25257 int ecode1 = 0 ;
25258 void *argp2 = 0 ;
25259 int res2 = 0 ;
25260 PyObject * obj0 = 0 ;
25261 PyObject * obj1 = 0 ;
25262 char * kwnames[] = {
25263 (char *) "winid",(char *) "gainedCapture", NULL
25264 };
25265
25266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25267 if (obj0) {
25268 ecode1 = SWIG_AsVal_int(obj0, &val1);
25269 if (!SWIG_IsOK(ecode1)) {
25270 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25271 }
25272 arg1 = static_cast< int >(val1);
25273 }
25274 if (obj1) {
25275 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25276 if (!SWIG_IsOK(res2)) {
25277 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25278 }
25279 arg2 = reinterpret_cast< wxWindow * >(argp2);
25280 }
25281 {
25282 PyThreadState* __tstate = wxPyBeginAllowThreads();
25283 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25284 wxPyEndAllowThreads(__tstate);
25285 if (PyErr_Occurred()) SWIG_fail;
25286 }
25287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25288 return resultobj;
25289 fail:
25290 return NULL;
25291 }
25292
25293
25294 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25295 PyObject *resultobj = 0;
25296 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25297 wxWindow *result = 0 ;
25298 void *argp1 = 0 ;
25299 int res1 = 0 ;
25300 PyObject *swig_obj[1] ;
25301
25302 if (!args) SWIG_fail;
25303 swig_obj[0] = args;
25304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25305 if (!SWIG_IsOK(res1)) {
25306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25307 }
25308 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25309 {
25310 PyThreadState* __tstate = wxPyBeginAllowThreads();
25311 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25312 wxPyEndAllowThreads(__tstate);
25313 if (PyErr_Occurred()) SWIG_fail;
25314 }
25315 {
25316 resultobj = wxPyMake_wxObject(result, (bool)0);
25317 }
25318 return resultobj;
25319 fail:
25320 return NULL;
25321 }
25322
25323
25324 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25325 PyObject *obj;
25326 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25327 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25328 return SWIG_Py_Void();
25329 }
25330
25331 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25332 return SWIG_Python_InitShadowInstance(args);
25333 }
25334
25335 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25336 PyObject *resultobj = 0;
25337 wxDisplayChangedEvent *result = 0 ;
25338
25339 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25340 {
25341 PyThreadState* __tstate = wxPyBeginAllowThreads();
25342 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25343 wxPyEndAllowThreads(__tstate);
25344 if (PyErr_Occurred()) SWIG_fail;
25345 }
25346 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25347 return resultobj;
25348 fail:
25349 return NULL;
25350 }
25351
25352
25353 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25354 PyObject *obj;
25355 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25356 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25357 return SWIG_Py_Void();
25358 }
25359
25360 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25361 return SWIG_Python_InitShadowInstance(args);
25362 }
25363
25364 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25365 PyObject *resultobj = 0;
25366 int arg1 = (int) 0 ;
25367 wxPaletteChangedEvent *result = 0 ;
25368 int val1 ;
25369 int ecode1 = 0 ;
25370 PyObject * obj0 = 0 ;
25371 char * kwnames[] = {
25372 (char *) "id", NULL
25373 };
25374
25375 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25376 if (obj0) {
25377 ecode1 = SWIG_AsVal_int(obj0, &val1);
25378 if (!SWIG_IsOK(ecode1)) {
25379 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25380 }
25381 arg1 = static_cast< int >(val1);
25382 }
25383 {
25384 PyThreadState* __tstate = wxPyBeginAllowThreads();
25385 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25386 wxPyEndAllowThreads(__tstate);
25387 if (PyErr_Occurred()) SWIG_fail;
25388 }
25389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25390 return resultobj;
25391 fail:
25392 return NULL;
25393 }
25394
25395
25396 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25397 PyObject *resultobj = 0;
25398 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25399 wxWindow *arg2 = (wxWindow *) 0 ;
25400 void *argp1 = 0 ;
25401 int res1 = 0 ;
25402 void *argp2 = 0 ;
25403 int res2 = 0 ;
25404 PyObject * obj0 = 0 ;
25405 PyObject * obj1 = 0 ;
25406 char * kwnames[] = {
25407 (char *) "self",(char *) "win", NULL
25408 };
25409
25410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25412 if (!SWIG_IsOK(res1)) {
25413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25414 }
25415 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25416 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25417 if (!SWIG_IsOK(res2)) {
25418 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25419 }
25420 arg2 = reinterpret_cast< wxWindow * >(argp2);
25421 {
25422 PyThreadState* __tstate = wxPyBeginAllowThreads();
25423 (arg1)->SetChangedWindow(arg2);
25424 wxPyEndAllowThreads(__tstate);
25425 if (PyErr_Occurred()) SWIG_fail;
25426 }
25427 resultobj = SWIG_Py_Void();
25428 return resultobj;
25429 fail:
25430 return NULL;
25431 }
25432
25433
25434 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25435 PyObject *resultobj = 0;
25436 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25437 wxWindow *result = 0 ;
25438 void *argp1 = 0 ;
25439 int res1 = 0 ;
25440 PyObject *swig_obj[1] ;
25441
25442 if (!args) SWIG_fail;
25443 swig_obj[0] = args;
25444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25445 if (!SWIG_IsOK(res1)) {
25446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25447 }
25448 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25449 {
25450 PyThreadState* __tstate = wxPyBeginAllowThreads();
25451 result = (wxWindow *)(arg1)->GetChangedWindow();
25452 wxPyEndAllowThreads(__tstate);
25453 if (PyErr_Occurred()) SWIG_fail;
25454 }
25455 {
25456 resultobj = wxPyMake_wxObject(result, (bool)0);
25457 }
25458 return resultobj;
25459 fail:
25460 return NULL;
25461 }
25462
25463
25464 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25465 PyObject *obj;
25466 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25467 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25468 return SWIG_Py_Void();
25469 }
25470
25471 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25472 return SWIG_Python_InitShadowInstance(args);
25473 }
25474
25475 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25476 PyObject *resultobj = 0;
25477 int arg1 = (int) 0 ;
25478 wxQueryNewPaletteEvent *result = 0 ;
25479 int val1 ;
25480 int ecode1 = 0 ;
25481 PyObject * obj0 = 0 ;
25482 char * kwnames[] = {
25483 (char *) "winid", NULL
25484 };
25485
25486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25487 if (obj0) {
25488 ecode1 = SWIG_AsVal_int(obj0, &val1);
25489 if (!SWIG_IsOK(ecode1)) {
25490 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25491 }
25492 arg1 = static_cast< int >(val1);
25493 }
25494 {
25495 PyThreadState* __tstate = wxPyBeginAllowThreads();
25496 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25497 wxPyEndAllowThreads(__tstate);
25498 if (PyErr_Occurred()) SWIG_fail;
25499 }
25500 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25501 return resultobj;
25502 fail:
25503 return NULL;
25504 }
25505
25506
25507 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25508 PyObject *resultobj = 0;
25509 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25510 bool arg2 ;
25511 void *argp1 = 0 ;
25512 int res1 = 0 ;
25513 bool val2 ;
25514 int ecode2 = 0 ;
25515 PyObject * obj0 = 0 ;
25516 PyObject * obj1 = 0 ;
25517 char * kwnames[] = {
25518 (char *) "self",(char *) "realized", NULL
25519 };
25520
25521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25523 if (!SWIG_IsOK(res1)) {
25524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25525 }
25526 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25527 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25528 if (!SWIG_IsOK(ecode2)) {
25529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25530 }
25531 arg2 = static_cast< bool >(val2);
25532 {
25533 PyThreadState* __tstate = wxPyBeginAllowThreads();
25534 (arg1)->SetPaletteRealized(arg2);
25535 wxPyEndAllowThreads(__tstate);
25536 if (PyErr_Occurred()) SWIG_fail;
25537 }
25538 resultobj = SWIG_Py_Void();
25539 return resultobj;
25540 fail:
25541 return NULL;
25542 }
25543
25544
25545 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25546 PyObject *resultobj = 0;
25547 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25548 bool result;
25549 void *argp1 = 0 ;
25550 int res1 = 0 ;
25551 PyObject *swig_obj[1] ;
25552
25553 if (!args) SWIG_fail;
25554 swig_obj[0] = args;
25555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25556 if (!SWIG_IsOK(res1)) {
25557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25558 }
25559 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25560 {
25561 PyThreadState* __tstate = wxPyBeginAllowThreads();
25562 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25563 wxPyEndAllowThreads(__tstate);
25564 if (PyErr_Occurred()) SWIG_fail;
25565 }
25566 {
25567 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25568 }
25569 return resultobj;
25570 fail:
25571 return NULL;
25572 }
25573
25574
25575 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25576 PyObject *obj;
25577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25578 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25579 return SWIG_Py_Void();
25580 }
25581
25582 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25583 return SWIG_Python_InitShadowInstance(args);
25584 }
25585
25586 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25587 PyObject *resultobj = 0;
25588 wxNavigationKeyEvent *result = 0 ;
25589
25590 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25591 {
25592 PyThreadState* __tstate = wxPyBeginAllowThreads();
25593 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25594 wxPyEndAllowThreads(__tstate);
25595 if (PyErr_Occurred()) SWIG_fail;
25596 }
25597 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25598 return resultobj;
25599 fail:
25600 return NULL;
25601 }
25602
25603
25604 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25605 PyObject *resultobj = 0;
25606 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25607 bool result;
25608 void *argp1 = 0 ;
25609 int res1 = 0 ;
25610 PyObject *swig_obj[1] ;
25611
25612 if (!args) SWIG_fail;
25613 swig_obj[0] = args;
25614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25615 if (!SWIG_IsOK(res1)) {
25616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25617 }
25618 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25619 {
25620 PyThreadState* __tstate = wxPyBeginAllowThreads();
25621 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25622 wxPyEndAllowThreads(__tstate);
25623 if (PyErr_Occurred()) SWIG_fail;
25624 }
25625 {
25626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25627 }
25628 return resultobj;
25629 fail:
25630 return NULL;
25631 }
25632
25633
25634 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25635 PyObject *resultobj = 0;
25636 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25637 bool arg2 ;
25638 void *argp1 = 0 ;
25639 int res1 = 0 ;
25640 bool val2 ;
25641 int ecode2 = 0 ;
25642 PyObject * obj0 = 0 ;
25643 PyObject * obj1 = 0 ;
25644 char * kwnames[] = {
25645 (char *) "self",(char *) "forward", NULL
25646 };
25647
25648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25650 if (!SWIG_IsOK(res1)) {
25651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25652 }
25653 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25654 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25655 if (!SWIG_IsOK(ecode2)) {
25656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25657 }
25658 arg2 = static_cast< bool >(val2);
25659 {
25660 PyThreadState* __tstate = wxPyBeginAllowThreads();
25661 (arg1)->SetDirection(arg2);
25662 wxPyEndAllowThreads(__tstate);
25663 if (PyErr_Occurred()) SWIG_fail;
25664 }
25665 resultobj = SWIG_Py_Void();
25666 return resultobj;
25667 fail:
25668 return NULL;
25669 }
25670
25671
25672 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25673 PyObject *resultobj = 0;
25674 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25675 bool result;
25676 void *argp1 = 0 ;
25677 int res1 = 0 ;
25678 PyObject *swig_obj[1] ;
25679
25680 if (!args) SWIG_fail;
25681 swig_obj[0] = args;
25682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25683 if (!SWIG_IsOK(res1)) {
25684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25685 }
25686 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25687 {
25688 PyThreadState* __tstate = wxPyBeginAllowThreads();
25689 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25690 wxPyEndAllowThreads(__tstate);
25691 if (PyErr_Occurred()) SWIG_fail;
25692 }
25693 {
25694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25695 }
25696 return resultobj;
25697 fail:
25698 return NULL;
25699 }
25700
25701
25702 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25703 PyObject *resultobj = 0;
25704 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25705 bool arg2 ;
25706 void *argp1 = 0 ;
25707 int res1 = 0 ;
25708 bool val2 ;
25709 int ecode2 = 0 ;
25710 PyObject * obj0 = 0 ;
25711 PyObject * obj1 = 0 ;
25712 char * kwnames[] = {
25713 (char *) "self",(char *) "ischange", NULL
25714 };
25715
25716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25718 if (!SWIG_IsOK(res1)) {
25719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25720 }
25721 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25722 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25723 if (!SWIG_IsOK(ecode2)) {
25724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25725 }
25726 arg2 = static_cast< bool >(val2);
25727 {
25728 PyThreadState* __tstate = wxPyBeginAllowThreads();
25729 (arg1)->SetWindowChange(arg2);
25730 wxPyEndAllowThreads(__tstate);
25731 if (PyErr_Occurred()) SWIG_fail;
25732 }
25733 resultobj = SWIG_Py_Void();
25734 return resultobj;
25735 fail:
25736 return NULL;
25737 }
25738
25739
25740 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25741 PyObject *resultobj = 0;
25742 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25743 bool result;
25744 void *argp1 = 0 ;
25745 int res1 = 0 ;
25746 PyObject *swig_obj[1] ;
25747
25748 if (!args) SWIG_fail;
25749 swig_obj[0] = args;
25750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25751 if (!SWIG_IsOK(res1)) {
25752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25753 }
25754 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25755 {
25756 PyThreadState* __tstate = wxPyBeginAllowThreads();
25757 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25758 wxPyEndAllowThreads(__tstate);
25759 if (PyErr_Occurred()) SWIG_fail;
25760 }
25761 {
25762 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25763 }
25764 return resultobj;
25765 fail:
25766 return NULL;
25767 }
25768
25769
25770 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25771 PyObject *resultobj = 0;
25772 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25773 bool arg2 ;
25774 void *argp1 = 0 ;
25775 int res1 = 0 ;
25776 bool val2 ;
25777 int ecode2 = 0 ;
25778 PyObject * obj0 = 0 ;
25779 PyObject * obj1 = 0 ;
25780 char * kwnames[] = {
25781 (char *) "self",(char *) "bIs", NULL
25782 };
25783
25784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25786 if (!SWIG_IsOK(res1)) {
25787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25788 }
25789 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25790 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25791 if (!SWIG_IsOK(ecode2)) {
25792 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25793 }
25794 arg2 = static_cast< bool >(val2);
25795 {
25796 PyThreadState* __tstate = wxPyBeginAllowThreads();
25797 (arg1)->SetFromTab(arg2);
25798 wxPyEndAllowThreads(__tstate);
25799 if (PyErr_Occurred()) SWIG_fail;
25800 }
25801 resultobj = SWIG_Py_Void();
25802 return resultobj;
25803 fail:
25804 return NULL;
25805 }
25806
25807
25808 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25809 PyObject *resultobj = 0;
25810 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25811 long arg2 ;
25812 void *argp1 = 0 ;
25813 int res1 = 0 ;
25814 long val2 ;
25815 int ecode2 = 0 ;
25816 PyObject * obj0 = 0 ;
25817 PyObject * obj1 = 0 ;
25818 char * kwnames[] = {
25819 (char *) "self",(char *) "flags", NULL
25820 };
25821
25822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
25823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25824 if (!SWIG_IsOK(res1)) {
25825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25826 }
25827 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25828 ecode2 = SWIG_AsVal_long(obj1, &val2);
25829 if (!SWIG_IsOK(ecode2)) {
25830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
25831 }
25832 arg2 = static_cast< long >(val2);
25833 {
25834 PyThreadState* __tstate = wxPyBeginAllowThreads();
25835 (arg1)->SetFlags(arg2);
25836 wxPyEndAllowThreads(__tstate);
25837 if (PyErr_Occurred()) SWIG_fail;
25838 }
25839 resultobj = SWIG_Py_Void();
25840 return resultobj;
25841 fail:
25842 return NULL;
25843 }
25844
25845
25846 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25847 PyObject *resultobj = 0;
25848 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25849 wxWindow *result = 0 ;
25850 void *argp1 = 0 ;
25851 int res1 = 0 ;
25852 PyObject *swig_obj[1] ;
25853
25854 if (!args) SWIG_fail;
25855 swig_obj[0] = args;
25856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25857 if (!SWIG_IsOK(res1)) {
25858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25859 }
25860 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25861 {
25862 PyThreadState* __tstate = wxPyBeginAllowThreads();
25863 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
25864 wxPyEndAllowThreads(__tstate);
25865 if (PyErr_Occurred()) SWIG_fail;
25866 }
25867 {
25868 resultobj = wxPyMake_wxObject(result, (bool)0);
25869 }
25870 return resultobj;
25871 fail:
25872 return NULL;
25873 }
25874
25875
25876 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25877 PyObject *resultobj = 0;
25878 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25879 wxWindow *arg2 = (wxWindow *) 0 ;
25880 void *argp1 = 0 ;
25881 int res1 = 0 ;
25882 void *argp2 = 0 ;
25883 int res2 = 0 ;
25884 PyObject * obj0 = 0 ;
25885 PyObject * obj1 = 0 ;
25886 char * kwnames[] = {
25887 (char *) "self",(char *) "win", NULL
25888 };
25889
25890 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
25891 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25892 if (!SWIG_IsOK(res1)) {
25893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25894 }
25895 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25896 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25897 if (!SWIG_IsOK(res2)) {
25898 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
25899 }
25900 arg2 = reinterpret_cast< wxWindow * >(argp2);
25901 {
25902 PyThreadState* __tstate = wxPyBeginAllowThreads();
25903 (arg1)->SetCurrentFocus(arg2);
25904 wxPyEndAllowThreads(__tstate);
25905 if (PyErr_Occurred()) SWIG_fail;
25906 }
25907 resultobj = SWIG_Py_Void();
25908 return resultobj;
25909 fail:
25910 return NULL;
25911 }
25912
25913
25914 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25915 PyObject *obj;
25916 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25917 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
25918 return SWIG_Py_Void();
25919 }
25920
25921 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25922 return SWIG_Python_InitShadowInstance(args);
25923 }
25924
25925 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25926 PyObject *resultobj = 0;
25927 wxWindow *arg1 = (wxWindow *) NULL ;
25928 wxWindowCreateEvent *result = 0 ;
25929 void *argp1 = 0 ;
25930 int res1 = 0 ;
25931 PyObject * obj0 = 0 ;
25932 char * kwnames[] = {
25933 (char *) "win", NULL
25934 };
25935
25936 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
25937 if (obj0) {
25938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25939 if (!SWIG_IsOK(res1)) {
25940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
25941 }
25942 arg1 = reinterpret_cast< wxWindow * >(argp1);
25943 }
25944 {
25945 PyThreadState* __tstate = wxPyBeginAllowThreads();
25946 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
25947 wxPyEndAllowThreads(__tstate);
25948 if (PyErr_Occurred()) SWIG_fail;
25949 }
25950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
25951 return resultobj;
25952 fail:
25953 return NULL;
25954 }
25955
25956
25957 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25958 PyObject *resultobj = 0;
25959 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
25960 wxWindow *result = 0 ;
25961 void *argp1 = 0 ;
25962 int res1 = 0 ;
25963 PyObject *swig_obj[1] ;
25964
25965 if (!args) SWIG_fail;
25966 swig_obj[0] = args;
25967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
25968 if (!SWIG_IsOK(res1)) {
25969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
25970 }
25971 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
25972 {
25973 PyThreadState* __tstate = wxPyBeginAllowThreads();
25974 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
25975 wxPyEndAllowThreads(__tstate);
25976 if (PyErr_Occurred()) SWIG_fail;
25977 }
25978 {
25979 resultobj = wxPyMake_wxObject(result, (bool)0);
25980 }
25981 return resultobj;
25982 fail:
25983 return NULL;
25984 }
25985
25986
25987 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25988 PyObject *obj;
25989 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25990 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
25991 return SWIG_Py_Void();
25992 }
25993
25994 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25995 return SWIG_Python_InitShadowInstance(args);
25996 }
25997
25998 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25999 PyObject *resultobj = 0;
26000 wxWindow *arg1 = (wxWindow *) NULL ;
26001 wxWindowDestroyEvent *result = 0 ;
26002 void *argp1 = 0 ;
26003 int res1 = 0 ;
26004 PyObject * obj0 = 0 ;
26005 char * kwnames[] = {
26006 (char *) "win", NULL
26007 };
26008
26009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26010 if (obj0) {
26011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26012 if (!SWIG_IsOK(res1)) {
26013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26014 }
26015 arg1 = reinterpret_cast< wxWindow * >(argp1);
26016 }
26017 {
26018 PyThreadState* __tstate = wxPyBeginAllowThreads();
26019 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26020 wxPyEndAllowThreads(__tstate);
26021 if (PyErr_Occurred()) SWIG_fail;
26022 }
26023 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26024 return resultobj;
26025 fail:
26026 return NULL;
26027 }
26028
26029
26030 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26031 PyObject *resultobj = 0;
26032 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26033 wxWindow *result = 0 ;
26034 void *argp1 = 0 ;
26035 int res1 = 0 ;
26036 PyObject *swig_obj[1] ;
26037
26038 if (!args) SWIG_fail;
26039 swig_obj[0] = args;
26040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26043 }
26044 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26045 {
26046 PyThreadState* __tstate = wxPyBeginAllowThreads();
26047 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26048 wxPyEndAllowThreads(__tstate);
26049 if (PyErr_Occurred()) SWIG_fail;
26050 }
26051 {
26052 resultobj = wxPyMake_wxObject(result, (bool)0);
26053 }
26054 return resultobj;
26055 fail:
26056 return NULL;
26057 }
26058
26059
26060 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26061 PyObject *obj;
26062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26063 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26064 return SWIG_Py_Void();
26065 }
26066
26067 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26068 return SWIG_Python_InitShadowInstance(args);
26069 }
26070
26071 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26072 PyObject *resultobj = 0;
26073 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26074 int arg2 = (int) 0 ;
26075 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26076 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26077 wxContextMenuEvent *result = 0 ;
26078 int val1 ;
26079 int ecode1 = 0 ;
26080 int val2 ;
26081 int ecode2 = 0 ;
26082 wxPoint temp3 ;
26083 PyObject * obj0 = 0 ;
26084 PyObject * obj1 = 0 ;
26085 PyObject * obj2 = 0 ;
26086 char * kwnames[] = {
26087 (char *) "type",(char *) "winid",(char *) "pt", NULL
26088 };
26089
26090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26091 if (obj0) {
26092 ecode1 = SWIG_AsVal_int(obj0, &val1);
26093 if (!SWIG_IsOK(ecode1)) {
26094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26095 }
26096 arg1 = static_cast< wxEventType >(val1);
26097 }
26098 if (obj1) {
26099 ecode2 = SWIG_AsVal_int(obj1, &val2);
26100 if (!SWIG_IsOK(ecode2)) {
26101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26102 }
26103 arg2 = static_cast< int >(val2);
26104 }
26105 if (obj2) {
26106 {
26107 arg3 = &temp3;
26108 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26109 }
26110 }
26111 {
26112 PyThreadState* __tstate = wxPyBeginAllowThreads();
26113 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26114 wxPyEndAllowThreads(__tstate);
26115 if (PyErr_Occurred()) SWIG_fail;
26116 }
26117 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26118 return resultobj;
26119 fail:
26120 return NULL;
26121 }
26122
26123
26124 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26125 PyObject *resultobj = 0;
26126 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26127 wxPoint *result = 0 ;
26128 void *argp1 = 0 ;
26129 int res1 = 0 ;
26130 PyObject *swig_obj[1] ;
26131
26132 if (!args) SWIG_fail;
26133 swig_obj[0] = args;
26134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26135 if (!SWIG_IsOK(res1)) {
26136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26137 }
26138 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26139 {
26140 PyThreadState* __tstate = wxPyBeginAllowThreads();
26141 {
26142 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26143 result = (wxPoint *) &_result_ref;
26144 }
26145 wxPyEndAllowThreads(__tstate);
26146 if (PyErr_Occurred()) SWIG_fail;
26147 }
26148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26149 return resultobj;
26150 fail:
26151 return NULL;
26152 }
26153
26154
26155 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26156 PyObject *resultobj = 0;
26157 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26158 wxPoint *arg2 = 0 ;
26159 void *argp1 = 0 ;
26160 int res1 = 0 ;
26161 wxPoint temp2 ;
26162 PyObject * obj0 = 0 ;
26163 PyObject * obj1 = 0 ;
26164 char * kwnames[] = {
26165 (char *) "self",(char *) "pos", NULL
26166 };
26167
26168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26170 if (!SWIG_IsOK(res1)) {
26171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26172 }
26173 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26174 {
26175 arg2 = &temp2;
26176 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26177 }
26178 {
26179 PyThreadState* __tstate = wxPyBeginAllowThreads();
26180 (arg1)->SetPosition((wxPoint const &)*arg2);
26181 wxPyEndAllowThreads(__tstate);
26182 if (PyErr_Occurred()) SWIG_fail;
26183 }
26184 resultobj = SWIG_Py_Void();
26185 return resultobj;
26186 fail:
26187 return NULL;
26188 }
26189
26190
26191 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26192 PyObject *obj;
26193 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26194 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26195 return SWIG_Py_Void();
26196 }
26197
26198 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26199 return SWIG_Python_InitShadowInstance(args);
26200 }
26201
26202 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26203 PyObject *resultobj = 0;
26204 wxIdleEvent *result = 0 ;
26205
26206 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26207 {
26208 PyThreadState* __tstate = wxPyBeginAllowThreads();
26209 result = (wxIdleEvent *)new wxIdleEvent();
26210 wxPyEndAllowThreads(__tstate);
26211 if (PyErr_Occurred()) SWIG_fail;
26212 }
26213 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26214 return resultobj;
26215 fail:
26216 return NULL;
26217 }
26218
26219
26220 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26221 PyObject *resultobj = 0;
26222 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26223 bool arg2 = (bool) true ;
26224 void *argp1 = 0 ;
26225 int res1 = 0 ;
26226 bool val2 ;
26227 int ecode2 = 0 ;
26228 PyObject * obj0 = 0 ;
26229 PyObject * obj1 = 0 ;
26230 char * kwnames[] = {
26231 (char *) "self",(char *) "needMore", NULL
26232 };
26233
26234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26236 if (!SWIG_IsOK(res1)) {
26237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26238 }
26239 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26240 if (obj1) {
26241 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26242 if (!SWIG_IsOK(ecode2)) {
26243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26244 }
26245 arg2 = static_cast< bool >(val2);
26246 }
26247 {
26248 PyThreadState* __tstate = wxPyBeginAllowThreads();
26249 (arg1)->RequestMore(arg2);
26250 wxPyEndAllowThreads(__tstate);
26251 if (PyErr_Occurred()) SWIG_fail;
26252 }
26253 resultobj = SWIG_Py_Void();
26254 return resultobj;
26255 fail:
26256 return NULL;
26257 }
26258
26259
26260 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26261 PyObject *resultobj = 0;
26262 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26263 bool result;
26264 void *argp1 = 0 ;
26265 int res1 = 0 ;
26266 PyObject *swig_obj[1] ;
26267
26268 if (!args) SWIG_fail;
26269 swig_obj[0] = args;
26270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26271 if (!SWIG_IsOK(res1)) {
26272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26273 }
26274 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26275 {
26276 PyThreadState* __tstate = wxPyBeginAllowThreads();
26277 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26278 wxPyEndAllowThreads(__tstate);
26279 if (PyErr_Occurred()) SWIG_fail;
26280 }
26281 {
26282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26283 }
26284 return resultobj;
26285 fail:
26286 return NULL;
26287 }
26288
26289
26290 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26291 PyObject *resultobj = 0;
26292 wxIdleMode arg1 ;
26293 int val1 ;
26294 int ecode1 = 0 ;
26295 PyObject * obj0 = 0 ;
26296 char * kwnames[] = {
26297 (char *) "mode", NULL
26298 };
26299
26300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26301 ecode1 = SWIG_AsVal_int(obj0, &val1);
26302 if (!SWIG_IsOK(ecode1)) {
26303 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26304 }
26305 arg1 = static_cast< wxIdleMode >(val1);
26306 {
26307 PyThreadState* __tstate = wxPyBeginAllowThreads();
26308 wxIdleEvent::SetMode(arg1);
26309 wxPyEndAllowThreads(__tstate);
26310 if (PyErr_Occurred()) SWIG_fail;
26311 }
26312 resultobj = SWIG_Py_Void();
26313 return resultobj;
26314 fail:
26315 return NULL;
26316 }
26317
26318
26319 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26320 PyObject *resultobj = 0;
26321 wxIdleMode result;
26322
26323 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26324 {
26325 PyThreadState* __tstate = wxPyBeginAllowThreads();
26326 result = (wxIdleMode)wxIdleEvent::GetMode();
26327 wxPyEndAllowThreads(__tstate);
26328 if (PyErr_Occurred()) SWIG_fail;
26329 }
26330 resultobj = SWIG_From_int(static_cast< int >(result));
26331 return resultobj;
26332 fail:
26333 return NULL;
26334 }
26335
26336
26337 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26338 PyObject *resultobj = 0;
26339 wxWindow *arg1 = (wxWindow *) 0 ;
26340 bool result;
26341 void *argp1 = 0 ;
26342 int res1 = 0 ;
26343 PyObject * obj0 = 0 ;
26344 char * kwnames[] = {
26345 (char *) "win", NULL
26346 };
26347
26348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26350 if (!SWIG_IsOK(res1)) {
26351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26352 }
26353 arg1 = reinterpret_cast< wxWindow * >(argp1);
26354 {
26355 PyThreadState* __tstate = wxPyBeginAllowThreads();
26356 result = (bool)wxIdleEvent::CanSend(arg1);
26357 wxPyEndAllowThreads(__tstate);
26358 if (PyErr_Occurred()) SWIG_fail;
26359 }
26360 {
26361 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26362 }
26363 return resultobj;
26364 fail:
26365 return NULL;
26366 }
26367
26368
26369 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26370 PyObject *obj;
26371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26372 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26373 return SWIG_Py_Void();
26374 }
26375
26376 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26377 return SWIG_Python_InitShadowInstance(args);
26378 }
26379
26380 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26381 PyObject *resultobj = 0;
26382 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26383 int arg2 = (int) 0 ;
26384 wxClipboardTextEvent *result = 0 ;
26385 int val1 ;
26386 int ecode1 = 0 ;
26387 int val2 ;
26388 int ecode2 = 0 ;
26389 PyObject * obj0 = 0 ;
26390 PyObject * obj1 = 0 ;
26391 char * kwnames[] = {
26392 (char *) "type",(char *) "winid", NULL
26393 };
26394
26395 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26396 if (obj0) {
26397 ecode1 = SWIG_AsVal_int(obj0, &val1);
26398 if (!SWIG_IsOK(ecode1)) {
26399 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26400 }
26401 arg1 = static_cast< wxEventType >(val1);
26402 }
26403 if (obj1) {
26404 ecode2 = SWIG_AsVal_int(obj1, &val2);
26405 if (!SWIG_IsOK(ecode2)) {
26406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26407 }
26408 arg2 = static_cast< int >(val2);
26409 }
26410 {
26411 PyThreadState* __tstate = wxPyBeginAllowThreads();
26412 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26413 wxPyEndAllowThreads(__tstate);
26414 if (PyErr_Occurred()) SWIG_fail;
26415 }
26416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26417 return resultobj;
26418 fail:
26419 return NULL;
26420 }
26421
26422
26423 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26424 PyObject *obj;
26425 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26426 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26427 return SWIG_Py_Void();
26428 }
26429
26430 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26431 return SWIG_Python_InitShadowInstance(args);
26432 }
26433
26434 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26435 PyObject *resultobj = 0;
26436 int arg1 = (int) 0 ;
26437 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26438 wxPyEvent *result = 0 ;
26439 int val1 ;
26440 int ecode1 = 0 ;
26441 int val2 ;
26442 int ecode2 = 0 ;
26443 PyObject * obj0 = 0 ;
26444 PyObject * obj1 = 0 ;
26445 char * kwnames[] = {
26446 (char *) "winid",(char *) "eventType", NULL
26447 };
26448
26449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26450 if (obj0) {
26451 ecode1 = SWIG_AsVal_int(obj0, &val1);
26452 if (!SWIG_IsOK(ecode1)) {
26453 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26454 }
26455 arg1 = static_cast< int >(val1);
26456 }
26457 if (obj1) {
26458 ecode2 = SWIG_AsVal_int(obj1, &val2);
26459 if (!SWIG_IsOK(ecode2)) {
26460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26461 }
26462 arg2 = static_cast< wxEventType >(val2);
26463 }
26464 {
26465 PyThreadState* __tstate = wxPyBeginAllowThreads();
26466 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26467 wxPyEndAllowThreads(__tstate);
26468 if (PyErr_Occurred()) SWIG_fail;
26469 }
26470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26471 return resultobj;
26472 fail:
26473 return NULL;
26474 }
26475
26476
26477 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26478 PyObject *resultobj = 0;
26479 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26480 void *argp1 = 0 ;
26481 int res1 = 0 ;
26482 PyObject *swig_obj[1] ;
26483
26484 if (!args) SWIG_fail;
26485 swig_obj[0] = args;
26486 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26487 if (!SWIG_IsOK(res1)) {
26488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26489 }
26490 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26491 {
26492 PyThreadState* __tstate = wxPyBeginAllowThreads();
26493 delete arg1;
26494
26495 wxPyEndAllowThreads(__tstate);
26496 if (PyErr_Occurred()) SWIG_fail;
26497 }
26498 resultobj = SWIG_Py_Void();
26499 return resultobj;
26500 fail:
26501 return NULL;
26502 }
26503
26504
26505 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26506 PyObject *resultobj = 0;
26507 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26508 PyObject *arg2 = (PyObject *) 0 ;
26509 void *argp1 = 0 ;
26510 int res1 = 0 ;
26511 PyObject * obj0 = 0 ;
26512 PyObject * obj1 = 0 ;
26513 char * kwnames[] = {
26514 (char *) "self",(char *) "self", NULL
26515 };
26516
26517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26519 if (!SWIG_IsOK(res1)) {
26520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26521 }
26522 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26523 arg2 = obj1;
26524 {
26525 PyThreadState* __tstate = wxPyBeginAllowThreads();
26526 (arg1)->SetSelf(arg2);
26527 wxPyEndAllowThreads(__tstate);
26528 if (PyErr_Occurred()) SWIG_fail;
26529 }
26530 resultobj = SWIG_Py_Void();
26531 return resultobj;
26532 fail:
26533 return NULL;
26534 }
26535
26536
26537 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26538 PyObject *resultobj = 0;
26539 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26540 PyObject *result = 0 ;
26541 void *argp1 = 0 ;
26542 int res1 = 0 ;
26543 PyObject *swig_obj[1] ;
26544
26545 if (!args) SWIG_fail;
26546 swig_obj[0] = args;
26547 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26548 if (!SWIG_IsOK(res1)) {
26549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26550 }
26551 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26552 {
26553 PyThreadState* __tstate = wxPyBeginAllowThreads();
26554 result = (PyObject *)(arg1)->GetSelf();
26555 wxPyEndAllowThreads(__tstate);
26556 if (PyErr_Occurred()) SWIG_fail;
26557 }
26558 resultobj = result;
26559 return resultobj;
26560 fail:
26561 return NULL;
26562 }
26563
26564
26565 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26566 PyObject *obj;
26567 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26568 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26569 return SWIG_Py_Void();
26570 }
26571
26572 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26573 return SWIG_Python_InitShadowInstance(args);
26574 }
26575
26576 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26577 PyObject *resultobj = 0;
26578 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26579 int arg2 = (int) 0 ;
26580 wxPyCommandEvent *result = 0 ;
26581 int val1 ;
26582 int ecode1 = 0 ;
26583 int val2 ;
26584 int ecode2 = 0 ;
26585 PyObject * obj0 = 0 ;
26586 PyObject * obj1 = 0 ;
26587 char * kwnames[] = {
26588 (char *) "eventType",(char *) "id", NULL
26589 };
26590
26591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26592 if (obj0) {
26593 ecode1 = SWIG_AsVal_int(obj0, &val1);
26594 if (!SWIG_IsOK(ecode1)) {
26595 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26596 }
26597 arg1 = static_cast< wxEventType >(val1);
26598 }
26599 if (obj1) {
26600 ecode2 = SWIG_AsVal_int(obj1, &val2);
26601 if (!SWIG_IsOK(ecode2)) {
26602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26603 }
26604 arg2 = static_cast< int >(val2);
26605 }
26606 {
26607 PyThreadState* __tstate = wxPyBeginAllowThreads();
26608 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26609 wxPyEndAllowThreads(__tstate);
26610 if (PyErr_Occurred()) SWIG_fail;
26611 }
26612 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26613 return resultobj;
26614 fail:
26615 return NULL;
26616 }
26617
26618
26619 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26620 PyObject *resultobj = 0;
26621 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26622 void *argp1 = 0 ;
26623 int res1 = 0 ;
26624 PyObject *swig_obj[1] ;
26625
26626 if (!args) SWIG_fail;
26627 swig_obj[0] = args;
26628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26629 if (!SWIG_IsOK(res1)) {
26630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26631 }
26632 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26633 {
26634 PyThreadState* __tstate = wxPyBeginAllowThreads();
26635 delete arg1;
26636
26637 wxPyEndAllowThreads(__tstate);
26638 if (PyErr_Occurred()) SWIG_fail;
26639 }
26640 resultobj = SWIG_Py_Void();
26641 return resultobj;
26642 fail:
26643 return NULL;
26644 }
26645
26646
26647 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26648 PyObject *resultobj = 0;
26649 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26650 PyObject *arg2 = (PyObject *) 0 ;
26651 void *argp1 = 0 ;
26652 int res1 = 0 ;
26653 PyObject * obj0 = 0 ;
26654 PyObject * obj1 = 0 ;
26655 char * kwnames[] = {
26656 (char *) "self",(char *) "self", NULL
26657 };
26658
26659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26661 if (!SWIG_IsOK(res1)) {
26662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26663 }
26664 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26665 arg2 = obj1;
26666 {
26667 PyThreadState* __tstate = wxPyBeginAllowThreads();
26668 (arg1)->SetSelf(arg2);
26669 wxPyEndAllowThreads(__tstate);
26670 if (PyErr_Occurred()) SWIG_fail;
26671 }
26672 resultobj = SWIG_Py_Void();
26673 return resultobj;
26674 fail:
26675 return NULL;
26676 }
26677
26678
26679 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26680 PyObject *resultobj = 0;
26681 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26682 PyObject *result = 0 ;
26683 void *argp1 = 0 ;
26684 int res1 = 0 ;
26685 PyObject *swig_obj[1] ;
26686
26687 if (!args) SWIG_fail;
26688 swig_obj[0] = args;
26689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26690 if (!SWIG_IsOK(res1)) {
26691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26692 }
26693 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26694 {
26695 PyThreadState* __tstate = wxPyBeginAllowThreads();
26696 result = (PyObject *)(arg1)->GetSelf();
26697 wxPyEndAllowThreads(__tstate);
26698 if (PyErr_Occurred()) SWIG_fail;
26699 }
26700 resultobj = result;
26701 return resultobj;
26702 fail:
26703 return NULL;
26704 }
26705
26706
26707 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26708 PyObject *obj;
26709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26710 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26711 return SWIG_Py_Void();
26712 }
26713
26714 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26715 return SWIG_Python_InitShadowInstance(args);
26716 }
26717
26718 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26719 PyObject *resultobj = 0;
26720 wxWindow *arg1 = (wxWindow *) 0 ;
26721 wxDateTime *arg2 = 0 ;
26722 wxEventType arg3 ;
26723 wxDateEvent *result = 0 ;
26724 void *argp1 = 0 ;
26725 int res1 = 0 ;
26726 void *argp2 = 0 ;
26727 int res2 = 0 ;
26728 int val3 ;
26729 int ecode3 = 0 ;
26730 PyObject * obj0 = 0 ;
26731 PyObject * obj1 = 0 ;
26732 PyObject * obj2 = 0 ;
26733 char * kwnames[] = {
26734 (char *) "win",(char *) "dt",(char *) "type", NULL
26735 };
26736
26737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26739 if (!SWIG_IsOK(res1)) {
26740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26741 }
26742 arg1 = reinterpret_cast< wxWindow * >(argp1);
26743 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26744 if (!SWIG_IsOK(res2)) {
26745 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26746 }
26747 if (!argp2) {
26748 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26749 }
26750 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26751 ecode3 = SWIG_AsVal_int(obj2, &val3);
26752 if (!SWIG_IsOK(ecode3)) {
26753 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26754 }
26755 arg3 = static_cast< wxEventType >(val3);
26756 {
26757 PyThreadState* __tstate = wxPyBeginAllowThreads();
26758 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26759 wxPyEndAllowThreads(__tstate);
26760 if (PyErr_Occurred()) SWIG_fail;
26761 }
26762 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26770 PyObject *resultobj = 0;
26771 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26772 wxDateTime *result = 0 ;
26773 void *argp1 = 0 ;
26774 int res1 = 0 ;
26775 PyObject *swig_obj[1] ;
26776
26777 if (!args) SWIG_fail;
26778 swig_obj[0] = args;
26779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26780 if (!SWIG_IsOK(res1)) {
26781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26782 }
26783 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26784 {
26785 PyThreadState* __tstate = wxPyBeginAllowThreads();
26786 {
26787 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26788 result = (wxDateTime *) &_result_ref;
26789 }
26790 wxPyEndAllowThreads(__tstate);
26791 if (PyErr_Occurred()) SWIG_fail;
26792 }
26793 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26794 return resultobj;
26795 fail:
26796 return NULL;
26797 }
26798
26799
26800 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26801 PyObject *resultobj = 0;
26802 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26803 wxDateTime *arg2 = 0 ;
26804 void *argp1 = 0 ;
26805 int res1 = 0 ;
26806 void *argp2 = 0 ;
26807 int res2 = 0 ;
26808 PyObject * obj0 = 0 ;
26809 PyObject * obj1 = 0 ;
26810 char * kwnames[] = {
26811 (char *) "self",(char *) "date", NULL
26812 };
26813
26814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
26815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26816 if (!SWIG_IsOK(res1)) {
26817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
26818 }
26819 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26821 if (!SWIG_IsOK(res2)) {
26822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26823 }
26824 if (!argp2) {
26825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26826 }
26827 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26828 {
26829 PyThreadState* __tstate = wxPyBeginAllowThreads();
26830 (arg1)->SetDate((wxDateTime const &)*arg2);
26831 wxPyEndAllowThreads(__tstate);
26832 if (PyErr_Occurred()) SWIG_fail;
26833 }
26834 resultobj = SWIG_Py_Void();
26835 return resultobj;
26836 fail:
26837 return NULL;
26838 }
26839
26840
26841 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26842 PyObject *obj;
26843 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26844 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
26845 return SWIG_Py_Void();
26846 }
26847
26848 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26849 return SWIG_Python_InitShadowInstance(args);
26850 }
26851
26852 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26853 PyObject *resultobj = 0;
26854 wxPyApp *result = 0 ;
26855
26856 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
26857 {
26858 PyThreadState* __tstate = wxPyBeginAllowThreads();
26859 result = (wxPyApp *)new_wxPyApp();
26860 wxPyEndAllowThreads(__tstate);
26861 if (PyErr_Occurred()) SWIG_fail;
26862 }
26863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
26864 return resultobj;
26865 fail:
26866 return NULL;
26867 }
26868
26869
26870 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26871 PyObject *resultobj = 0;
26872 wxPyApp *arg1 = (wxPyApp *) 0 ;
26873 void *argp1 = 0 ;
26874 int res1 = 0 ;
26875 PyObject *swig_obj[1] ;
26876
26877 if (!args) SWIG_fail;
26878 swig_obj[0] = args;
26879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
26880 if (!SWIG_IsOK(res1)) {
26881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
26882 }
26883 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26884 {
26885 PyThreadState* __tstate = wxPyBeginAllowThreads();
26886 delete arg1;
26887
26888 wxPyEndAllowThreads(__tstate);
26889 if (PyErr_Occurred()) SWIG_fail;
26890 }
26891 resultobj = SWIG_Py_Void();
26892 return resultobj;
26893 fail:
26894 return NULL;
26895 }
26896
26897
26898 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26899 PyObject *resultobj = 0;
26900 wxPyApp *arg1 = (wxPyApp *) 0 ;
26901 PyObject *arg2 = (PyObject *) 0 ;
26902 PyObject *arg3 = (PyObject *) 0 ;
26903 bool arg4 ;
26904 void *argp1 = 0 ;
26905 int res1 = 0 ;
26906 bool val4 ;
26907 int ecode4 = 0 ;
26908 PyObject * obj0 = 0 ;
26909 PyObject * obj1 = 0 ;
26910 PyObject * obj2 = 0 ;
26911 PyObject * obj3 = 0 ;
26912 char * kwnames[] = {
26913 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
26914 };
26915
26916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
26917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26918 if (!SWIG_IsOK(res1)) {
26919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
26920 }
26921 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26922 arg2 = obj1;
26923 arg3 = obj2;
26924 ecode4 = SWIG_AsVal_bool(obj3, &val4);
26925 if (!SWIG_IsOK(ecode4)) {
26926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
26927 }
26928 arg4 = static_cast< bool >(val4);
26929 {
26930 PyThreadState* __tstate = wxPyBeginAllowThreads();
26931 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
26932 wxPyEndAllowThreads(__tstate);
26933 if (PyErr_Occurred()) SWIG_fail;
26934 }
26935 resultobj = SWIG_Py_Void();
26936 return resultobj;
26937 fail:
26938 return NULL;
26939 }
26940
26941
26942 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26943 PyObject *resultobj = 0;
26944 wxPyApp *arg1 = (wxPyApp *) 0 ;
26945 wxString result;
26946 void *argp1 = 0 ;
26947 int res1 = 0 ;
26948 PyObject *swig_obj[1] ;
26949
26950 if (!args) SWIG_fail;
26951 swig_obj[0] = args;
26952 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26953 if (!SWIG_IsOK(res1)) {
26954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
26955 }
26956 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26957 {
26958 PyThreadState* __tstate = wxPyBeginAllowThreads();
26959 result = ((wxPyApp const *)arg1)->GetAppName();
26960 wxPyEndAllowThreads(__tstate);
26961 if (PyErr_Occurred()) SWIG_fail;
26962 }
26963 {
26964 #if wxUSE_UNICODE
26965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
26966 #else
26967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
26968 #endif
26969 }
26970 return resultobj;
26971 fail:
26972 return NULL;
26973 }
26974
26975
26976 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26977 PyObject *resultobj = 0;
26978 wxPyApp *arg1 = (wxPyApp *) 0 ;
26979 wxString *arg2 = 0 ;
26980 void *argp1 = 0 ;
26981 int res1 = 0 ;
26982 bool temp2 = false ;
26983 PyObject * obj0 = 0 ;
26984 PyObject * obj1 = 0 ;
26985 char * kwnames[] = {
26986 (char *) "self",(char *) "name", NULL
26987 };
26988
26989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
26990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
26991 if (!SWIG_IsOK(res1)) {
26992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
26993 }
26994 arg1 = reinterpret_cast< wxPyApp * >(argp1);
26995 {
26996 arg2 = wxString_in_helper(obj1);
26997 if (arg2 == NULL) SWIG_fail;
26998 temp2 = true;
26999 }
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 (arg1)->SetAppName((wxString const &)*arg2);
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 resultobj = SWIG_Py_Void();
27007 {
27008 if (temp2)
27009 delete arg2;
27010 }
27011 return resultobj;
27012 fail:
27013 {
27014 if (temp2)
27015 delete arg2;
27016 }
27017 return NULL;
27018 }
27019
27020
27021 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27022 PyObject *resultobj = 0;
27023 wxPyApp *arg1 = (wxPyApp *) 0 ;
27024 wxString result;
27025 void *argp1 = 0 ;
27026 int res1 = 0 ;
27027 PyObject *swig_obj[1] ;
27028
27029 if (!args) SWIG_fail;
27030 swig_obj[0] = args;
27031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27032 if (!SWIG_IsOK(res1)) {
27033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27034 }
27035 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27036 {
27037 PyThreadState* __tstate = wxPyBeginAllowThreads();
27038 result = ((wxPyApp const *)arg1)->GetClassName();
27039 wxPyEndAllowThreads(__tstate);
27040 if (PyErr_Occurred()) SWIG_fail;
27041 }
27042 {
27043 #if wxUSE_UNICODE
27044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27045 #else
27046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27047 #endif
27048 }
27049 return resultobj;
27050 fail:
27051 return NULL;
27052 }
27053
27054
27055 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27056 PyObject *resultobj = 0;
27057 wxPyApp *arg1 = (wxPyApp *) 0 ;
27058 wxString *arg2 = 0 ;
27059 void *argp1 = 0 ;
27060 int res1 = 0 ;
27061 bool temp2 = false ;
27062 PyObject * obj0 = 0 ;
27063 PyObject * obj1 = 0 ;
27064 char * kwnames[] = {
27065 (char *) "self",(char *) "name", NULL
27066 };
27067
27068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27070 if (!SWIG_IsOK(res1)) {
27071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27072 }
27073 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27074 {
27075 arg2 = wxString_in_helper(obj1);
27076 if (arg2 == NULL) SWIG_fail;
27077 temp2 = true;
27078 }
27079 {
27080 PyThreadState* __tstate = wxPyBeginAllowThreads();
27081 (arg1)->SetClassName((wxString const &)*arg2);
27082 wxPyEndAllowThreads(__tstate);
27083 if (PyErr_Occurred()) SWIG_fail;
27084 }
27085 resultobj = SWIG_Py_Void();
27086 {
27087 if (temp2)
27088 delete arg2;
27089 }
27090 return resultobj;
27091 fail:
27092 {
27093 if (temp2)
27094 delete arg2;
27095 }
27096 return NULL;
27097 }
27098
27099
27100 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27101 PyObject *resultobj = 0;
27102 wxPyApp *arg1 = (wxPyApp *) 0 ;
27103 wxString *result = 0 ;
27104 void *argp1 = 0 ;
27105 int res1 = 0 ;
27106 PyObject *swig_obj[1] ;
27107
27108 if (!args) SWIG_fail;
27109 swig_obj[0] = args;
27110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27111 if (!SWIG_IsOK(res1)) {
27112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27113 }
27114 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27115 {
27116 PyThreadState* __tstate = wxPyBeginAllowThreads();
27117 {
27118 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27119 result = (wxString *) &_result_ref;
27120 }
27121 wxPyEndAllowThreads(__tstate);
27122 if (PyErr_Occurred()) SWIG_fail;
27123 }
27124 {
27125 #if wxUSE_UNICODE
27126 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27127 #else
27128 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27129 #endif
27130 }
27131 return resultobj;
27132 fail:
27133 return NULL;
27134 }
27135
27136
27137 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27138 PyObject *resultobj = 0;
27139 wxPyApp *arg1 = (wxPyApp *) 0 ;
27140 wxString *arg2 = 0 ;
27141 void *argp1 = 0 ;
27142 int res1 = 0 ;
27143 bool temp2 = false ;
27144 PyObject * obj0 = 0 ;
27145 PyObject * obj1 = 0 ;
27146 char * kwnames[] = {
27147 (char *) "self",(char *) "name", NULL
27148 };
27149
27150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27152 if (!SWIG_IsOK(res1)) {
27153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27154 }
27155 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27156 {
27157 arg2 = wxString_in_helper(obj1);
27158 if (arg2 == NULL) SWIG_fail;
27159 temp2 = true;
27160 }
27161 {
27162 PyThreadState* __tstate = wxPyBeginAllowThreads();
27163 (arg1)->SetVendorName((wxString const &)*arg2);
27164 wxPyEndAllowThreads(__tstate);
27165 if (PyErr_Occurred()) SWIG_fail;
27166 }
27167 resultobj = SWIG_Py_Void();
27168 {
27169 if (temp2)
27170 delete arg2;
27171 }
27172 return resultobj;
27173 fail:
27174 {
27175 if (temp2)
27176 delete arg2;
27177 }
27178 return NULL;
27179 }
27180
27181
27182 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27183 PyObject *resultobj = 0;
27184 wxPyApp *arg1 = (wxPyApp *) 0 ;
27185 wxAppTraits *result = 0 ;
27186 void *argp1 = 0 ;
27187 int res1 = 0 ;
27188 PyObject *swig_obj[1] ;
27189
27190 if (!args) SWIG_fail;
27191 swig_obj[0] = args;
27192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27193 if (!SWIG_IsOK(res1)) {
27194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27195 }
27196 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27197 {
27198 PyThreadState* __tstate = wxPyBeginAllowThreads();
27199 result = (wxAppTraits *)(arg1)->GetTraits();
27200 wxPyEndAllowThreads(__tstate);
27201 if (PyErr_Occurred()) SWIG_fail;
27202 }
27203 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27204 return resultobj;
27205 fail:
27206 return NULL;
27207 }
27208
27209
27210 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27211 PyObject *resultobj = 0;
27212 wxPyApp *arg1 = (wxPyApp *) 0 ;
27213 void *argp1 = 0 ;
27214 int res1 = 0 ;
27215 PyObject *swig_obj[1] ;
27216
27217 if (!args) SWIG_fail;
27218 swig_obj[0] = args;
27219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27220 if (!SWIG_IsOK(res1)) {
27221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27222 }
27223 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27224 {
27225 PyThreadState* __tstate = wxPyBeginAllowThreads();
27226 (arg1)->ProcessPendingEvents();
27227 wxPyEndAllowThreads(__tstate);
27228 if (PyErr_Occurred()) SWIG_fail;
27229 }
27230 resultobj = SWIG_Py_Void();
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj = 0;
27239 wxPyApp *arg1 = (wxPyApp *) 0 ;
27240 bool arg2 = (bool) false ;
27241 bool result;
27242 void *argp1 = 0 ;
27243 int res1 = 0 ;
27244 bool val2 ;
27245 int ecode2 = 0 ;
27246 PyObject * obj0 = 0 ;
27247 PyObject * obj1 = 0 ;
27248 char * kwnames[] = {
27249 (char *) "self",(char *) "onlyIfNeeded", NULL
27250 };
27251
27252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27254 if (!SWIG_IsOK(res1)) {
27255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27256 }
27257 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27258 if (obj1) {
27259 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27260 if (!SWIG_IsOK(ecode2)) {
27261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27262 }
27263 arg2 = static_cast< bool >(val2);
27264 }
27265 {
27266 PyThreadState* __tstate = wxPyBeginAllowThreads();
27267 result = (bool)(arg1)->Yield(arg2);
27268 wxPyEndAllowThreads(__tstate);
27269 if (PyErr_Occurred()) SWIG_fail;
27270 }
27271 {
27272 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27273 }
27274 return resultobj;
27275 fail:
27276 return NULL;
27277 }
27278
27279
27280 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27281 PyObject *resultobj = 0;
27282 wxPyApp *arg1 = (wxPyApp *) 0 ;
27283 void *argp1 = 0 ;
27284 int res1 = 0 ;
27285 PyObject *swig_obj[1] ;
27286
27287 if (!args) SWIG_fail;
27288 swig_obj[0] = args;
27289 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27290 if (!SWIG_IsOK(res1)) {
27291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27292 }
27293 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27294 {
27295 PyThreadState* __tstate = wxPyBeginAllowThreads();
27296 (arg1)->WakeUpIdle();
27297 wxPyEndAllowThreads(__tstate);
27298 if (PyErr_Occurred()) SWIG_fail;
27299 }
27300 resultobj = SWIG_Py_Void();
27301 return resultobj;
27302 fail:
27303 return NULL;
27304 }
27305
27306
27307 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27308 PyObject *resultobj = 0;
27309 bool result;
27310
27311 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27312 {
27313 PyThreadState* __tstate = wxPyBeginAllowThreads();
27314 result = (bool)wxPyApp::IsMainLoopRunning();
27315 wxPyEndAllowThreads(__tstate);
27316 if (PyErr_Occurred()) SWIG_fail;
27317 }
27318 {
27319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27320 }
27321 return resultobj;
27322 fail:
27323 return NULL;
27324 }
27325
27326
27327 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27328 PyObject *resultobj = 0;
27329 wxPyApp *arg1 = (wxPyApp *) 0 ;
27330 int result;
27331 void *argp1 = 0 ;
27332 int res1 = 0 ;
27333 PyObject *swig_obj[1] ;
27334
27335 if (!args) SWIG_fail;
27336 swig_obj[0] = args;
27337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27338 if (!SWIG_IsOK(res1)) {
27339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27340 }
27341 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27342 {
27343 PyThreadState* __tstate = wxPyBeginAllowThreads();
27344 result = (int)(arg1)->MainLoop();
27345 wxPyEndAllowThreads(__tstate);
27346 if (PyErr_Occurred()) SWIG_fail;
27347 }
27348 resultobj = SWIG_From_int(static_cast< int >(result));
27349 return resultobj;
27350 fail:
27351 return NULL;
27352 }
27353
27354
27355 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27356 PyObject *resultobj = 0;
27357 wxPyApp *arg1 = (wxPyApp *) 0 ;
27358 void *argp1 = 0 ;
27359 int res1 = 0 ;
27360 PyObject *swig_obj[1] ;
27361
27362 if (!args) SWIG_fail;
27363 swig_obj[0] = args;
27364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27365 if (!SWIG_IsOK(res1)) {
27366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27367 }
27368 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27369 {
27370 PyThreadState* __tstate = wxPyBeginAllowThreads();
27371 (arg1)->Exit();
27372 wxPyEndAllowThreads(__tstate);
27373 if (PyErr_Occurred()) SWIG_fail;
27374 }
27375 resultobj = SWIG_Py_Void();
27376 return resultobj;
27377 fail:
27378 return NULL;
27379 }
27380
27381
27382 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27383 PyObject *resultobj = 0;
27384 wxPyApp *arg1 = (wxPyApp *) 0 ;
27385 void *argp1 = 0 ;
27386 int res1 = 0 ;
27387 PyObject *swig_obj[1] ;
27388
27389 if (!args) SWIG_fail;
27390 swig_obj[0] = args;
27391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27392 if (!SWIG_IsOK(res1)) {
27393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27394 }
27395 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27396 {
27397 PyThreadState* __tstate = wxPyBeginAllowThreads();
27398 (arg1)->ExitMainLoop();
27399 wxPyEndAllowThreads(__tstate);
27400 if (PyErr_Occurred()) SWIG_fail;
27401 }
27402 resultobj = SWIG_Py_Void();
27403 return resultobj;
27404 fail:
27405 return NULL;
27406 }
27407
27408
27409 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27410 PyObject *resultobj = 0;
27411 wxPyApp *arg1 = (wxPyApp *) 0 ;
27412 bool result;
27413 void *argp1 = 0 ;
27414 int res1 = 0 ;
27415 PyObject *swig_obj[1] ;
27416
27417 if (!args) SWIG_fail;
27418 swig_obj[0] = args;
27419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27420 if (!SWIG_IsOK(res1)) {
27421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27422 }
27423 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27424 {
27425 PyThreadState* __tstate = wxPyBeginAllowThreads();
27426 result = (bool)(arg1)->Pending();
27427 wxPyEndAllowThreads(__tstate);
27428 if (PyErr_Occurred()) SWIG_fail;
27429 }
27430 {
27431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27432 }
27433 return resultobj;
27434 fail:
27435 return NULL;
27436 }
27437
27438
27439 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27440 PyObject *resultobj = 0;
27441 wxPyApp *arg1 = (wxPyApp *) 0 ;
27442 bool result;
27443 void *argp1 = 0 ;
27444 int res1 = 0 ;
27445 PyObject *swig_obj[1] ;
27446
27447 if (!args) SWIG_fail;
27448 swig_obj[0] = args;
27449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27450 if (!SWIG_IsOK(res1)) {
27451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27452 }
27453 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27454 {
27455 PyThreadState* __tstate = wxPyBeginAllowThreads();
27456 result = (bool)(arg1)->Dispatch();
27457 wxPyEndAllowThreads(__tstate);
27458 if (PyErr_Occurred()) SWIG_fail;
27459 }
27460 {
27461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27462 }
27463 return resultobj;
27464 fail:
27465 return NULL;
27466 }
27467
27468
27469 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27470 PyObject *resultobj = 0;
27471 wxPyApp *arg1 = (wxPyApp *) 0 ;
27472 bool result;
27473 void *argp1 = 0 ;
27474 int res1 = 0 ;
27475 PyObject *swig_obj[1] ;
27476
27477 if (!args) SWIG_fail;
27478 swig_obj[0] = args;
27479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27480 if (!SWIG_IsOK(res1)) {
27481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27482 }
27483 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27484 {
27485 PyThreadState* __tstate = wxPyBeginAllowThreads();
27486 result = (bool)(arg1)->ProcessIdle();
27487 wxPyEndAllowThreads(__tstate);
27488 if (PyErr_Occurred()) SWIG_fail;
27489 }
27490 {
27491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27492 }
27493 return resultobj;
27494 fail:
27495 return NULL;
27496 }
27497
27498
27499 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27500 PyObject *resultobj = 0;
27501 wxPyApp *arg1 = (wxPyApp *) 0 ;
27502 wxWindow *arg2 = (wxWindow *) 0 ;
27503 wxIdleEvent *arg3 = 0 ;
27504 bool result;
27505 void *argp1 = 0 ;
27506 int res1 = 0 ;
27507 void *argp2 = 0 ;
27508 int res2 = 0 ;
27509 void *argp3 = 0 ;
27510 int res3 = 0 ;
27511 PyObject * obj0 = 0 ;
27512 PyObject * obj1 = 0 ;
27513 PyObject * obj2 = 0 ;
27514 char * kwnames[] = {
27515 (char *) "self",(char *) "win",(char *) "event", NULL
27516 };
27517
27518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27520 if (!SWIG_IsOK(res1)) {
27521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27522 }
27523 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27524 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27525 if (!SWIG_IsOK(res2)) {
27526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27527 }
27528 arg2 = reinterpret_cast< wxWindow * >(argp2);
27529 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27530 if (!SWIG_IsOK(res3)) {
27531 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27532 }
27533 if (!argp3) {
27534 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27535 }
27536 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27537 {
27538 PyThreadState* __tstate = wxPyBeginAllowThreads();
27539 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27540 wxPyEndAllowThreads(__tstate);
27541 if (PyErr_Occurred()) SWIG_fail;
27542 }
27543 {
27544 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27545 }
27546 return resultobj;
27547 fail:
27548 return NULL;
27549 }
27550
27551
27552 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27553 PyObject *resultobj = 0;
27554 wxPyApp *arg1 = (wxPyApp *) 0 ;
27555 bool result;
27556 void *argp1 = 0 ;
27557 int res1 = 0 ;
27558 PyObject *swig_obj[1] ;
27559
27560 if (!args) SWIG_fail;
27561 swig_obj[0] = args;
27562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27563 if (!SWIG_IsOK(res1)) {
27564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27565 }
27566 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27567 {
27568 PyThreadState* __tstate = wxPyBeginAllowThreads();
27569 result = (bool)((wxPyApp const *)arg1)->IsActive();
27570 wxPyEndAllowThreads(__tstate);
27571 if (PyErr_Occurred()) SWIG_fail;
27572 }
27573 {
27574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27575 }
27576 return resultobj;
27577 fail:
27578 return NULL;
27579 }
27580
27581
27582 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27583 PyObject *resultobj = 0;
27584 wxPyApp *arg1 = (wxPyApp *) 0 ;
27585 wxWindow *arg2 = (wxWindow *) 0 ;
27586 void *argp1 = 0 ;
27587 int res1 = 0 ;
27588 void *argp2 = 0 ;
27589 int res2 = 0 ;
27590 PyObject * obj0 = 0 ;
27591 PyObject * obj1 = 0 ;
27592 char * kwnames[] = {
27593 (char *) "self",(char *) "win", NULL
27594 };
27595
27596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27598 if (!SWIG_IsOK(res1)) {
27599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27600 }
27601 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27602 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27603 if (!SWIG_IsOK(res2)) {
27604 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27605 }
27606 arg2 = reinterpret_cast< wxWindow * >(argp2);
27607 {
27608 PyThreadState* __tstate = wxPyBeginAllowThreads();
27609 (arg1)->SetTopWindow(arg2);
27610 wxPyEndAllowThreads(__tstate);
27611 if (PyErr_Occurred()) SWIG_fail;
27612 }
27613 resultobj = SWIG_Py_Void();
27614 return resultobj;
27615 fail:
27616 return NULL;
27617 }
27618
27619
27620 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27621 PyObject *resultobj = 0;
27622 wxPyApp *arg1 = (wxPyApp *) 0 ;
27623 wxWindow *result = 0 ;
27624 void *argp1 = 0 ;
27625 int res1 = 0 ;
27626 PyObject *swig_obj[1] ;
27627
27628 if (!args) SWIG_fail;
27629 swig_obj[0] = args;
27630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27631 if (!SWIG_IsOK(res1)) {
27632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27633 }
27634 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27635 {
27636 PyThreadState* __tstate = wxPyBeginAllowThreads();
27637 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27638 wxPyEndAllowThreads(__tstate);
27639 if (PyErr_Occurred()) SWIG_fail;
27640 }
27641 {
27642 resultobj = wxPyMake_wxObject(result, (bool)0);
27643 }
27644 return resultobj;
27645 fail:
27646 return NULL;
27647 }
27648
27649
27650 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27651 PyObject *resultobj = 0;
27652 wxPyApp *arg1 = (wxPyApp *) 0 ;
27653 bool arg2 ;
27654 void *argp1 = 0 ;
27655 int res1 = 0 ;
27656 bool val2 ;
27657 int ecode2 = 0 ;
27658 PyObject * obj0 = 0 ;
27659 PyObject * obj1 = 0 ;
27660 char * kwnames[] = {
27661 (char *) "self",(char *) "flag", NULL
27662 };
27663
27664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27666 if (!SWIG_IsOK(res1)) {
27667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27668 }
27669 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27670 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27671 if (!SWIG_IsOK(ecode2)) {
27672 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27673 }
27674 arg2 = static_cast< bool >(val2);
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 (arg1)->SetExitOnFrameDelete(arg2);
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 resultobj = SWIG_Py_Void();
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27689 PyObject *resultobj = 0;
27690 wxPyApp *arg1 = (wxPyApp *) 0 ;
27691 bool result;
27692 void *argp1 = 0 ;
27693 int res1 = 0 ;
27694 PyObject *swig_obj[1] ;
27695
27696 if (!args) SWIG_fail;
27697 swig_obj[0] = args;
27698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27699 if (!SWIG_IsOK(res1)) {
27700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27701 }
27702 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27703 {
27704 PyThreadState* __tstate = wxPyBeginAllowThreads();
27705 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27706 wxPyEndAllowThreads(__tstate);
27707 if (PyErr_Occurred()) SWIG_fail;
27708 }
27709 {
27710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27711 }
27712 return resultobj;
27713 fail:
27714 return NULL;
27715 }
27716
27717
27718 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27719 PyObject *resultobj = 0;
27720 wxPyApp *arg1 = (wxPyApp *) 0 ;
27721 bool arg2 ;
27722 void *argp1 = 0 ;
27723 int res1 = 0 ;
27724 bool val2 ;
27725 int ecode2 = 0 ;
27726 PyObject * obj0 = 0 ;
27727 PyObject * obj1 = 0 ;
27728 char * kwnames[] = {
27729 (char *) "self",(char *) "flag", NULL
27730 };
27731
27732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27734 if (!SWIG_IsOK(res1)) {
27735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27736 }
27737 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27738 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27739 if (!SWIG_IsOK(ecode2)) {
27740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27741 }
27742 arg2 = static_cast< bool >(val2);
27743 {
27744 PyThreadState* __tstate = wxPyBeginAllowThreads();
27745 (arg1)->SetUseBestVisual(arg2);
27746 wxPyEndAllowThreads(__tstate);
27747 if (PyErr_Occurred()) SWIG_fail;
27748 }
27749 resultobj = SWIG_Py_Void();
27750 return resultobj;
27751 fail:
27752 return NULL;
27753 }
27754
27755
27756 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27757 PyObject *resultobj = 0;
27758 wxPyApp *arg1 = (wxPyApp *) 0 ;
27759 bool result;
27760 void *argp1 = 0 ;
27761 int res1 = 0 ;
27762 PyObject *swig_obj[1] ;
27763
27764 if (!args) SWIG_fail;
27765 swig_obj[0] = args;
27766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27767 if (!SWIG_IsOK(res1)) {
27768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27769 }
27770 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27771 {
27772 PyThreadState* __tstate = wxPyBeginAllowThreads();
27773 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27774 wxPyEndAllowThreads(__tstate);
27775 if (PyErr_Occurred()) SWIG_fail;
27776 }
27777 {
27778 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27779 }
27780 return resultobj;
27781 fail:
27782 return NULL;
27783 }
27784
27785
27786 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27787 PyObject *resultobj = 0;
27788 wxPyApp *arg1 = (wxPyApp *) 0 ;
27789 int arg2 ;
27790 void *argp1 = 0 ;
27791 int res1 = 0 ;
27792 int val2 ;
27793 int ecode2 = 0 ;
27794 PyObject * obj0 = 0 ;
27795 PyObject * obj1 = 0 ;
27796 char * kwnames[] = {
27797 (char *) "self",(char *) "mode", NULL
27798 };
27799
27800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27802 if (!SWIG_IsOK(res1)) {
27803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27804 }
27805 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27806 ecode2 = SWIG_AsVal_int(obj1, &val2);
27807 if (!SWIG_IsOK(ecode2)) {
27808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
27809 }
27810 arg2 = static_cast< int >(val2);
27811 {
27812 PyThreadState* __tstate = wxPyBeginAllowThreads();
27813 (arg1)->SetPrintMode(arg2);
27814 wxPyEndAllowThreads(__tstate);
27815 if (PyErr_Occurred()) SWIG_fail;
27816 }
27817 resultobj = SWIG_Py_Void();
27818 return resultobj;
27819 fail:
27820 return NULL;
27821 }
27822
27823
27824 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27825 PyObject *resultobj = 0;
27826 wxPyApp *arg1 = (wxPyApp *) 0 ;
27827 int result;
27828 void *argp1 = 0 ;
27829 int res1 = 0 ;
27830 PyObject *swig_obj[1] ;
27831
27832 if (!args) SWIG_fail;
27833 swig_obj[0] = args;
27834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27835 if (!SWIG_IsOK(res1)) {
27836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27837 }
27838 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27839 {
27840 PyThreadState* __tstate = wxPyBeginAllowThreads();
27841 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
27842 wxPyEndAllowThreads(__tstate);
27843 if (PyErr_Occurred()) SWIG_fail;
27844 }
27845 resultobj = SWIG_From_int(static_cast< int >(result));
27846 return resultobj;
27847 fail:
27848 return NULL;
27849 }
27850
27851
27852 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27853 PyObject *resultobj = 0;
27854 wxPyApp *arg1 = (wxPyApp *) 0 ;
27855 int arg2 ;
27856 void *argp1 = 0 ;
27857 int res1 = 0 ;
27858 int val2 ;
27859 int ecode2 = 0 ;
27860 PyObject * obj0 = 0 ;
27861 PyObject * obj1 = 0 ;
27862 char * kwnames[] = {
27863 (char *) "self",(char *) "mode", NULL
27864 };
27865
27866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
27867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27868 if (!SWIG_IsOK(res1)) {
27869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27870 }
27871 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27872 ecode2 = SWIG_AsVal_int(obj1, &val2);
27873 if (!SWIG_IsOK(ecode2)) {
27874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
27875 }
27876 arg2 = static_cast< int >(val2);
27877 {
27878 PyThreadState* __tstate = wxPyBeginAllowThreads();
27879 (arg1)->SetAssertMode(arg2);
27880 wxPyEndAllowThreads(__tstate);
27881 if (PyErr_Occurred()) SWIG_fail;
27882 }
27883 resultobj = SWIG_Py_Void();
27884 return resultobj;
27885 fail:
27886 return NULL;
27887 }
27888
27889
27890 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27891 PyObject *resultobj = 0;
27892 wxPyApp *arg1 = (wxPyApp *) 0 ;
27893 int result;
27894 void *argp1 = 0 ;
27895 int res1 = 0 ;
27896 PyObject *swig_obj[1] ;
27897
27898 if (!args) SWIG_fail;
27899 swig_obj[0] = args;
27900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27901 if (!SWIG_IsOK(res1)) {
27902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27903 }
27904 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27905 {
27906 PyThreadState* __tstate = wxPyBeginAllowThreads();
27907 result = (int)(arg1)->GetAssertMode();
27908 wxPyEndAllowThreads(__tstate);
27909 if (PyErr_Occurred()) SWIG_fail;
27910 }
27911 resultobj = SWIG_From_int(static_cast< int >(result));
27912 return resultobj;
27913 fail:
27914 return NULL;
27915 }
27916
27917
27918 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27919 PyObject *resultobj = 0;
27920 bool result;
27921
27922 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
27923 {
27924 PyThreadState* __tstate = wxPyBeginAllowThreads();
27925 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
27926 wxPyEndAllowThreads(__tstate);
27927 if (PyErr_Occurred()) SWIG_fail;
27928 }
27929 {
27930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27931 }
27932 return resultobj;
27933 fail:
27934 return NULL;
27935 }
27936
27937
27938 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27939 PyObject *resultobj = 0;
27940 long result;
27941
27942 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
27943 {
27944 PyThreadState* __tstate = wxPyBeginAllowThreads();
27945 result = (long)wxPyApp::GetMacAboutMenuItemId();
27946 wxPyEndAllowThreads(__tstate);
27947 if (PyErr_Occurred()) SWIG_fail;
27948 }
27949 resultobj = SWIG_From_long(static_cast< long >(result));
27950 return resultobj;
27951 fail:
27952 return NULL;
27953 }
27954
27955
27956 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27957 PyObject *resultobj = 0;
27958 long result;
27959
27960 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
27961 {
27962 PyThreadState* __tstate = wxPyBeginAllowThreads();
27963 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
27964 wxPyEndAllowThreads(__tstate);
27965 if (PyErr_Occurred()) SWIG_fail;
27966 }
27967 resultobj = SWIG_From_long(static_cast< long >(result));
27968 return resultobj;
27969 fail:
27970 return NULL;
27971 }
27972
27973
27974 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27975 PyObject *resultobj = 0;
27976 long result;
27977
27978 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
27979 {
27980 PyThreadState* __tstate = wxPyBeginAllowThreads();
27981 result = (long)wxPyApp::GetMacExitMenuItemId();
27982 wxPyEndAllowThreads(__tstate);
27983 if (PyErr_Occurred()) SWIG_fail;
27984 }
27985 resultobj = SWIG_From_long(static_cast< long >(result));
27986 return resultobj;
27987 fail:
27988 return NULL;
27989 }
27990
27991
27992 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27993 PyObject *resultobj = 0;
27994 wxString result;
27995
27996 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
27997 {
27998 PyThreadState* __tstate = wxPyBeginAllowThreads();
27999 result = wxPyApp::GetMacHelpMenuTitleName();
28000 wxPyEndAllowThreads(__tstate);
28001 if (PyErr_Occurred()) SWIG_fail;
28002 }
28003 {
28004 #if wxUSE_UNICODE
28005 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28006 #else
28007 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28008 #endif
28009 }
28010 return resultobj;
28011 fail:
28012 return NULL;
28013 }
28014
28015
28016 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28017 PyObject *resultobj = 0;
28018 bool arg1 ;
28019 bool val1 ;
28020 int ecode1 = 0 ;
28021 PyObject * obj0 = 0 ;
28022 char * kwnames[] = {
28023 (char *) "val", NULL
28024 };
28025
28026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28027 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28028 if (!SWIG_IsOK(ecode1)) {
28029 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28030 }
28031 arg1 = static_cast< bool >(val1);
28032 {
28033 PyThreadState* __tstate = wxPyBeginAllowThreads();
28034 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28035 wxPyEndAllowThreads(__tstate);
28036 if (PyErr_Occurred()) SWIG_fail;
28037 }
28038 resultobj = SWIG_Py_Void();
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj = 0;
28047 long arg1 ;
28048 long val1 ;
28049 int ecode1 = 0 ;
28050 PyObject * obj0 = 0 ;
28051 char * kwnames[] = {
28052 (char *) "val", NULL
28053 };
28054
28055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28056 ecode1 = SWIG_AsVal_long(obj0, &val1);
28057 if (!SWIG_IsOK(ecode1)) {
28058 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28059 }
28060 arg1 = static_cast< long >(val1);
28061 {
28062 PyThreadState* __tstate = wxPyBeginAllowThreads();
28063 wxPyApp::SetMacAboutMenuItemId(arg1);
28064 wxPyEndAllowThreads(__tstate);
28065 if (PyErr_Occurred()) SWIG_fail;
28066 }
28067 resultobj = SWIG_Py_Void();
28068 return resultobj;
28069 fail:
28070 return NULL;
28071 }
28072
28073
28074 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28075 PyObject *resultobj = 0;
28076 long arg1 ;
28077 long val1 ;
28078 int ecode1 = 0 ;
28079 PyObject * obj0 = 0 ;
28080 char * kwnames[] = {
28081 (char *) "val", NULL
28082 };
28083
28084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28085 ecode1 = SWIG_AsVal_long(obj0, &val1);
28086 if (!SWIG_IsOK(ecode1)) {
28087 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28088 }
28089 arg1 = static_cast< long >(val1);
28090 {
28091 PyThreadState* __tstate = wxPyBeginAllowThreads();
28092 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28093 wxPyEndAllowThreads(__tstate);
28094 if (PyErr_Occurred()) SWIG_fail;
28095 }
28096 resultobj = SWIG_Py_Void();
28097 return resultobj;
28098 fail:
28099 return NULL;
28100 }
28101
28102
28103 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28104 PyObject *resultobj = 0;
28105 long arg1 ;
28106 long val1 ;
28107 int ecode1 = 0 ;
28108 PyObject * obj0 = 0 ;
28109 char * kwnames[] = {
28110 (char *) "val", NULL
28111 };
28112
28113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28114 ecode1 = SWIG_AsVal_long(obj0, &val1);
28115 if (!SWIG_IsOK(ecode1)) {
28116 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28117 }
28118 arg1 = static_cast< long >(val1);
28119 {
28120 PyThreadState* __tstate = wxPyBeginAllowThreads();
28121 wxPyApp::SetMacExitMenuItemId(arg1);
28122 wxPyEndAllowThreads(__tstate);
28123 if (PyErr_Occurred()) SWIG_fail;
28124 }
28125 resultobj = SWIG_Py_Void();
28126 return resultobj;
28127 fail:
28128 return NULL;
28129 }
28130
28131
28132 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28133 PyObject *resultobj = 0;
28134 wxString *arg1 = 0 ;
28135 bool temp1 = false ;
28136 PyObject * obj0 = 0 ;
28137 char * kwnames[] = {
28138 (char *) "val", NULL
28139 };
28140
28141 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28142 {
28143 arg1 = wxString_in_helper(obj0);
28144 if (arg1 == NULL) SWIG_fail;
28145 temp1 = true;
28146 }
28147 {
28148 PyThreadState* __tstate = wxPyBeginAllowThreads();
28149 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28150 wxPyEndAllowThreads(__tstate);
28151 if (PyErr_Occurred()) SWIG_fail;
28152 }
28153 resultobj = SWIG_Py_Void();
28154 {
28155 if (temp1)
28156 delete arg1;
28157 }
28158 return resultobj;
28159 fail:
28160 {
28161 if (temp1)
28162 delete arg1;
28163 }
28164 return NULL;
28165 }
28166
28167
28168 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28169 PyObject *resultobj = 0;
28170 wxPyApp *arg1 = (wxPyApp *) 0 ;
28171 void *argp1 = 0 ;
28172 int res1 = 0 ;
28173 PyObject *swig_obj[1] ;
28174
28175 if (!args) SWIG_fail;
28176 swig_obj[0] = args;
28177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28178 if (!SWIG_IsOK(res1)) {
28179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28180 }
28181 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28182 {
28183 PyThreadState* __tstate = wxPyBeginAllowThreads();
28184 (arg1)->_BootstrapApp();
28185 wxPyEndAllowThreads(__tstate);
28186 if (PyErr_Occurred()) SWIG_fail;
28187 }
28188 resultobj = SWIG_Py_Void();
28189 return resultobj;
28190 fail:
28191 return NULL;
28192 }
28193
28194
28195 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28196 PyObject *resultobj = 0;
28197 int result;
28198
28199 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28200 {
28201 PyThreadState* __tstate = wxPyBeginAllowThreads();
28202 result = (int)wxPyApp_GetComCtl32Version();
28203 wxPyEndAllowThreads(__tstate);
28204 if (PyErr_Occurred()) SWIG_fail;
28205 }
28206 resultobj = SWIG_From_int(static_cast< int >(result));
28207 return resultobj;
28208 fail:
28209 return NULL;
28210 }
28211
28212
28213 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28214 PyObject *obj;
28215 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28216 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28217 return SWIG_Py_Void();
28218 }
28219
28220 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28221 return SWIG_Python_InitShadowInstance(args);
28222 }
28223
28224 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28225 PyObject *resultobj = 0;
28226
28227 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28228 {
28229 PyThreadState* __tstate = wxPyBeginAllowThreads();
28230 wxExit();
28231 wxPyEndAllowThreads(__tstate);
28232 if (PyErr_Occurred()) SWIG_fail;
28233 }
28234 resultobj = SWIG_Py_Void();
28235 return resultobj;
28236 fail:
28237 return NULL;
28238 }
28239
28240
28241 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28242 PyObject *resultobj = 0;
28243 bool result;
28244
28245 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28246 {
28247 PyThreadState* __tstate = wxPyBeginAllowThreads();
28248 result = (bool)wxYield();
28249 wxPyEndAllowThreads(__tstate);
28250 if (PyErr_Occurred()) SWIG_fail;
28251 }
28252 {
28253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28254 }
28255 return resultobj;
28256 fail:
28257 return NULL;
28258 }
28259
28260
28261 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28262 PyObject *resultobj = 0;
28263 bool result;
28264
28265 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28266 {
28267 PyThreadState* __tstate = wxPyBeginAllowThreads();
28268 result = (bool)wxYieldIfNeeded();
28269 wxPyEndAllowThreads(__tstate);
28270 if (PyErr_Occurred()) SWIG_fail;
28271 }
28272 {
28273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28274 }
28275 return resultobj;
28276 fail:
28277 return NULL;
28278 }
28279
28280
28281 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28282 PyObject *resultobj = 0;
28283 wxWindow *arg1 = (wxWindow *) NULL ;
28284 bool arg2 = (bool) false ;
28285 bool result;
28286 void *argp1 = 0 ;
28287 int res1 = 0 ;
28288 bool val2 ;
28289 int ecode2 = 0 ;
28290 PyObject * obj0 = 0 ;
28291 PyObject * obj1 = 0 ;
28292 char * kwnames[] = {
28293 (char *) "win",(char *) "onlyIfNeeded", NULL
28294 };
28295
28296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28297 if (obj0) {
28298 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28299 if (!SWIG_IsOK(res1)) {
28300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28301 }
28302 arg1 = reinterpret_cast< wxWindow * >(argp1);
28303 }
28304 if (obj1) {
28305 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28306 if (!SWIG_IsOK(ecode2)) {
28307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28308 }
28309 arg2 = static_cast< bool >(val2);
28310 }
28311 {
28312 PyThreadState* __tstate = wxPyBeginAllowThreads();
28313 result = (bool)wxSafeYield(arg1,arg2);
28314 wxPyEndAllowThreads(__tstate);
28315 if (PyErr_Occurred()) SWIG_fail;
28316 }
28317 {
28318 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28319 }
28320 return resultobj;
28321 fail:
28322 return NULL;
28323 }
28324
28325
28326 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28327 PyObject *resultobj = 0;
28328
28329 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28330 {
28331 PyThreadState* __tstate = wxPyBeginAllowThreads();
28332 wxWakeUpIdle();
28333 wxPyEndAllowThreads(__tstate);
28334 if (PyErr_Occurred()) SWIG_fail;
28335 }
28336 resultobj = SWIG_Py_Void();
28337 return resultobj;
28338 fail:
28339 return NULL;
28340 }
28341
28342
28343 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28344 PyObject *resultobj = 0;
28345 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28346 wxEvent *arg2 = 0 ;
28347 void *argp1 = 0 ;
28348 int res1 = 0 ;
28349 void *argp2 = 0 ;
28350 int res2 = 0 ;
28351 PyObject * obj0 = 0 ;
28352 PyObject * obj1 = 0 ;
28353 char * kwnames[] = {
28354 (char *) "dest",(char *) "event", NULL
28355 };
28356
28357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28359 if (!SWIG_IsOK(res1)) {
28360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28361 }
28362 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28363 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28364 if (!SWIG_IsOK(res2)) {
28365 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28366 }
28367 if (!argp2) {
28368 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28369 }
28370 arg2 = reinterpret_cast< wxEvent * >(argp2);
28371 {
28372 PyThreadState* __tstate = wxPyBeginAllowThreads();
28373 wxPostEvent(arg1,*arg2);
28374 wxPyEndAllowThreads(__tstate);
28375 if (PyErr_Occurred()) SWIG_fail;
28376 }
28377 resultobj = SWIG_Py_Void();
28378 return resultobj;
28379 fail:
28380 return NULL;
28381 }
28382
28383
28384 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28385 PyObject *resultobj = 0;
28386
28387 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28388 {
28389 PyThreadState* __tstate = wxPyBeginAllowThreads();
28390 wxApp_CleanUp();
28391 wxPyEndAllowThreads(__tstate);
28392 if (PyErr_Occurred()) SWIG_fail;
28393 }
28394 resultobj = SWIG_Py_Void();
28395 return resultobj;
28396 fail:
28397 return NULL;
28398 }
28399
28400
28401 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28402 PyObject *resultobj = 0;
28403 wxPyApp *result = 0 ;
28404
28405 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28406 {
28407 PyThreadState* __tstate = wxPyBeginAllowThreads();
28408 result = (wxPyApp *)wxPyGetApp();
28409 wxPyEndAllowThreads(__tstate);
28410 if (PyErr_Occurred()) SWIG_fail;
28411 }
28412 {
28413 resultobj = wxPyMake_wxObject(result, 0);
28414 }
28415 return resultobj;
28416 fail:
28417 return NULL;
28418 }
28419
28420
28421 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28422 PyObject *resultobj = 0;
28423 char *arg1 = (char *) 0 ;
28424 int res1 ;
28425 char *buf1 = 0 ;
28426 int alloc1 = 0 ;
28427 PyObject * obj0 = 0 ;
28428 char * kwnames[] = {
28429 (char *) "encoding", NULL
28430 };
28431
28432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28433 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28434 if (!SWIG_IsOK(res1)) {
28435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28436 }
28437 arg1 = buf1;
28438 {
28439 PyThreadState* __tstate = wxPyBeginAllowThreads();
28440 wxSetDefaultPyEncoding((char const *)arg1);
28441 wxPyEndAllowThreads(__tstate);
28442 if (PyErr_Occurred()) SWIG_fail;
28443 }
28444 resultobj = SWIG_Py_Void();
28445 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28446 return resultobj;
28447 fail:
28448 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28449 return NULL;
28450 }
28451
28452
28453 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28454 PyObject *resultobj = 0;
28455 char *result = 0 ;
28456
28457 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28458 {
28459 PyThreadState* __tstate = wxPyBeginAllowThreads();
28460 result = (char *)wxGetDefaultPyEncoding();
28461 wxPyEndAllowThreads(__tstate);
28462 if (PyErr_Occurred()) SWIG_fail;
28463 }
28464 resultobj = SWIG_FromCharPtr(result);
28465 return resultobj;
28466 fail:
28467 return NULL;
28468 }
28469
28470
28471 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28472 PyObject *resultobj = 0;
28473 wxEventLoop *result = 0 ;
28474
28475 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28476 {
28477 PyThreadState* __tstate = wxPyBeginAllowThreads();
28478 result = (wxEventLoop *)new wxEventLoop();
28479 wxPyEndAllowThreads(__tstate);
28480 if (PyErr_Occurred()) SWIG_fail;
28481 }
28482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28483 return resultobj;
28484 fail:
28485 return NULL;
28486 }
28487
28488
28489 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28490 PyObject *resultobj = 0;
28491 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28492 void *argp1 = 0 ;
28493 int res1 = 0 ;
28494 PyObject *swig_obj[1] ;
28495
28496 if (!args) SWIG_fail;
28497 swig_obj[0] = args;
28498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28499 if (!SWIG_IsOK(res1)) {
28500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28501 }
28502 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28503 {
28504 PyThreadState* __tstate = wxPyBeginAllowThreads();
28505 delete arg1;
28506
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 resultobj = SWIG_Py_Void();
28511 return resultobj;
28512 fail:
28513 return NULL;
28514 }
28515
28516
28517 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28518 PyObject *resultobj = 0;
28519 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28520 int result;
28521 void *argp1 = 0 ;
28522 int res1 = 0 ;
28523 PyObject *swig_obj[1] ;
28524
28525 if (!args) SWIG_fail;
28526 swig_obj[0] = args;
28527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28528 if (!SWIG_IsOK(res1)) {
28529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28530 }
28531 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28532 {
28533 PyThreadState* __tstate = wxPyBeginAllowThreads();
28534 result = (int)(arg1)->Run();
28535 wxPyEndAllowThreads(__tstate);
28536 if (PyErr_Occurred()) SWIG_fail;
28537 }
28538 resultobj = SWIG_From_int(static_cast< int >(result));
28539 return resultobj;
28540 fail:
28541 return NULL;
28542 }
28543
28544
28545 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28546 PyObject *resultobj = 0;
28547 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28548 int arg2 = (int) 0 ;
28549 void *argp1 = 0 ;
28550 int res1 = 0 ;
28551 int val2 ;
28552 int ecode2 = 0 ;
28553 PyObject * obj0 = 0 ;
28554 PyObject * obj1 = 0 ;
28555 char * kwnames[] = {
28556 (char *) "self",(char *) "rc", NULL
28557 };
28558
28559 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28560 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28561 if (!SWIG_IsOK(res1)) {
28562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28563 }
28564 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28565 if (obj1) {
28566 ecode2 = SWIG_AsVal_int(obj1, &val2);
28567 if (!SWIG_IsOK(ecode2)) {
28568 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28569 }
28570 arg2 = static_cast< int >(val2);
28571 }
28572 {
28573 PyThreadState* __tstate = wxPyBeginAllowThreads();
28574 (arg1)->Exit(arg2);
28575 wxPyEndAllowThreads(__tstate);
28576 if (PyErr_Occurred()) SWIG_fail;
28577 }
28578 resultobj = SWIG_Py_Void();
28579 return resultobj;
28580 fail:
28581 return NULL;
28582 }
28583
28584
28585 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28586 PyObject *resultobj = 0;
28587 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28588 bool result;
28589 void *argp1 = 0 ;
28590 int res1 = 0 ;
28591 PyObject *swig_obj[1] ;
28592
28593 if (!args) SWIG_fail;
28594 swig_obj[0] = args;
28595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28596 if (!SWIG_IsOK(res1)) {
28597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28598 }
28599 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28600 {
28601 PyThreadState* __tstate = wxPyBeginAllowThreads();
28602 result = (bool)((wxEventLoop const *)arg1)->Pending();
28603 wxPyEndAllowThreads(__tstate);
28604 if (PyErr_Occurred()) SWIG_fail;
28605 }
28606 {
28607 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28608 }
28609 return resultobj;
28610 fail:
28611 return NULL;
28612 }
28613
28614
28615 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28616 PyObject *resultobj = 0;
28617 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28618 bool result;
28619 void *argp1 = 0 ;
28620 int res1 = 0 ;
28621 PyObject *swig_obj[1] ;
28622
28623 if (!args) SWIG_fail;
28624 swig_obj[0] = args;
28625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28626 if (!SWIG_IsOK(res1)) {
28627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28628 }
28629 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28630 {
28631 PyThreadState* __tstate = wxPyBeginAllowThreads();
28632 result = (bool)(arg1)->Dispatch();
28633 wxPyEndAllowThreads(__tstate);
28634 if (PyErr_Occurred()) SWIG_fail;
28635 }
28636 {
28637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28638 }
28639 return resultobj;
28640 fail:
28641 return NULL;
28642 }
28643
28644
28645 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28646 PyObject *resultobj = 0;
28647 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28648 bool result;
28649 void *argp1 = 0 ;
28650 int res1 = 0 ;
28651 PyObject *swig_obj[1] ;
28652
28653 if (!args) SWIG_fail;
28654 swig_obj[0] = args;
28655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28656 if (!SWIG_IsOK(res1)) {
28657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28658 }
28659 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28660 {
28661 PyThreadState* __tstate = wxPyBeginAllowThreads();
28662 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28663 wxPyEndAllowThreads(__tstate);
28664 if (PyErr_Occurred()) SWIG_fail;
28665 }
28666 {
28667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28668 }
28669 return resultobj;
28670 fail:
28671 return NULL;
28672 }
28673
28674
28675 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28676 PyObject *resultobj = 0;
28677 wxEventLoop *result = 0 ;
28678
28679 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28680 {
28681 PyThreadState* __tstate = wxPyBeginAllowThreads();
28682 result = (wxEventLoop *)wxEventLoop::GetActive();
28683 wxPyEndAllowThreads(__tstate);
28684 if (PyErr_Occurred()) SWIG_fail;
28685 }
28686 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28687 return resultobj;
28688 fail:
28689 return NULL;
28690 }
28691
28692
28693 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28694 PyObject *resultobj = 0;
28695 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28696 void *argp1 = 0 ;
28697 int res1 = 0 ;
28698 PyObject * obj0 = 0 ;
28699 char * kwnames[] = {
28700 (char *) "loop", NULL
28701 };
28702
28703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28704 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28705 if (!SWIG_IsOK(res1)) {
28706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28707 }
28708 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28709 {
28710 PyThreadState* __tstate = wxPyBeginAllowThreads();
28711 wxEventLoop::SetActive(arg1);
28712 wxPyEndAllowThreads(__tstate);
28713 if (PyErr_Occurred()) SWIG_fail;
28714 }
28715 resultobj = SWIG_Py_Void();
28716 return resultobj;
28717 fail:
28718 return NULL;
28719 }
28720
28721
28722 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28723 PyObject *obj;
28724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28725 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28726 return SWIG_Py_Void();
28727 }
28728
28729 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28730 return SWIG_Python_InitShadowInstance(args);
28731 }
28732
28733 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28734 PyObject *resultobj = 0;
28735 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28736 wxEventLoopActivator *result = 0 ;
28737 void *argp1 = 0 ;
28738 int res1 = 0 ;
28739 PyObject * obj0 = 0 ;
28740 char * kwnames[] = {
28741 (char *) "evtLoop", NULL
28742 };
28743
28744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28746 if (!SWIG_IsOK(res1)) {
28747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28748 }
28749 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28750 {
28751 PyThreadState* __tstate = wxPyBeginAllowThreads();
28752 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28753 wxPyEndAllowThreads(__tstate);
28754 if (PyErr_Occurred()) SWIG_fail;
28755 }
28756 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28757 return resultobj;
28758 fail:
28759 return NULL;
28760 }
28761
28762
28763 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28764 PyObject *resultobj = 0;
28765 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28766 void *argp1 = 0 ;
28767 int res1 = 0 ;
28768 PyObject *swig_obj[1] ;
28769
28770 if (!args) SWIG_fail;
28771 swig_obj[0] = args;
28772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28773 if (!SWIG_IsOK(res1)) {
28774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28775 }
28776 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28777 {
28778 PyThreadState* __tstate = wxPyBeginAllowThreads();
28779 delete arg1;
28780
28781 wxPyEndAllowThreads(__tstate);
28782 if (PyErr_Occurred()) SWIG_fail;
28783 }
28784 resultobj = SWIG_Py_Void();
28785 return resultobj;
28786 fail:
28787 return NULL;
28788 }
28789
28790
28791 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28792 PyObject *obj;
28793 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28794 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28795 return SWIG_Py_Void();
28796 }
28797
28798 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28799 return SWIG_Python_InitShadowInstance(args);
28800 }
28801
28802 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28803 PyObject *resultobj = 0;
28804 int arg1 = (int) 0 ;
28805 int arg2 = (int) 0 ;
28806 int arg3 = (int) 0 ;
28807 wxAcceleratorEntry *result = 0 ;
28808 int val1 ;
28809 int ecode1 = 0 ;
28810 int val2 ;
28811 int ecode2 = 0 ;
28812 int val3 ;
28813 int ecode3 = 0 ;
28814 PyObject * obj0 = 0 ;
28815 PyObject * obj1 = 0 ;
28816 PyObject * obj2 = 0 ;
28817 char * kwnames[] = {
28818 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
28819 };
28820
28821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
28822 if (obj0) {
28823 ecode1 = SWIG_AsVal_int(obj0, &val1);
28824 if (!SWIG_IsOK(ecode1)) {
28825 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
28826 }
28827 arg1 = static_cast< int >(val1);
28828 }
28829 if (obj1) {
28830 ecode2 = SWIG_AsVal_int(obj1, &val2);
28831 if (!SWIG_IsOK(ecode2)) {
28832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
28833 }
28834 arg2 = static_cast< int >(val2);
28835 }
28836 if (obj2) {
28837 ecode3 = SWIG_AsVal_int(obj2, &val3);
28838 if (!SWIG_IsOK(ecode3)) {
28839 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
28840 }
28841 arg3 = static_cast< int >(val3);
28842 }
28843 {
28844 PyThreadState* __tstate = wxPyBeginAllowThreads();
28845 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
28846 wxPyEndAllowThreads(__tstate);
28847 if (PyErr_Occurred()) SWIG_fail;
28848 }
28849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
28850 return resultobj;
28851 fail:
28852 return NULL;
28853 }
28854
28855
28856 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28857 PyObject *resultobj = 0;
28858 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28859 void *argp1 = 0 ;
28860 int res1 = 0 ;
28861 PyObject *swig_obj[1] ;
28862
28863 if (!args) SWIG_fail;
28864 swig_obj[0] = args;
28865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
28866 if (!SWIG_IsOK(res1)) {
28867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28868 }
28869 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28870 {
28871 PyThreadState* __tstate = wxPyBeginAllowThreads();
28872 delete arg1;
28873
28874 wxPyEndAllowThreads(__tstate);
28875 if (PyErr_Occurred()) SWIG_fail;
28876 }
28877 resultobj = SWIG_Py_Void();
28878 return resultobj;
28879 fail:
28880 return NULL;
28881 }
28882
28883
28884 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28885 PyObject *resultobj = 0;
28886 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28887 int arg2 ;
28888 int arg3 ;
28889 int arg4 ;
28890 void *argp1 = 0 ;
28891 int res1 = 0 ;
28892 int val2 ;
28893 int ecode2 = 0 ;
28894 int val3 ;
28895 int ecode3 = 0 ;
28896 int val4 ;
28897 int ecode4 = 0 ;
28898 PyObject * obj0 = 0 ;
28899 PyObject * obj1 = 0 ;
28900 PyObject * obj2 = 0 ;
28901 PyObject * obj3 = 0 ;
28902 char * kwnames[] = {
28903 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
28904 };
28905
28906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
28907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28908 if (!SWIG_IsOK(res1)) {
28909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28910 }
28911 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28912 ecode2 = SWIG_AsVal_int(obj1, &val2);
28913 if (!SWIG_IsOK(ecode2)) {
28914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
28915 }
28916 arg2 = static_cast< int >(val2);
28917 ecode3 = SWIG_AsVal_int(obj2, &val3);
28918 if (!SWIG_IsOK(ecode3)) {
28919 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
28920 }
28921 arg3 = static_cast< int >(val3);
28922 ecode4 = SWIG_AsVal_int(obj3, &val4);
28923 if (!SWIG_IsOK(ecode4)) {
28924 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
28925 }
28926 arg4 = static_cast< int >(val4);
28927 {
28928 PyThreadState* __tstate = wxPyBeginAllowThreads();
28929 (arg1)->Set(arg2,arg3,arg4);
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 resultobj = SWIG_Py_Void();
28934 return resultobj;
28935 fail:
28936 return NULL;
28937 }
28938
28939
28940 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28941 PyObject *resultobj = 0;
28942 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28943 int result;
28944 void *argp1 = 0 ;
28945 int res1 = 0 ;
28946 PyObject *swig_obj[1] ;
28947
28948 if (!args) SWIG_fail;
28949 swig_obj[0] = args;
28950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28951 if (!SWIG_IsOK(res1)) {
28952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28953 }
28954 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28955 {
28956 PyThreadState* __tstate = wxPyBeginAllowThreads();
28957 result = (int)(arg1)->GetFlags();
28958 wxPyEndAllowThreads(__tstate);
28959 if (PyErr_Occurred()) SWIG_fail;
28960 }
28961 resultobj = SWIG_From_int(static_cast< int >(result));
28962 return resultobj;
28963 fail:
28964 return NULL;
28965 }
28966
28967
28968 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28969 PyObject *resultobj = 0;
28970 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28971 int result;
28972 void *argp1 = 0 ;
28973 int res1 = 0 ;
28974 PyObject *swig_obj[1] ;
28975
28976 if (!args) SWIG_fail;
28977 swig_obj[0] = args;
28978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
28979 if (!SWIG_IsOK(res1)) {
28980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
28981 }
28982 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
28983 {
28984 PyThreadState* __tstate = wxPyBeginAllowThreads();
28985 result = (int)(arg1)->GetKeyCode();
28986 wxPyEndAllowThreads(__tstate);
28987 if (PyErr_Occurred()) SWIG_fail;
28988 }
28989 resultobj = SWIG_From_int(static_cast< int >(result));
28990 return resultobj;
28991 fail:
28992 return NULL;
28993 }
28994
28995
28996 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28997 PyObject *resultobj = 0;
28998 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
28999 int result;
29000 void *argp1 = 0 ;
29001 int res1 = 0 ;
29002 PyObject *swig_obj[1] ;
29003
29004 if (!args) SWIG_fail;
29005 swig_obj[0] = args;
29006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29007 if (!SWIG_IsOK(res1)) {
29008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29009 }
29010 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29011 {
29012 PyThreadState* __tstate = wxPyBeginAllowThreads();
29013 result = (int)(arg1)->GetCommand();
29014 wxPyEndAllowThreads(__tstate);
29015 if (PyErr_Occurred()) SWIG_fail;
29016 }
29017 resultobj = SWIG_From_int(static_cast< int >(result));
29018 return resultobj;
29019 fail:
29020 return NULL;
29021 }
29022
29023
29024 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29025 PyObject *obj;
29026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29027 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29028 return SWIG_Py_Void();
29029 }
29030
29031 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29032 return SWIG_Python_InitShadowInstance(args);
29033 }
29034
29035 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29036 PyObject *resultobj = 0;
29037 int arg1 ;
29038 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29039 wxAcceleratorTable *result = 0 ;
29040 PyObject * obj0 = 0 ;
29041 char * kwnames[] = {
29042 (char *) "n", NULL
29043 };
29044
29045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29046 {
29047 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29048 if (arg2) arg1 = PyList_Size(obj0);
29049 else arg1 = 0;
29050 }
29051 {
29052 PyThreadState* __tstate = wxPyBeginAllowThreads();
29053 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29054 wxPyEndAllowThreads(__tstate);
29055 if (PyErr_Occurred()) SWIG_fail;
29056 }
29057 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29058 return resultobj;
29059 fail:
29060 return NULL;
29061 }
29062
29063
29064 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29065 PyObject *resultobj = 0;
29066 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29067 void *argp1 = 0 ;
29068 int res1 = 0 ;
29069 PyObject *swig_obj[1] ;
29070
29071 if (!args) SWIG_fail;
29072 swig_obj[0] = args;
29073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29074 if (!SWIG_IsOK(res1)) {
29075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29076 }
29077 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29078 {
29079 PyThreadState* __tstate = wxPyBeginAllowThreads();
29080 delete arg1;
29081
29082 wxPyEndAllowThreads(__tstate);
29083 if (PyErr_Occurred()) SWIG_fail;
29084 }
29085 resultobj = SWIG_Py_Void();
29086 return resultobj;
29087 fail:
29088 return NULL;
29089 }
29090
29091
29092 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29093 PyObject *resultobj = 0;
29094 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29095 bool result;
29096 void *argp1 = 0 ;
29097 int res1 = 0 ;
29098 PyObject *swig_obj[1] ;
29099
29100 if (!args) SWIG_fail;
29101 swig_obj[0] = args;
29102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29103 if (!SWIG_IsOK(res1)) {
29104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29105 }
29106 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29107 {
29108 PyThreadState* __tstate = wxPyBeginAllowThreads();
29109 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29110 wxPyEndAllowThreads(__tstate);
29111 if (PyErr_Occurred()) SWIG_fail;
29112 }
29113 {
29114 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29115 }
29116 return resultobj;
29117 fail:
29118 return NULL;
29119 }
29120
29121
29122 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29123 PyObject *obj;
29124 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29125 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29126 return SWIG_Py_Void();
29127 }
29128
29129 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29130 return SWIG_Python_InitShadowInstance(args);
29131 }
29132
29133 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29134 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29135 return 1;
29136 }
29137
29138
29139 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29140 PyObject *pyobj = 0;
29141
29142 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29143 return pyobj;
29144 }
29145
29146
29147 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29148 PyObject *resultobj = 0;
29149 wxString *arg1 = 0 ;
29150 wxAcceleratorEntry *result = 0 ;
29151 bool temp1 = false ;
29152 PyObject * obj0 = 0 ;
29153 char * kwnames[] = {
29154 (char *) "label", NULL
29155 };
29156
29157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29158 {
29159 arg1 = wxString_in_helper(obj0);
29160 if (arg1 == NULL) SWIG_fail;
29161 temp1 = true;
29162 }
29163 {
29164 PyThreadState* __tstate = wxPyBeginAllowThreads();
29165 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29166 wxPyEndAllowThreads(__tstate);
29167 if (PyErr_Occurred()) SWIG_fail;
29168 }
29169 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29170 {
29171 if (temp1)
29172 delete arg1;
29173 }
29174 return resultobj;
29175 fail:
29176 {
29177 if (temp1)
29178 delete arg1;
29179 }
29180 return NULL;
29181 }
29182
29183
29184 SWIGINTERN int PanelNameStr_set(PyObject *) {
29185 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29186 return 1;
29187 }
29188
29189
29190 SWIGINTERN PyObject *PanelNameStr_get(void) {
29191 PyObject *pyobj = 0;
29192
29193 {
29194 #if wxUSE_UNICODE
29195 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29196 #else
29197 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29198 #endif
29199 }
29200 return pyobj;
29201 }
29202
29203
29204 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29205 PyObject *resultobj = 0;
29206 wxVisualAttributes *result = 0 ;
29207
29208 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29209 {
29210 PyThreadState* __tstate = wxPyBeginAllowThreads();
29211 result = (wxVisualAttributes *)new_wxVisualAttributes();
29212 wxPyEndAllowThreads(__tstate);
29213 if (PyErr_Occurred()) SWIG_fail;
29214 }
29215 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29216 return resultobj;
29217 fail:
29218 return NULL;
29219 }
29220
29221
29222 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29223 PyObject *resultobj = 0;
29224 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29225 void *argp1 = 0 ;
29226 int res1 = 0 ;
29227 PyObject *swig_obj[1] ;
29228
29229 if (!args) SWIG_fail;
29230 swig_obj[0] = args;
29231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29232 if (!SWIG_IsOK(res1)) {
29233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29234 }
29235 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29236 {
29237 PyThreadState* __tstate = wxPyBeginAllowThreads();
29238 delete_wxVisualAttributes(arg1);
29239
29240 wxPyEndAllowThreads(__tstate);
29241 if (PyErr_Occurred()) SWIG_fail;
29242 }
29243 resultobj = SWIG_Py_Void();
29244 return resultobj;
29245 fail:
29246 return NULL;
29247 }
29248
29249
29250 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29251 PyObject *resultobj = 0;
29252 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29253 wxFont *arg2 = (wxFont *) 0 ;
29254 void *argp1 = 0 ;
29255 int res1 = 0 ;
29256 void *argp2 = 0 ;
29257 int res2 = 0 ;
29258 PyObject *swig_obj[2] ;
29259
29260 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29262 if (!SWIG_IsOK(res1)) {
29263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29264 }
29265 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29266 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29267 if (!SWIG_IsOK(res2)) {
29268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29269 }
29270 arg2 = reinterpret_cast< wxFont * >(argp2);
29271 if (arg1) (arg1)->font = *arg2;
29272
29273 resultobj = SWIG_Py_Void();
29274 return resultobj;
29275 fail:
29276 return NULL;
29277 }
29278
29279
29280 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29281 PyObject *resultobj = 0;
29282 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29283 wxFont *result = 0 ;
29284 void *argp1 = 0 ;
29285 int res1 = 0 ;
29286 PyObject *swig_obj[1] ;
29287
29288 if (!args) SWIG_fail;
29289 swig_obj[0] = args;
29290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29291 if (!SWIG_IsOK(res1)) {
29292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29293 }
29294 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29295 result = (wxFont *)& ((arg1)->font);
29296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29297 return resultobj;
29298 fail:
29299 return NULL;
29300 }
29301
29302
29303 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29304 PyObject *resultobj = 0;
29305 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29306 wxColour *arg2 = (wxColour *) 0 ;
29307 void *argp1 = 0 ;
29308 int res1 = 0 ;
29309 void *argp2 = 0 ;
29310 int res2 = 0 ;
29311 PyObject *swig_obj[2] ;
29312
29313 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29315 if (!SWIG_IsOK(res1)) {
29316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29317 }
29318 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29319 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29320 if (!SWIG_IsOK(res2)) {
29321 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29322 }
29323 arg2 = reinterpret_cast< wxColour * >(argp2);
29324 if (arg1) (arg1)->colFg = *arg2;
29325
29326 resultobj = SWIG_Py_Void();
29327 return resultobj;
29328 fail:
29329 return NULL;
29330 }
29331
29332
29333 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29334 PyObject *resultobj = 0;
29335 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29336 wxColour *result = 0 ;
29337 void *argp1 = 0 ;
29338 int res1 = 0 ;
29339 PyObject *swig_obj[1] ;
29340
29341 if (!args) SWIG_fail;
29342 swig_obj[0] = args;
29343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29344 if (!SWIG_IsOK(res1)) {
29345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29346 }
29347 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29348 result = (wxColour *)& ((arg1)->colFg);
29349 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29357 PyObject *resultobj = 0;
29358 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29359 wxColour *arg2 = (wxColour *) 0 ;
29360 void *argp1 = 0 ;
29361 int res1 = 0 ;
29362 void *argp2 = 0 ;
29363 int res2 = 0 ;
29364 PyObject *swig_obj[2] ;
29365
29366 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29368 if (!SWIG_IsOK(res1)) {
29369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29370 }
29371 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29372 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29373 if (!SWIG_IsOK(res2)) {
29374 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29375 }
29376 arg2 = reinterpret_cast< wxColour * >(argp2);
29377 if (arg1) (arg1)->colBg = *arg2;
29378
29379 resultobj = SWIG_Py_Void();
29380 return resultobj;
29381 fail:
29382 return NULL;
29383 }
29384
29385
29386 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29387 PyObject *resultobj = 0;
29388 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29389 wxColour *result = 0 ;
29390 void *argp1 = 0 ;
29391 int res1 = 0 ;
29392 PyObject *swig_obj[1] ;
29393
29394 if (!args) SWIG_fail;
29395 swig_obj[0] = args;
29396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29397 if (!SWIG_IsOK(res1)) {
29398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29399 }
29400 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29401 result = (wxColour *)& ((arg1)->colBg);
29402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29403 return resultobj;
29404 fail:
29405 return NULL;
29406 }
29407
29408
29409 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29410 PyObject *obj;
29411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29412 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29413 return SWIG_Py_Void();
29414 }
29415
29416 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29417 return SWIG_Python_InitShadowInstance(args);
29418 }
29419
29420 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29421 PyObject *resultobj = 0;
29422 wxWindow *arg1 = (wxWindow *) 0 ;
29423 int arg2 = (int) (int)-1 ;
29424 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29425 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29426 wxSize const &arg4_defvalue = wxDefaultSize ;
29427 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29428 long arg5 = (long) 0 ;
29429 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29430 wxString *arg6 = (wxString *) &arg6_defvalue ;
29431 wxWindow *result = 0 ;
29432 void *argp1 = 0 ;
29433 int res1 = 0 ;
29434 int val2 ;
29435 int ecode2 = 0 ;
29436 wxPoint temp3 ;
29437 wxSize temp4 ;
29438 long val5 ;
29439 int ecode5 = 0 ;
29440 bool temp6 = false ;
29441 PyObject * obj0 = 0 ;
29442 PyObject * obj1 = 0 ;
29443 PyObject * obj2 = 0 ;
29444 PyObject * obj3 = 0 ;
29445 PyObject * obj4 = 0 ;
29446 PyObject * obj5 = 0 ;
29447 char * kwnames[] = {
29448 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29449 };
29450
29451 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29452 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29453 if (!SWIG_IsOK(res1)) {
29454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29455 }
29456 arg1 = reinterpret_cast< wxWindow * >(argp1);
29457 if (obj1) {
29458 ecode2 = SWIG_AsVal_int(obj1, &val2);
29459 if (!SWIG_IsOK(ecode2)) {
29460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29461 }
29462 arg2 = static_cast< int >(val2);
29463 }
29464 if (obj2) {
29465 {
29466 arg3 = &temp3;
29467 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29468 }
29469 }
29470 if (obj3) {
29471 {
29472 arg4 = &temp4;
29473 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29474 }
29475 }
29476 if (obj4) {
29477 ecode5 = SWIG_AsVal_long(obj4, &val5);
29478 if (!SWIG_IsOK(ecode5)) {
29479 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29480 }
29481 arg5 = static_cast< long >(val5);
29482 }
29483 if (obj5) {
29484 {
29485 arg6 = wxString_in_helper(obj5);
29486 if (arg6 == NULL) SWIG_fail;
29487 temp6 = true;
29488 }
29489 }
29490 {
29491 if (!wxPyCheckForApp()) SWIG_fail;
29492 PyThreadState* __tstate = wxPyBeginAllowThreads();
29493 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29494 wxPyEndAllowThreads(__tstate);
29495 if (PyErr_Occurred()) SWIG_fail;
29496 }
29497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29498 {
29499 if (temp6)
29500 delete arg6;
29501 }
29502 return resultobj;
29503 fail:
29504 {
29505 if (temp6)
29506 delete arg6;
29507 }
29508 return NULL;
29509 }
29510
29511
29512 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29513 PyObject *resultobj = 0;
29514 wxWindow *result = 0 ;
29515
29516 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29517 {
29518 if (!wxPyCheckForApp()) SWIG_fail;
29519 PyThreadState* __tstate = wxPyBeginAllowThreads();
29520 result = (wxWindow *)new wxWindow();
29521 wxPyEndAllowThreads(__tstate);
29522 if (PyErr_Occurred()) SWIG_fail;
29523 }
29524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29525 return resultobj;
29526 fail:
29527 return NULL;
29528 }
29529
29530
29531 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29532 PyObject *resultobj = 0;
29533 wxWindow *arg1 = (wxWindow *) 0 ;
29534 wxWindow *arg2 = (wxWindow *) 0 ;
29535 int arg3 = (int) (int)-1 ;
29536 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29537 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29538 wxSize const &arg5_defvalue = wxDefaultSize ;
29539 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29540 long arg6 = (long) 0 ;
29541 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29542 wxString *arg7 = (wxString *) &arg7_defvalue ;
29543 bool result;
29544 void *argp1 = 0 ;
29545 int res1 = 0 ;
29546 void *argp2 = 0 ;
29547 int res2 = 0 ;
29548 int val3 ;
29549 int ecode3 = 0 ;
29550 wxPoint temp4 ;
29551 wxSize temp5 ;
29552 long val6 ;
29553 int ecode6 = 0 ;
29554 bool temp7 = false ;
29555 PyObject * obj0 = 0 ;
29556 PyObject * obj1 = 0 ;
29557 PyObject * obj2 = 0 ;
29558 PyObject * obj3 = 0 ;
29559 PyObject * obj4 = 0 ;
29560 PyObject * obj5 = 0 ;
29561 PyObject * obj6 = 0 ;
29562 char * kwnames[] = {
29563 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29564 };
29565
29566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29568 if (!SWIG_IsOK(res1)) {
29569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29570 }
29571 arg1 = reinterpret_cast< wxWindow * >(argp1);
29572 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29573 if (!SWIG_IsOK(res2)) {
29574 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29575 }
29576 arg2 = reinterpret_cast< wxWindow * >(argp2);
29577 if (obj2) {
29578 ecode3 = SWIG_AsVal_int(obj2, &val3);
29579 if (!SWIG_IsOK(ecode3)) {
29580 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29581 }
29582 arg3 = static_cast< int >(val3);
29583 }
29584 if (obj3) {
29585 {
29586 arg4 = &temp4;
29587 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29588 }
29589 }
29590 if (obj4) {
29591 {
29592 arg5 = &temp5;
29593 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29594 }
29595 }
29596 if (obj5) {
29597 ecode6 = SWIG_AsVal_long(obj5, &val6);
29598 if (!SWIG_IsOK(ecode6)) {
29599 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29600 }
29601 arg6 = static_cast< long >(val6);
29602 }
29603 if (obj6) {
29604 {
29605 arg7 = wxString_in_helper(obj6);
29606 if (arg7 == NULL) SWIG_fail;
29607 temp7 = true;
29608 }
29609 }
29610 {
29611 PyThreadState* __tstate = wxPyBeginAllowThreads();
29612 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29613 wxPyEndAllowThreads(__tstate);
29614 if (PyErr_Occurred()) SWIG_fail;
29615 }
29616 {
29617 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29618 }
29619 {
29620 if (temp7)
29621 delete arg7;
29622 }
29623 return resultobj;
29624 fail:
29625 {
29626 if (temp7)
29627 delete arg7;
29628 }
29629 return NULL;
29630 }
29631
29632
29633 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29634 PyObject *resultobj = 0;
29635 wxWindow *arg1 = (wxWindow *) 0 ;
29636 bool arg2 = (bool) false ;
29637 bool result;
29638 void *argp1 = 0 ;
29639 int res1 = 0 ;
29640 bool val2 ;
29641 int ecode2 = 0 ;
29642 PyObject * obj0 = 0 ;
29643 PyObject * obj1 = 0 ;
29644 char * kwnames[] = {
29645 (char *) "self",(char *) "force", NULL
29646 };
29647
29648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29650 if (!SWIG_IsOK(res1)) {
29651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29652 }
29653 arg1 = reinterpret_cast< wxWindow * >(argp1);
29654 if (obj1) {
29655 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29656 if (!SWIG_IsOK(ecode2)) {
29657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29658 }
29659 arg2 = static_cast< bool >(val2);
29660 }
29661 {
29662 PyThreadState* __tstate = wxPyBeginAllowThreads();
29663 result = (bool)(arg1)->Close(arg2);
29664 wxPyEndAllowThreads(__tstate);
29665 if (PyErr_Occurred()) SWIG_fail;
29666 }
29667 {
29668 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29669 }
29670 return resultobj;
29671 fail:
29672 return NULL;
29673 }
29674
29675
29676 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29677 PyObject *resultobj = 0;
29678 wxWindow *arg1 = (wxWindow *) 0 ;
29679 bool result;
29680 void *argp1 = 0 ;
29681 int res1 = 0 ;
29682 PyObject *swig_obj[1] ;
29683
29684 if (!args) SWIG_fail;
29685 swig_obj[0] = args;
29686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29687 if (!SWIG_IsOK(res1)) {
29688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29689 }
29690 arg1 = reinterpret_cast< wxWindow * >(argp1);
29691 {
29692 PyThreadState* __tstate = wxPyBeginAllowThreads();
29693 result = (bool)(arg1)->Destroy();
29694 wxPyEndAllowThreads(__tstate);
29695 if (PyErr_Occurred()) SWIG_fail;
29696 }
29697 {
29698 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29699 }
29700 return resultobj;
29701 fail:
29702 return NULL;
29703 }
29704
29705
29706 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29707 PyObject *resultobj = 0;
29708 wxWindow *arg1 = (wxWindow *) 0 ;
29709 bool result;
29710 void *argp1 = 0 ;
29711 int res1 = 0 ;
29712 PyObject *swig_obj[1] ;
29713
29714 if (!args) SWIG_fail;
29715 swig_obj[0] = args;
29716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29717 if (!SWIG_IsOK(res1)) {
29718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29719 }
29720 arg1 = reinterpret_cast< wxWindow * >(argp1);
29721 {
29722 PyThreadState* __tstate = wxPyBeginAllowThreads();
29723 result = (bool)(arg1)->DestroyChildren();
29724 wxPyEndAllowThreads(__tstate);
29725 if (PyErr_Occurred()) SWIG_fail;
29726 }
29727 {
29728 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29729 }
29730 return resultobj;
29731 fail:
29732 return NULL;
29733 }
29734
29735
29736 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29737 PyObject *resultobj = 0;
29738 wxWindow *arg1 = (wxWindow *) 0 ;
29739 bool result;
29740 void *argp1 = 0 ;
29741 int res1 = 0 ;
29742 PyObject *swig_obj[1] ;
29743
29744 if (!args) SWIG_fail;
29745 swig_obj[0] = args;
29746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29747 if (!SWIG_IsOK(res1)) {
29748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29749 }
29750 arg1 = reinterpret_cast< wxWindow * >(argp1);
29751 {
29752 PyThreadState* __tstate = wxPyBeginAllowThreads();
29753 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29754 wxPyEndAllowThreads(__tstate);
29755 if (PyErr_Occurred()) SWIG_fail;
29756 }
29757 {
29758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29759 }
29760 return resultobj;
29761 fail:
29762 return NULL;
29763 }
29764
29765
29766 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29767 PyObject *resultobj = 0;
29768 wxWindow *arg1 = (wxWindow *) 0 ;
29769 wxString *arg2 = 0 ;
29770 void *argp1 = 0 ;
29771 int res1 = 0 ;
29772 bool temp2 = false ;
29773 PyObject * obj0 = 0 ;
29774 PyObject * obj1 = 0 ;
29775 char * kwnames[] = {
29776 (char *) "self",(char *) "label", NULL
29777 };
29778
29779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29781 if (!SWIG_IsOK(res1)) {
29782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29783 }
29784 arg1 = reinterpret_cast< wxWindow * >(argp1);
29785 {
29786 arg2 = wxString_in_helper(obj1);
29787 if (arg2 == NULL) SWIG_fail;
29788 temp2 = true;
29789 }
29790 {
29791 PyThreadState* __tstate = wxPyBeginAllowThreads();
29792 (arg1)->SetLabel((wxString const &)*arg2);
29793 wxPyEndAllowThreads(__tstate);
29794 if (PyErr_Occurred()) SWIG_fail;
29795 }
29796 resultobj = SWIG_Py_Void();
29797 {
29798 if (temp2)
29799 delete arg2;
29800 }
29801 return resultobj;
29802 fail:
29803 {
29804 if (temp2)
29805 delete arg2;
29806 }
29807 return NULL;
29808 }
29809
29810
29811 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29812 PyObject *resultobj = 0;
29813 wxWindow *arg1 = (wxWindow *) 0 ;
29814 wxString result;
29815 void *argp1 = 0 ;
29816 int res1 = 0 ;
29817 PyObject *swig_obj[1] ;
29818
29819 if (!args) SWIG_fail;
29820 swig_obj[0] = args;
29821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29822 if (!SWIG_IsOK(res1)) {
29823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
29824 }
29825 arg1 = reinterpret_cast< wxWindow * >(argp1);
29826 {
29827 PyThreadState* __tstate = wxPyBeginAllowThreads();
29828 result = ((wxWindow const *)arg1)->GetLabel();
29829 wxPyEndAllowThreads(__tstate);
29830 if (PyErr_Occurred()) SWIG_fail;
29831 }
29832 {
29833 #if wxUSE_UNICODE
29834 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29835 #else
29836 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29837 #endif
29838 }
29839 return resultobj;
29840 fail:
29841 return NULL;
29842 }
29843
29844
29845 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29846 PyObject *resultobj = 0;
29847 wxWindow *arg1 = (wxWindow *) 0 ;
29848 wxString *arg2 = 0 ;
29849 void *argp1 = 0 ;
29850 int res1 = 0 ;
29851 bool temp2 = false ;
29852 PyObject * obj0 = 0 ;
29853 PyObject * obj1 = 0 ;
29854 char * kwnames[] = {
29855 (char *) "self",(char *) "name", NULL
29856 };
29857
29858 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
29859 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29860 if (!SWIG_IsOK(res1)) {
29861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
29862 }
29863 arg1 = reinterpret_cast< wxWindow * >(argp1);
29864 {
29865 arg2 = wxString_in_helper(obj1);
29866 if (arg2 == NULL) SWIG_fail;
29867 temp2 = true;
29868 }
29869 {
29870 PyThreadState* __tstate = wxPyBeginAllowThreads();
29871 (arg1)->SetName((wxString const &)*arg2);
29872 wxPyEndAllowThreads(__tstate);
29873 if (PyErr_Occurred()) SWIG_fail;
29874 }
29875 resultobj = SWIG_Py_Void();
29876 {
29877 if (temp2)
29878 delete arg2;
29879 }
29880 return resultobj;
29881 fail:
29882 {
29883 if (temp2)
29884 delete arg2;
29885 }
29886 return NULL;
29887 }
29888
29889
29890 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29891 PyObject *resultobj = 0;
29892 wxWindow *arg1 = (wxWindow *) 0 ;
29893 wxString result;
29894 void *argp1 = 0 ;
29895 int res1 = 0 ;
29896 PyObject *swig_obj[1] ;
29897
29898 if (!args) SWIG_fail;
29899 swig_obj[0] = args;
29900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29901 if (!SWIG_IsOK(res1)) {
29902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
29903 }
29904 arg1 = reinterpret_cast< wxWindow * >(argp1);
29905 {
29906 PyThreadState* __tstate = wxPyBeginAllowThreads();
29907 result = ((wxWindow const *)arg1)->GetName();
29908 wxPyEndAllowThreads(__tstate);
29909 if (PyErr_Occurred()) SWIG_fail;
29910 }
29911 {
29912 #if wxUSE_UNICODE
29913 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
29914 #else
29915 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
29916 #endif
29917 }
29918 return resultobj;
29919 fail:
29920 return NULL;
29921 }
29922
29923
29924 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29925 PyObject *resultobj = 0;
29926 wxWindow *arg1 = (wxWindow *) 0 ;
29927 wxWindowVariant arg2 ;
29928 void *argp1 = 0 ;
29929 int res1 = 0 ;
29930 int val2 ;
29931 int ecode2 = 0 ;
29932 PyObject * obj0 = 0 ;
29933 PyObject * obj1 = 0 ;
29934 char * kwnames[] = {
29935 (char *) "self",(char *) "variant", NULL
29936 };
29937
29938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
29939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29940 if (!SWIG_IsOK(res1)) {
29941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
29942 }
29943 arg1 = reinterpret_cast< wxWindow * >(argp1);
29944 ecode2 = SWIG_AsVal_int(obj1, &val2);
29945 if (!SWIG_IsOK(ecode2)) {
29946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
29947 }
29948 arg2 = static_cast< wxWindowVariant >(val2);
29949 {
29950 PyThreadState* __tstate = wxPyBeginAllowThreads();
29951 (arg1)->SetWindowVariant(arg2);
29952 wxPyEndAllowThreads(__tstate);
29953 if (PyErr_Occurred()) SWIG_fail;
29954 }
29955 resultobj = SWIG_Py_Void();
29956 return resultobj;
29957 fail:
29958 return NULL;
29959 }
29960
29961
29962 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29963 PyObject *resultobj = 0;
29964 wxWindow *arg1 = (wxWindow *) 0 ;
29965 wxWindowVariant result;
29966 void *argp1 = 0 ;
29967 int res1 = 0 ;
29968 PyObject *swig_obj[1] ;
29969
29970 if (!args) SWIG_fail;
29971 swig_obj[0] = args;
29972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29973 if (!SWIG_IsOK(res1)) {
29974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
29975 }
29976 arg1 = reinterpret_cast< wxWindow * >(argp1);
29977 {
29978 PyThreadState* __tstate = wxPyBeginAllowThreads();
29979 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
29980 wxPyEndAllowThreads(__tstate);
29981 if (PyErr_Occurred()) SWIG_fail;
29982 }
29983 resultobj = SWIG_From_int(static_cast< int >(result));
29984 return resultobj;
29985 fail:
29986 return NULL;
29987 }
29988
29989
29990 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29991 PyObject *resultobj = 0;
29992 wxWindow *arg1 = (wxWindow *) 0 ;
29993 int arg2 ;
29994 void *argp1 = 0 ;
29995 int res1 = 0 ;
29996 int val2 ;
29997 int ecode2 = 0 ;
29998 PyObject * obj0 = 0 ;
29999 PyObject * obj1 = 0 ;
30000 char * kwnames[] = {
30001 (char *) "self",(char *) "winid", NULL
30002 };
30003
30004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30006 if (!SWIG_IsOK(res1)) {
30007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30008 }
30009 arg1 = reinterpret_cast< wxWindow * >(argp1);
30010 ecode2 = SWIG_AsVal_int(obj1, &val2);
30011 if (!SWIG_IsOK(ecode2)) {
30012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30013 }
30014 arg2 = static_cast< int >(val2);
30015 {
30016 PyThreadState* __tstate = wxPyBeginAllowThreads();
30017 (arg1)->SetId(arg2);
30018 wxPyEndAllowThreads(__tstate);
30019 if (PyErr_Occurred()) SWIG_fail;
30020 }
30021 resultobj = SWIG_Py_Void();
30022 return resultobj;
30023 fail:
30024 return NULL;
30025 }
30026
30027
30028 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30029 PyObject *resultobj = 0;
30030 wxWindow *arg1 = (wxWindow *) 0 ;
30031 int result;
30032 void *argp1 = 0 ;
30033 int res1 = 0 ;
30034 PyObject *swig_obj[1] ;
30035
30036 if (!args) SWIG_fail;
30037 swig_obj[0] = args;
30038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30039 if (!SWIG_IsOK(res1)) {
30040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30041 }
30042 arg1 = reinterpret_cast< wxWindow * >(argp1);
30043 {
30044 PyThreadState* __tstate = wxPyBeginAllowThreads();
30045 result = (int)((wxWindow const *)arg1)->GetId();
30046 wxPyEndAllowThreads(__tstate);
30047 if (PyErr_Occurred()) SWIG_fail;
30048 }
30049 resultobj = SWIG_From_int(static_cast< int >(result));
30050 return resultobj;
30051 fail:
30052 return NULL;
30053 }
30054
30055
30056 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30057 PyObject *resultobj = 0;
30058 int result;
30059
30060 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30061 {
30062 PyThreadState* __tstate = wxPyBeginAllowThreads();
30063 result = (int)wxWindow::NewControlId();
30064 wxPyEndAllowThreads(__tstate);
30065 if (PyErr_Occurred()) SWIG_fail;
30066 }
30067 resultobj = SWIG_From_int(static_cast< int >(result));
30068 return resultobj;
30069 fail:
30070 return NULL;
30071 }
30072
30073
30074 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30075 PyObject *resultobj = 0;
30076 int arg1 ;
30077 int result;
30078 int val1 ;
30079 int ecode1 = 0 ;
30080 PyObject * obj0 = 0 ;
30081 char * kwnames[] = {
30082 (char *) "winid", NULL
30083 };
30084
30085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30086 ecode1 = SWIG_AsVal_int(obj0, &val1);
30087 if (!SWIG_IsOK(ecode1)) {
30088 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30089 }
30090 arg1 = static_cast< int >(val1);
30091 {
30092 PyThreadState* __tstate = wxPyBeginAllowThreads();
30093 result = (int)wxWindow::NextControlId(arg1);
30094 wxPyEndAllowThreads(__tstate);
30095 if (PyErr_Occurred()) SWIG_fail;
30096 }
30097 resultobj = SWIG_From_int(static_cast< int >(result));
30098 return resultobj;
30099 fail:
30100 return NULL;
30101 }
30102
30103
30104 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30105 PyObject *resultobj = 0;
30106 int arg1 ;
30107 int result;
30108 int val1 ;
30109 int ecode1 = 0 ;
30110 PyObject * obj0 = 0 ;
30111 char * kwnames[] = {
30112 (char *) "winid", NULL
30113 };
30114
30115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30116 ecode1 = SWIG_AsVal_int(obj0, &val1);
30117 if (!SWIG_IsOK(ecode1)) {
30118 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30119 }
30120 arg1 = static_cast< int >(val1);
30121 {
30122 PyThreadState* __tstate = wxPyBeginAllowThreads();
30123 result = (int)wxWindow::PrevControlId(arg1);
30124 wxPyEndAllowThreads(__tstate);
30125 if (PyErr_Occurred()) SWIG_fail;
30126 }
30127 resultobj = SWIG_From_int(static_cast< int >(result));
30128 return resultobj;
30129 fail:
30130 return NULL;
30131 }
30132
30133
30134 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30135 PyObject *resultobj = 0;
30136 wxWindow *arg1 = (wxWindow *) 0 ;
30137 wxSize *arg2 = 0 ;
30138 void *argp1 = 0 ;
30139 int res1 = 0 ;
30140 wxSize temp2 ;
30141 PyObject * obj0 = 0 ;
30142 PyObject * obj1 = 0 ;
30143 char * kwnames[] = {
30144 (char *) "self",(char *) "size", NULL
30145 };
30146
30147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30149 if (!SWIG_IsOK(res1)) {
30150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30151 }
30152 arg1 = reinterpret_cast< wxWindow * >(argp1);
30153 {
30154 arg2 = &temp2;
30155 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30156 }
30157 {
30158 PyThreadState* __tstate = wxPyBeginAllowThreads();
30159 (arg1)->SetSize((wxSize const &)*arg2);
30160 wxPyEndAllowThreads(__tstate);
30161 if (PyErr_Occurred()) SWIG_fail;
30162 }
30163 resultobj = SWIG_Py_Void();
30164 return resultobj;
30165 fail:
30166 return NULL;
30167 }
30168
30169
30170 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30171 PyObject *resultobj = 0;
30172 wxWindow *arg1 = (wxWindow *) 0 ;
30173 int arg2 ;
30174 int arg3 ;
30175 int arg4 ;
30176 int arg5 ;
30177 int arg6 = (int) wxSIZE_AUTO ;
30178 void *argp1 = 0 ;
30179 int res1 = 0 ;
30180 int val2 ;
30181 int ecode2 = 0 ;
30182 int val3 ;
30183 int ecode3 = 0 ;
30184 int val4 ;
30185 int ecode4 = 0 ;
30186 int val5 ;
30187 int ecode5 = 0 ;
30188 int val6 ;
30189 int ecode6 = 0 ;
30190 PyObject * obj0 = 0 ;
30191 PyObject * obj1 = 0 ;
30192 PyObject * obj2 = 0 ;
30193 PyObject * obj3 = 0 ;
30194 PyObject * obj4 = 0 ;
30195 PyObject * obj5 = 0 ;
30196 char * kwnames[] = {
30197 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30198 };
30199
30200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30202 if (!SWIG_IsOK(res1)) {
30203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30204 }
30205 arg1 = reinterpret_cast< wxWindow * >(argp1);
30206 ecode2 = SWIG_AsVal_int(obj1, &val2);
30207 if (!SWIG_IsOK(ecode2)) {
30208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30209 }
30210 arg2 = static_cast< int >(val2);
30211 ecode3 = SWIG_AsVal_int(obj2, &val3);
30212 if (!SWIG_IsOK(ecode3)) {
30213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30214 }
30215 arg3 = static_cast< int >(val3);
30216 ecode4 = SWIG_AsVal_int(obj3, &val4);
30217 if (!SWIG_IsOK(ecode4)) {
30218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30219 }
30220 arg4 = static_cast< int >(val4);
30221 ecode5 = SWIG_AsVal_int(obj4, &val5);
30222 if (!SWIG_IsOK(ecode5)) {
30223 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30224 }
30225 arg5 = static_cast< int >(val5);
30226 if (obj5) {
30227 ecode6 = SWIG_AsVal_int(obj5, &val6);
30228 if (!SWIG_IsOK(ecode6)) {
30229 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30230 }
30231 arg6 = static_cast< int >(val6);
30232 }
30233 {
30234 PyThreadState* __tstate = wxPyBeginAllowThreads();
30235 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30236 wxPyEndAllowThreads(__tstate);
30237 if (PyErr_Occurred()) SWIG_fail;
30238 }
30239 resultobj = SWIG_Py_Void();
30240 return resultobj;
30241 fail:
30242 return NULL;
30243 }
30244
30245
30246 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30247 PyObject *resultobj = 0;
30248 wxWindow *arg1 = (wxWindow *) 0 ;
30249 wxRect *arg2 = 0 ;
30250 int arg3 = (int) wxSIZE_AUTO ;
30251 void *argp1 = 0 ;
30252 int res1 = 0 ;
30253 wxRect temp2 ;
30254 int val3 ;
30255 int ecode3 = 0 ;
30256 PyObject * obj0 = 0 ;
30257 PyObject * obj1 = 0 ;
30258 PyObject * obj2 = 0 ;
30259 char * kwnames[] = {
30260 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30261 };
30262
30263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30265 if (!SWIG_IsOK(res1)) {
30266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30267 }
30268 arg1 = reinterpret_cast< wxWindow * >(argp1);
30269 {
30270 arg2 = &temp2;
30271 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30272 }
30273 if (obj2) {
30274 ecode3 = SWIG_AsVal_int(obj2, &val3);
30275 if (!SWIG_IsOK(ecode3)) {
30276 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30277 }
30278 arg3 = static_cast< int >(val3);
30279 }
30280 {
30281 PyThreadState* __tstate = wxPyBeginAllowThreads();
30282 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 resultobj = SWIG_Py_Void();
30287 return resultobj;
30288 fail:
30289 return NULL;
30290 }
30291
30292
30293 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30294 PyObject *resultobj = 0;
30295 wxWindow *arg1 = (wxWindow *) 0 ;
30296 int arg2 ;
30297 int arg3 ;
30298 void *argp1 = 0 ;
30299 int res1 = 0 ;
30300 int val2 ;
30301 int ecode2 = 0 ;
30302 int val3 ;
30303 int ecode3 = 0 ;
30304 PyObject * obj0 = 0 ;
30305 PyObject * obj1 = 0 ;
30306 PyObject * obj2 = 0 ;
30307 char * kwnames[] = {
30308 (char *) "self",(char *) "width",(char *) "height", NULL
30309 };
30310
30311 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30312 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30313 if (!SWIG_IsOK(res1)) {
30314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30315 }
30316 arg1 = reinterpret_cast< wxWindow * >(argp1);
30317 ecode2 = SWIG_AsVal_int(obj1, &val2);
30318 if (!SWIG_IsOK(ecode2)) {
30319 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30320 }
30321 arg2 = static_cast< int >(val2);
30322 ecode3 = SWIG_AsVal_int(obj2, &val3);
30323 if (!SWIG_IsOK(ecode3)) {
30324 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30325 }
30326 arg3 = static_cast< int >(val3);
30327 {
30328 PyThreadState* __tstate = wxPyBeginAllowThreads();
30329 (arg1)->SetSize(arg2,arg3);
30330 wxPyEndAllowThreads(__tstate);
30331 if (PyErr_Occurred()) SWIG_fail;
30332 }
30333 resultobj = SWIG_Py_Void();
30334 return resultobj;
30335 fail:
30336 return NULL;
30337 }
30338
30339
30340 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30341 PyObject *resultobj = 0;
30342 wxWindow *arg1 = (wxWindow *) 0 ;
30343 wxPoint *arg2 = 0 ;
30344 int arg3 = (int) wxSIZE_USE_EXISTING ;
30345 void *argp1 = 0 ;
30346 int res1 = 0 ;
30347 wxPoint temp2 ;
30348 int val3 ;
30349 int ecode3 = 0 ;
30350 PyObject * obj0 = 0 ;
30351 PyObject * obj1 = 0 ;
30352 PyObject * obj2 = 0 ;
30353 char * kwnames[] = {
30354 (char *) "self",(char *) "pt",(char *) "flags", NULL
30355 };
30356
30357 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30358 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30359 if (!SWIG_IsOK(res1)) {
30360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30361 }
30362 arg1 = reinterpret_cast< wxWindow * >(argp1);
30363 {
30364 arg2 = &temp2;
30365 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30366 }
30367 if (obj2) {
30368 ecode3 = SWIG_AsVal_int(obj2, &val3);
30369 if (!SWIG_IsOK(ecode3)) {
30370 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30371 }
30372 arg3 = static_cast< int >(val3);
30373 }
30374 {
30375 PyThreadState* __tstate = wxPyBeginAllowThreads();
30376 (arg1)->Move((wxPoint const &)*arg2,arg3);
30377 wxPyEndAllowThreads(__tstate);
30378 if (PyErr_Occurred()) SWIG_fail;
30379 }
30380 resultobj = SWIG_Py_Void();
30381 return resultobj;
30382 fail:
30383 return NULL;
30384 }
30385
30386
30387 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30388 PyObject *resultobj = 0;
30389 wxWindow *arg1 = (wxWindow *) 0 ;
30390 int arg2 ;
30391 int arg3 ;
30392 int arg4 = (int) wxSIZE_USE_EXISTING ;
30393 void *argp1 = 0 ;
30394 int res1 = 0 ;
30395 int val2 ;
30396 int ecode2 = 0 ;
30397 int val3 ;
30398 int ecode3 = 0 ;
30399 int val4 ;
30400 int ecode4 = 0 ;
30401 PyObject * obj0 = 0 ;
30402 PyObject * obj1 = 0 ;
30403 PyObject * obj2 = 0 ;
30404 PyObject * obj3 = 0 ;
30405 char * kwnames[] = {
30406 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30407 };
30408
30409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30411 if (!SWIG_IsOK(res1)) {
30412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30413 }
30414 arg1 = reinterpret_cast< wxWindow * >(argp1);
30415 ecode2 = SWIG_AsVal_int(obj1, &val2);
30416 if (!SWIG_IsOK(ecode2)) {
30417 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30418 }
30419 arg2 = static_cast< int >(val2);
30420 ecode3 = SWIG_AsVal_int(obj2, &val3);
30421 if (!SWIG_IsOK(ecode3)) {
30422 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30423 }
30424 arg3 = static_cast< int >(val3);
30425 if (obj3) {
30426 ecode4 = SWIG_AsVal_int(obj3, &val4);
30427 if (!SWIG_IsOK(ecode4)) {
30428 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30429 }
30430 arg4 = static_cast< int >(val4);
30431 }
30432 {
30433 PyThreadState* __tstate = wxPyBeginAllowThreads();
30434 (arg1)->Move(arg2,arg3,arg4);
30435 wxPyEndAllowThreads(__tstate);
30436 if (PyErr_Occurred()) SWIG_fail;
30437 }
30438 resultobj = SWIG_Py_Void();
30439 return resultobj;
30440 fail:
30441 return NULL;
30442 }
30443
30444
30445 SWIGINTERN PyObject *_wrap_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30446 PyObject *resultobj = 0;
30447 wxWindow *arg1 = (wxWindow *) 0 ;
30448 wxSize const &arg2_defvalue = wxDefaultSize ;
30449 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30450 void *argp1 = 0 ;
30451 int res1 = 0 ;
30452 wxSize temp2 ;
30453 PyObject * obj0 = 0 ;
30454 PyObject * obj1 = 0 ;
30455 char * kwnames[] = {
30456 (char *) "self",(char *) "size", NULL
30457 };
30458
30459 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30460 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30461 if (!SWIG_IsOK(res1)) {
30462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30463 }
30464 arg1 = reinterpret_cast< wxWindow * >(argp1);
30465 if (obj1) {
30466 {
30467 arg2 = &temp2;
30468 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30469 }
30470 }
30471 {
30472 PyThreadState* __tstate = wxPyBeginAllowThreads();
30473 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30474 wxPyEndAllowThreads(__tstate);
30475 if (PyErr_Occurred()) SWIG_fail;
30476 }
30477 resultobj = SWIG_Py_Void();
30478 return resultobj;
30479 fail:
30480 return NULL;
30481 }
30482
30483
30484 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30485 PyObject *resultobj = 0;
30486 wxWindow *arg1 = (wxWindow *) 0 ;
30487 void *argp1 = 0 ;
30488 int res1 = 0 ;
30489 PyObject *swig_obj[1] ;
30490
30491 if (!args) SWIG_fail;
30492 swig_obj[0] = args;
30493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30494 if (!SWIG_IsOK(res1)) {
30495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30496 }
30497 arg1 = reinterpret_cast< wxWindow * >(argp1);
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 (arg1)->Raise();
30501 wxPyEndAllowThreads(__tstate);
30502 if (PyErr_Occurred()) SWIG_fail;
30503 }
30504 resultobj = SWIG_Py_Void();
30505 return resultobj;
30506 fail:
30507 return NULL;
30508 }
30509
30510
30511 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30512 PyObject *resultobj = 0;
30513 wxWindow *arg1 = (wxWindow *) 0 ;
30514 void *argp1 = 0 ;
30515 int res1 = 0 ;
30516 PyObject *swig_obj[1] ;
30517
30518 if (!args) SWIG_fail;
30519 swig_obj[0] = args;
30520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30521 if (!SWIG_IsOK(res1)) {
30522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30523 }
30524 arg1 = reinterpret_cast< wxWindow * >(argp1);
30525 {
30526 PyThreadState* __tstate = wxPyBeginAllowThreads();
30527 (arg1)->Lower();
30528 wxPyEndAllowThreads(__tstate);
30529 if (PyErr_Occurred()) SWIG_fail;
30530 }
30531 resultobj = SWIG_Py_Void();
30532 return resultobj;
30533 fail:
30534 return NULL;
30535 }
30536
30537
30538 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30539 PyObject *resultobj = 0;
30540 wxWindow *arg1 = (wxWindow *) 0 ;
30541 wxSize *arg2 = 0 ;
30542 void *argp1 = 0 ;
30543 int res1 = 0 ;
30544 wxSize temp2 ;
30545 PyObject * obj0 = 0 ;
30546 PyObject * obj1 = 0 ;
30547 char * kwnames[] = {
30548 (char *) "self",(char *) "size", NULL
30549 };
30550
30551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30552 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30553 if (!SWIG_IsOK(res1)) {
30554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30555 }
30556 arg1 = reinterpret_cast< wxWindow * >(argp1);
30557 {
30558 arg2 = &temp2;
30559 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30560 }
30561 {
30562 PyThreadState* __tstate = wxPyBeginAllowThreads();
30563 (arg1)->SetClientSize((wxSize const &)*arg2);
30564 wxPyEndAllowThreads(__tstate);
30565 if (PyErr_Occurred()) SWIG_fail;
30566 }
30567 resultobj = SWIG_Py_Void();
30568 return resultobj;
30569 fail:
30570 return NULL;
30571 }
30572
30573
30574 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30575 PyObject *resultobj = 0;
30576 wxWindow *arg1 = (wxWindow *) 0 ;
30577 int arg2 ;
30578 int arg3 ;
30579 void *argp1 = 0 ;
30580 int res1 = 0 ;
30581 int val2 ;
30582 int ecode2 = 0 ;
30583 int val3 ;
30584 int ecode3 = 0 ;
30585 PyObject * obj0 = 0 ;
30586 PyObject * obj1 = 0 ;
30587 PyObject * obj2 = 0 ;
30588 char * kwnames[] = {
30589 (char *) "self",(char *) "width",(char *) "height", NULL
30590 };
30591
30592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30596 }
30597 arg1 = reinterpret_cast< wxWindow * >(argp1);
30598 ecode2 = SWIG_AsVal_int(obj1, &val2);
30599 if (!SWIG_IsOK(ecode2)) {
30600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30601 }
30602 arg2 = static_cast< int >(val2);
30603 ecode3 = SWIG_AsVal_int(obj2, &val3);
30604 if (!SWIG_IsOK(ecode3)) {
30605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30606 }
30607 arg3 = static_cast< int >(val3);
30608 {
30609 PyThreadState* __tstate = wxPyBeginAllowThreads();
30610 (arg1)->SetClientSize(arg2,arg3);
30611 wxPyEndAllowThreads(__tstate);
30612 if (PyErr_Occurred()) SWIG_fail;
30613 }
30614 resultobj = SWIG_Py_Void();
30615 return resultobj;
30616 fail:
30617 return NULL;
30618 }
30619
30620
30621 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30622 PyObject *resultobj = 0;
30623 wxWindow *arg1 = (wxWindow *) 0 ;
30624 wxRect *arg2 = 0 ;
30625 void *argp1 = 0 ;
30626 int res1 = 0 ;
30627 wxRect temp2 ;
30628 PyObject * obj0 = 0 ;
30629 PyObject * obj1 = 0 ;
30630 char * kwnames[] = {
30631 (char *) "self",(char *) "rect", NULL
30632 };
30633
30634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30636 if (!SWIG_IsOK(res1)) {
30637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30638 }
30639 arg1 = reinterpret_cast< wxWindow * >(argp1);
30640 {
30641 arg2 = &temp2;
30642 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30643 }
30644 {
30645 PyThreadState* __tstate = wxPyBeginAllowThreads();
30646 (arg1)->SetClientSize((wxRect const &)*arg2);
30647 wxPyEndAllowThreads(__tstate);
30648 if (PyErr_Occurred()) SWIG_fail;
30649 }
30650 resultobj = SWIG_Py_Void();
30651 return resultobj;
30652 fail:
30653 return NULL;
30654 }
30655
30656
30657 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30658 PyObject *resultobj = 0;
30659 wxWindow *arg1 = (wxWindow *) 0 ;
30660 wxPoint result;
30661 void *argp1 = 0 ;
30662 int res1 = 0 ;
30663 PyObject *swig_obj[1] ;
30664
30665 if (!args) SWIG_fail;
30666 swig_obj[0] = args;
30667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30668 if (!SWIG_IsOK(res1)) {
30669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30670 }
30671 arg1 = reinterpret_cast< wxWindow * >(argp1);
30672 {
30673 PyThreadState* __tstate = wxPyBeginAllowThreads();
30674 result = ((wxWindow const *)arg1)->GetPosition();
30675 wxPyEndAllowThreads(__tstate);
30676 if (PyErr_Occurred()) SWIG_fail;
30677 }
30678 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30679 return resultobj;
30680 fail:
30681 return NULL;
30682 }
30683
30684
30685 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30686 PyObject *resultobj = 0;
30687 wxWindow *arg1 = (wxWindow *) 0 ;
30688 int *arg2 = (int *) 0 ;
30689 int *arg3 = (int *) 0 ;
30690 void *argp1 = 0 ;
30691 int res1 = 0 ;
30692 int temp2 ;
30693 int res2 = SWIG_TMPOBJ ;
30694 int temp3 ;
30695 int res3 = SWIG_TMPOBJ ;
30696 PyObject *swig_obj[1] ;
30697
30698 arg2 = &temp2;
30699 arg3 = &temp3;
30700 if (!args) SWIG_fail;
30701 swig_obj[0] = args;
30702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30703 if (!SWIG_IsOK(res1)) {
30704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30705 }
30706 arg1 = reinterpret_cast< wxWindow * >(argp1);
30707 {
30708 PyThreadState* __tstate = wxPyBeginAllowThreads();
30709 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30710 wxPyEndAllowThreads(__tstate);
30711 if (PyErr_Occurred()) SWIG_fail;
30712 }
30713 resultobj = SWIG_Py_Void();
30714 if (SWIG_IsTmpObj(res2)) {
30715 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30716 } else {
30717 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30718 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30719 }
30720 if (SWIG_IsTmpObj(res3)) {
30721 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30722 } else {
30723 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30724 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30725 }
30726 return resultobj;
30727 fail:
30728 return NULL;
30729 }
30730
30731
30732 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30733 PyObject *resultobj = 0;
30734 wxWindow *arg1 = (wxWindow *) 0 ;
30735 wxPoint result;
30736 void *argp1 = 0 ;
30737 int res1 = 0 ;
30738 PyObject *swig_obj[1] ;
30739
30740 if (!args) SWIG_fail;
30741 swig_obj[0] = args;
30742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30743 if (!SWIG_IsOK(res1)) {
30744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30745 }
30746 arg1 = reinterpret_cast< wxWindow * >(argp1);
30747 {
30748 PyThreadState* __tstate = wxPyBeginAllowThreads();
30749 result = ((wxWindow const *)arg1)->GetScreenPosition();
30750 wxPyEndAllowThreads(__tstate);
30751 if (PyErr_Occurred()) SWIG_fail;
30752 }
30753 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30754 return resultobj;
30755 fail:
30756 return NULL;
30757 }
30758
30759
30760 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30761 PyObject *resultobj = 0;
30762 wxWindow *arg1 = (wxWindow *) 0 ;
30763 int *arg2 = (int *) 0 ;
30764 int *arg3 = (int *) 0 ;
30765 void *argp1 = 0 ;
30766 int res1 = 0 ;
30767 int temp2 ;
30768 int res2 = SWIG_TMPOBJ ;
30769 int temp3 ;
30770 int res3 = SWIG_TMPOBJ ;
30771 PyObject *swig_obj[1] ;
30772
30773 arg2 = &temp2;
30774 arg3 = &temp3;
30775 if (!args) SWIG_fail;
30776 swig_obj[0] = args;
30777 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30778 if (!SWIG_IsOK(res1)) {
30779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30780 }
30781 arg1 = reinterpret_cast< wxWindow * >(argp1);
30782 {
30783 PyThreadState* __tstate = wxPyBeginAllowThreads();
30784 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30785 wxPyEndAllowThreads(__tstate);
30786 if (PyErr_Occurred()) SWIG_fail;
30787 }
30788 resultobj = SWIG_Py_Void();
30789 if (SWIG_IsTmpObj(res2)) {
30790 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30791 } else {
30792 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30793 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30794 }
30795 if (SWIG_IsTmpObj(res3)) {
30796 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30797 } else {
30798 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30799 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30800 }
30801 return resultobj;
30802 fail:
30803 return NULL;
30804 }
30805
30806
30807 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30808 PyObject *resultobj = 0;
30809 wxWindow *arg1 = (wxWindow *) 0 ;
30810 wxRect result;
30811 void *argp1 = 0 ;
30812 int res1 = 0 ;
30813 PyObject *swig_obj[1] ;
30814
30815 if (!args) SWIG_fail;
30816 swig_obj[0] = args;
30817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30818 if (!SWIG_IsOK(res1)) {
30819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30820 }
30821 arg1 = reinterpret_cast< wxWindow * >(argp1);
30822 {
30823 PyThreadState* __tstate = wxPyBeginAllowThreads();
30824 result = ((wxWindow const *)arg1)->GetScreenRect();
30825 wxPyEndAllowThreads(__tstate);
30826 if (PyErr_Occurred()) SWIG_fail;
30827 }
30828 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30829 return resultobj;
30830 fail:
30831 return NULL;
30832 }
30833
30834
30835 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30836 PyObject *resultobj = 0;
30837 wxWindow *arg1 = (wxWindow *) 0 ;
30838 wxSize result;
30839 void *argp1 = 0 ;
30840 int res1 = 0 ;
30841 PyObject *swig_obj[1] ;
30842
30843 if (!args) SWIG_fail;
30844 swig_obj[0] = args;
30845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30846 if (!SWIG_IsOK(res1)) {
30847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30848 }
30849 arg1 = reinterpret_cast< wxWindow * >(argp1);
30850 {
30851 PyThreadState* __tstate = wxPyBeginAllowThreads();
30852 result = ((wxWindow const *)arg1)->GetSize();
30853 wxPyEndAllowThreads(__tstate);
30854 if (PyErr_Occurred()) SWIG_fail;
30855 }
30856 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30857 return resultobj;
30858 fail:
30859 return NULL;
30860 }
30861
30862
30863 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30864 PyObject *resultobj = 0;
30865 wxWindow *arg1 = (wxWindow *) 0 ;
30866 int *arg2 = (int *) 0 ;
30867 int *arg3 = (int *) 0 ;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 int temp2 ;
30871 int res2 = SWIG_TMPOBJ ;
30872 int temp3 ;
30873 int res3 = SWIG_TMPOBJ ;
30874 PyObject *swig_obj[1] ;
30875
30876 arg2 = &temp2;
30877 arg3 = &temp3;
30878 if (!args) SWIG_fail;
30879 swig_obj[0] = args;
30880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30881 if (!SWIG_IsOK(res1)) {
30882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30883 }
30884 arg1 = reinterpret_cast< wxWindow * >(argp1);
30885 {
30886 PyThreadState* __tstate = wxPyBeginAllowThreads();
30887 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
30888 wxPyEndAllowThreads(__tstate);
30889 if (PyErr_Occurred()) SWIG_fail;
30890 }
30891 resultobj = SWIG_Py_Void();
30892 if (SWIG_IsTmpObj(res2)) {
30893 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30894 } else {
30895 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30896 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30897 }
30898 if (SWIG_IsTmpObj(res3)) {
30899 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30900 } else {
30901 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30902 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30903 }
30904 return resultobj;
30905 fail:
30906 return NULL;
30907 }
30908
30909
30910 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30911 PyObject *resultobj = 0;
30912 wxWindow *arg1 = (wxWindow *) 0 ;
30913 wxRect result;
30914 void *argp1 = 0 ;
30915 int res1 = 0 ;
30916 PyObject *swig_obj[1] ;
30917
30918 if (!args) SWIG_fail;
30919 swig_obj[0] = args;
30920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30921 if (!SWIG_IsOK(res1)) {
30922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
30923 }
30924 arg1 = reinterpret_cast< wxWindow * >(argp1);
30925 {
30926 PyThreadState* __tstate = wxPyBeginAllowThreads();
30927 result = ((wxWindow const *)arg1)->GetRect();
30928 wxPyEndAllowThreads(__tstate);
30929 if (PyErr_Occurred()) SWIG_fail;
30930 }
30931 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
30932 return resultobj;
30933 fail:
30934 return NULL;
30935 }
30936
30937
30938 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30939 PyObject *resultobj = 0;
30940 wxWindow *arg1 = (wxWindow *) 0 ;
30941 wxSize result;
30942 void *argp1 = 0 ;
30943 int res1 = 0 ;
30944 PyObject *swig_obj[1] ;
30945
30946 if (!args) SWIG_fail;
30947 swig_obj[0] = args;
30948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30949 if (!SWIG_IsOK(res1)) {
30950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
30951 }
30952 arg1 = reinterpret_cast< wxWindow * >(argp1);
30953 {
30954 PyThreadState* __tstate = wxPyBeginAllowThreads();
30955 result = ((wxWindow const *)arg1)->GetClientSize();
30956 wxPyEndAllowThreads(__tstate);
30957 if (PyErr_Occurred()) SWIG_fail;
30958 }
30959 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
30960 return resultobj;
30961 fail:
30962 return NULL;
30963 }
30964
30965
30966 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30967 PyObject *resultobj = 0;
30968 wxWindow *arg1 = (wxWindow *) 0 ;
30969 int *arg2 = (int *) 0 ;
30970 int *arg3 = (int *) 0 ;
30971 void *argp1 = 0 ;
30972 int res1 = 0 ;
30973 int temp2 ;
30974 int res2 = SWIG_TMPOBJ ;
30975 int temp3 ;
30976 int res3 = SWIG_TMPOBJ ;
30977 PyObject *swig_obj[1] ;
30978
30979 arg2 = &temp2;
30980 arg3 = &temp3;
30981 if (!args) SWIG_fail;
30982 swig_obj[0] = args;
30983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30984 if (!SWIG_IsOK(res1)) {
30985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30986 }
30987 arg1 = reinterpret_cast< wxWindow * >(argp1);
30988 {
30989 PyThreadState* __tstate = wxPyBeginAllowThreads();
30990 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
30991 wxPyEndAllowThreads(__tstate);
30992 if (PyErr_Occurred()) SWIG_fail;
30993 }
30994 resultobj = SWIG_Py_Void();
30995 if (SWIG_IsTmpObj(res2)) {
30996 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30997 } else {
30998 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30999 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31000 }
31001 if (SWIG_IsTmpObj(res3)) {
31002 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31003 } else {
31004 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31005 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31006 }
31007 return resultobj;
31008 fail:
31009 return NULL;
31010 }
31011
31012
31013 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31014 PyObject *resultobj = 0;
31015 wxWindow *arg1 = (wxWindow *) 0 ;
31016 wxPoint result;
31017 void *argp1 = 0 ;
31018 int res1 = 0 ;
31019 PyObject *swig_obj[1] ;
31020
31021 if (!args) SWIG_fail;
31022 swig_obj[0] = args;
31023 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31024 if (!SWIG_IsOK(res1)) {
31025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31026 }
31027 arg1 = reinterpret_cast< wxWindow * >(argp1);
31028 {
31029 PyThreadState* __tstate = wxPyBeginAllowThreads();
31030 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31031 wxPyEndAllowThreads(__tstate);
31032 if (PyErr_Occurred()) SWIG_fail;
31033 }
31034 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31035 return resultobj;
31036 fail:
31037 return NULL;
31038 }
31039
31040
31041 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31042 PyObject *resultobj = 0;
31043 wxWindow *arg1 = (wxWindow *) 0 ;
31044 wxRect result;
31045 void *argp1 = 0 ;
31046 int res1 = 0 ;
31047 PyObject *swig_obj[1] ;
31048
31049 if (!args) SWIG_fail;
31050 swig_obj[0] = args;
31051 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31052 if (!SWIG_IsOK(res1)) {
31053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31054 }
31055 arg1 = reinterpret_cast< wxWindow * >(argp1);
31056 {
31057 PyThreadState* __tstate = wxPyBeginAllowThreads();
31058 result = ((wxWindow const *)arg1)->GetClientRect();
31059 wxPyEndAllowThreads(__tstate);
31060 if (PyErr_Occurred()) SWIG_fail;
31061 }
31062 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31063 return resultobj;
31064 fail:
31065 return NULL;
31066 }
31067
31068
31069 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31070 PyObject *resultobj = 0;
31071 wxWindow *arg1 = (wxWindow *) 0 ;
31072 wxSize result;
31073 void *argp1 = 0 ;
31074 int res1 = 0 ;
31075 PyObject *swig_obj[1] ;
31076
31077 if (!args) SWIG_fail;
31078 swig_obj[0] = args;
31079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31080 if (!SWIG_IsOK(res1)) {
31081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31082 }
31083 arg1 = reinterpret_cast< wxWindow * >(argp1);
31084 {
31085 PyThreadState* __tstate = wxPyBeginAllowThreads();
31086 result = ((wxWindow const *)arg1)->GetBestSize();
31087 wxPyEndAllowThreads(__tstate);
31088 if (PyErr_Occurred()) SWIG_fail;
31089 }
31090 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31091 return resultobj;
31092 fail:
31093 return NULL;
31094 }
31095
31096
31097 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31098 PyObject *resultobj = 0;
31099 wxWindow *arg1 = (wxWindow *) 0 ;
31100 int *arg2 = (int *) 0 ;
31101 int *arg3 = (int *) 0 ;
31102 void *argp1 = 0 ;
31103 int res1 = 0 ;
31104 int temp2 ;
31105 int res2 = SWIG_TMPOBJ ;
31106 int temp3 ;
31107 int res3 = SWIG_TMPOBJ ;
31108 PyObject *swig_obj[1] ;
31109
31110 arg2 = &temp2;
31111 arg3 = &temp3;
31112 if (!args) SWIG_fail;
31113 swig_obj[0] = args;
31114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31115 if (!SWIG_IsOK(res1)) {
31116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31117 }
31118 arg1 = reinterpret_cast< wxWindow * >(argp1);
31119 {
31120 PyThreadState* __tstate = wxPyBeginAllowThreads();
31121 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31122 wxPyEndAllowThreads(__tstate);
31123 if (PyErr_Occurred()) SWIG_fail;
31124 }
31125 resultobj = SWIG_Py_Void();
31126 if (SWIG_IsTmpObj(res2)) {
31127 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31128 } else {
31129 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31130 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31131 }
31132 if (SWIG_IsTmpObj(res3)) {
31133 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31134 } else {
31135 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31136 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31137 }
31138 return resultobj;
31139 fail:
31140 return NULL;
31141 }
31142
31143
31144 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31145 PyObject *resultobj = 0;
31146 wxWindow *arg1 = (wxWindow *) 0 ;
31147 void *argp1 = 0 ;
31148 int res1 = 0 ;
31149 PyObject *swig_obj[1] ;
31150
31151 if (!args) SWIG_fail;
31152 swig_obj[0] = args;
31153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31154 if (!SWIG_IsOK(res1)) {
31155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31156 }
31157 arg1 = reinterpret_cast< wxWindow * >(argp1);
31158 {
31159 PyThreadState* __tstate = wxPyBeginAllowThreads();
31160 (arg1)->InvalidateBestSize();
31161 wxPyEndAllowThreads(__tstate);
31162 if (PyErr_Occurred()) SWIG_fail;
31163 }
31164 resultobj = SWIG_Py_Void();
31165 return resultobj;
31166 fail:
31167 return NULL;
31168 }
31169
31170
31171 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31172 PyObject *resultobj = 0;
31173 wxWindow *arg1 = (wxWindow *) 0 ;
31174 wxSize *arg2 = 0 ;
31175 void *argp1 = 0 ;
31176 int res1 = 0 ;
31177 wxSize temp2 ;
31178 PyObject * obj0 = 0 ;
31179 PyObject * obj1 = 0 ;
31180 char * kwnames[] = {
31181 (char *) "self",(char *) "size", NULL
31182 };
31183
31184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31186 if (!SWIG_IsOK(res1)) {
31187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31188 }
31189 arg1 = reinterpret_cast< wxWindow * >(argp1);
31190 {
31191 arg2 = &temp2;
31192 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31193 }
31194 {
31195 PyThreadState* __tstate = wxPyBeginAllowThreads();
31196 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31197 wxPyEndAllowThreads(__tstate);
31198 if (PyErr_Occurred()) SWIG_fail;
31199 }
31200 resultobj = SWIG_Py_Void();
31201 return resultobj;
31202 fail:
31203 return NULL;
31204 }
31205
31206
31207 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31208 PyObject *resultobj = 0;
31209 wxWindow *arg1 = (wxWindow *) 0 ;
31210 wxSize result;
31211 void *argp1 = 0 ;
31212 int res1 = 0 ;
31213 PyObject *swig_obj[1] ;
31214
31215 if (!args) SWIG_fail;
31216 swig_obj[0] = args;
31217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31218 if (!SWIG_IsOK(res1)) {
31219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31220 }
31221 arg1 = reinterpret_cast< wxWindow * >(argp1);
31222 {
31223 PyThreadState* __tstate = wxPyBeginAllowThreads();
31224 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31229 return resultobj;
31230 fail:
31231 return NULL;
31232 }
31233
31234
31235 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31236 PyObject *resultobj = 0;
31237 wxWindow *arg1 = (wxWindow *) 0 ;
31238 wxSize result;
31239 void *argp1 = 0 ;
31240 int res1 = 0 ;
31241 PyObject *swig_obj[1] ;
31242
31243 if (!args) SWIG_fail;
31244 swig_obj[0] = args;
31245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31246 if (!SWIG_IsOK(res1)) {
31247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31248 }
31249 arg1 = reinterpret_cast< wxWindow * >(argp1);
31250 {
31251 PyThreadState* __tstate = wxPyBeginAllowThreads();
31252 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31253 wxPyEndAllowThreads(__tstate);
31254 if (PyErr_Occurred()) SWIG_fail;
31255 }
31256 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31257 return resultobj;
31258 fail:
31259 return NULL;
31260 }
31261
31262
31263 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31264 PyObject *resultobj = 0;
31265 wxWindow *arg1 = (wxWindow *) 0 ;
31266 int arg2 = (int) wxBOTH ;
31267 void *argp1 = 0 ;
31268 int res1 = 0 ;
31269 int val2 ;
31270 int ecode2 = 0 ;
31271 PyObject * obj0 = 0 ;
31272 PyObject * obj1 = 0 ;
31273 char * kwnames[] = {
31274 (char *) "self",(char *) "direction", NULL
31275 };
31276
31277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31279 if (!SWIG_IsOK(res1)) {
31280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31281 }
31282 arg1 = reinterpret_cast< wxWindow * >(argp1);
31283 if (obj1) {
31284 ecode2 = SWIG_AsVal_int(obj1, &val2);
31285 if (!SWIG_IsOK(ecode2)) {
31286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31287 }
31288 arg2 = static_cast< int >(val2);
31289 }
31290 {
31291 PyThreadState* __tstate = wxPyBeginAllowThreads();
31292 (arg1)->Center(arg2);
31293 wxPyEndAllowThreads(__tstate);
31294 if (PyErr_Occurred()) SWIG_fail;
31295 }
31296 resultobj = SWIG_Py_Void();
31297 return resultobj;
31298 fail:
31299 return NULL;
31300 }
31301
31302
31303 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31304 PyObject *resultobj = 0;
31305 wxWindow *arg1 = (wxWindow *) 0 ;
31306 int arg2 = (int) wxBOTH ;
31307 void *argp1 = 0 ;
31308 int res1 = 0 ;
31309 int val2 ;
31310 int ecode2 = 0 ;
31311 PyObject * obj0 = 0 ;
31312 PyObject * obj1 = 0 ;
31313 char * kwnames[] = {
31314 (char *) "self",(char *) "dir", NULL
31315 };
31316
31317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31319 if (!SWIG_IsOK(res1)) {
31320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31321 }
31322 arg1 = reinterpret_cast< wxWindow * >(argp1);
31323 if (obj1) {
31324 ecode2 = SWIG_AsVal_int(obj1, &val2);
31325 if (!SWIG_IsOK(ecode2)) {
31326 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31327 }
31328 arg2 = static_cast< int >(val2);
31329 }
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 (arg1)->CenterOnParent(arg2);
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 resultobj = SWIG_Py_Void();
31337 return resultobj;
31338 fail:
31339 return NULL;
31340 }
31341
31342
31343 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31344 PyObject *resultobj = 0;
31345 wxWindow *arg1 = (wxWindow *) 0 ;
31346 void *argp1 = 0 ;
31347 int res1 = 0 ;
31348 PyObject *swig_obj[1] ;
31349
31350 if (!args) SWIG_fail;
31351 swig_obj[0] = args;
31352 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31353 if (!SWIG_IsOK(res1)) {
31354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31355 }
31356 arg1 = reinterpret_cast< wxWindow * >(argp1);
31357 {
31358 PyThreadState* __tstate = wxPyBeginAllowThreads();
31359 (arg1)->Fit();
31360 wxPyEndAllowThreads(__tstate);
31361 if (PyErr_Occurred()) SWIG_fail;
31362 }
31363 resultobj = SWIG_Py_Void();
31364 return resultobj;
31365 fail:
31366 return NULL;
31367 }
31368
31369
31370 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31371 PyObject *resultobj = 0;
31372 wxWindow *arg1 = (wxWindow *) 0 ;
31373 void *argp1 = 0 ;
31374 int res1 = 0 ;
31375 PyObject *swig_obj[1] ;
31376
31377 if (!args) SWIG_fail;
31378 swig_obj[0] = args;
31379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31380 if (!SWIG_IsOK(res1)) {
31381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31382 }
31383 arg1 = reinterpret_cast< wxWindow * >(argp1);
31384 {
31385 PyThreadState* __tstate = wxPyBeginAllowThreads();
31386 (arg1)->FitInside();
31387 wxPyEndAllowThreads(__tstate);
31388 if (PyErr_Occurred()) SWIG_fail;
31389 }
31390 resultobj = SWIG_Py_Void();
31391 return resultobj;
31392 fail:
31393 return NULL;
31394 }
31395
31396
31397 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31398 PyObject *resultobj = 0;
31399 wxWindow *arg1 = (wxWindow *) 0 ;
31400 int arg2 ;
31401 int arg3 ;
31402 int arg4 = (int) -1 ;
31403 int arg5 = (int) -1 ;
31404 int arg6 = (int) -1 ;
31405 int arg7 = (int) -1 ;
31406 void *argp1 = 0 ;
31407 int res1 = 0 ;
31408 int val2 ;
31409 int ecode2 = 0 ;
31410 int val3 ;
31411 int ecode3 = 0 ;
31412 int val4 ;
31413 int ecode4 = 0 ;
31414 int val5 ;
31415 int ecode5 = 0 ;
31416 int val6 ;
31417 int ecode6 = 0 ;
31418 int val7 ;
31419 int ecode7 = 0 ;
31420 PyObject * obj0 = 0 ;
31421 PyObject * obj1 = 0 ;
31422 PyObject * obj2 = 0 ;
31423 PyObject * obj3 = 0 ;
31424 PyObject * obj4 = 0 ;
31425 PyObject * obj5 = 0 ;
31426 PyObject * obj6 = 0 ;
31427 char * kwnames[] = {
31428 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31429 };
31430
31431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31433 if (!SWIG_IsOK(res1)) {
31434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31435 }
31436 arg1 = reinterpret_cast< wxWindow * >(argp1);
31437 ecode2 = SWIG_AsVal_int(obj1, &val2);
31438 if (!SWIG_IsOK(ecode2)) {
31439 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31440 }
31441 arg2 = static_cast< int >(val2);
31442 ecode3 = SWIG_AsVal_int(obj2, &val3);
31443 if (!SWIG_IsOK(ecode3)) {
31444 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31445 }
31446 arg3 = static_cast< int >(val3);
31447 if (obj3) {
31448 ecode4 = SWIG_AsVal_int(obj3, &val4);
31449 if (!SWIG_IsOK(ecode4)) {
31450 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31451 }
31452 arg4 = static_cast< int >(val4);
31453 }
31454 if (obj4) {
31455 ecode5 = SWIG_AsVal_int(obj4, &val5);
31456 if (!SWIG_IsOK(ecode5)) {
31457 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31458 }
31459 arg5 = static_cast< int >(val5);
31460 }
31461 if (obj5) {
31462 ecode6 = SWIG_AsVal_int(obj5, &val6);
31463 if (!SWIG_IsOK(ecode6)) {
31464 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31465 }
31466 arg6 = static_cast< int >(val6);
31467 }
31468 if (obj6) {
31469 ecode7 = SWIG_AsVal_int(obj6, &val7);
31470 if (!SWIG_IsOK(ecode7)) {
31471 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31472 }
31473 arg7 = static_cast< int >(val7);
31474 }
31475 {
31476 PyThreadState* __tstate = wxPyBeginAllowThreads();
31477 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31478 wxPyEndAllowThreads(__tstate);
31479 if (PyErr_Occurred()) SWIG_fail;
31480 }
31481 resultobj = SWIG_Py_Void();
31482 return resultobj;
31483 fail:
31484 return NULL;
31485 }
31486
31487
31488 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31489 PyObject *resultobj = 0;
31490 wxWindow *arg1 = (wxWindow *) 0 ;
31491 wxSize *arg2 = 0 ;
31492 wxSize const &arg3_defvalue = wxDefaultSize ;
31493 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31494 wxSize const &arg4_defvalue = wxDefaultSize ;
31495 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31496 void *argp1 = 0 ;
31497 int res1 = 0 ;
31498 wxSize temp2 ;
31499 wxSize temp3 ;
31500 wxSize temp4 ;
31501 PyObject * obj0 = 0 ;
31502 PyObject * obj1 = 0 ;
31503 PyObject * obj2 = 0 ;
31504 PyObject * obj3 = 0 ;
31505 char * kwnames[] = {
31506 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31507 };
31508
31509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31510 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31511 if (!SWIG_IsOK(res1)) {
31512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31513 }
31514 arg1 = reinterpret_cast< wxWindow * >(argp1);
31515 {
31516 arg2 = &temp2;
31517 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31518 }
31519 if (obj2) {
31520 {
31521 arg3 = &temp3;
31522 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31523 }
31524 }
31525 if (obj3) {
31526 {
31527 arg4 = &temp4;
31528 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31529 }
31530 }
31531 {
31532 PyThreadState* __tstate = wxPyBeginAllowThreads();
31533 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31534 wxPyEndAllowThreads(__tstate);
31535 if (PyErr_Occurred()) SWIG_fail;
31536 }
31537 resultobj = SWIG_Py_Void();
31538 return resultobj;
31539 fail:
31540 return NULL;
31541 }
31542
31543
31544 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31545 PyObject *resultobj = 0;
31546 wxWindow *arg1 = (wxWindow *) 0 ;
31547 int arg2 ;
31548 int arg3 ;
31549 int arg4 = (int) -1 ;
31550 int arg5 = (int) -1 ;
31551 void *argp1 = 0 ;
31552 int res1 = 0 ;
31553 int val2 ;
31554 int ecode2 = 0 ;
31555 int val3 ;
31556 int ecode3 = 0 ;
31557 int val4 ;
31558 int ecode4 = 0 ;
31559 int val5 ;
31560 int ecode5 = 0 ;
31561 PyObject * obj0 = 0 ;
31562 PyObject * obj1 = 0 ;
31563 PyObject * obj2 = 0 ;
31564 PyObject * obj3 = 0 ;
31565 PyObject * obj4 = 0 ;
31566 char * kwnames[] = {
31567 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31568 };
31569
31570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31572 if (!SWIG_IsOK(res1)) {
31573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31574 }
31575 arg1 = reinterpret_cast< wxWindow * >(argp1);
31576 ecode2 = SWIG_AsVal_int(obj1, &val2);
31577 if (!SWIG_IsOK(ecode2)) {
31578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31579 }
31580 arg2 = static_cast< int >(val2);
31581 ecode3 = SWIG_AsVal_int(obj2, &val3);
31582 if (!SWIG_IsOK(ecode3)) {
31583 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31584 }
31585 arg3 = static_cast< int >(val3);
31586 if (obj3) {
31587 ecode4 = SWIG_AsVal_int(obj3, &val4);
31588 if (!SWIG_IsOK(ecode4)) {
31589 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31590 }
31591 arg4 = static_cast< int >(val4);
31592 }
31593 if (obj4) {
31594 ecode5 = SWIG_AsVal_int(obj4, &val5);
31595 if (!SWIG_IsOK(ecode5)) {
31596 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31597 }
31598 arg5 = static_cast< int >(val5);
31599 }
31600 {
31601 PyThreadState* __tstate = wxPyBeginAllowThreads();
31602 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31603 wxPyEndAllowThreads(__tstate);
31604 if (PyErr_Occurred()) SWIG_fail;
31605 }
31606 resultobj = SWIG_Py_Void();
31607 return resultobj;
31608 fail:
31609 return NULL;
31610 }
31611
31612
31613 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31614 PyObject *resultobj = 0;
31615 wxWindow *arg1 = (wxWindow *) 0 ;
31616 wxSize *arg2 = 0 ;
31617 wxSize const &arg3_defvalue = wxDefaultSize ;
31618 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31619 void *argp1 = 0 ;
31620 int res1 = 0 ;
31621 wxSize temp2 ;
31622 wxSize temp3 ;
31623 PyObject * obj0 = 0 ;
31624 PyObject * obj1 = 0 ;
31625 PyObject * obj2 = 0 ;
31626 char * kwnames[] = {
31627 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31628 };
31629
31630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31632 if (!SWIG_IsOK(res1)) {
31633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31634 }
31635 arg1 = reinterpret_cast< wxWindow * >(argp1);
31636 {
31637 arg2 = &temp2;
31638 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31639 }
31640 if (obj2) {
31641 {
31642 arg3 = &temp3;
31643 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31644 }
31645 }
31646 {
31647 PyThreadState* __tstate = wxPyBeginAllowThreads();
31648 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31649 wxPyEndAllowThreads(__tstate);
31650 if (PyErr_Occurred()) SWIG_fail;
31651 }
31652 resultobj = SWIG_Py_Void();
31653 return resultobj;
31654 fail:
31655 return NULL;
31656 }
31657
31658
31659 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31660 PyObject *resultobj = 0;
31661 wxWindow *arg1 = (wxWindow *) 0 ;
31662 wxSize result;
31663 void *argp1 = 0 ;
31664 int res1 = 0 ;
31665 PyObject *swig_obj[1] ;
31666
31667 if (!args) SWIG_fail;
31668 swig_obj[0] = args;
31669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31670 if (!SWIG_IsOK(res1)) {
31671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31672 }
31673 arg1 = reinterpret_cast< wxWindow * >(argp1);
31674 {
31675 PyThreadState* __tstate = wxPyBeginAllowThreads();
31676 result = ((wxWindow const *)arg1)->GetMaxSize();
31677 wxPyEndAllowThreads(__tstate);
31678 if (PyErr_Occurred()) SWIG_fail;
31679 }
31680 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31681 return resultobj;
31682 fail:
31683 return NULL;
31684 }
31685
31686
31687 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31688 PyObject *resultobj = 0;
31689 wxWindow *arg1 = (wxWindow *) 0 ;
31690 wxSize result;
31691 void *argp1 = 0 ;
31692 int res1 = 0 ;
31693 PyObject *swig_obj[1] ;
31694
31695 if (!args) SWIG_fail;
31696 swig_obj[0] = args;
31697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31698 if (!SWIG_IsOK(res1)) {
31699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31700 }
31701 arg1 = reinterpret_cast< wxWindow * >(argp1);
31702 {
31703 PyThreadState* __tstate = wxPyBeginAllowThreads();
31704 result = ((wxWindow const *)arg1)->GetMinSize();
31705 wxPyEndAllowThreads(__tstate);
31706 if (PyErr_Occurred()) SWIG_fail;
31707 }
31708 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31709 return resultobj;
31710 fail:
31711 return NULL;
31712 }
31713
31714
31715 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31716 PyObject *resultobj = 0;
31717 wxWindow *arg1 = (wxWindow *) 0 ;
31718 wxSize *arg2 = 0 ;
31719 void *argp1 = 0 ;
31720 int res1 = 0 ;
31721 wxSize temp2 ;
31722 PyObject * obj0 = 0 ;
31723 PyObject * obj1 = 0 ;
31724 char * kwnames[] = {
31725 (char *) "self",(char *) "minSize", NULL
31726 };
31727
31728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31730 if (!SWIG_IsOK(res1)) {
31731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31732 }
31733 arg1 = reinterpret_cast< wxWindow * >(argp1);
31734 {
31735 arg2 = &temp2;
31736 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31737 }
31738 {
31739 PyThreadState* __tstate = wxPyBeginAllowThreads();
31740 (arg1)->SetMinSize((wxSize const &)*arg2);
31741 wxPyEndAllowThreads(__tstate);
31742 if (PyErr_Occurred()) SWIG_fail;
31743 }
31744 resultobj = SWIG_Py_Void();
31745 return resultobj;
31746 fail:
31747 return NULL;
31748 }
31749
31750
31751 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31752 PyObject *resultobj = 0;
31753 wxWindow *arg1 = (wxWindow *) 0 ;
31754 wxSize *arg2 = 0 ;
31755 void *argp1 = 0 ;
31756 int res1 = 0 ;
31757 wxSize temp2 ;
31758 PyObject * obj0 = 0 ;
31759 PyObject * obj1 = 0 ;
31760 char * kwnames[] = {
31761 (char *) "self",(char *) "maxSize", NULL
31762 };
31763
31764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31766 if (!SWIG_IsOK(res1)) {
31767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31768 }
31769 arg1 = reinterpret_cast< wxWindow * >(argp1);
31770 {
31771 arg2 = &temp2;
31772 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31773 }
31774 {
31775 PyThreadState* __tstate = wxPyBeginAllowThreads();
31776 (arg1)->SetMaxSize((wxSize const &)*arg2);
31777 wxPyEndAllowThreads(__tstate);
31778 if (PyErr_Occurred()) SWIG_fail;
31779 }
31780 resultobj = SWIG_Py_Void();
31781 return resultobj;
31782 fail:
31783 return NULL;
31784 }
31785
31786
31787 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31788 PyObject *resultobj = 0;
31789 wxWindow *arg1 = (wxWindow *) 0 ;
31790 int result;
31791 void *argp1 = 0 ;
31792 int res1 = 0 ;
31793 PyObject *swig_obj[1] ;
31794
31795 if (!args) SWIG_fail;
31796 swig_obj[0] = args;
31797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31798 if (!SWIG_IsOK(res1)) {
31799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31800 }
31801 arg1 = reinterpret_cast< wxWindow * >(argp1);
31802 {
31803 PyThreadState* __tstate = wxPyBeginAllowThreads();
31804 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31805 wxPyEndAllowThreads(__tstate);
31806 if (PyErr_Occurred()) SWIG_fail;
31807 }
31808 resultobj = SWIG_From_int(static_cast< int >(result));
31809 return resultobj;
31810 fail:
31811 return NULL;
31812 }
31813
31814
31815 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31816 PyObject *resultobj = 0;
31817 wxWindow *arg1 = (wxWindow *) 0 ;
31818 int result;
31819 void *argp1 = 0 ;
31820 int res1 = 0 ;
31821 PyObject *swig_obj[1] ;
31822
31823 if (!args) SWIG_fail;
31824 swig_obj[0] = args;
31825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31826 if (!SWIG_IsOK(res1)) {
31827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31828 }
31829 arg1 = reinterpret_cast< wxWindow * >(argp1);
31830 {
31831 PyThreadState* __tstate = wxPyBeginAllowThreads();
31832 result = (int)((wxWindow const *)arg1)->GetMinHeight();
31833 wxPyEndAllowThreads(__tstate);
31834 if (PyErr_Occurred()) SWIG_fail;
31835 }
31836 resultobj = SWIG_From_int(static_cast< int >(result));
31837 return resultobj;
31838 fail:
31839 return NULL;
31840 }
31841
31842
31843 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31844 PyObject *resultobj = 0;
31845 wxWindow *arg1 = (wxWindow *) 0 ;
31846 int result;
31847 void *argp1 = 0 ;
31848 int res1 = 0 ;
31849 PyObject *swig_obj[1] ;
31850
31851 if (!args) SWIG_fail;
31852 swig_obj[0] = args;
31853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31854 if (!SWIG_IsOK(res1)) {
31855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31856 }
31857 arg1 = reinterpret_cast< wxWindow * >(argp1);
31858 {
31859 PyThreadState* __tstate = wxPyBeginAllowThreads();
31860 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
31861 wxPyEndAllowThreads(__tstate);
31862 if (PyErr_Occurred()) SWIG_fail;
31863 }
31864 resultobj = SWIG_From_int(static_cast< int >(result));
31865 return resultobj;
31866 fail:
31867 return NULL;
31868 }
31869
31870
31871 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31872 PyObject *resultobj = 0;
31873 wxWindow *arg1 = (wxWindow *) 0 ;
31874 int result;
31875 void *argp1 = 0 ;
31876 int res1 = 0 ;
31877 PyObject *swig_obj[1] ;
31878
31879 if (!args) SWIG_fail;
31880 swig_obj[0] = args;
31881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31882 if (!SWIG_IsOK(res1)) {
31883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
31884 }
31885 arg1 = reinterpret_cast< wxWindow * >(argp1);
31886 {
31887 PyThreadState* __tstate = wxPyBeginAllowThreads();
31888 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
31889 wxPyEndAllowThreads(__tstate);
31890 if (PyErr_Occurred()) SWIG_fail;
31891 }
31892 resultobj = SWIG_From_int(static_cast< int >(result));
31893 return resultobj;
31894 fail:
31895 return NULL;
31896 }
31897
31898
31899 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31900 PyObject *resultobj = 0;
31901 wxWindow *arg1 = (wxWindow *) 0 ;
31902 wxSize *arg2 = 0 ;
31903 void *argp1 = 0 ;
31904 int res1 = 0 ;
31905 wxSize temp2 ;
31906 PyObject * obj0 = 0 ;
31907 PyObject * obj1 = 0 ;
31908 char * kwnames[] = {
31909 (char *) "self",(char *) "size", NULL
31910 };
31911
31912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
31913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31914 if (!SWIG_IsOK(res1)) {
31915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31916 }
31917 arg1 = reinterpret_cast< wxWindow * >(argp1);
31918 {
31919 arg2 = &temp2;
31920 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31921 }
31922 {
31923 PyThreadState* __tstate = wxPyBeginAllowThreads();
31924 (arg1)->SetVirtualSize((wxSize const &)*arg2);
31925 wxPyEndAllowThreads(__tstate);
31926 if (PyErr_Occurred()) SWIG_fail;
31927 }
31928 resultobj = SWIG_Py_Void();
31929 return resultobj;
31930 fail:
31931 return NULL;
31932 }
31933
31934
31935 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31936 PyObject *resultobj = 0;
31937 wxWindow *arg1 = (wxWindow *) 0 ;
31938 int arg2 ;
31939 int arg3 ;
31940 void *argp1 = 0 ;
31941 int res1 = 0 ;
31942 int val2 ;
31943 int ecode2 = 0 ;
31944 int val3 ;
31945 int ecode3 = 0 ;
31946 PyObject * obj0 = 0 ;
31947 PyObject * obj1 = 0 ;
31948 PyObject * obj2 = 0 ;
31949 char * kwnames[] = {
31950 (char *) "self",(char *) "w",(char *) "h", NULL
31951 };
31952
31953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31955 if (!SWIG_IsOK(res1)) {
31956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
31957 }
31958 arg1 = reinterpret_cast< wxWindow * >(argp1);
31959 ecode2 = SWIG_AsVal_int(obj1, &val2);
31960 if (!SWIG_IsOK(ecode2)) {
31961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
31962 }
31963 arg2 = static_cast< int >(val2);
31964 ecode3 = SWIG_AsVal_int(obj2, &val3);
31965 if (!SWIG_IsOK(ecode3)) {
31966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
31967 }
31968 arg3 = static_cast< int >(val3);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 (arg1)->SetVirtualSize(arg2,arg3);
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 resultobj = SWIG_Py_Void();
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31983 PyObject *resultobj = 0;
31984 wxWindow *arg1 = (wxWindow *) 0 ;
31985 wxSize result;
31986 void *argp1 = 0 ;
31987 int res1 = 0 ;
31988 PyObject *swig_obj[1] ;
31989
31990 if (!args) SWIG_fail;
31991 swig_obj[0] = args;
31992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31993 if (!SWIG_IsOK(res1)) {
31994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31995 }
31996 arg1 = reinterpret_cast< wxWindow * >(argp1);
31997 {
31998 PyThreadState* __tstate = wxPyBeginAllowThreads();
31999 result = ((wxWindow const *)arg1)->GetVirtualSize();
32000 wxPyEndAllowThreads(__tstate);
32001 if (PyErr_Occurred()) SWIG_fail;
32002 }
32003 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32004 return resultobj;
32005 fail:
32006 return NULL;
32007 }
32008
32009
32010 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32011 PyObject *resultobj = 0;
32012 wxWindow *arg1 = (wxWindow *) 0 ;
32013 int *arg2 = (int *) 0 ;
32014 int *arg3 = (int *) 0 ;
32015 void *argp1 = 0 ;
32016 int res1 = 0 ;
32017 int temp2 ;
32018 int res2 = SWIG_TMPOBJ ;
32019 int temp3 ;
32020 int res3 = SWIG_TMPOBJ ;
32021 PyObject *swig_obj[1] ;
32022
32023 arg2 = &temp2;
32024 arg3 = &temp3;
32025 if (!args) SWIG_fail;
32026 swig_obj[0] = args;
32027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32028 if (!SWIG_IsOK(res1)) {
32029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32030 }
32031 arg1 = reinterpret_cast< wxWindow * >(argp1);
32032 {
32033 PyThreadState* __tstate = wxPyBeginAllowThreads();
32034 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32035 wxPyEndAllowThreads(__tstate);
32036 if (PyErr_Occurred()) SWIG_fail;
32037 }
32038 resultobj = SWIG_Py_Void();
32039 if (SWIG_IsTmpObj(res2)) {
32040 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32041 } else {
32042 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32043 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32044 }
32045 if (SWIG_IsTmpObj(res3)) {
32046 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32047 } else {
32048 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32049 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32050 }
32051 return resultobj;
32052 fail:
32053 return NULL;
32054 }
32055
32056
32057 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32058 PyObject *resultobj = 0;
32059 wxWindow *arg1 = (wxWindow *) 0 ;
32060 wxSize result;
32061 void *argp1 = 0 ;
32062 int res1 = 0 ;
32063 PyObject *swig_obj[1] ;
32064
32065 if (!args) SWIG_fail;
32066 swig_obj[0] = args;
32067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32068 if (!SWIG_IsOK(res1)) {
32069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32070 }
32071 arg1 = reinterpret_cast< wxWindow * >(argp1);
32072 {
32073 PyThreadState* __tstate = wxPyBeginAllowThreads();
32074 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32075 wxPyEndAllowThreads(__tstate);
32076 if (PyErr_Occurred()) SWIG_fail;
32077 }
32078 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32079 return resultobj;
32080 fail:
32081 return NULL;
32082 }
32083
32084
32085 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32086 PyObject *resultobj = 0;
32087 wxWindow *arg1 = (wxWindow *) 0 ;
32088 bool arg2 = (bool) true ;
32089 bool result;
32090 void *argp1 = 0 ;
32091 int res1 = 0 ;
32092 bool val2 ;
32093 int ecode2 = 0 ;
32094 PyObject * obj0 = 0 ;
32095 PyObject * obj1 = 0 ;
32096 char * kwnames[] = {
32097 (char *) "self",(char *) "show", NULL
32098 };
32099
32100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32102 if (!SWIG_IsOK(res1)) {
32103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32104 }
32105 arg1 = reinterpret_cast< wxWindow * >(argp1);
32106 if (obj1) {
32107 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32108 if (!SWIG_IsOK(ecode2)) {
32109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32110 }
32111 arg2 = static_cast< bool >(val2);
32112 }
32113 {
32114 PyThreadState* __tstate = wxPyBeginAllowThreads();
32115 result = (bool)(arg1)->Show(arg2);
32116 wxPyEndAllowThreads(__tstate);
32117 if (PyErr_Occurred()) SWIG_fail;
32118 }
32119 {
32120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32121 }
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32129 PyObject *resultobj = 0;
32130 wxWindow *arg1 = (wxWindow *) 0 ;
32131 bool result;
32132 void *argp1 = 0 ;
32133 int res1 = 0 ;
32134 PyObject *swig_obj[1] ;
32135
32136 if (!args) SWIG_fail;
32137 swig_obj[0] = args;
32138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32139 if (!SWIG_IsOK(res1)) {
32140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32141 }
32142 arg1 = reinterpret_cast< wxWindow * >(argp1);
32143 {
32144 PyThreadState* __tstate = wxPyBeginAllowThreads();
32145 result = (bool)(arg1)->Hide();
32146 wxPyEndAllowThreads(__tstate);
32147 if (PyErr_Occurred()) SWIG_fail;
32148 }
32149 {
32150 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32151 }
32152 return resultobj;
32153 fail:
32154 return NULL;
32155 }
32156
32157
32158 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32159 PyObject *resultobj = 0;
32160 wxWindow *arg1 = (wxWindow *) 0 ;
32161 bool arg2 = (bool) true ;
32162 bool result;
32163 void *argp1 = 0 ;
32164 int res1 = 0 ;
32165 bool val2 ;
32166 int ecode2 = 0 ;
32167 PyObject * obj0 = 0 ;
32168 PyObject * obj1 = 0 ;
32169 char * kwnames[] = {
32170 (char *) "self",(char *) "enable", NULL
32171 };
32172
32173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32175 if (!SWIG_IsOK(res1)) {
32176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32177 }
32178 arg1 = reinterpret_cast< wxWindow * >(argp1);
32179 if (obj1) {
32180 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32181 if (!SWIG_IsOK(ecode2)) {
32182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32183 }
32184 arg2 = static_cast< bool >(val2);
32185 }
32186 {
32187 PyThreadState* __tstate = wxPyBeginAllowThreads();
32188 result = (bool)(arg1)->Enable(arg2);
32189 wxPyEndAllowThreads(__tstate);
32190 if (PyErr_Occurred()) SWIG_fail;
32191 }
32192 {
32193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32194 }
32195 return resultobj;
32196 fail:
32197 return NULL;
32198 }
32199
32200
32201 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32202 PyObject *resultobj = 0;
32203 wxWindow *arg1 = (wxWindow *) 0 ;
32204 bool result;
32205 void *argp1 = 0 ;
32206 int res1 = 0 ;
32207 PyObject *swig_obj[1] ;
32208
32209 if (!args) SWIG_fail;
32210 swig_obj[0] = args;
32211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32212 if (!SWIG_IsOK(res1)) {
32213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32214 }
32215 arg1 = reinterpret_cast< wxWindow * >(argp1);
32216 {
32217 PyThreadState* __tstate = wxPyBeginAllowThreads();
32218 result = (bool)(arg1)->Disable();
32219 wxPyEndAllowThreads(__tstate);
32220 if (PyErr_Occurred()) SWIG_fail;
32221 }
32222 {
32223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32224 }
32225 return resultobj;
32226 fail:
32227 return NULL;
32228 }
32229
32230
32231 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32232 PyObject *resultobj = 0;
32233 wxWindow *arg1 = (wxWindow *) 0 ;
32234 bool result;
32235 void *argp1 = 0 ;
32236 int res1 = 0 ;
32237 PyObject *swig_obj[1] ;
32238
32239 if (!args) SWIG_fail;
32240 swig_obj[0] = args;
32241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32242 if (!SWIG_IsOK(res1)) {
32243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32244 }
32245 arg1 = reinterpret_cast< wxWindow * >(argp1);
32246 {
32247 PyThreadState* __tstate = wxPyBeginAllowThreads();
32248 result = (bool)((wxWindow const *)arg1)->IsShown();
32249 wxPyEndAllowThreads(__tstate);
32250 if (PyErr_Occurred()) SWIG_fail;
32251 }
32252 {
32253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32254 }
32255 return resultobj;
32256 fail:
32257 return NULL;
32258 }
32259
32260
32261 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32262 PyObject *resultobj = 0;
32263 wxWindow *arg1 = (wxWindow *) 0 ;
32264 bool result;
32265 void *argp1 = 0 ;
32266 int res1 = 0 ;
32267 PyObject *swig_obj[1] ;
32268
32269 if (!args) SWIG_fail;
32270 swig_obj[0] = args;
32271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32272 if (!SWIG_IsOK(res1)) {
32273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32274 }
32275 arg1 = reinterpret_cast< wxWindow * >(argp1);
32276 {
32277 PyThreadState* __tstate = wxPyBeginAllowThreads();
32278 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32279 wxPyEndAllowThreads(__tstate);
32280 if (PyErr_Occurred()) SWIG_fail;
32281 }
32282 {
32283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32284 }
32285 return resultobj;
32286 fail:
32287 return NULL;
32288 }
32289
32290
32291 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32292 PyObject *resultobj = 0;
32293 wxWindow *arg1 = (wxWindow *) 0 ;
32294 long arg2 ;
32295 void *argp1 = 0 ;
32296 int res1 = 0 ;
32297 long val2 ;
32298 int ecode2 = 0 ;
32299 PyObject * obj0 = 0 ;
32300 PyObject * obj1 = 0 ;
32301 char * kwnames[] = {
32302 (char *) "self",(char *) "style", NULL
32303 };
32304
32305 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32306 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32307 if (!SWIG_IsOK(res1)) {
32308 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32309 }
32310 arg1 = reinterpret_cast< wxWindow * >(argp1);
32311 ecode2 = SWIG_AsVal_long(obj1, &val2);
32312 if (!SWIG_IsOK(ecode2)) {
32313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32314 }
32315 arg2 = static_cast< long >(val2);
32316 {
32317 PyThreadState* __tstate = wxPyBeginAllowThreads();
32318 (arg1)->SetWindowStyleFlag(arg2);
32319 wxPyEndAllowThreads(__tstate);
32320 if (PyErr_Occurred()) SWIG_fail;
32321 }
32322 resultobj = SWIG_Py_Void();
32323 return resultobj;
32324 fail:
32325 return NULL;
32326 }
32327
32328
32329 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32330 PyObject *resultobj = 0;
32331 wxWindow *arg1 = (wxWindow *) 0 ;
32332 long result;
32333 void *argp1 = 0 ;
32334 int res1 = 0 ;
32335 PyObject *swig_obj[1] ;
32336
32337 if (!args) SWIG_fail;
32338 swig_obj[0] = args;
32339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32340 if (!SWIG_IsOK(res1)) {
32341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32342 }
32343 arg1 = reinterpret_cast< wxWindow * >(argp1);
32344 {
32345 PyThreadState* __tstate = wxPyBeginAllowThreads();
32346 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32347 wxPyEndAllowThreads(__tstate);
32348 if (PyErr_Occurred()) SWIG_fail;
32349 }
32350 resultobj = SWIG_From_long(static_cast< long >(result));
32351 return resultobj;
32352 fail:
32353 return NULL;
32354 }
32355
32356
32357 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32358 PyObject *resultobj = 0;
32359 wxWindow *arg1 = (wxWindow *) 0 ;
32360 int arg2 ;
32361 bool result;
32362 void *argp1 = 0 ;
32363 int res1 = 0 ;
32364 int val2 ;
32365 int ecode2 = 0 ;
32366 PyObject * obj0 = 0 ;
32367 PyObject * obj1 = 0 ;
32368 char * kwnames[] = {
32369 (char *) "self",(char *) "flag", NULL
32370 };
32371
32372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32374 if (!SWIG_IsOK(res1)) {
32375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32376 }
32377 arg1 = reinterpret_cast< wxWindow * >(argp1);
32378 ecode2 = SWIG_AsVal_int(obj1, &val2);
32379 if (!SWIG_IsOK(ecode2)) {
32380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32381 }
32382 arg2 = static_cast< int >(val2);
32383 {
32384 PyThreadState* __tstate = wxPyBeginAllowThreads();
32385 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32386 wxPyEndAllowThreads(__tstate);
32387 if (PyErr_Occurred()) SWIG_fail;
32388 }
32389 {
32390 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32391 }
32392 return resultobj;
32393 fail:
32394 return NULL;
32395 }
32396
32397
32398 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32399 PyObject *resultobj = 0;
32400 wxWindow *arg1 = (wxWindow *) 0 ;
32401 bool result;
32402 void *argp1 = 0 ;
32403 int res1 = 0 ;
32404 PyObject *swig_obj[1] ;
32405
32406 if (!args) SWIG_fail;
32407 swig_obj[0] = args;
32408 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32409 if (!SWIG_IsOK(res1)) {
32410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32411 }
32412 arg1 = reinterpret_cast< wxWindow * >(argp1);
32413 {
32414 PyThreadState* __tstate = wxPyBeginAllowThreads();
32415 result = (bool)((wxWindow const *)arg1)->IsRetained();
32416 wxPyEndAllowThreads(__tstate);
32417 if (PyErr_Occurred()) SWIG_fail;
32418 }
32419 {
32420 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32421 }
32422 return resultobj;
32423 fail:
32424 return NULL;
32425 }
32426
32427
32428 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32429 PyObject *resultobj = 0;
32430 wxWindow *arg1 = (wxWindow *) 0 ;
32431 long arg2 ;
32432 void *argp1 = 0 ;
32433 int res1 = 0 ;
32434 long val2 ;
32435 int ecode2 = 0 ;
32436 PyObject * obj0 = 0 ;
32437 PyObject * obj1 = 0 ;
32438 char * kwnames[] = {
32439 (char *) "self",(char *) "exStyle", NULL
32440 };
32441
32442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32444 if (!SWIG_IsOK(res1)) {
32445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32446 }
32447 arg1 = reinterpret_cast< wxWindow * >(argp1);
32448 ecode2 = SWIG_AsVal_long(obj1, &val2);
32449 if (!SWIG_IsOK(ecode2)) {
32450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32451 }
32452 arg2 = static_cast< long >(val2);
32453 {
32454 PyThreadState* __tstate = wxPyBeginAllowThreads();
32455 (arg1)->SetExtraStyle(arg2);
32456 wxPyEndAllowThreads(__tstate);
32457 if (PyErr_Occurred()) SWIG_fail;
32458 }
32459 resultobj = SWIG_Py_Void();
32460 return resultobj;
32461 fail:
32462 return NULL;
32463 }
32464
32465
32466 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32467 PyObject *resultobj = 0;
32468 wxWindow *arg1 = (wxWindow *) 0 ;
32469 long result;
32470 void *argp1 = 0 ;
32471 int res1 = 0 ;
32472 PyObject *swig_obj[1] ;
32473
32474 if (!args) SWIG_fail;
32475 swig_obj[0] = args;
32476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32477 if (!SWIG_IsOK(res1)) {
32478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32479 }
32480 arg1 = reinterpret_cast< wxWindow * >(argp1);
32481 {
32482 PyThreadState* __tstate = wxPyBeginAllowThreads();
32483 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32484 wxPyEndAllowThreads(__tstate);
32485 if (PyErr_Occurred()) SWIG_fail;
32486 }
32487 resultobj = SWIG_From_long(static_cast< long >(result));
32488 return resultobj;
32489 fail:
32490 return NULL;
32491 }
32492
32493
32494 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32495 PyObject *resultobj = 0;
32496 wxWindow *arg1 = (wxWindow *) 0 ;
32497 bool arg2 = (bool) true ;
32498 void *argp1 = 0 ;
32499 int res1 = 0 ;
32500 bool val2 ;
32501 int ecode2 = 0 ;
32502 PyObject * obj0 = 0 ;
32503 PyObject * obj1 = 0 ;
32504 char * kwnames[] = {
32505 (char *) "self",(char *) "modal", NULL
32506 };
32507
32508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32510 if (!SWIG_IsOK(res1)) {
32511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32512 }
32513 arg1 = reinterpret_cast< wxWindow * >(argp1);
32514 if (obj1) {
32515 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32516 if (!SWIG_IsOK(ecode2)) {
32517 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32518 }
32519 arg2 = static_cast< bool >(val2);
32520 }
32521 {
32522 PyThreadState* __tstate = wxPyBeginAllowThreads();
32523 (arg1)->MakeModal(arg2);
32524 wxPyEndAllowThreads(__tstate);
32525 if (PyErr_Occurred()) SWIG_fail;
32526 }
32527 resultobj = SWIG_Py_Void();
32528 return resultobj;
32529 fail:
32530 return NULL;
32531 }
32532
32533
32534 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32535 PyObject *resultobj = 0;
32536 wxWindow *arg1 = (wxWindow *) 0 ;
32537 bool arg2 ;
32538 void *argp1 = 0 ;
32539 int res1 = 0 ;
32540 bool val2 ;
32541 int ecode2 = 0 ;
32542 PyObject * obj0 = 0 ;
32543 PyObject * obj1 = 0 ;
32544 char * kwnames[] = {
32545 (char *) "self",(char *) "enableTheme", NULL
32546 };
32547
32548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32550 if (!SWIG_IsOK(res1)) {
32551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32552 }
32553 arg1 = reinterpret_cast< wxWindow * >(argp1);
32554 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32555 if (!SWIG_IsOK(ecode2)) {
32556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32557 }
32558 arg2 = static_cast< bool >(val2);
32559 {
32560 PyThreadState* __tstate = wxPyBeginAllowThreads();
32561 (arg1)->SetThemeEnabled(arg2);
32562 wxPyEndAllowThreads(__tstate);
32563 if (PyErr_Occurred()) SWIG_fail;
32564 }
32565 resultobj = SWIG_Py_Void();
32566 return resultobj;
32567 fail:
32568 return NULL;
32569 }
32570
32571
32572 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32573 PyObject *resultobj = 0;
32574 wxWindow *arg1 = (wxWindow *) 0 ;
32575 bool result;
32576 void *argp1 = 0 ;
32577 int res1 = 0 ;
32578 PyObject *swig_obj[1] ;
32579
32580 if (!args) SWIG_fail;
32581 swig_obj[0] = args;
32582 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32583 if (!SWIG_IsOK(res1)) {
32584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32585 }
32586 arg1 = reinterpret_cast< wxWindow * >(argp1);
32587 {
32588 PyThreadState* __tstate = wxPyBeginAllowThreads();
32589 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32590 wxPyEndAllowThreads(__tstate);
32591 if (PyErr_Occurred()) SWIG_fail;
32592 }
32593 {
32594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32595 }
32596 return resultobj;
32597 fail:
32598 return NULL;
32599 }
32600
32601
32602 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32603 PyObject *resultobj = 0;
32604 wxWindow *arg1 = (wxWindow *) 0 ;
32605 void *argp1 = 0 ;
32606 int res1 = 0 ;
32607 PyObject *swig_obj[1] ;
32608
32609 if (!args) SWIG_fail;
32610 swig_obj[0] = args;
32611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32612 if (!SWIG_IsOK(res1)) {
32613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32614 }
32615 arg1 = reinterpret_cast< wxWindow * >(argp1);
32616 {
32617 PyThreadState* __tstate = wxPyBeginAllowThreads();
32618 (arg1)->SetFocus();
32619 wxPyEndAllowThreads(__tstate);
32620 if (PyErr_Occurred()) SWIG_fail;
32621 }
32622 resultobj = SWIG_Py_Void();
32623 return resultobj;
32624 fail:
32625 return NULL;
32626 }
32627
32628
32629 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32630 PyObject *resultobj = 0;
32631 wxWindow *arg1 = (wxWindow *) 0 ;
32632 void *argp1 = 0 ;
32633 int res1 = 0 ;
32634 PyObject *swig_obj[1] ;
32635
32636 if (!args) SWIG_fail;
32637 swig_obj[0] = args;
32638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32639 if (!SWIG_IsOK(res1)) {
32640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32641 }
32642 arg1 = reinterpret_cast< wxWindow * >(argp1);
32643 {
32644 PyThreadState* __tstate = wxPyBeginAllowThreads();
32645 (arg1)->SetFocusFromKbd();
32646 wxPyEndAllowThreads(__tstate);
32647 if (PyErr_Occurred()) SWIG_fail;
32648 }
32649 resultobj = SWIG_Py_Void();
32650 return resultobj;
32651 fail:
32652 return NULL;
32653 }
32654
32655
32656 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32657 PyObject *resultobj = 0;
32658 wxWindow *result = 0 ;
32659
32660 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32661 {
32662 if (!wxPyCheckForApp()) SWIG_fail;
32663 PyThreadState* __tstate = wxPyBeginAllowThreads();
32664 result = (wxWindow *)wxWindow::FindFocus();
32665 wxPyEndAllowThreads(__tstate);
32666 if (PyErr_Occurred()) SWIG_fail;
32667 }
32668 {
32669 resultobj = wxPyMake_wxObject(result, 0);
32670 }
32671 return resultobj;
32672 fail:
32673 return NULL;
32674 }
32675
32676
32677 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32678 PyObject *resultobj = 0;
32679 wxWindow *arg1 = (wxWindow *) 0 ;
32680 bool result;
32681 void *argp1 = 0 ;
32682 int res1 = 0 ;
32683 PyObject *swig_obj[1] ;
32684
32685 if (!args) SWIG_fail;
32686 swig_obj[0] = args;
32687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32688 if (!SWIG_IsOK(res1)) {
32689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32690 }
32691 arg1 = reinterpret_cast< wxWindow * >(argp1);
32692 {
32693 PyThreadState* __tstate = wxPyBeginAllowThreads();
32694 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32695 wxPyEndAllowThreads(__tstate);
32696 if (PyErr_Occurred()) SWIG_fail;
32697 }
32698 {
32699 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32700 }
32701 return resultobj;
32702 fail:
32703 return NULL;
32704 }
32705
32706
32707 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32708 PyObject *resultobj = 0;
32709 wxWindow *arg1 = (wxWindow *) 0 ;
32710 bool result;
32711 void *argp1 = 0 ;
32712 int res1 = 0 ;
32713 PyObject *swig_obj[1] ;
32714
32715 if (!args) SWIG_fail;
32716 swig_obj[0] = args;
32717 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32718 if (!SWIG_IsOK(res1)) {
32719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32720 }
32721 arg1 = reinterpret_cast< wxWindow * >(argp1);
32722 {
32723 PyThreadState* __tstate = wxPyBeginAllowThreads();
32724 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32725 wxPyEndAllowThreads(__tstate);
32726 if (PyErr_Occurred()) SWIG_fail;
32727 }
32728 {
32729 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32730 }
32731 return resultobj;
32732 fail:
32733 return NULL;
32734 }
32735
32736
32737 SWIGINTERN PyObject *_wrap_Window_GetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32738 PyObject *resultobj = 0;
32739 wxWindow *arg1 = (wxWindow *) 0 ;
32740 wxWindow *result = 0 ;
32741 void *argp1 = 0 ;
32742 int res1 = 0 ;
32743 PyObject *swig_obj[1] ;
32744
32745 if (!args) SWIG_fail;
32746 swig_obj[0] = args;
32747 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32748 if (!SWIG_IsOK(res1)) {
32749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultItem" "', expected argument " "1"" of type '" "wxWindow const *""'");
32750 }
32751 arg1 = reinterpret_cast< wxWindow * >(argp1);
32752 {
32753 PyThreadState* __tstate = wxPyBeginAllowThreads();
32754 result = (wxWindow *)((wxWindow const *)arg1)->GetDefaultItem();
32755 wxPyEndAllowThreads(__tstate);
32756 if (PyErr_Occurred()) SWIG_fail;
32757 }
32758 {
32759 resultobj = wxPyMake_wxObject(result, 0);
32760 }
32761 return resultobj;
32762 fail:
32763 return NULL;
32764 }
32765
32766
32767 SWIGINTERN PyObject *_wrap_Window_SetDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32768 PyObject *resultobj = 0;
32769 wxWindow *arg1 = (wxWindow *) 0 ;
32770 wxWindow *arg2 = (wxWindow *) 0 ;
32771 wxWindow *result = 0 ;
32772 void *argp1 = 0 ;
32773 int res1 = 0 ;
32774 void *argp2 = 0 ;
32775 int res2 = 0 ;
32776 PyObject * obj0 = 0 ;
32777 PyObject * obj1 = 0 ;
32778 char * kwnames[] = {
32779 (char *) "self",(char *) "child", NULL
32780 };
32781
32782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32784 if (!SWIG_IsOK(res1)) {
32785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32786 }
32787 arg1 = reinterpret_cast< wxWindow * >(argp1);
32788 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32789 if (!SWIG_IsOK(res2)) {
32790 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32791 }
32792 arg2 = reinterpret_cast< wxWindow * >(argp2);
32793 {
32794 PyThreadState* __tstate = wxPyBeginAllowThreads();
32795 result = (wxWindow *)(arg1)->SetDefaultItem(arg2);
32796 wxPyEndAllowThreads(__tstate);
32797 if (PyErr_Occurred()) SWIG_fail;
32798 }
32799 {
32800 resultobj = wxPyMake_wxObject(result, 0);
32801 }
32802 return resultobj;
32803 fail:
32804 return NULL;
32805 }
32806
32807
32808 SWIGINTERN PyObject *_wrap_Window_SetTmpDefaultItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32809 PyObject *resultobj = 0;
32810 wxWindow *arg1 = (wxWindow *) 0 ;
32811 wxWindow *arg2 = (wxWindow *) 0 ;
32812 void *argp1 = 0 ;
32813 int res1 = 0 ;
32814 void *argp2 = 0 ;
32815 int res2 = 0 ;
32816 PyObject * obj0 = 0 ;
32817 PyObject * obj1 = 0 ;
32818 char * kwnames[] = {
32819 (char *) "self",(char *) "win", NULL
32820 };
32821
32822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTmpDefaultItem",kwnames,&obj0,&obj1)) SWIG_fail;
32823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32824 if (!SWIG_IsOK(res1)) {
32825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "1"" of type '" "wxWindow *""'");
32826 }
32827 arg1 = reinterpret_cast< wxWindow * >(argp1);
32828 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32829 if (!SWIG_IsOK(res2)) {
32830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetTmpDefaultItem" "', expected argument " "2"" of type '" "wxWindow *""'");
32831 }
32832 arg2 = reinterpret_cast< wxWindow * >(argp2);
32833 {
32834 PyThreadState* __tstate = wxPyBeginAllowThreads();
32835 (arg1)->SetTmpDefaultItem(arg2);
32836 wxPyEndAllowThreads(__tstate);
32837 if (PyErr_Occurred()) SWIG_fail;
32838 }
32839 resultobj = SWIG_Py_Void();
32840 return resultobj;
32841 fail:
32842 return NULL;
32843 }
32844
32845
32846 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32847 PyObject *resultobj = 0;
32848 wxWindow *arg1 = (wxWindow *) 0 ;
32849 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32850 bool result;
32851 void *argp1 = 0 ;
32852 int res1 = 0 ;
32853 int val2 ;
32854 int ecode2 = 0 ;
32855 PyObject * obj0 = 0 ;
32856 PyObject * obj1 = 0 ;
32857 char * kwnames[] = {
32858 (char *) "self",(char *) "flags", NULL
32859 };
32860
32861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32862 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32863 if (!SWIG_IsOK(res1)) {
32864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32865 }
32866 arg1 = reinterpret_cast< wxWindow * >(argp1);
32867 if (obj1) {
32868 ecode2 = SWIG_AsVal_int(obj1, &val2);
32869 if (!SWIG_IsOK(ecode2)) {
32870 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32871 }
32872 arg2 = static_cast< int >(val2);
32873 }
32874 {
32875 PyThreadState* __tstate = wxPyBeginAllowThreads();
32876 result = (bool)(arg1)->Navigate(arg2);
32877 wxPyEndAllowThreads(__tstate);
32878 if (PyErr_Occurred()) SWIG_fail;
32879 }
32880 {
32881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32882 }
32883 return resultobj;
32884 fail:
32885 return NULL;
32886 }
32887
32888
32889 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32890 PyObject *resultobj = 0;
32891 wxWindow *arg1 = (wxWindow *) 0 ;
32892 wxWindow *arg2 = (wxWindow *) 0 ;
32893 void *argp1 = 0 ;
32894 int res1 = 0 ;
32895 void *argp2 = 0 ;
32896 int res2 = 0 ;
32897 PyObject * obj0 = 0 ;
32898 PyObject * obj1 = 0 ;
32899 char * kwnames[] = {
32900 (char *) "self",(char *) "win", NULL
32901 };
32902
32903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32905 if (!SWIG_IsOK(res1)) {
32906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32907 }
32908 arg1 = reinterpret_cast< wxWindow * >(argp1);
32909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32910 if (!SWIG_IsOK(res2)) {
32911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32912 }
32913 arg2 = reinterpret_cast< wxWindow * >(argp2);
32914 {
32915 PyThreadState* __tstate = wxPyBeginAllowThreads();
32916 (arg1)->MoveAfterInTabOrder(arg2);
32917 wxPyEndAllowThreads(__tstate);
32918 if (PyErr_Occurred()) SWIG_fail;
32919 }
32920 resultobj = SWIG_Py_Void();
32921 return resultobj;
32922 fail:
32923 return NULL;
32924 }
32925
32926
32927 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32928 PyObject *resultobj = 0;
32929 wxWindow *arg1 = (wxWindow *) 0 ;
32930 wxWindow *arg2 = (wxWindow *) 0 ;
32931 void *argp1 = 0 ;
32932 int res1 = 0 ;
32933 void *argp2 = 0 ;
32934 int res2 = 0 ;
32935 PyObject * obj0 = 0 ;
32936 PyObject * obj1 = 0 ;
32937 char * kwnames[] = {
32938 (char *) "self",(char *) "win", NULL
32939 };
32940
32941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32943 if (!SWIG_IsOK(res1)) {
32944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32945 }
32946 arg1 = reinterpret_cast< wxWindow * >(argp1);
32947 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32948 if (!SWIG_IsOK(res2)) {
32949 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32950 }
32951 arg2 = reinterpret_cast< wxWindow * >(argp2);
32952 {
32953 PyThreadState* __tstate = wxPyBeginAllowThreads();
32954 (arg1)->MoveBeforeInTabOrder(arg2);
32955 wxPyEndAllowThreads(__tstate);
32956 if (PyErr_Occurred()) SWIG_fail;
32957 }
32958 resultobj = SWIG_Py_Void();
32959 return resultobj;
32960 fail:
32961 return NULL;
32962 }
32963
32964
32965 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32966 PyObject *resultobj = 0;
32967 wxWindow *arg1 = (wxWindow *) 0 ;
32968 PyObject *result = 0 ;
32969 void *argp1 = 0 ;
32970 int res1 = 0 ;
32971 PyObject *swig_obj[1] ;
32972
32973 if (!args) SWIG_fail;
32974 swig_obj[0] = args;
32975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32976 if (!SWIG_IsOK(res1)) {
32977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
32978 }
32979 arg1 = reinterpret_cast< wxWindow * >(argp1);
32980 {
32981 PyThreadState* __tstate = wxPyBeginAllowThreads();
32982 result = (PyObject *)wxWindow_GetChildren(arg1);
32983 wxPyEndAllowThreads(__tstate);
32984 if (PyErr_Occurred()) SWIG_fail;
32985 }
32986 resultobj = result;
32987 return resultobj;
32988 fail:
32989 return NULL;
32990 }
32991
32992
32993 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32994 PyObject *resultobj = 0;
32995 wxWindow *arg1 = (wxWindow *) 0 ;
32996 wxWindow *result = 0 ;
32997 void *argp1 = 0 ;
32998 int res1 = 0 ;
32999 PyObject *swig_obj[1] ;
33000
33001 if (!args) SWIG_fail;
33002 swig_obj[0] = args;
33003 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33004 if (!SWIG_IsOK(res1)) {
33005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33006 }
33007 arg1 = reinterpret_cast< wxWindow * >(argp1);
33008 {
33009 PyThreadState* __tstate = wxPyBeginAllowThreads();
33010 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33011 wxPyEndAllowThreads(__tstate);
33012 if (PyErr_Occurred()) SWIG_fail;
33013 }
33014 {
33015 resultobj = wxPyMake_wxObject(result, 0);
33016 }
33017 return resultobj;
33018 fail:
33019 return NULL;
33020 }
33021
33022
33023 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33024 PyObject *resultobj = 0;
33025 wxWindow *arg1 = (wxWindow *) 0 ;
33026 wxWindow *result = 0 ;
33027 void *argp1 = 0 ;
33028 int res1 = 0 ;
33029 PyObject *swig_obj[1] ;
33030
33031 if (!args) SWIG_fail;
33032 swig_obj[0] = args;
33033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33034 if (!SWIG_IsOK(res1)) {
33035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33036 }
33037 arg1 = reinterpret_cast< wxWindow * >(argp1);
33038 {
33039 PyThreadState* __tstate = wxPyBeginAllowThreads();
33040 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33041 wxPyEndAllowThreads(__tstate);
33042 if (PyErr_Occurred()) SWIG_fail;
33043 }
33044 {
33045 resultobj = wxPyMake_wxObject(result, 0);
33046 }
33047 return resultobj;
33048 fail:
33049 return NULL;
33050 }
33051
33052
33053 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33054 PyObject *resultobj = 0;
33055 wxWindow *arg1 = (wxWindow *) 0 ;
33056 bool result;
33057 void *argp1 = 0 ;
33058 int res1 = 0 ;
33059 PyObject *swig_obj[1] ;
33060
33061 if (!args) SWIG_fail;
33062 swig_obj[0] = args;
33063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33064 if (!SWIG_IsOK(res1)) {
33065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33066 }
33067 arg1 = reinterpret_cast< wxWindow * >(argp1);
33068 {
33069 PyThreadState* __tstate = wxPyBeginAllowThreads();
33070 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33071 wxPyEndAllowThreads(__tstate);
33072 if (PyErr_Occurred()) SWIG_fail;
33073 }
33074 {
33075 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33076 }
33077 return resultobj;
33078 fail:
33079 return NULL;
33080 }
33081
33082
33083 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33084 PyObject *resultobj = 0;
33085 wxWindow *arg1 = (wxWindow *) 0 ;
33086 wxWindow *arg2 = (wxWindow *) 0 ;
33087 bool result;
33088 void *argp1 = 0 ;
33089 int res1 = 0 ;
33090 void *argp2 = 0 ;
33091 int res2 = 0 ;
33092 PyObject * obj0 = 0 ;
33093 PyObject * obj1 = 0 ;
33094 char * kwnames[] = {
33095 (char *) "self",(char *) "newParent", NULL
33096 };
33097
33098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33100 if (!SWIG_IsOK(res1)) {
33101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33102 }
33103 arg1 = reinterpret_cast< wxWindow * >(argp1);
33104 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33105 if (!SWIG_IsOK(res2)) {
33106 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33107 }
33108 arg2 = reinterpret_cast< wxWindow * >(argp2);
33109 {
33110 PyThreadState* __tstate = wxPyBeginAllowThreads();
33111 result = (bool)(arg1)->Reparent(arg2);
33112 wxPyEndAllowThreads(__tstate);
33113 if (PyErr_Occurred()) SWIG_fail;
33114 }
33115 {
33116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33117 }
33118 return resultobj;
33119 fail:
33120 return NULL;
33121 }
33122
33123
33124 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33125 PyObject *resultobj = 0;
33126 wxWindow *arg1 = (wxWindow *) 0 ;
33127 wxWindow *arg2 = (wxWindow *) 0 ;
33128 void *argp1 = 0 ;
33129 int res1 = 0 ;
33130 void *argp2 = 0 ;
33131 int res2 = 0 ;
33132 PyObject * obj0 = 0 ;
33133 PyObject * obj1 = 0 ;
33134 char * kwnames[] = {
33135 (char *) "self",(char *) "child", NULL
33136 };
33137
33138 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33139 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33140 if (!SWIG_IsOK(res1)) {
33141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33142 }
33143 arg1 = reinterpret_cast< wxWindow * >(argp1);
33144 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33145 if (!SWIG_IsOK(res2)) {
33146 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33147 }
33148 arg2 = reinterpret_cast< wxWindow * >(argp2);
33149 {
33150 PyThreadState* __tstate = wxPyBeginAllowThreads();
33151 (arg1)->AddChild(arg2);
33152 wxPyEndAllowThreads(__tstate);
33153 if (PyErr_Occurred()) SWIG_fail;
33154 }
33155 resultobj = SWIG_Py_Void();
33156 return resultobj;
33157 fail:
33158 return NULL;
33159 }
33160
33161
33162 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33163 PyObject *resultobj = 0;
33164 wxWindow *arg1 = (wxWindow *) 0 ;
33165 wxWindow *arg2 = (wxWindow *) 0 ;
33166 void *argp1 = 0 ;
33167 int res1 = 0 ;
33168 void *argp2 = 0 ;
33169 int res2 = 0 ;
33170 PyObject * obj0 = 0 ;
33171 PyObject * obj1 = 0 ;
33172 char * kwnames[] = {
33173 (char *) "self",(char *) "child", NULL
33174 };
33175
33176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33178 if (!SWIG_IsOK(res1)) {
33179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33180 }
33181 arg1 = reinterpret_cast< wxWindow * >(argp1);
33182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33183 if (!SWIG_IsOK(res2)) {
33184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33185 }
33186 arg2 = reinterpret_cast< wxWindow * >(argp2);
33187 {
33188 PyThreadState* __tstate = wxPyBeginAllowThreads();
33189 (arg1)->RemoveChild(arg2);
33190 wxPyEndAllowThreads(__tstate);
33191 if (PyErr_Occurred()) SWIG_fail;
33192 }
33193 resultobj = SWIG_Py_Void();
33194 return resultobj;
33195 fail:
33196 return NULL;
33197 }
33198
33199
33200 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33201 PyObject *resultobj = 0;
33202 wxWindow *arg1 = (wxWindow *) 0 ;
33203 bool arg2 ;
33204 void *argp1 = 0 ;
33205 int res1 = 0 ;
33206 bool val2 ;
33207 int ecode2 = 0 ;
33208 PyObject * obj0 = 0 ;
33209 PyObject * obj1 = 0 ;
33210 char * kwnames[] = {
33211 (char *) "self",(char *) "on", NULL
33212 };
33213
33214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",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_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33218 }
33219 arg1 = reinterpret_cast< wxWindow * >(argp1);
33220 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33221 if (!SWIG_IsOK(ecode2)) {
33222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33223 }
33224 arg2 = static_cast< bool >(val2);
33225 {
33226 PyThreadState* __tstate = wxPyBeginAllowThreads();
33227 wxWindow_SetDoubleBuffered(arg1,arg2);
33228 wxPyEndAllowThreads(__tstate);
33229 if (PyErr_Occurred()) SWIG_fail;
33230 }
33231 resultobj = SWIG_Py_Void();
33232 return resultobj;
33233 fail:
33234 return NULL;
33235 }
33236
33237
33238 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33239 PyObject *resultobj = 0;
33240 wxWindow *arg1 = (wxWindow *) 0 ;
33241 long arg2 ;
33242 wxWindow *result = 0 ;
33243 void *argp1 = 0 ;
33244 int res1 = 0 ;
33245 long val2 ;
33246 int ecode2 = 0 ;
33247 PyObject * obj0 = 0 ;
33248 PyObject * obj1 = 0 ;
33249 char * kwnames[] = {
33250 (char *) "self",(char *) "winid", NULL
33251 };
33252
33253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33255 if (!SWIG_IsOK(res1)) {
33256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33257 }
33258 arg1 = reinterpret_cast< wxWindow * >(argp1);
33259 ecode2 = SWIG_AsVal_long(obj1, &val2);
33260 if (!SWIG_IsOK(ecode2)) {
33261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33262 }
33263 arg2 = static_cast< long >(val2);
33264 {
33265 PyThreadState* __tstate = wxPyBeginAllowThreads();
33266 result = (wxWindow *)(arg1)->FindWindow(arg2);
33267 wxPyEndAllowThreads(__tstate);
33268 if (PyErr_Occurred()) SWIG_fail;
33269 }
33270 {
33271 resultobj = wxPyMake_wxObject(result, 0);
33272 }
33273 return resultobj;
33274 fail:
33275 return NULL;
33276 }
33277
33278
33279 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33280 PyObject *resultobj = 0;
33281 wxWindow *arg1 = (wxWindow *) 0 ;
33282 wxString *arg2 = 0 ;
33283 wxWindow *result = 0 ;
33284 void *argp1 = 0 ;
33285 int res1 = 0 ;
33286 bool temp2 = false ;
33287 PyObject * obj0 = 0 ;
33288 PyObject * obj1 = 0 ;
33289 char * kwnames[] = {
33290 (char *) "self",(char *) "name", NULL
33291 };
33292
33293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33295 if (!SWIG_IsOK(res1)) {
33296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33297 }
33298 arg1 = reinterpret_cast< wxWindow * >(argp1);
33299 {
33300 arg2 = wxString_in_helper(obj1);
33301 if (arg2 == NULL) SWIG_fail;
33302 temp2 = true;
33303 }
33304 {
33305 PyThreadState* __tstate = wxPyBeginAllowThreads();
33306 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33307 wxPyEndAllowThreads(__tstate);
33308 if (PyErr_Occurred()) SWIG_fail;
33309 }
33310 {
33311 resultobj = wxPyMake_wxObject(result, 0);
33312 }
33313 {
33314 if (temp2)
33315 delete arg2;
33316 }
33317 return resultobj;
33318 fail:
33319 {
33320 if (temp2)
33321 delete arg2;
33322 }
33323 return NULL;
33324 }
33325
33326
33327 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33328 PyObject *resultobj = 0;
33329 wxWindow *arg1 = (wxWindow *) 0 ;
33330 wxEvtHandler *result = 0 ;
33331 void *argp1 = 0 ;
33332 int res1 = 0 ;
33333 PyObject *swig_obj[1] ;
33334
33335 if (!args) SWIG_fail;
33336 swig_obj[0] = args;
33337 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33338 if (!SWIG_IsOK(res1)) {
33339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33340 }
33341 arg1 = reinterpret_cast< wxWindow * >(argp1);
33342 {
33343 PyThreadState* __tstate = wxPyBeginAllowThreads();
33344 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33345 wxPyEndAllowThreads(__tstate);
33346 if (PyErr_Occurred()) SWIG_fail;
33347 }
33348 {
33349 resultobj = wxPyMake_wxObject(result, 0);
33350 }
33351 return resultobj;
33352 fail:
33353 return NULL;
33354 }
33355
33356
33357 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33358 PyObject *resultobj = 0;
33359 wxWindow *arg1 = (wxWindow *) 0 ;
33360 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33361 void *argp1 = 0 ;
33362 int res1 = 0 ;
33363 void *argp2 = 0 ;
33364 int res2 = 0 ;
33365 PyObject * obj0 = 0 ;
33366 PyObject * obj1 = 0 ;
33367 char * kwnames[] = {
33368 (char *) "self",(char *) "handler", NULL
33369 };
33370
33371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33373 if (!SWIG_IsOK(res1)) {
33374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33375 }
33376 arg1 = reinterpret_cast< wxWindow * >(argp1);
33377 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33378 if (!SWIG_IsOK(res2)) {
33379 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33380 }
33381 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33382 {
33383 PyThreadState* __tstate = wxPyBeginAllowThreads();
33384 (arg1)->SetEventHandler(arg2);
33385 wxPyEndAllowThreads(__tstate);
33386 if (PyErr_Occurred()) SWIG_fail;
33387 }
33388 resultobj = SWIG_Py_Void();
33389 return resultobj;
33390 fail:
33391 return NULL;
33392 }
33393
33394
33395 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33396 PyObject *resultobj = 0;
33397 wxWindow *arg1 = (wxWindow *) 0 ;
33398 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33399 void *argp1 = 0 ;
33400 int res1 = 0 ;
33401 void *argp2 = 0 ;
33402 int res2 = 0 ;
33403 PyObject * obj0 = 0 ;
33404 PyObject * obj1 = 0 ;
33405 char * kwnames[] = {
33406 (char *) "self",(char *) "handler", NULL
33407 };
33408
33409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",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_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33413 }
33414 arg1 = reinterpret_cast< wxWindow * >(argp1);
33415 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33416 if (!SWIG_IsOK(res2)) {
33417 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33418 }
33419 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33420 {
33421 PyThreadState* __tstate = wxPyBeginAllowThreads();
33422 (arg1)->PushEventHandler(arg2);
33423 wxPyEndAllowThreads(__tstate);
33424 if (PyErr_Occurred()) SWIG_fail;
33425 }
33426 resultobj = SWIG_Py_Void();
33427 return resultobj;
33428 fail:
33429 return NULL;
33430 }
33431
33432
33433 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33434 PyObject *resultobj = 0;
33435 wxWindow *arg1 = (wxWindow *) 0 ;
33436 bool arg2 = (bool) false ;
33437 wxEvtHandler *result = 0 ;
33438 void *argp1 = 0 ;
33439 int res1 = 0 ;
33440 bool val2 ;
33441 int ecode2 = 0 ;
33442 PyObject * obj0 = 0 ;
33443 PyObject * obj1 = 0 ;
33444 char * kwnames[] = {
33445 (char *) "self",(char *) "deleteHandler", NULL
33446 };
33447
33448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33450 if (!SWIG_IsOK(res1)) {
33451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33452 }
33453 arg1 = reinterpret_cast< wxWindow * >(argp1);
33454 if (obj1) {
33455 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33456 if (!SWIG_IsOK(ecode2)) {
33457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33458 }
33459 arg2 = static_cast< bool >(val2);
33460 }
33461 {
33462 PyThreadState* __tstate = wxPyBeginAllowThreads();
33463 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33464 wxPyEndAllowThreads(__tstate);
33465 if (PyErr_Occurred()) SWIG_fail;
33466 }
33467 {
33468 resultobj = wxPyMake_wxObject(result, 0);
33469 }
33470 return resultobj;
33471 fail:
33472 return NULL;
33473 }
33474
33475
33476 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33477 PyObject *resultobj = 0;
33478 wxWindow *arg1 = (wxWindow *) 0 ;
33479 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33480 bool result;
33481 void *argp1 = 0 ;
33482 int res1 = 0 ;
33483 void *argp2 = 0 ;
33484 int res2 = 0 ;
33485 PyObject * obj0 = 0 ;
33486 PyObject * obj1 = 0 ;
33487 char * kwnames[] = {
33488 (char *) "self",(char *) "handler", NULL
33489 };
33490
33491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33493 if (!SWIG_IsOK(res1)) {
33494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33495 }
33496 arg1 = reinterpret_cast< wxWindow * >(argp1);
33497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33498 if (!SWIG_IsOK(res2)) {
33499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33500 }
33501 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33502 {
33503 PyThreadState* __tstate = wxPyBeginAllowThreads();
33504 result = (bool)(arg1)->RemoveEventHandler(arg2);
33505 wxPyEndAllowThreads(__tstate);
33506 if (PyErr_Occurred()) SWIG_fail;
33507 }
33508 {
33509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33510 }
33511 return resultobj;
33512 fail:
33513 return NULL;
33514 }
33515
33516
33517 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33518 PyObject *resultobj = 0;
33519 wxWindow *arg1 = (wxWindow *) 0 ;
33520 wxValidator *arg2 = 0 ;
33521 void *argp1 = 0 ;
33522 int res1 = 0 ;
33523 void *argp2 = 0 ;
33524 int res2 = 0 ;
33525 PyObject * obj0 = 0 ;
33526 PyObject * obj1 = 0 ;
33527 char * kwnames[] = {
33528 (char *) "self",(char *) "validator", NULL
33529 };
33530
33531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33533 if (!SWIG_IsOK(res1)) {
33534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33535 }
33536 arg1 = reinterpret_cast< wxWindow * >(argp1);
33537 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33538 if (!SWIG_IsOK(res2)) {
33539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33540 }
33541 if (!argp2) {
33542 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33543 }
33544 arg2 = reinterpret_cast< wxValidator * >(argp2);
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 (arg1)->SetValidator((wxValidator const &)*arg2);
33548 wxPyEndAllowThreads(__tstate);
33549 if (PyErr_Occurred()) SWIG_fail;
33550 }
33551 resultobj = SWIG_Py_Void();
33552 return resultobj;
33553 fail:
33554 return NULL;
33555 }
33556
33557
33558 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33559 PyObject *resultobj = 0;
33560 wxWindow *arg1 = (wxWindow *) 0 ;
33561 wxValidator *result = 0 ;
33562 void *argp1 = 0 ;
33563 int res1 = 0 ;
33564 PyObject *swig_obj[1] ;
33565
33566 if (!args) SWIG_fail;
33567 swig_obj[0] = args;
33568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33569 if (!SWIG_IsOK(res1)) {
33570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33571 }
33572 arg1 = reinterpret_cast< wxWindow * >(argp1);
33573 {
33574 PyThreadState* __tstate = wxPyBeginAllowThreads();
33575 result = (wxValidator *)(arg1)->GetValidator();
33576 wxPyEndAllowThreads(__tstate);
33577 if (PyErr_Occurred()) SWIG_fail;
33578 }
33579 {
33580 resultobj = wxPyMake_wxObject(result, (bool)0);
33581 }
33582 return resultobj;
33583 fail:
33584 return NULL;
33585 }
33586
33587
33588 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33589 PyObject *resultobj = 0;
33590 wxWindow *arg1 = (wxWindow *) 0 ;
33591 bool result;
33592 void *argp1 = 0 ;
33593 int res1 = 0 ;
33594 PyObject *swig_obj[1] ;
33595
33596 if (!args) SWIG_fail;
33597 swig_obj[0] = args;
33598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33599 if (!SWIG_IsOK(res1)) {
33600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33601 }
33602 arg1 = reinterpret_cast< wxWindow * >(argp1);
33603 {
33604 PyThreadState* __tstate = wxPyBeginAllowThreads();
33605 result = (bool)(arg1)->Validate();
33606 wxPyEndAllowThreads(__tstate);
33607 if (PyErr_Occurred()) SWIG_fail;
33608 }
33609 {
33610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33611 }
33612 return resultobj;
33613 fail:
33614 return NULL;
33615 }
33616
33617
33618 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33619 PyObject *resultobj = 0;
33620 wxWindow *arg1 = (wxWindow *) 0 ;
33621 bool result;
33622 void *argp1 = 0 ;
33623 int res1 = 0 ;
33624 PyObject *swig_obj[1] ;
33625
33626 if (!args) SWIG_fail;
33627 swig_obj[0] = args;
33628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33629 if (!SWIG_IsOK(res1)) {
33630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33631 }
33632 arg1 = reinterpret_cast< wxWindow * >(argp1);
33633 {
33634 PyThreadState* __tstate = wxPyBeginAllowThreads();
33635 result = (bool)(arg1)->TransferDataToWindow();
33636 wxPyEndAllowThreads(__tstate);
33637 if (PyErr_Occurred()) SWIG_fail;
33638 }
33639 {
33640 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33641 }
33642 return resultobj;
33643 fail:
33644 return NULL;
33645 }
33646
33647
33648 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33649 PyObject *resultobj = 0;
33650 wxWindow *arg1 = (wxWindow *) 0 ;
33651 bool result;
33652 void *argp1 = 0 ;
33653 int res1 = 0 ;
33654 PyObject *swig_obj[1] ;
33655
33656 if (!args) SWIG_fail;
33657 swig_obj[0] = args;
33658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33659 if (!SWIG_IsOK(res1)) {
33660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33661 }
33662 arg1 = reinterpret_cast< wxWindow * >(argp1);
33663 {
33664 PyThreadState* __tstate = wxPyBeginAllowThreads();
33665 result = (bool)(arg1)->TransferDataFromWindow();
33666 wxPyEndAllowThreads(__tstate);
33667 if (PyErr_Occurred()) SWIG_fail;
33668 }
33669 {
33670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33671 }
33672 return resultobj;
33673 fail:
33674 return NULL;
33675 }
33676
33677
33678 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33679 PyObject *resultobj = 0;
33680 wxWindow *arg1 = (wxWindow *) 0 ;
33681 void *argp1 = 0 ;
33682 int res1 = 0 ;
33683 PyObject *swig_obj[1] ;
33684
33685 if (!args) SWIG_fail;
33686 swig_obj[0] = args;
33687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33688 if (!SWIG_IsOK(res1)) {
33689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33690 }
33691 arg1 = reinterpret_cast< wxWindow * >(argp1);
33692 {
33693 PyThreadState* __tstate = wxPyBeginAllowThreads();
33694 (arg1)->InitDialog();
33695 wxPyEndAllowThreads(__tstate);
33696 if (PyErr_Occurred()) SWIG_fail;
33697 }
33698 resultobj = SWIG_Py_Void();
33699 return resultobj;
33700 fail:
33701 return NULL;
33702 }
33703
33704
33705 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33706 PyObject *resultobj = 0;
33707 wxWindow *arg1 = (wxWindow *) 0 ;
33708 wxAcceleratorTable *arg2 = 0 ;
33709 void *argp1 = 0 ;
33710 int res1 = 0 ;
33711 void *argp2 = 0 ;
33712 int res2 = 0 ;
33713 PyObject * obj0 = 0 ;
33714 PyObject * obj1 = 0 ;
33715 char * kwnames[] = {
33716 (char *) "self",(char *) "accel", NULL
33717 };
33718
33719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33721 if (!SWIG_IsOK(res1)) {
33722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33723 }
33724 arg1 = reinterpret_cast< wxWindow * >(argp1);
33725 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33726 if (!SWIG_IsOK(res2)) {
33727 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33728 }
33729 if (!argp2) {
33730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33731 }
33732 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33733 {
33734 PyThreadState* __tstate = wxPyBeginAllowThreads();
33735 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33736 wxPyEndAllowThreads(__tstate);
33737 if (PyErr_Occurred()) SWIG_fail;
33738 }
33739 resultobj = SWIG_Py_Void();
33740 return resultobj;
33741 fail:
33742 return NULL;
33743 }
33744
33745
33746 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33747 PyObject *resultobj = 0;
33748 wxWindow *arg1 = (wxWindow *) 0 ;
33749 wxAcceleratorTable *result = 0 ;
33750 void *argp1 = 0 ;
33751 int res1 = 0 ;
33752 PyObject *swig_obj[1] ;
33753
33754 if (!args) SWIG_fail;
33755 swig_obj[0] = args;
33756 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33757 if (!SWIG_IsOK(res1)) {
33758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33759 }
33760 arg1 = reinterpret_cast< wxWindow * >(argp1);
33761 {
33762 PyThreadState* __tstate = wxPyBeginAllowThreads();
33763 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33764 wxPyEndAllowThreads(__tstate);
33765 if (PyErr_Occurred()) SWIG_fail;
33766 }
33767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33768 return resultobj;
33769 fail:
33770 return NULL;
33771 }
33772
33773
33774 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33775 PyObject *resultobj = 0;
33776 wxWindow *arg1 = (wxWindow *) 0 ;
33777 int arg2 ;
33778 int arg3 ;
33779 int arg4 ;
33780 bool result;
33781 void *argp1 = 0 ;
33782 int res1 = 0 ;
33783 int val2 ;
33784 int ecode2 = 0 ;
33785 int val3 ;
33786 int ecode3 = 0 ;
33787 int val4 ;
33788 int ecode4 = 0 ;
33789 PyObject * obj0 = 0 ;
33790 PyObject * obj1 = 0 ;
33791 PyObject * obj2 = 0 ;
33792 PyObject * obj3 = 0 ;
33793 char * kwnames[] = {
33794 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33795 };
33796
33797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33799 if (!SWIG_IsOK(res1)) {
33800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33801 }
33802 arg1 = reinterpret_cast< wxWindow * >(argp1);
33803 ecode2 = SWIG_AsVal_int(obj1, &val2);
33804 if (!SWIG_IsOK(ecode2)) {
33805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33806 }
33807 arg2 = static_cast< int >(val2);
33808 ecode3 = SWIG_AsVal_int(obj2, &val3);
33809 if (!SWIG_IsOK(ecode3)) {
33810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33811 }
33812 arg3 = static_cast< int >(val3);
33813 ecode4 = SWIG_AsVal_int(obj3, &val4);
33814 if (!SWIG_IsOK(ecode4)) {
33815 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33816 }
33817 arg4 = static_cast< int >(val4);
33818 {
33819 PyThreadState* __tstate = wxPyBeginAllowThreads();
33820 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33821 wxPyEndAllowThreads(__tstate);
33822 if (PyErr_Occurred()) SWIG_fail;
33823 }
33824 {
33825 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33826 }
33827 return resultobj;
33828 fail:
33829 return NULL;
33830 }
33831
33832
33833 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33834 PyObject *resultobj = 0;
33835 wxWindow *arg1 = (wxWindow *) 0 ;
33836 int arg2 ;
33837 bool result;
33838 void *argp1 = 0 ;
33839 int res1 = 0 ;
33840 int val2 ;
33841 int ecode2 = 0 ;
33842 PyObject * obj0 = 0 ;
33843 PyObject * obj1 = 0 ;
33844 char * kwnames[] = {
33845 (char *) "self",(char *) "hotkeyId", NULL
33846 };
33847
33848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33850 if (!SWIG_IsOK(res1)) {
33851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33852 }
33853 arg1 = reinterpret_cast< wxWindow * >(argp1);
33854 ecode2 = SWIG_AsVal_int(obj1, &val2);
33855 if (!SWIG_IsOK(ecode2)) {
33856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33857 }
33858 arg2 = static_cast< int >(val2);
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 {
33866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33867 }
33868 return resultobj;
33869 fail:
33870 return NULL;
33871 }
33872
33873
33874 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33875 PyObject *resultobj = 0;
33876 wxWindow *arg1 = (wxWindow *) 0 ;
33877 wxPoint *arg2 = 0 ;
33878 wxPoint result;
33879 void *argp1 = 0 ;
33880 int res1 = 0 ;
33881 wxPoint temp2 ;
33882 PyObject * obj0 = 0 ;
33883 PyObject * obj1 = 0 ;
33884 char * kwnames[] = {
33885 (char *) "self",(char *) "pt", NULL
33886 };
33887
33888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33890 if (!SWIG_IsOK(res1)) {
33891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33892 }
33893 arg1 = reinterpret_cast< wxWindow * >(argp1);
33894 {
33895 arg2 = &temp2;
33896 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33897 }
33898 {
33899 PyThreadState* __tstate = wxPyBeginAllowThreads();
33900 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33901 wxPyEndAllowThreads(__tstate);
33902 if (PyErr_Occurred()) SWIG_fail;
33903 }
33904 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33905 return resultobj;
33906 fail:
33907 return NULL;
33908 }
33909
33910
33911 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33912 PyObject *resultobj = 0;
33913 wxWindow *arg1 = (wxWindow *) 0 ;
33914 wxSize *arg2 = 0 ;
33915 wxSize result;
33916 void *argp1 = 0 ;
33917 int res1 = 0 ;
33918 wxSize temp2 ;
33919 PyObject * obj0 = 0 ;
33920 PyObject * obj1 = 0 ;
33921 char * kwnames[] = {
33922 (char *) "self",(char *) "sz", NULL
33923 };
33924
33925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33927 if (!SWIG_IsOK(res1)) {
33928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33929 }
33930 arg1 = reinterpret_cast< wxWindow * >(argp1);
33931 {
33932 arg2 = &temp2;
33933 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33934 }
33935 {
33936 PyThreadState* __tstate = wxPyBeginAllowThreads();
33937 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
33938 wxPyEndAllowThreads(__tstate);
33939 if (PyErr_Occurred()) SWIG_fail;
33940 }
33941 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
33942 return resultobj;
33943 fail:
33944 return NULL;
33945 }
33946
33947
33948 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33949 PyObject *resultobj = 0;
33950 wxWindow *arg1 = (wxWindow *) 0 ;
33951 wxPoint *arg2 = 0 ;
33952 wxPoint result;
33953 void *argp1 = 0 ;
33954 int res1 = 0 ;
33955 wxPoint temp2 ;
33956 PyObject * obj0 = 0 ;
33957 PyObject * obj1 = 0 ;
33958 char * kwnames[] = {
33959 (char *) "self",(char *) "pt", NULL
33960 };
33961
33962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
33963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33964 if (!SWIG_IsOK(res1)) {
33965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
33966 }
33967 arg1 = reinterpret_cast< wxWindow * >(argp1);
33968 {
33969 arg2 = &temp2;
33970 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33971 }
33972 {
33973 PyThreadState* __tstate = wxPyBeginAllowThreads();
33974 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33975 wxPyEndAllowThreads(__tstate);
33976 if (PyErr_Occurred()) SWIG_fail;
33977 }
33978 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33979 return resultobj;
33980 fail:
33981 return NULL;
33982 }
33983
33984
33985 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33986 PyObject *resultobj = 0;
33987 wxWindow *arg1 = (wxWindow *) 0 ;
33988 wxSize *arg2 = 0 ;
33989 wxSize result;
33990 void *argp1 = 0 ;
33991 int res1 = 0 ;
33992 wxSize temp2 ;
33993 PyObject * obj0 = 0 ;
33994 PyObject * obj1 = 0 ;
33995 char * kwnames[] = {
33996 (char *) "self",(char *) "sz", NULL
33997 };
33998
33999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
34000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34001 if (!SWIG_IsOK(res1)) {
34002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
34003 }
34004 arg1 = reinterpret_cast< wxWindow * >(argp1);
34005 {
34006 arg2 = &temp2;
34007 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34008 }
34009 {
34010 PyThreadState* __tstate = wxPyBeginAllowThreads();
34011 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34012 wxPyEndAllowThreads(__tstate);
34013 if (PyErr_Occurred()) SWIG_fail;
34014 }
34015 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34016 return resultobj;
34017 fail:
34018 return NULL;
34019 }
34020
34021
34022 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34023 PyObject *resultobj = 0;
34024 wxWindow *arg1 = (wxWindow *) 0 ;
34025 wxPoint *arg2 = 0 ;
34026 wxPoint result;
34027 void *argp1 = 0 ;
34028 int res1 = 0 ;
34029 wxPoint temp2 ;
34030 PyObject * obj0 = 0 ;
34031 PyObject * obj1 = 0 ;
34032 char * kwnames[] = {
34033 (char *) "self",(char *) "pt", NULL
34034 };
34035
34036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34038 if (!SWIG_IsOK(res1)) {
34039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34040 }
34041 arg1 = reinterpret_cast< wxWindow * >(argp1);
34042 {
34043 arg2 = &temp2;
34044 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34045 }
34046 {
34047 PyThreadState* __tstate = wxPyBeginAllowThreads();
34048 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34049 wxPyEndAllowThreads(__tstate);
34050 if (PyErr_Occurred()) SWIG_fail;
34051 }
34052 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34053 return resultobj;
34054 fail:
34055 return NULL;
34056 }
34057
34058
34059 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34060 PyObject *resultobj = 0;
34061 wxWindow *arg1 = (wxWindow *) 0 ;
34062 wxSize *arg2 = 0 ;
34063 wxSize result;
34064 void *argp1 = 0 ;
34065 int res1 = 0 ;
34066 wxSize temp2 ;
34067 PyObject * obj0 = 0 ;
34068 PyObject * obj1 = 0 ;
34069 char * kwnames[] = {
34070 (char *) "self",(char *) "sz", NULL
34071 };
34072
34073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34075 if (!SWIG_IsOK(res1)) {
34076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34077 }
34078 arg1 = reinterpret_cast< wxWindow * >(argp1);
34079 {
34080 arg2 = &temp2;
34081 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34082 }
34083 {
34084 PyThreadState* __tstate = wxPyBeginAllowThreads();
34085 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34086 wxPyEndAllowThreads(__tstate);
34087 if (PyErr_Occurred()) SWIG_fail;
34088 }
34089 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34090 return resultobj;
34091 fail:
34092 return NULL;
34093 }
34094
34095
34096 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34097 PyObject *resultobj = 0;
34098 wxWindow *arg1 = (wxWindow *) 0 ;
34099 int arg2 ;
34100 int arg3 ;
34101 void *argp1 = 0 ;
34102 int res1 = 0 ;
34103 int val2 ;
34104 int ecode2 = 0 ;
34105 int val3 ;
34106 int ecode3 = 0 ;
34107 PyObject * obj0 = 0 ;
34108 PyObject * obj1 = 0 ;
34109 PyObject * obj2 = 0 ;
34110 char * kwnames[] = {
34111 (char *) "self",(char *) "x",(char *) "y", NULL
34112 };
34113
34114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34116 if (!SWIG_IsOK(res1)) {
34117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34118 }
34119 arg1 = reinterpret_cast< wxWindow * >(argp1);
34120 ecode2 = SWIG_AsVal_int(obj1, &val2);
34121 if (!SWIG_IsOK(ecode2)) {
34122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34123 }
34124 arg2 = static_cast< int >(val2);
34125 ecode3 = SWIG_AsVal_int(obj2, &val3);
34126 if (!SWIG_IsOK(ecode3)) {
34127 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34128 }
34129 arg3 = static_cast< int >(val3);
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 (arg1)->WarpPointer(arg2,arg3);
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_Py_Void();
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34144 PyObject *resultobj = 0;
34145 wxWindow *arg1 = (wxWindow *) 0 ;
34146 void *argp1 = 0 ;
34147 int res1 = 0 ;
34148 PyObject *swig_obj[1] ;
34149
34150 if (!args) SWIG_fail;
34151 swig_obj[0] = args;
34152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34153 if (!SWIG_IsOK(res1)) {
34154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34155 }
34156 arg1 = reinterpret_cast< wxWindow * >(argp1);
34157 {
34158 PyThreadState* __tstate = wxPyBeginAllowThreads();
34159 (arg1)->CaptureMouse();
34160 wxPyEndAllowThreads(__tstate);
34161 if (PyErr_Occurred()) SWIG_fail;
34162 }
34163 resultobj = SWIG_Py_Void();
34164 return resultobj;
34165 fail:
34166 return NULL;
34167 }
34168
34169
34170 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34171 PyObject *resultobj = 0;
34172 wxWindow *arg1 = (wxWindow *) 0 ;
34173 void *argp1 = 0 ;
34174 int res1 = 0 ;
34175 PyObject *swig_obj[1] ;
34176
34177 if (!args) SWIG_fail;
34178 swig_obj[0] = args;
34179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34180 if (!SWIG_IsOK(res1)) {
34181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34182 }
34183 arg1 = reinterpret_cast< wxWindow * >(argp1);
34184 {
34185 PyThreadState* __tstate = wxPyBeginAllowThreads();
34186 (arg1)->ReleaseMouse();
34187 wxPyEndAllowThreads(__tstate);
34188 if (PyErr_Occurred()) SWIG_fail;
34189 }
34190 resultobj = SWIG_Py_Void();
34191 return resultobj;
34192 fail:
34193 return NULL;
34194 }
34195
34196
34197 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34198 PyObject *resultobj = 0;
34199 wxWindow *result = 0 ;
34200
34201 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34202 {
34203 if (!wxPyCheckForApp()) SWIG_fail;
34204 PyThreadState* __tstate = wxPyBeginAllowThreads();
34205 result = (wxWindow *)wxWindow::GetCapture();
34206 wxPyEndAllowThreads(__tstate);
34207 if (PyErr_Occurred()) SWIG_fail;
34208 }
34209 {
34210 resultobj = wxPyMake_wxObject(result, 0);
34211 }
34212 return resultobj;
34213 fail:
34214 return NULL;
34215 }
34216
34217
34218 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34219 PyObject *resultobj = 0;
34220 wxWindow *arg1 = (wxWindow *) 0 ;
34221 bool result;
34222 void *argp1 = 0 ;
34223 int res1 = 0 ;
34224 PyObject *swig_obj[1] ;
34225
34226 if (!args) SWIG_fail;
34227 swig_obj[0] = args;
34228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34229 if (!SWIG_IsOK(res1)) {
34230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34231 }
34232 arg1 = reinterpret_cast< wxWindow * >(argp1);
34233 {
34234 PyThreadState* __tstate = wxPyBeginAllowThreads();
34235 result = (bool)((wxWindow const *)arg1)->HasCapture();
34236 wxPyEndAllowThreads(__tstate);
34237 if (PyErr_Occurred()) SWIG_fail;
34238 }
34239 {
34240 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34241 }
34242 return resultobj;
34243 fail:
34244 return NULL;
34245 }
34246
34247
34248 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34249 PyObject *resultobj = 0;
34250 wxWindow *arg1 = (wxWindow *) 0 ;
34251 bool arg2 = (bool) true ;
34252 wxRect *arg3 = (wxRect *) NULL ;
34253 void *argp1 = 0 ;
34254 int res1 = 0 ;
34255 bool val2 ;
34256 int ecode2 = 0 ;
34257 void *argp3 = 0 ;
34258 int res3 = 0 ;
34259 PyObject * obj0 = 0 ;
34260 PyObject * obj1 = 0 ;
34261 PyObject * obj2 = 0 ;
34262 char * kwnames[] = {
34263 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34264 };
34265
34266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34268 if (!SWIG_IsOK(res1)) {
34269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34270 }
34271 arg1 = reinterpret_cast< wxWindow * >(argp1);
34272 if (obj1) {
34273 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34274 if (!SWIG_IsOK(ecode2)) {
34275 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34276 }
34277 arg2 = static_cast< bool >(val2);
34278 }
34279 if (obj2) {
34280 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34281 if (!SWIG_IsOK(res3)) {
34282 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34283 }
34284 arg3 = reinterpret_cast< wxRect * >(argp3);
34285 }
34286 {
34287 PyThreadState* __tstate = wxPyBeginAllowThreads();
34288 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34289 wxPyEndAllowThreads(__tstate);
34290 if (PyErr_Occurred()) SWIG_fail;
34291 }
34292 resultobj = SWIG_Py_Void();
34293 return resultobj;
34294 fail:
34295 return NULL;
34296 }
34297
34298
34299 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34300 PyObject *resultobj = 0;
34301 wxWindow *arg1 = (wxWindow *) 0 ;
34302 wxRect *arg2 = 0 ;
34303 bool arg3 = (bool) true ;
34304 void *argp1 = 0 ;
34305 int res1 = 0 ;
34306 wxRect temp2 ;
34307 bool val3 ;
34308 int ecode3 = 0 ;
34309 PyObject * obj0 = 0 ;
34310 PyObject * obj1 = 0 ;
34311 PyObject * obj2 = 0 ;
34312 char * kwnames[] = {
34313 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34314 };
34315
34316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34318 if (!SWIG_IsOK(res1)) {
34319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34320 }
34321 arg1 = reinterpret_cast< wxWindow * >(argp1);
34322 {
34323 arg2 = &temp2;
34324 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34325 }
34326 if (obj2) {
34327 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34328 if (!SWIG_IsOK(ecode3)) {
34329 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34330 }
34331 arg3 = static_cast< bool >(val3);
34332 }
34333 {
34334 PyThreadState* __tstate = wxPyBeginAllowThreads();
34335 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34336 wxPyEndAllowThreads(__tstate);
34337 if (PyErr_Occurred()) SWIG_fail;
34338 }
34339 resultobj = SWIG_Py_Void();
34340 return resultobj;
34341 fail:
34342 return NULL;
34343 }
34344
34345
34346 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34347 PyObject *resultobj = 0;
34348 wxWindow *arg1 = (wxWindow *) 0 ;
34349 void *argp1 = 0 ;
34350 int res1 = 0 ;
34351 PyObject *swig_obj[1] ;
34352
34353 if (!args) SWIG_fail;
34354 swig_obj[0] = args;
34355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34356 if (!SWIG_IsOK(res1)) {
34357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34358 }
34359 arg1 = reinterpret_cast< wxWindow * >(argp1);
34360 {
34361 PyThreadState* __tstate = wxPyBeginAllowThreads();
34362 (arg1)->Update();
34363 wxPyEndAllowThreads(__tstate);
34364 if (PyErr_Occurred()) SWIG_fail;
34365 }
34366 resultobj = SWIG_Py_Void();
34367 return resultobj;
34368 fail:
34369 return NULL;
34370 }
34371
34372
34373 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34374 PyObject *resultobj = 0;
34375 wxWindow *arg1 = (wxWindow *) 0 ;
34376 void *argp1 = 0 ;
34377 int res1 = 0 ;
34378 PyObject *swig_obj[1] ;
34379
34380 if (!args) SWIG_fail;
34381 swig_obj[0] = args;
34382 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34383 if (!SWIG_IsOK(res1)) {
34384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34385 }
34386 arg1 = reinterpret_cast< wxWindow * >(argp1);
34387 {
34388 PyThreadState* __tstate = wxPyBeginAllowThreads();
34389 (arg1)->ClearBackground();
34390 wxPyEndAllowThreads(__tstate);
34391 if (PyErr_Occurred()) SWIG_fail;
34392 }
34393 resultobj = SWIG_Py_Void();
34394 return resultobj;
34395 fail:
34396 return NULL;
34397 }
34398
34399
34400 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34401 PyObject *resultobj = 0;
34402 wxWindow *arg1 = (wxWindow *) 0 ;
34403 void *argp1 = 0 ;
34404 int res1 = 0 ;
34405 PyObject *swig_obj[1] ;
34406
34407 if (!args) SWIG_fail;
34408 swig_obj[0] = args;
34409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34410 if (!SWIG_IsOK(res1)) {
34411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34412 }
34413 arg1 = reinterpret_cast< wxWindow * >(argp1);
34414 {
34415 PyThreadState* __tstate = wxPyBeginAllowThreads();
34416 (arg1)->Freeze();
34417 wxPyEndAllowThreads(__tstate);
34418 if (PyErr_Occurred()) SWIG_fail;
34419 }
34420 resultobj = SWIG_Py_Void();
34421 return resultobj;
34422 fail:
34423 return NULL;
34424 }
34425
34426
34427 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34428 PyObject *resultobj = 0;
34429 wxWindow *arg1 = (wxWindow *) 0 ;
34430 void *argp1 = 0 ;
34431 int res1 = 0 ;
34432 PyObject *swig_obj[1] ;
34433
34434 if (!args) SWIG_fail;
34435 swig_obj[0] = args;
34436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34437 if (!SWIG_IsOK(res1)) {
34438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34439 }
34440 arg1 = reinterpret_cast< wxWindow * >(argp1);
34441 {
34442 PyThreadState* __tstate = wxPyBeginAllowThreads();
34443 (arg1)->Thaw();
34444 wxPyEndAllowThreads(__tstate);
34445 if (PyErr_Occurred()) SWIG_fail;
34446 }
34447 resultobj = SWIG_Py_Void();
34448 return resultobj;
34449 fail:
34450 return NULL;
34451 }
34452
34453
34454 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34455 PyObject *resultobj = 0;
34456 wxWindow *arg1 = (wxWindow *) 0 ;
34457 wxDC *arg2 = 0 ;
34458 void *argp1 = 0 ;
34459 int res1 = 0 ;
34460 void *argp2 = 0 ;
34461 int res2 = 0 ;
34462 PyObject * obj0 = 0 ;
34463 PyObject * obj1 = 0 ;
34464 char * kwnames[] = {
34465 (char *) "self",(char *) "dc", NULL
34466 };
34467
34468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34470 if (!SWIG_IsOK(res1)) {
34471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34472 }
34473 arg1 = reinterpret_cast< wxWindow * >(argp1);
34474 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34475 if (!SWIG_IsOK(res2)) {
34476 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34477 }
34478 if (!argp2) {
34479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34480 }
34481 arg2 = reinterpret_cast< wxDC * >(argp2);
34482 {
34483 PyThreadState* __tstate = wxPyBeginAllowThreads();
34484 (arg1)->PrepareDC(*arg2);
34485 wxPyEndAllowThreads(__tstate);
34486 if (PyErr_Occurred()) SWIG_fail;
34487 }
34488 resultobj = SWIG_Py_Void();
34489 return resultobj;
34490 fail:
34491 return NULL;
34492 }
34493
34494
34495 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34496 PyObject *resultobj = 0;
34497 wxWindow *arg1 = (wxWindow *) 0 ;
34498 wxRegion *result = 0 ;
34499 void *argp1 = 0 ;
34500 int res1 = 0 ;
34501 PyObject *swig_obj[1] ;
34502
34503 if (!args) SWIG_fail;
34504 swig_obj[0] = args;
34505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34506 if (!SWIG_IsOK(res1)) {
34507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34508 }
34509 arg1 = reinterpret_cast< wxWindow * >(argp1);
34510 {
34511 PyThreadState* __tstate = wxPyBeginAllowThreads();
34512 {
34513 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34514 result = (wxRegion *) &_result_ref;
34515 }
34516 wxPyEndAllowThreads(__tstate);
34517 if (PyErr_Occurred()) SWIG_fail;
34518 }
34519 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34520 return resultobj;
34521 fail:
34522 return NULL;
34523 }
34524
34525
34526 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34527 PyObject *resultobj = 0;
34528 wxWindow *arg1 = (wxWindow *) 0 ;
34529 wxRect result;
34530 void *argp1 = 0 ;
34531 int res1 = 0 ;
34532 PyObject *swig_obj[1] ;
34533
34534 if (!args) SWIG_fail;
34535 swig_obj[0] = args;
34536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34537 if (!SWIG_IsOK(res1)) {
34538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34539 }
34540 arg1 = reinterpret_cast< wxWindow * >(argp1);
34541 {
34542 PyThreadState* __tstate = wxPyBeginAllowThreads();
34543 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34544 wxPyEndAllowThreads(__tstate);
34545 if (PyErr_Occurred()) SWIG_fail;
34546 }
34547 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34548 return resultobj;
34549 fail:
34550 return NULL;
34551 }
34552
34553
34554 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34555 PyObject *resultobj = 0;
34556 wxWindow *arg1 = (wxWindow *) 0 ;
34557 int arg2 ;
34558 int arg3 ;
34559 int arg4 = (int) 1 ;
34560 int arg5 = (int) 1 ;
34561 bool result;
34562 void *argp1 = 0 ;
34563 int res1 = 0 ;
34564 int val2 ;
34565 int ecode2 = 0 ;
34566 int val3 ;
34567 int ecode3 = 0 ;
34568 int val4 ;
34569 int ecode4 = 0 ;
34570 int val5 ;
34571 int ecode5 = 0 ;
34572 PyObject * obj0 = 0 ;
34573 PyObject * obj1 = 0 ;
34574 PyObject * obj2 = 0 ;
34575 PyObject * obj3 = 0 ;
34576 PyObject * obj4 = 0 ;
34577 char * kwnames[] = {
34578 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34579 };
34580
34581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34583 if (!SWIG_IsOK(res1)) {
34584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34585 }
34586 arg1 = reinterpret_cast< wxWindow * >(argp1);
34587 ecode2 = SWIG_AsVal_int(obj1, &val2);
34588 if (!SWIG_IsOK(ecode2)) {
34589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34590 }
34591 arg2 = static_cast< int >(val2);
34592 ecode3 = SWIG_AsVal_int(obj2, &val3);
34593 if (!SWIG_IsOK(ecode3)) {
34594 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34595 }
34596 arg3 = static_cast< int >(val3);
34597 if (obj3) {
34598 ecode4 = SWIG_AsVal_int(obj3, &val4);
34599 if (!SWIG_IsOK(ecode4)) {
34600 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34601 }
34602 arg4 = static_cast< int >(val4);
34603 }
34604 if (obj4) {
34605 ecode5 = SWIG_AsVal_int(obj4, &val5);
34606 if (!SWIG_IsOK(ecode5)) {
34607 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34608 }
34609 arg5 = static_cast< int >(val5);
34610 }
34611 {
34612 PyThreadState* __tstate = wxPyBeginAllowThreads();
34613 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
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_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34627 PyObject *resultobj = 0;
34628 wxWindow *arg1 = (wxWindow *) 0 ;
34629 wxPoint *arg2 = 0 ;
34630 bool result;
34631 void *argp1 = 0 ;
34632 int res1 = 0 ;
34633 wxPoint temp2 ;
34634 PyObject * obj0 = 0 ;
34635 PyObject * obj1 = 0 ;
34636 char * kwnames[] = {
34637 (char *) "self",(char *) "pt", NULL
34638 };
34639
34640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",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_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34644 }
34645 arg1 = reinterpret_cast< wxWindow * >(argp1);
34646 {
34647 arg2 = &temp2;
34648 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34649 }
34650 {
34651 PyThreadState* __tstate = wxPyBeginAllowThreads();
34652 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint 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_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34666 PyObject *resultobj = 0;
34667 wxWindow *arg1 = (wxWindow *) 0 ;
34668 wxRect *arg2 = 0 ;
34669 bool result;
34670 void *argp1 = 0 ;
34671 int res1 = 0 ;
34672 wxRect temp2 ;
34673 PyObject * obj0 = 0 ;
34674 PyObject * obj1 = 0 ;
34675 char * kwnames[] = {
34676 (char *) "self",(char *) "rect", NULL
34677 };
34678
34679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34681 if (!SWIG_IsOK(res1)) {
34682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34683 }
34684 arg1 = reinterpret_cast< wxWindow * >(argp1);
34685 {
34686 arg2 = &temp2;
34687 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34688 }
34689 {
34690 PyThreadState* __tstate = wxPyBeginAllowThreads();
34691 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34692 wxPyEndAllowThreads(__tstate);
34693 if (PyErr_Occurred()) SWIG_fail;
34694 }
34695 {
34696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34697 }
34698 return resultobj;
34699 fail:
34700 return NULL;
34701 }
34702
34703
34704 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34705 PyObject *resultobj = 0;
34706 wxWindow *arg1 = (wxWindow *) 0 ;
34707 SwigValueWrapper<wxVisualAttributes > result;
34708 void *argp1 = 0 ;
34709 int res1 = 0 ;
34710 PyObject *swig_obj[1] ;
34711
34712 if (!args) SWIG_fail;
34713 swig_obj[0] = args;
34714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34715 if (!SWIG_IsOK(res1)) {
34716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34717 }
34718 arg1 = reinterpret_cast< wxWindow * >(argp1);
34719 {
34720 PyThreadState* __tstate = wxPyBeginAllowThreads();
34721 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34722 wxPyEndAllowThreads(__tstate);
34723 if (PyErr_Occurred()) SWIG_fail;
34724 }
34725 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34726 return resultobj;
34727 fail:
34728 return NULL;
34729 }
34730
34731
34732 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34733 PyObject *resultobj = 0;
34734 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34735 SwigValueWrapper<wxVisualAttributes > result;
34736 int val1 ;
34737 int ecode1 = 0 ;
34738 PyObject * obj0 = 0 ;
34739 char * kwnames[] = {
34740 (char *) "variant", NULL
34741 };
34742
34743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34744 if (obj0) {
34745 ecode1 = SWIG_AsVal_int(obj0, &val1);
34746 if (!SWIG_IsOK(ecode1)) {
34747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34748 }
34749 arg1 = static_cast< wxWindowVariant >(val1);
34750 }
34751 {
34752 if (!wxPyCheckForApp()) SWIG_fail;
34753 PyThreadState* __tstate = wxPyBeginAllowThreads();
34754 result = wxWindow::GetClassDefaultAttributes(arg1);
34755 wxPyEndAllowThreads(__tstate);
34756 if (PyErr_Occurred()) SWIG_fail;
34757 }
34758 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34759 return resultobj;
34760 fail:
34761 return NULL;
34762 }
34763
34764
34765 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34766 PyObject *resultobj = 0;
34767 wxWindow *arg1 = (wxWindow *) 0 ;
34768 wxColour *arg2 = 0 ;
34769 bool result;
34770 void *argp1 = 0 ;
34771 int res1 = 0 ;
34772 wxColour temp2 ;
34773 PyObject * obj0 = 0 ;
34774 PyObject * obj1 = 0 ;
34775 char * kwnames[] = {
34776 (char *) "self",(char *) "colour", NULL
34777 };
34778
34779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34781 if (!SWIG_IsOK(res1)) {
34782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34783 }
34784 arg1 = reinterpret_cast< wxWindow * >(argp1);
34785 {
34786 arg2 = &temp2;
34787 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34788 }
34789 {
34790 PyThreadState* __tstate = wxPyBeginAllowThreads();
34791 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34792 wxPyEndAllowThreads(__tstate);
34793 if (PyErr_Occurred()) SWIG_fail;
34794 }
34795 {
34796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34797 }
34798 return resultobj;
34799 fail:
34800 return NULL;
34801 }
34802
34803
34804 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34805 PyObject *resultobj = 0;
34806 wxWindow *arg1 = (wxWindow *) 0 ;
34807 wxColour *arg2 = 0 ;
34808 void *argp1 = 0 ;
34809 int res1 = 0 ;
34810 wxColour temp2 ;
34811 PyObject * obj0 = 0 ;
34812 PyObject * obj1 = 0 ;
34813 char * kwnames[] = {
34814 (char *) "self",(char *) "colour", NULL
34815 };
34816
34817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34819 if (!SWIG_IsOK(res1)) {
34820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34821 }
34822 arg1 = reinterpret_cast< wxWindow * >(argp1);
34823 {
34824 arg2 = &temp2;
34825 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34826 }
34827 {
34828 PyThreadState* __tstate = wxPyBeginAllowThreads();
34829 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34830 wxPyEndAllowThreads(__tstate);
34831 if (PyErr_Occurred()) SWIG_fail;
34832 }
34833 resultobj = SWIG_Py_Void();
34834 return resultobj;
34835 fail:
34836 return NULL;
34837 }
34838
34839
34840 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34841 PyObject *resultobj = 0;
34842 wxWindow *arg1 = (wxWindow *) 0 ;
34843 wxColour *arg2 = 0 ;
34844 bool result;
34845 void *argp1 = 0 ;
34846 int res1 = 0 ;
34847 wxColour temp2 ;
34848 PyObject * obj0 = 0 ;
34849 PyObject * obj1 = 0 ;
34850 char * kwnames[] = {
34851 (char *) "self",(char *) "colour", NULL
34852 };
34853
34854 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34855 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34856 if (!SWIG_IsOK(res1)) {
34857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34858 }
34859 arg1 = reinterpret_cast< wxWindow * >(argp1);
34860 {
34861 arg2 = &temp2;
34862 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34863 }
34864 {
34865 PyThreadState* __tstate = wxPyBeginAllowThreads();
34866 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34867 wxPyEndAllowThreads(__tstate);
34868 if (PyErr_Occurred()) SWIG_fail;
34869 }
34870 {
34871 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34872 }
34873 return resultobj;
34874 fail:
34875 return NULL;
34876 }
34877
34878
34879 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34880 PyObject *resultobj = 0;
34881 wxWindow *arg1 = (wxWindow *) 0 ;
34882 wxColour *arg2 = 0 ;
34883 void *argp1 = 0 ;
34884 int res1 = 0 ;
34885 wxColour temp2 ;
34886 PyObject * obj0 = 0 ;
34887 PyObject * obj1 = 0 ;
34888 char * kwnames[] = {
34889 (char *) "self",(char *) "colour", NULL
34890 };
34891
34892 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34893 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34894 if (!SWIG_IsOK(res1)) {
34895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34896 }
34897 arg1 = reinterpret_cast< wxWindow * >(argp1);
34898 {
34899 arg2 = &temp2;
34900 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34901 }
34902 {
34903 PyThreadState* __tstate = wxPyBeginAllowThreads();
34904 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34905 wxPyEndAllowThreads(__tstate);
34906 if (PyErr_Occurred()) SWIG_fail;
34907 }
34908 resultobj = SWIG_Py_Void();
34909 return resultobj;
34910 fail:
34911 return NULL;
34912 }
34913
34914
34915 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34916 PyObject *resultobj = 0;
34917 wxWindow *arg1 = (wxWindow *) 0 ;
34918 wxColour result;
34919 void *argp1 = 0 ;
34920 int res1 = 0 ;
34921 PyObject *swig_obj[1] ;
34922
34923 if (!args) SWIG_fail;
34924 swig_obj[0] = args;
34925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34926 if (!SWIG_IsOK(res1)) {
34927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34928 }
34929 arg1 = reinterpret_cast< wxWindow * >(argp1);
34930 {
34931 PyThreadState* __tstate = wxPyBeginAllowThreads();
34932 result = ((wxWindow const *)arg1)->GetBackgroundColour();
34933 wxPyEndAllowThreads(__tstate);
34934 if (PyErr_Occurred()) SWIG_fail;
34935 }
34936 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34937 return resultobj;
34938 fail:
34939 return NULL;
34940 }
34941
34942
34943 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34944 PyObject *resultobj = 0;
34945 wxWindow *arg1 = (wxWindow *) 0 ;
34946 wxColour result;
34947 void *argp1 = 0 ;
34948 int res1 = 0 ;
34949 PyObject *swig_obj[1] ;
34950
34951 if (!args) SWIG_fail;
34952 swig_obj[0] = args;
34953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34954 if (!SWIG_IsOK(res1)) {
34955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34956 }
34957 arg1 = reinterpret_cast< wxWindow * >(argp1);
34958 {
34959 PyThreadState* __tstate = wxPyBeginAllowThreads();
34960 result = ((wxWindow const *)arg1)->GetForegroundColour();
34961 wxPyEndAllowThreads(__tstate);
34962 if (PyErr_Occurred()) SWIG_fail;
34963 }
34964 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
34965 return resultobj;
34966 fail:
34967 return NULL;
34968 }
34969
34970
34971 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34972 PyObject *resultobj = 0;
34973 wxWindow *arg1 = (wxWindow *) 0 ;
34974 bool result;
34975 void *argp1 = 0 ;
34976 int res1 = 0 ;
34977 PyObject *swig_obj[1] ;
34978
34979 if (!args) SWIG_fail;
34980 swig_obj[0] = args;
34981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34982 if (!SWIG_IsOK(res1)) {
34983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
34984 }
34985 arg1 = reinterpret_cast< wxWindow * >(argp1);
34986 {
34987 PyThreadState* __tstate = wxPyBeginAllowThreads();
34988 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
34989 wxPyEndAllowThreads(__tstate);
34990 if (PyErr_Occurred()) SWIG_fail;
34991 }
34992 {
34993 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34994 }
34995 return resultobj;
34996 fail:
34997 return NULL;
34998 }
34999
35000
35001 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35002 PyObject *resultobj = 0;
35003 wxWindow *arg1 = (wxWindow *) 0 ;
35004 bool result;
35005 void *argp1 = 0 ;
35006 int res1 = 0 ;
35007 PyObject *swig_obj[1] ;
35008
35009 if (!args) SWIG_fail;
35010 swig_obj[0] = args;
35011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35012 if (!SWIG_IsOK(res1)) {
35013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35014 }
35015 arg1 = reinterpret_cast< wxWindow * >(argp1);
35016 {
35017 PyThreadState* __tstate = wxPyBeginAllowThreads();
35018 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35019 wxPyEndAllowThreads(__tstate);
35020 if (PyErr_Occurred()) SWIG_fail;
35021 }
35022 {
35023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35024 }
35025 return resultobj;
35026 fail:
35027 return NULL;
35028 }
35029
35030
35031 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35032 PyObject *resultobj = 0;
35033 wxWindow *arg1 = (wxWindow *) 0 ;
35034 wxBackgroundStyle arg2 ;
35035 bool result;
35036 void *argp1 = 0 ;
35037 int res1 = 0 ;
35038 int val2 ;
35039 int ecode2 = 0 ;
35040 PyObject * obj0 = 0 ;
35041 PyObject * obj1 = 0 ;
35042 char * kwnames[] = {
35043 (char *) "self",(char *) "style", NULL
35044 };
35045
35046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35048 if (!SWIG_IsOK(res1)) {
35049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35050 }
35051 arg1 = reinterpret_cast< wxWindow * >(argp1);
35052 ecode2 = SWIG_AsVal_int(obj1, &val2);
35053 if (!SWIG_IsOK(ecode2)) {
35054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35055 }
35056 arg2 = static_cast< wxBackgroundStyle >(val2);
35057 {
35058 PyThreadState* __tstate = wxPyBeginAllowThreads();
35059 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35060 wxPyEndAllowThreads(__tstate);
35061 if (PyErr_Occurred()) SWIG_fail;
35062 }
35063 {
35064 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35065 }
35066 return resultobj;
35067 fail:
35068 return NULL;
35069 }
35070
35071
35072 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35073 PyObject *resultobj = 0;
35074 wxWindow *arg1 = (wxWindow *) 0 ;
35075 wxBackgroundStyle result;
35076 void *argp1 = 0 ;
35077 int res1 = 0 ;
35078 PyObject *swig_obj[1] ;
35079
35080 if (!args) SWIG_fail;
35081 swig_obj[0] = args;
35082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35083 if (!SWIG_IsOK(res1)) {
35084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35085 }
35086 arg1 = reinterpret_cast< wxWindow * >(argp1);
35087 {
35088 PyThreadState* __tstate = wxPyBeginAllowThreads();
35089 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35090 wxPyEndAllowThreads(__tstate);
35091 if (PyErr_Occurred()) SWIG_fail;
35092 }
35093 resultobj = SWIG_From_int(static_cast< int >(result));
35094 return resultobj;
35095 fail:
35096 return NULL;
35097 }
35098
35099
35100 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35101 PyObject *resultobj = 0;
35102 wxWindow *arg1 = (wxWindow *) 0 ;
35103 bool result;
35104 void *argp1 = 0 ;
35105 int res1 = 0 ;
35106 PyObject *swig_obj[1] ;
35107
35108 if (!args) SWIG_fail;
35109 swig_obj[0] = args;
35110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35111 if (!SWIG_IsOK(res1)) {
35112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35113 }
35114 arg1 = reinterpret_cast< wxWindow * >(argp1);
35115 {
35116 PyThreadState* __tstate = wxPyBeginAllowThreads();
35117 result = (bool)(arg1)->HasTransparentBackground();
35118 wxPyEndAllowThreads(__tstate);
35119 if (PyErr_Occurred()) SWIG_fail;
35120 }
35121 {
35122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35123 }
35124 return resultobj;
35125 fail:
35126 return NULL;
35127 }
35128
35129
35130 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35131 PyObject *resultobj = 0;
35132 wxWindow *arg1 = (wxWindow *) 0 ;
35133 wxCursor *arg2 = 0 ;
35134 bool result;
35135 void *argp1 = 0 ;
35136 int res1 = 0 ;
35137 void *argp2 = 0 ;
35138 int res2 = 0 ;
35139 PyObject * obj0 = 0 ;
35140 PyObject * obj1 = 0 ;
35141 char * kwnames[] = {
35142 (char *) "self",(char *) "cursor", NULL
35143 };
35144
35145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35147 if (!SWIG_IsOK(res1)) {
35148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35149 }
35150 arg1 = reinterpret_cast< wxWindow * >(argp1);
35151 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35152 if (!SWIG_IsOK(res2)) {
35153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35154 }
35155 if (!argp2) {
35156 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35157 }
35158 arg2 = reinterpret_cast< wxCursor * >(argp2);
35159 {
35160 PyThreadState* __tstate = wxPyBeginAllowThreads();
35161 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35162 wxPyEndAllowThreads(__tstate);
35163 if (PyErr_Occurred()) SWIG_fail;
35164 }
35165 {
35166 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35167 }
35168 return resultobj;
35169 fail:
35170 return NULL;
35171 }
35172
35173
35174 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35175 PyObject *resultobj = 0;
35176 wxWindow *arg1 = (wxWindow *) 0 ;
35177 wxCursor result;
35178 void *argp1 = 0 ;
35179 int res1 = 0 ;
35180 PyObject *swig_obj[1] ;
35181
35182 if (!args) SWIG_fail;
35183 swig_obj[0] = args;
35184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35185 if (!SWIG_IsOK(res1)) {
35186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35187 }
35188 arg1 = reinterpret_cast< wxWindow * >(argp1);
35189 {
35190 PyThreadState* __tstate = wxPyBeginAllowThreads();
35191 result = (arg1)->GetCursor();
35192 wxPyEndAllowThreads(__tstate);
35193 if (PyErr_Occurred()) SWIG_fail;
35194 }
35195 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35196 return resultobj;
35197 fail:
35198 return NULL;
35199 }
35200
35201
35202 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35203 PyObject *resultobj = 0;
35204 wxWindow *arg1 = (wxWindow *) 0 ;
35205 wxFont *arg2 = 0 ;
35206 bool result;
35207 void *argp1 = 0 ;
35208 int res1 = 0 ;
35209 void *argp2 = 0 ;
35210 int res2 = 0 ;
35211 PyObject * obj0 = 0 ;
35212 PyObject * obj1 = 0 ;
35213 char * kwnames[] = {
35214 (char *) "self",(char *) "font", NULL
35215 };
35216
35217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35219 if (!SWIG_IsOK(res1)) {
35220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35221 }
35222 arg1 = reinterpret_cast< wxWindow * >(argp1);
35223 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35224 if (!SWIG_IsOK(res2)) {
35225 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35226 }
35227 if (!argp2) {
35228 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35229 }
35230 arg2 = reinterpret_cast< wxFont * >(argp2);
35231 {
35232 PyThreadState* __tstate = wxPyBeginAllowThreads();
35233 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35234 wxPyEndAllowThreads(__tstate);
35235 if (PyErr_Occurred()) SWIG_fail;
35236 }
35237 {
35238 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35239 }
35240 return resultobj;
35241 fail:
35242 return NULL;
35243 }
35244
35245
35246 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35247 PyObject *resultobj = 0;
35248 wxWindow *arg1 = (wxWindow *) 0 ;
35249 wxFont *arg2 = 0 ;
35250 void *argp1 = 0 ;
35251 int res1 = 0 ;
35252 void *argp2 = 0 ;
35253 int res2 = 0 ;
35254 PyObject * obj0 = 0 ;
35255 PyObject * obj1 = 0 ;
35256 char * kwnames[] = {
35257 (char *) "self",(char *) "font", NULL
35258 };
35259
35260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35262 if (!SWIG_IsOK(res1)) {
35263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35264 }
35265 arg1 = reinterpret_cast< wxWindow * >(argp1);
35266 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35267 if (!SWIG_IsOK(res2)) {
35268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35269 }
35270 if (!argp2) {
35271 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35272 }
35273 arg2 = reinterpret_cast< wxFont * >(argp2);
35274 {
35275 PyThreadState* __tstate = wxPyBeginAllowThreads();
35276 (arg1)->SetOwnFont((wxFont const &)*arg2);
35277 wxPyEndAllowThreads(__tstate);
35278 if (PyErr_Occurred()) SWIG_fail;
35279 }
35280 resultobj = SWIG_Py_Void();
35281 return resultobj;
35282 fail:
35283 return NULL;
35284 }
35285
35286
35287 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35288 PyObject *resultobj = 0;
35289 wxWindow *arg1 = (wxWindow *) 0 ;
35290 wxFont result;
35291 void *argp1 = 0 ;
35292 int res1 = 0 ;
35293 PyObject *swig_obj[1] ;
35294
35295 if (!args) SWIG_fail;
35296 swig_obj[0] = args;
35297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35298 if (!SWIG_IsOK(res1)) {
35299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35300 }
35301 arg1 = reinterpret_cast< wxWindow * >(argp1);
35302 {
35303 PyThreadState* __tstate = wxPyBeginAllowThreads();
35304 result = (arg1)->GetFont();
35305 wxPyEndAllowThreads(__tstate);
35306 if (PyErr_Occurred()) SWIG_fail;
35307 }
35308 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35309 return resultobj;
35310 fail:
35311 return NULL;
35312 }
35313
35314
35315 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35316 PyObject *resultobj = 0;
35317 wxWindow *arg1 = (wxWindow *) 0 ;
35318 wxCaret *arg2 = (wxCaret *) 0 ;
35319 void *argp1 = 0 ;
35320 int res1 = 0 ;
35321 int res2 = 0 ;
35322 PyObject * obj0 = 0 ;
35323 PyObject * obj1 = 0 ;
35324 char * kwnames[] = {
35325 (char *) "self",(char *) "caret", NULL
35326 };
35327
35328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35330 if (!SWIG_IsOK(res1)) {
35331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35332 }
35333 arg1 = reinterpret_cast< wxWindow * >(argp1);
35334 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35335 if (!SWIG_IsOK(res2)) {
35336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35337 }
35338 {
35339 PyThreadState* __tstate = wxPyBeginAllowThreads();
35340 (arg1)->SetCaret(arg2);
35341 wxPyEndAllowThreads(__tstate);
35342 if (PyErr_Occurred()) SWIG_fail;
35343 }
35344 resultobj = SWIG_Py_Void();
35345 return resultobj;
35346 fail:
35347 return NULL;
35348 }
35349
35350
35351 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35352 PyObject *resultobj = 0;
35353 wxWindow *arg1 = (wxWindow *) 0 ;
35354 wxCaret *result = 0 ;
35355 void *argp1 = 0 ;
35356 int res1 = 0 ;
35357 PyObject *swig_obj[1] ;
35358
35359 if (!args) SWIG_fail;
35360 swig_obj[0] = args;
35361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35362 if (!SWIG_IsOK(res1)) {
35363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35364 }
35365 arg1 = reinterpret_cast< wxWindow * >(argp1);
35366 {
35367 PyThreadState* __tstate = wxPyBeginAllowThreads();
35368 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35369 wxPyEndAllowThreads(__tstate);
35370 if (PyErr_Occurred()) SWIG_fail;
35371 }
35372 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35373 return resultobj;
35374 fail:
35375 return NULL;
35376 }
35377
35378
35379 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35380 PyObject *resultobj = 0;
35381 wxWindow *arg1 = (wxWindow *) 0 ;
35382 int result;
35383 void *argp1 = 0 ;
35384 int res1 = 0 ;
35385 PyObject *swig_obj[1] ;
35386
35387 if (!args) SWIG_fail;
35388 swig_obj[0] = args;
35389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35390 if (!SWIG_IsOK(res1)) {
35391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35392 }
35393 arg1 = reinterpret_cast< wxWindow * >(argp1);
35394 {
35395 PyThreadState* __tstate = wxPyBeginAllowThreads();
35396 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35397 wxPyEndAllowThreads(__tstate);
35398 if (PyErr_Occurred()) SWIG_fail;
35399 }
35400 resultobj = SWIG_From_int(static_cast< int >(result));
35401 return resultobj;
35402 fail:
35403 return NULL;
35404 }
35405
35406
35407 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35408 PyObject *resultobj = 0;
35409 wxWindow *arg1 = (wxWindow *) 0 ;
35410 int result;
35411 void *argp1 = 0 ;
35412 int res1 = 0 ;
35413 PyObject *swig_obj[1] ;
35414
35415 if (!args) SWIG_fail;
35416 swig_obj[0] = args;
35417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35418 if (!SWIG_IsOK(res1)) {
35419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35420 }
35421 arg1 = reinterpret_cast< wxWindow * >(argp1);
35422 {
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35425 wxPyEndAllowThreads(__tstate);
35426 if (PyErr_Occurred()) SWIG_fail;
35427 }
35428 resultobj = SWIG_From_int(static_cast< int >(result));
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35436 PyObject *resultobj = 0;
35437 wxWindow *arg1 = (wxWindow *) 0 ;
35438 wxString *arg2 = 0 ;
35439 int *arg3 = (int *) 0 ;
35440 int *arg4 = (int *) 0 ;
35441 void *argp1 = 0 ;
35442 int res1 = 0 ;
35443 bool temp2 = false ;
35444 int temp3 ;
35445 int res3 = SWIG_TMPOBJ ;
35446 int temp4 ;
35447 int res4 = SWIG_TMPOBJ ;
35448 PyObject * obj0 = 0 ;
35449 PyObject * obj1 = 0 ;
35450 char * kwnames[] = {
35451 (char *) "self",(char *) "string", NULL
35452 };
35453
35454 arg3 = &temp3;
35455 arg4 = &temp4;
35456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35458 if (!SWIG_IsOK(res1)) {
35459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35460 }
35461 arg1 = reinterpret_cast< wxWindow * >(argp1);
35462 {
35463 arg2 = wxString_in_helper(obj1);
35464 if (arg2 == NULL) SWIG_fail;
35465 temp2 = true;
35466 }
35467 {
35468 PyThreadState* __tstate = wxPyBeginAllowThreads();
35469 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35470 wxPyEndAllowThreads(__tstate);
35471 if (PyErr_Occurred()) SWIG_fail;
35472 }
35473 resultobj = SWIG_Py_Void();
35474 if (SWIG_IsTmpObj(res3)) {
35475 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35476 } else {
35477 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35478 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35479 }
35480 if (SWIG_IsTmpObj(res4)) {
35481 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35482 } else {
35483 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35484 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35485 }
35486 {
35487 if (temp2)
35488 delete arg2;
35489 }
35490 return resultobj;
35491 fail:
35492 {
35493 if (temp2)
35494 delete arg2;
35495 }
35496 return NULL;
35497 }
35498
35499
35500 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35501 PyObject *resultobj = 0;
35502 wxWindow *arg1 = (wxWindow *) 0 ;
35503 wxString *arg2 = 0 ;
35504 int *arg3 = (int *) 0 ;
35505 int *arg4 = (int *) 0 ;
35506 int *arg5 = (int *) 0 ;
35507 int *arg6 = (int *) 0 ;
35508 wxFont *arg7 = (wxFont *) NULL ;
35509 void *argp1 = 0 ;
35510 int res1 = 0 ;
35511 bool temp2 = false ;
35512 int temp3 ;
35513 int res3 = SWIG_TMPOBJ ;
35514 int temp4 ;
35515 int res4 = SWIG_TMPOBJ ;
35516 int temp5 ;
35517 int res5 = SWIG_TMPOBJ ;
35518 int temp6 ;
35519 int res6 = SWIG_TMPOBJ ;
35520 void *argp7 = 0 ;
35521 int res7 = 0 ;
35522 PyObject * obj0 = 0 ;
35523 PyObject * obj1 = 0 ;
35524 PyObject * obj2 = 0 ;
35525 char * kwnames[] = {
35526 (char *) "self",(char *) "string",(char *) "font", NULL
35527 };
35528
35529 arg3 = &temp3;
35530 arg4 = &temp4;
35531 arg5 = &temp5;
35532 arg6 = &temp6;
35533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35535 if (!SWIG_IsOK(res1)) {
35536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35537 }
35538 arg1 = reinterpret_cast< wxWindow * >(argp1);
35539 {
35540 arg2 = wxString_in_helper(obj1);
35541 if (arg2 == NULL) SWIG_fail;
35542 temp2 = true;
35543 }
35544 if (obj2) {
35545 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35546 if (!SWIG_IsOK(res7)) {
35547 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35548 }
35549 arg7 = reinterpret_cast< wxFont * >(argp7);
35550 }
35551 {
35552 PyThreadState* __tstate = wxPyBeginAllowThreads();
35553 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35554 wxPyEndAllowThreads(__tstate);
35555 if (PyErr_Occurred()) SWIG_fail;
35556 }
35557 resultobj = SWIG_Py_Void();
35558 if (SWIG_IsTmpObj(res3)) {
35559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35560 } else {
35561 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35563 }
35564 if (SWIG_IsTmpObj(res4)) {
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35566 } else {
35567 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35569 }
35570 if (SWIG_IsTmpObj(res5)) {
35571 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35572 } else {
35573 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35574 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35575 }
35576 if (SWIG_IsTmpObj(res6)) {
35577 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35578 } else {
35579 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35580 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35581 }
35582 {
35583 if (temp2)
35584 delete arg2;
35585 }
35586 return resultobj;
35587 fail:
35588 {
35589 if (temp2)
35590 delete arg2;
35591 }
35592 return NULL;
35593 }
35594
35595
35596 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35597 PyObject *resultobj = 0;
35598 wxWindow *arg1 = (wxWindow *) 0 ;
35599 int *arg2 = (int *) 0 ;
35600 int *arg3 = (int *) 0 ;
35601 void *argp1 = 0 ;
35602 int res1 = 0 ;
35603 int temp2 ;
35604 int res2 = 0 ;
35605 int temp3 ;
35606 int res3 = 0 ;
35607 PyObject * obj0 = 0 ;
35608 PyObject * obj1 = 0 ;
35609 PyObject * obj2 = 0 ;
35610 char * kwnames[] = {
35611 (char *) "self",(char *) "x",(char *) "y", NULL
35612 };
35613
35614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35616 if (!SWIG_IsOK(res1)) {
35617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35618 }
35619 arg1 = reinterpret_cast< wxWindow * >(argp1);
35620 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35621 int val;
35622 int ecode = SWIG_AsVal_int(obj1, &val);
35623 if (!SWIG_IsOK(ecode)) {
35624 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35625 }
35626 temp2 = static_cast< int >(val);
35627 arg2 = &temp2;
35628 res2 = SWIG_AddTmpMask(ecode);
35629 }
35630 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35631 int val;
35632 int ecode = SWIG_AsVal_int(obj2, &val);
35633 if (!SWIG_IsOK(ecode)) {
35634 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35635 }
35636 temp3 = static_cast< int >(val);
35637 arg3 = &temp3;
35638 res3 = SWIG_AddTmpMask(ecode);
35639 }
35640 {
35641 PyThreadState* __tstate = wxPyBeginAllowThreads();
35642 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35643 wxPyEndAllowThreads(__tstate);
35644 if (PyErr_Occurred()) SWIG_fail;
35645 }
35646 resultobj = SWIG_Py_Void();
35647 if (SWIG_IsTmpObj(res2)) {
35648 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35649 } else {
35650 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35651 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35652 }
35653 if (SWIG_IsTmpObj(res3)) {
35654 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35655 } else {
35656 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35657 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35658 }
35659 return resultobj;
35660 fail:
35661 return NULL;
35662 }
35663
35664
35665 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35666 PyObject *resultobj = 0;
35667 wxWindow *arg1 = (wxWindow *) 0 ;
35668 int *arg2 = (int *) 0 ;
35669 int *arg3 = (int *) 0 ;
35670 void *argp1 = 0 ;
35671 int res1 = 0 ;
35672 int temp2 ;
35673 int res2 = 0 ;
35674 int temp3 ;
35675 int res3 = 0 ;
35676 PyObject * obj0 = 0 ;
35677 PyObject * obj1 = 0 ;
35678 PyObject * obj2 = 0 ;
35679 char * kwnames[] = {
35680 (char *) "self",(char *) "x",(char *) "y", NULL
35681 };
35682
35683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35685 if (!SWIG_IsOK(res1)) {
35686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35687 }
35688 arg1 = reinterpret_cast< wxWindow * >(argp1);
35689 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35690 int val;
35691 int ecode = SWIG_AsVal_int(obj1, &val);
35692 if (!SWIG_IsOK(ecode)) {
35693 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35694 }
35695 temp2 = static_cast< int >(val);
35696 arg2 = &temp2;
35697 res2 = SWIG_AddTmpMask(ecode);
35698 }
35699 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35700 int val;
35701 int ecode = SWIG_AsVal_int(obj2, &val);
35702 if (!SWIG_IsOK(ecode)) {
35703 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35704 }
35705 temp3 = static_cast< int >(val);
35706 arg3 = &temp3;
35707 res3 = SWIG_AddTmpMask(ecode);
35708 }
35709 {
35710 PyThreadState* __tstate = wxPyBeginAllowThreads();
35711 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35712 wxPyEndAllowThreads(__tstate);
35713 if (PyErr_Occurred()) SWIG_fail;
35714 }
35715 resultobj = SWIG_Py_Void();
35716 if (SWIG_IsTmpObj(res2)) {
35717 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35718 } else {
35719 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35720 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35721 }
35722 if (SWIG_IsTmpObj(res3)) {
35723 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35724 } else {
35725 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35726 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35727 }
35728 return resultobj;
35729 fail:
35730 return NULL;
35731 }
35732
35733
35734 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35735 PyObject *resultobj = 0;
35736 wxWindow *arg1 = (wxWindow *) 0 ;
35737 wxPoint *arg2 = 0 ;
35738 wxPoint result;
35739 void *argp1 = 0 ;
35740 int res1 = 0 ;
35741 wxPoint temp2 ;
35742 PyObject * obj0 = 0 ;
35743 PyObject * obj1 = 0 ;
35744 char * kwnames[] = {
35745 (char *) "self",(char *) "pt", NULL
35746 };
35747
35748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35750 if (!SWIG_IsOK(res1)) {
35751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35752 }
35753 arg1 = reinterpret_cast< wxWindow * >(argp1);
35754 {
35755 arg2 = &temp2;
35756 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35757 }
35758 {
35759 PyThreadState* __tstate = wxPyBeginAllowThreads();
35760 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35761 wxPyEndAllowThreads(__tstate);
35762 if (PyErr_Occurred()) SWIG_fail;
35763 }
35764 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35765 return resultobj;
35766 fail:
35767 return NULL;
35768 }
35769
35770
35771 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35772 PyObject *resultobj = 0;
35773 wxWindow *arg1 = (wxWindow *) 0 ;
35774 wxPoint *arg2 = 0 ;
35775 wxPoint result;
35776 void *argp1 = 0 ;
35777 int res1 = 0 ;
35778 wxPoint temp2 ;
35779 PyObject * obj0 = 0 ;
35780 PyObject * obj1 = 0 ;
35781 char * kwnames[] = {
35782 (char *) "self",(char *) "pt", NULL
35783 };
35784
35785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35787 if (!SWIG_IsOK(res1)) {
35788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35789 }
35790 arg1 = reinterpret_cast< wxWindow * >(argp1);
35791 {
35792 arg2 = &temp2;
35793 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35794 }
35795 {
35796 PyThreadState* __tstate = wxPyBeginAllowThreads();
35797 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35798 wxPyEndAllowThreads(__tstate);
35799 if (PyErr_Occurred()) SWIG_fail;
35800 }
35801 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35802 return resultobj;
35803 fail:
35804 return NULL;
35805 }
35806
35807
35808 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35809 PyObject *resultobj = 0;
35810 wxWindow *arg1 = (wxWindow *) 0 ;
35811 int arg2 ;
35812 int arg3 ;
35813 wxHitTest result;
35814 void *argp1 = 0 ;
35815 int res1 = 0 ;
35816 int val2 ;
35817 int ecode2 = 0 ;
35818 int val3 ;
35819 int ecode3 = 0 ;
35820 PyObject * obj0 = 0 ;
35821 PyObject * obj1 = 0 ;
35822 PyObject * obj2 = 0 ;
35823 char * kwnames[] = {
35824 (char *) "self",(char *) "x",(char *) "y", NULL
35825 };
35826
35827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35829 if (!SWIG_IsOK(res1)) {
35830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35831 }
35832 arg1 = reinterpret_cast< wxWindow * >(argp1);
35833 ecode2 = SWIG_AsVal_int(obj1, &val2);
35834 if (!SWIG_IsOK(ecode2)) {
35835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35836 }
35837 arg2 = static_cast< int >(val2);
35838 ecode3 = SWIG_AsVal_int(obj2, &val3);
35839 if (!SWIG_IsOK(ecode3)) {
35840 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35841 }
35842 arg3 = static_cast< int >(val3);
35843 {
35844 PyThreadState* __tstate = wxPyBeginAllowThreads();
35845 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35846 wxPyEndAllowThreads(__tstate);
35847 if (PyErr_Occurred()) SWIG_fail;
35848 }
35849 resultobj = SWIG_From_int(static_cast< int >(result));
35850 return resultobj;
35851 fail:
35852 return NULL;
35853 }
35854
35855
35856 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35857 PyObject *resultobj = 0;
35858 wxWindow *arg1 = (wxWindow *) 0 ;
35859 wxPoint *arg2 = 0 ;
35860 wxHitTest result;
35861 void *argp1 = 0 ;
35862 int res1 = 0 ;
35863 wxPoint temp2 ;
35864 PyObject * obj0 = 0 ;
35865 PyObject * obj1 = 0 ;
35866 char * kwnames[] = {
35867 (char *) "self",(char *) "pt", NULL
35868 };
35869
35870 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35871 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35872 if (!SWIG_IsOK(res1)) {
35873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35874 }
35875 arg1 = reinterpret_cast< wxWindow * >(argp1);
35876 {
35877 arg2 = &temp2;
35878 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35879 }
35880 {
35881 PyThreadState* __tstate = wxPyBeginAllowThreads();
35882 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35883 wxPyEndAllowThreads(__tstate);
35884 if (PyErr_Occurred()) SWIG_fail;
35885 }
35886 resultobj = SWIG_From_int(static_cast< int >(result));
35887 return resultobj;
35888 fail:
35889 return NULL;
35890 }
35891
35892
35893 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35894 PyObject *resultobj = 0;
35895 wxWindow *arg1 = (wxWindow *) 0 ;
35896 long arg2 ;
35897 wxBorder result;
35898 void *argp1 = 0 ;
35899 int res1 = 0 ;
35900 long val2 ;
35901 int ecode2 = 0 ;
35902
35903 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35905 if (!SWIG_IsOK(res1)) {
35906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35907 }
35908 arg1 = reinterpret_cast< wxWindow * >(argp1);
35909 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35910 if (!SWIG_IsOK(ecode2)) {
35911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35912 }
35913 arg2 = static_cast< long >(val2);
35914 {
35915 PyThreadState* __tstate = wxPyBeginAllowThreads();
35916 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
35917 wxPyEndAllowThreads(__tstate);
35918 if (PyErr_Occurred()) SWIG_fail;
35919 }
35920 resultobj = SWIG_From_int(static_cast< int >(result));
35921 return resultobj;
35922 fail:
35923 return NULL;
35924 }
35925
35926
35927 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35928 PyObject *resultobj = 0;
35929 wxWindow *arg1 = (wxWindow *) 0 ;
35930 wxBorder result;
35931 void *argp1 = 0 ;
35932 int res1 = 0 ;
35933
35934 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
35935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35936 if (!SWIG_IsOK(res1)) {
35937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35938 }
35939 arg1 = reinterpret_cast< wxWindow * >(argp1);
35940 {
35941 PyThreadState* __tstate = wxPyBeginAllowThreads();
35942 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
35943 wxPyEndAllowThreads(__tstate);
35944 if (PyErr_Occurred()) SWIG_fail;
35945 }
35946 resultobj = SWIG_From_int(static_cast< int >(result));
35947 return resultobj;
35948 fail:
35949 return NULL;
35950 }
35951
35952
35953 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
35954 int argc;
35955 PyObject *argv[3];
35956
35957 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
35958 --argc;
35959 if (argc == 1) {
35960 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
35961 }
35962 if (argc == 2) {
35963 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
35964 }
35965
35966 fail:
35967 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
35968 return NULL;
35969 }
35970
35971
35972 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35973 PyObject *resultobj = 0;
35974 wxWindow *arg1 = (wxWindow *) 0 ;
35975 long arg2 = (long) wxUPDATE_UI_NONE ;
35976 void *argp1 = 0 ;
35977 int res1 = 0 ;
35978 long val2 ;
35979 int ecode2 = 0 ;
35980 PyObject * obj0 = 0 ;
35981 PyObject * obj1 = 0 ;
35982 char * kwnames[] = {
35983 (char *) "self",(char *) "flags", NULL
35984 };
35985
35986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
35987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35988 if (!SWIG_IsOK(res1)) {
35989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
35990 }
35991 arg1 = reinterpret_cast< wxWindow * >(argp1);
35992 if (obj1) {
35993 ecode2 = SWIG_AsVal_long(obj1, &val2);
35994 if (!SWIG_IsOK(ecode2)) {
35995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
35996 }
35997 arg2 = static_cast< long >(val2);
35998 }
35999 {
36000 PyThreadState* __tstate = wxPyBeginAllowThreads();
36001 (arg1)->UpdateWindowUI(arg2);
36002 wxPyEndAllowThreads(__tstate);
36003 if (PyErr_Occurred()) SWIG_fail;
36004 }
36005 resultobj = SWIG_Py_Void();
36006 return resultobj;
36007 fail:
36008 return NULL;
36009 }
36010
36011
36012 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36013 PyObject *resultobj = 0;
36014 wxWindow *arg1 = (wxWindow *) 0 ;
36015 wxMenu *arg2 = (wxMenu *) 0 ;
36016 int arg3 = (int) -1 ;
36017 int arg4 = (int) -1 ;
36018 bool result;
36019 void *argp1 = 0 ;
36020 int res1 = 0 ;
36021 void *argp2 = 0 ;
36022 int res2 = 0 ;
36023 int val3 ;
36024 int ecode3 = 0 ;
36025 int val4 ;
36026 int ecode4 = 0 ;
36027 PyObject * obj0 = 0 ;
36028 PyObject * obj1 = 0 ;
36029 PyObject * obj2 = 0 ;
36030 PyObject * obj3 = 0 ;
36031 char * kwnames[] = {
36032 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36033 };
36034
36035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36037 if (!SWIG_IsOK(res1)) {
36038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36039 }
36040 arg1 = reinterpret_cast< wxWindow * >(argp1);
36041 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36042 if (!SWIG_IsOK(res2)) {
36043 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36044 }
36045 arg2 = reinterpret_cast< wxMenu * >(argp2);
36046 if (obj2) {
36047 ecode3 = SWIG_AsVal_int(obj2, &val3);
36048 if (!SWIG_IsOK(ecode3)) {
36049 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36050 }
36051 arg3 = static_cast< int >(val3);
36052 }
36053 if (obj3) {
36054 ecode4 = SWIG_AsVal_int(obj3, &val4);
36055 if (!SWIG_IsOK(ecode4)) {
36056 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36057 }
36058 arg4 = static_cast< int >(val4);
36059 }
36060 {
36061 PyThreadState* __tstate = wxPyBeginAllowThreads();
36062 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36063 wxPyEndAllowThreads(__tstate);
36064 if (PyErr_Occurred()) SWIG_fail;
36065 }
36066 {
36067 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36068 }
36069 return resultobj;
36070 fail:
36071 return NULL;
36072 }
36073
36074
36075 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36076 PyObject *resultobj = 0;
36077 wxWindow *arg1 = (wxWindow *) 0 ;
36078 wxMenu *arg2 = (wxMenu *) 0 ;
36079 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36080 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36081 bool result;
36082 void *argp1 = 0 ;
36083 int res1 = 0 ;
36084 void *argp2 = 0 ;
36085 int res2 = 0 ;
36086 wxPoint temp3 ;
36087 PyObject * obj0 = 0 ;
36088 PyObject * obj1 = 0 ;
36089 PyObject * obj2 = 0 ;
36090 char * kwnames[] = {
36091 (char *) "self",(char *) "menu",(char *) "pos", NULL
36092 };
36093
36094 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36095 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36096 if (!SWIG_IsOK(res1)) {
36097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36098 }
36099 arg1 = reinterpret_cast< wxWindow * >(argp1);
36100 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36101 if (!SWIG_IsOK(res2)) {
36102 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36103 }
36104 arg2 = reinterpret_cast< wxMenu * >(argp2);
36105 if (obj2) {
36106 {
36107 arg3 = &temp3;
36108 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36109 }
36110 }
36111 {
36112 PyThreadState* __tstate = wxPyBeginAllowThreads();
36113 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36114 wxPyEndAllowThreads(__tstate);
36115 if (PyErr_Occurred()) SWIG_fail;
36116 }
36117 {
36118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36119 }
36120 return resultobj;
36121 fail:
36122 return NULL;
36123 }
36124
36125
36126 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36127 PyObject *resultobj = 0;
36128 wxWindow *arg1 = (wxWindow *) 0 ;
36129 long result;
36130 void *argp1 = 0 ;
36131 int res1 = 0 ;
36132 PyObject *swig_obj[1] ;
36133
36134 if (!args) SWIG_fail;
36135 swig_obj[0] = args;
36136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36137 if (!SWIG_IsOK(res1)) {
36138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36139 }
36140 arg1 = reinterpret_cast< wxWindow * >(argp1);
36141 {
36142 PyThreadState* __tstate = wxPyBeginAllowThreads();
36143 result = (long)wxWindow_GetHandle(arg1);
36144 wxPyEndAllowThreads(__tstate);
36145 if (PyErr_Occurred()) SWIG_fail;
36146 }
36147 resultobj = SWIG_From_long(static_cast< long >(result));
36148 return resultobj;
36149 fail:
36150 return NULL;
36151 }
36152
36153
36154 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36155 PyObject *resultobj = 0;
36156 wxWindow *arg1 = (wxWindow *) 0 ;
36157 long arg2 ;
36158 void *argp1 = 0 ;
36159 int res1 = 0 ;
36160 long val2 ;
36161 int ecode2 = 0 ;
36162 PyObject * obj0 = 0 ;
36163 PyObject * obj1 = 0 ;
36164 char * kwnames[] = {
36165 (char *) "self",(char *) "handle", NULL
36166 };
36167
36168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36170 if (!SWIG_IsOK(res1)) {
36171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36172 }
36173 arg1 = reinterpret_cast< wxWindow * >(argp1);
36174 ecode2 = SWIG_AsVal_long(obj1, &val2);
36175 if (!SWIG_IsOK(ecode2)) {
36176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36177 }
36178 arg2 = static_cast< long >(val2);
36179 {
36180 PyThreadState* __tstate = wxPyBeginAllowThreads();
36181 wxWindow_AssociateHandle(arg1,arg2);
36182 wxPyEndAllowThreads(__tstate);
36183 if (PyErr_Occurred()) SWIG_fail;
36184 }
36185 resultobj = SWIG_Py_Void();
36186 return resultobj;
36187 fail:
36188 return NULL;
36189 }
36190
36191
36192 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36193 PyObject *resultobj = 0;
36194 wxWindow *arg1 = (wxWindow *) 0 ;
36195 void *argp1 = 0 ;
36196 int res1 = 0 ;
36197 PyObject *swig_obj[1] ;
36198
36199 if (!args) SWIG_fail;
36200 swig_obj[0] = args;
36201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36202 if (!SWIG_IsOK(res1)) {
36203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36204 }
36205 arg1 = reinterpret_cast< wxWindow * >(argp1);
36206 {
36207 PyThreadState* __tstate = wxPyBeginAllowThreads();
36208 (arg1)->DissociateHandle();
36209 wxPyEndAllowThreads(__tstate);
36210 if (PyErr_Occurred()) SWIG_fail;
36211 }
36212 resultobj = SWIG_Py_Void();
36213 return resultobj;
36214 fail:
36215 return NULL;
36216 }
36217
36218
36219 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36220 PyObject *resultobj = 0;
36221 wxWindow *arg1 = (wxWindow *) 0 ;
36222 int arg2 ;
36223 bool result;
36224 void *argp1 = 0 ;
36225 int res1 = 0 ;
36226 int val2 ;
36227 int ecode2 = 0 ;
36228 PyObject * obj0 = 0 ;
36229 PyObject * obj1 = 0 ;
36230 char * kwnames[] = {
36231 (char *) "self",(char *) "orient", NULL
36232 };
36233
36234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36236 if (!SWIG_IsOK(res1)) {
36237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36238 }
36239 arg1 = reinterpret_cast< wxWindow * >(argp1);
36240 ecode2 = SWIG_AsVal_int(obj1, &val2);
36241 if (!SWIG_IsOK(ecode2)) {
36242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36243 }
36244 arg2 = static_cast< int >(val2);
36245 {
36246 PyThreadState* __tstate = wxPyBeginAllowThreads();
36247 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36248 wxPyEndAllowThreads(__tstate);
36249 if (PyErr_Occurred()) SWIG_fail;
36250 }
36251 {
36252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36253 }
36254 return resultobj;
36255 fail:
36256 return NULL;
36257 }
36258
36259
36260 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36261 PyObject *resultobj = 0;
36262 wxWindow *arg1 = (wxWindow *) 0 ;
36263 int arg2 ;
36264 int arg3 ;
36265 int arg4 ;
36266 int arg5 ;
36267 bool arg6 = (bool) true ;
36268 void *argp1 = 0 ;
36269 int res1 = 0 ;
36270 int val2 ;
36271 int ecode2 = 0 ;
36272 int val3 ;
36273 int ecode3 = 0 ;
36274 int val4 ;
36275 int ecode4 = 0 ;
36276 int val5 ;
36277 int ecode5 = 0 ;
36278 bool val6 ;
36279 int ecode6 = 0 ;
36280 PyObject * obj0 = 0 ;
36281 PyObject * obj1 = 0 ;
36282 PyObject * obj2 = 0 ;
36283 PyObject * obj3 = 0 ;
36284 PyObject * obj4 = 0 ;
36285 PyObject * obj5 = 0 ;
36286 char * kwnames[] = {
36287 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36288 };
36289
36290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36292 if (!SWIG_IsOK(res1)) {
36293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36294 }
36295 arg1 = reinterpret_cast< wxWindow * >(argp1);
36296 ecode2 = SWIG_AsVal_int(obj1, &val2);
36297 if (!SWIG_IsOK(ecode2)) {
36298 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36299 }
36300 arg2 = static_cast< int >(val2);
36301 ecode3 = SWIG_AsVal_int(obj2, &val3);
36302 if (!SWIG_IsOK(ecode3)) {
36303 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36304 }
36305 arg3 = static_cast< int >(val3);
36306 ecode4 = SWIG_AsVal_int(obj3, &val4);
36307 if (!SWIG_IsOK(ecode4)) {
36308 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36309 }
36310 arg4 = static_cast< int >(val4);
36311 ecode5 = SWIG_AsVal_int(obj4, &val5);
36312 if (!SWIG_IsOK(ecode5)) {
36313 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36314 }
36315 arg5 = static_cast< int >(val5);
36316 if (obj5) {
36317 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36318 if (!SWIG_IsOK(ecode6)) {
36319 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36320 }
36321 arg6 = static_cast< bool >(val6);
36322 }
36323 {
36324 PyThreadState* __tstate = wxPyBeginAllowThreads();
36325 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36326 wxPyEndAllowThreads(__tstate);
36327 if (PyErr_Occurred()) SWIG_fail;
36328 }
36329 resultobj = SWIG_Py_Void();
36330 return resultobj;
36331 fail:
36332 return NULL;
36333 }
36334
36335
36336 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36337 PyObject *resultobj = 0;
36338 wxWindow *arg1 = (wxWindow *) 0 ;
36339 int arg2 ;
36340 int arg3 ;
36341 bool arg4 = (bool) true ;
36342 void *argp1 = 0 ;
36343 int res1 = 0 ;
36344 int val2 ;
36345 int ecode2 = 0 ;
36346 int val3 ;
36347 int ecode3 = 0 ;
36348 bool val4 ;
36349 int ecode4 = 0 ;
36350 PyObject * obj0 = 0 ;
36351 PyObject * obj1 = 0 ;
36352 PyObject * obj2 = 0 ;
36353 PyObject * obj3 = 0 ;
36354 char * kwnames[] = {
36355 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36356 };
36357
36358 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36359 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36360 if (!SWIG_IsOK(res1)) {
36361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36362 }
36363 arg1 = reinterpret_cast< wxWindow * >(argp1);
36364 ecode2 = SWIG_AsVal_int(obj1, &val2);
36365 if (!SWIG_IsOK(ecode2)) {
36366 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36367 }
36368 arg2 = static_cast< int >(val2);
36369 ecode3 = SWIG_AsVal_int(obj2, &val3);
36370 if (!SWIG_IsOK(ecode3)) {
36371 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36372 }
36373 arg3 = static_cast< int >(val3);
36374 if (obj3) {
36375 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36376 if (!SWIG_IsOK(ecode4)) {
36377 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36378 }
36379 arg4 = static_cast< bool >(val4);
36380 }
36381 {
36382 PyThreadState* __tstate = wxPyBeginAllowThreads();
36383 (arg1)->SetScrollPos(arg2,arg3,arg4);
36384 wxPyEndAllowThreads(__tstate);
36385 if (PyErr_Occurred()) SWIG_fail;
36386 }
36387 resultobj = SWIG_Py_Void();
36388 return resultobj;
36389 fail:
36390 return NULL;
36391 }
36392
36393
36394 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(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_GetScrollPos",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_GetScrollPos" "', 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_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36418 }
36419 arg2 = static_cast< int >(val2);
36420 {
36421 PyThreadState* __tstate = wxPyBeginAllowThreads();
36422 result = (int)((wxWindow const *)arg1)->GetScrollPos(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_GetScrollThumb(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_GetScrollThumb",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_GetScrollThumb" "', 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_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36457 }
36458 arg2 = static_cast< int >(val2);
36459 {
36460 PyThreadState* __tstate = wxPyBeginAllowThreads();
36461 result = (int)((wxWindow const *)arg1)->GetScrollThumb(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_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36473 PyObject *resultobj = 0;
36474 wxWindow *arg1 = (wxWindow *) 0 ;
36475 int arg2 ;
36476 int result;
36477 void *argp1 = 0 ;
36478 int res1 = 0 ;
36479 int val2 ;
36480 int ecode2 = 0 ;
36481 PyObject * obj0 = 0 ;
36482 PyObject * obj1 = 0 ;
36483 char * kwnames[] = {
36484 (char *) "self",(char *) "orientation", NULL
36485 };
36486
36487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36489 if (!SWIG_IsOK(res1)) {
36490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36491 }
36492 arg1 = reinterpret_cast< wxWindow * >(argp1);
36493 ecode2 = SWIG_AsVal_int(obj1, &val2);
36494 if (!SWIG_IsOK(ecode2)) {
36495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36496 }
36497 arg2 = static_cast< int >(val2);
36498 {
36499 PyThreadState* __tstate = wxPyBeginAllowThreads();
36500 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36501 wxPyEndAllowThreads(__tstate);
36502 if (PyErr_Occurred()) SWIG_fail;
36503 }
36504 resultobj = SWIG_From_int(static_cast< int >(result));
36505 return resultobj;
36506 fail:
36507 return NULL;
36508 }
36509
36510
36511 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36512 PyObject *resultobj = 0;
36513 wxWindow *arg1 = (wxWindow *) 0 ;
36514 int arg2 ;
36515 int arg3 ;
36516 wxRect *arg4 = (wxRect *) NULL ;
36517 void *argp1 = 0 ;
36518 int res1 = 0 ;
36519 int val2 ;
36520 int ecode2 = 0 ;
36521 int val3 ;
36522 int ecode3 = 0 ;
36523 void *argp4 = 0 ;
36524 int res4 = 0 ;
36525 PyObject * obj0 = 0 ;
36526 PyObject * obj1 = 0 ;
36527 PyObject * obj2 = 0 ;
36528 PyObject * obj3 = 0 ;
36529 char * kwnames[] = {
36530 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36531 };
36532
36533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36535 if (!SWIG_IsOK(res1)) {
36536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36537 }
36538 arg1 = reinterpret_cast< wxWindow * >(argp1);
36539 ecode2 = SWIG_AsVal_int(obj1, &val2);
36540 if (!SWIG_IsOK(ecode2)) {
36541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36542 }
36543 arg2 = static_cast< int >(val2);
36544 ecode3 = SWIG_AsVal_int(obj2, &val3);
36545 if (!SWIG_IsOK(ecode3)) {
36546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36547 }
36548 arg3 = static_cast< int >(val3);
36549 if (obj3) {
36550 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36551 if (!SWIG_IsOK(res4)) {
36552 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36553 }
36554 arg4 = reinterpret_cast< wxRect * >(argp4);
36555 }
36556 {
36557 PyThreadState* __tstate = wxPyBeginAllowThreads();
36558 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36559 wxPyEndAllowThreads(__tstate);
36560 if (PyErr_Occurred()) SWIG_fail;
36561 }
36562 resultobj = SWIG_Py_Void();
36563 return resultobj;
36564 fail:
36565 return NULL;
36566 }
36567
36568
36569 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36570 PyObject *resultobj = 0;
36571 wxWindow *arg1 = (wxWindow *) 0 ;
36572 int arg2 ;
36573 bool result;
36574 void *argp1 = 0 ;
36575 int res1 = 0 ;
36576 int val2 ;
36577 int ecode2 = 0 ;
36578 PyObject * obj0 = 0 ;
36579 PyObject * obj1 = 0 ;
36580 char * kwnames[] = {
36581 (char *) "self",(char *) "lines", NULL
36582 };
36583
36584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36586 if (!SWIG_IsOK(res1)) {
36587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36588 }
36589 arg1 = reinterpret_cast< wxWindow * >(argp1);
36590 ecode2 = SWIG_AsVal_int(obj1, &val2);
36591 if (!SWIG_IsOK(ecode2)) {
36592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36593 }
36594 arg2 = static_cast< int >(val2);
36595 {
36596 PyThreadState* __tstate = wxPyBeginAllowThreads();
36597 result = (bool)(arg1)->ScrollLines(arg2);
36598 wxPyEndAllowThreads(__tstate);
36599 if (PyErr_Occurred()) SWIG_fail;
36600 }
36601 {
36602 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36603 }
36604 return resultobj;
36605 fail:
36606 return NULL;
36607 }
36608
36609
36610 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36611 PyObject *resultobj = 0;
36612 wxWindow *arg1 = (wxWindow *) 0 ;
36613 int arg2 ;
36614 bool result;
36615 void *argp1 = 0 ;
36616 int res1 = 0 ;
36617 int val2 ;
36618 int ecode2 = 0 ;
36619 PyObject * obj0 = 0 ;
36620 PyObject * obj1 = 0 ;
36621 char * kwnames[] = {
36622 (char *) "self",(char *) "pages", NULL
36623 };
36624
36625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36627 if (!SWIG_IsOK(res1)) {
36628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36629 }
36630 arg1 = reinterpret_cast< wxWindow * >(argp1);
36631 ecode2 = SWIG_AsVal_int(obj1, &val2);
36632 if (!SWIG_IsOK(ecode2)) {
36633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36634 }
36635 arg2 = static_cast< int >(val2);
36636 {
36637 PyThreadState* __tstate = wxPyBeginAllowThreads();
36638 result = (bool)(arg1)->ScrollPages(arg2);
36639 wxPyEndAllowThreads(__tstate);
36640 if (PyErr_Occurred()) SWIG_fail;
36641 }
36642 {
36643 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36644 }
36645 return resultobj;
36646 fail:
36647 return NULL;
36648 }
36649
36650
36651 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36652 PyObject *resultobj = 0;
36653 wxWindow *arg1 = (wxWindow *) 0 ;
36654 bool result;
36655 void *argp1 = 0 ;
36656 int res1 = 0 ;
36657 PyObject *swig_obj[1] ;
36658
36659 if (!args) SWIG_fail;
36660 swig_obj[0] = args;
36661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36662 if (!SWIG_IsOK(res1)) {
36663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36664 }
36665 arg1 = reinterpret_cast< wxWindow * >(argp1);
36666 {
36667 PyThreadState* __tstate = wxPyBeginAllowThreads();
36668 result = (bool)(arg1)->LineUp();
36669 wxPyEndAllowThreads(__tstate);
36670 if (PyErr_Occurred()) SWIG_fail;
36671 }
36672 {
36673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36674 }
36675 return resultobj;
36676 fail:
36677 return NULL;
36678 }
36679
36680
36681 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36682 PyObject *resultobj = 0;
36683 wxWindow *arg1 = (wxWindow *) 0 ;
36684 bool result;
36685 void *argp1 = 0 ;
36686 int res1 = 0 ;
36687 PyObject *swig_obj[1] ;
36688
36689 if (!args) SWIG_fail;
36690 swig_obj[0] = args;
36691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36692 if (!SWIG_IsOK(res1)) {
36693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36694 }
36695 arg1 = reinterpret_cast< wxWindow * >(argp1);
36696 {
36697 PyThreadState* __tstate = wxPyBeginAllowThreads();
36698 result = (bool)(arg1)->LineDown();
36699 wxPyEndAllowThreads(__tstate);
36700 if (PyErr_Occurred()) SWIG_fail;
36701 }
36702 {
36703 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36704 }
36705 return resultobj;
36706 fail:
36707 return NULL;
36708 }
36709
36710
36711 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36712 PyObject *resultobj = 0;
36713 wxWindow *arg1 = (wxWindow *) 0 ;
36714 bool result;
36715 void *argp1 = 0 ;
36716 int res1 = 0 ;
36717 PyObject *swig_obj[1] ;
36718
36719 if (!args) SWIG_fail;
36720 swig_obj[0] = args;
36721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36722 if (!SWIG_IsOK(res1)) {
36723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36724 }
36725 arg1 = reinterpret_cast< wxWindow * >(argp1);
36726 {
36727 PyThreadState* __tstate = wxPyBeginAllowThreads();
36728 result = (bool)(arg1)->PageUp();
36729 wxPyEndAllowThreads(__tstate);
36730 if (PyErr_Occurred()) SWIG_fail;
36731 }
36732 {
36733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36734 }
36735 return resultobj;
36736 fail:
36737 return NULL;
36738 }
36739
36740
36741 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36742 PyObject *resultobj = 0;
36743 wxWindow *arg1 = (wxWindow *) 0 ;
36744 bool result;
36745 void *argp1 = 0 ;
36746 int res1 = 0 ;
36747 PyObject *swig_obj[1] ;
36748
36749 if (!args) SWIG_fail;
36750 swig_obj[0] = args;
36751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36752 if (!SWIG_IsOK(res1)) {
36753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36754 }
36755 arg1 = reinterpret_cast< wxWindow * >(argp1);
36756 {
36757 PyThreadState* __tstate = wxPyBeginAllowThreads();
36758 result = (bool)(arg1)->PageDown();
36759 wxPyEndAllowThreads(__tstate);
36760 if (PyErr_Occurred()) SWIG_fail;
36761 }
36762 {
36763 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36764 }
36765 return resultobj;
36766 fail:
36767 return NULL;
36768 }
36769
36770
36771 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36772 PyObject *resultobj = 0;
36773 wxWindow *arg1 = (wxWindow *) 0 ;
36774 wxString *arg2 = 0 ;
36775 void *argp1 = 0 ;
36776 int res1 = 0 ;
36777 bool temp2 = false ;
36778 PyObject * obj0 = 0 ;
36779 PyObject * obj1 = 0 ;
36780 char * kwnames[] = {
36781 (char *) "self",(char *) "text", NULL
36782 };
36783
36784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36786 if (!SWIG_IsOK(res1)) {
36787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36788 }
36789 arg1 = reinterpret_cast< wxWindow * >(argp1);
36790 {
36791 arg2 = wxString_in_helper(obj1);
36792 if (arg2 == NULL) SWIG_fail;
36793 temp2 = true;
36794 }
36795 {
36796 PyThreadState* __tstate = wxPyBeginAllowThreads();
36797 (arg1)->SetHelpText((wxString const &)*arg2);
36798 wxPyEndAllowThreads(__tstate);
36799 if (PyErr_Occurred()) SWIG_fail;
36800 }
36801 resultobj = SWIG_Py_Void();
36802 {
36803 if (temp2)
36804 delete arg2;
36805 }
36806 return resultobj;
36807 fail:
36808 {
36809 if (temp2)
36810 delete arg2;
36811 }
36812 return NULL;
36813 }
36814
36815
36816 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36817 PyObject *resultobj = 0;
36818 wxWindow *arg1 = (wxWindow *) 0 ;
36819 wxString *arg2 = 0 ;
36820 void *argp1 = 0 ;
36821 int res1 = 0 ;
36822 bool temp2 = false ;
36823 PyObject * obj0 = 0 ;
36824 PyObject * obj1 = 0 ;
36825 char * kwnames[] = {
36826 (char *) "self",(char *) "text", NULL
36827 };
36828
36829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36831 if (!SWIG_IsOK(res1)) {
36832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36833 }
36834 arg1 = reinterpret_cast< wxWindow * >(argp1);
36835 {
36836 arg2 = wxString_in_helper(obj1);
36837 if (arg2 == NULL) SWIG_fail;
36838 temp2 = true;
36839 }
36840 {
36841 PyThreadState* __tstate = wxPyBeginAllowThreads();
36842 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36843 wxPyEndAllowThreads(__tstate);
36844 if (PyErr_Occurred()) SWIG_fail;
36845 }
36846 resultobj = SWIG_Py_Void();
36847 {
36848 if (temp2)
36849 delete arg2;
36850 }
36851 return resultobj;
36852 fail:
36853 {
36854 if (temp2)
36855 delete arg2;
36856 }
36857 return NULL;
36858 }
36859
36860
36861 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36862 PyObject *resultobj = 0;
36863 wxWindow *arg1 = (wxWindow *) 0 ;
36864 wxString result;
36865 void *argp1 = 0 ;
36866 int res1 = 0 ;
36867 PyObject *swig_obj[1] ;
36868
36869 if (!args) SWIG_fail;
36870 swig_obj[0] = args;
36871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36872 if (!SWIG_IsOK(res1)) {
36873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
36874 }
36875 arg1 = reinterpret_cast< wxWindow * >(argp1);
36876 {
36877 PyThreadState* __tstate = wxPyBeginAllowThreads();
36878 result = ((wxWindow const *)arg1)->GetHelpText();
36879 wxPyEndAllowThreads(__tstate);
36880 if (PyErr_Occurred()) SWIG_fail;
36881 }
36882 {
36883 #if wxUSE_UNICODE
36884 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
36885 #else
36886 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
36887 #endif
36888 }
36889 return resultobj;
36890 fail:
36891 return NULL;
36892 }
36893
36894
36895 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36896 PyObject *resultobj = 0;
36897 wxWindow *arg1 = (wxWindow *) 0 ;
36898 wxString *arg2 = 0 ;
36899 void *argp1 = 0 ;
36900 int res1 = 0 ;
36901 bool temp2 = false ;
36902 PyObject * obj0 = 0 ;
36903 PyObject * obj1 = 0 ;
36904 char * kwnames[] = {
36905 (char *) "self",(char *) "tip", NULL
36906 };
36907
36908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
36909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36910 if (!SWIG_IsOK(res1)) {
36911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
36912 }
36913 arg1 = reinterpret_cast< wxWindow * >(argp1);
36914 {
36915 arg2 = wxString_in_helper(obj1);
36916 if (arg2 == NULL) SWIG_fail;
36917 temp2 = true;
36918 }
36919 {
36920 PyThreadState* __tstate = wxPyBeginAllowThreads();
36921 (arg1)->SetToolTip((wxString const &)*arg2);
36922 wxPyEndAllowThreads(__tstate);
36923 if (PyErr_Occurred()) SWIG_fail;
36924 }
36925 resultobj = SWIG_Py_Void();
36926 {
36927 if (temp2)
36928 delete arg2;
36929 }
36930 return resultobj;
36931 fail:
36932 {
36933 if (temp2)
36934 delete arg2;
36935 }
36936 return NULL;
36937 }
36938
36939
36940 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36941 PyObject *resultobj = 0;
36942 wxWindow *arg1 = (wxWindow *) 0 ;
36943 wxToolTip *arg2 = (wxToolTip *) 0 ;
36944 void *argp1 = 0 ;
36945 int res1 = 0 ;
36946 int res2 = 0 ;
36947 PyObject * obj0 = 0 ;
36948 PyObject * obj1 = 0 ;
36949 char * kwnames[] = {
36950 (char *) "self",(char *) "tip", NULL
36951 };
36952
36953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
36954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36955 if (!SWIG_IsOK(res1)) {
36956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
36957 }
36958 arg1 = reinterpret_cast< wxWindow * >(argp1);
36959 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
36960 if (!SWIG_IsOK(res2)) {
36961 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
36962 }
36963 {
36964 PyThreadState* __tstate = wxPyBeginAllowThreads();
36965 (arg1)->SetToolTip(arg2);
36966 wxPyEndAllowThreads(__tstate);
36967 if (PyErr_Occurred()) SWIG_fail;
36968 }
36969 resultobj = SWIG_Py_Void();
36970 return resultobj;
36971 fail:
36972 return NULL;
36973 }
36974
36975
36976 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36977 PyObject *resultobj = 0;
36978 wxWindow *arg1 = (wxWindow *) 0 ;
36979 wxToolTip *result = 0 ;
36980 void *argp1 = 0 ;
36981 int res1 = 0 ;
36982 PyObject *swig_obj[1] ;
36983
36984 if (!args) SWIG_fail;
36985 swig_obj[0] = args;
36986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36987 if (!SWIG_IsOK(res1)) {
36988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
36989 }
36990 arg1 = reinterpret_cast< wxWindow * >(argp1);
36991 {
36992 PyThreadState* __tstate = wxPyBeginAllowThreads();
36993 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
36994 wxPyEndAllowThreads(__tstate);
36995 if (PyErr_Occurred()) SWIG_fail;
36996 }
36997 {
36998 resultobj = wxPyMake_wxObject(result, (bool)0);
36999 }
37000 return resultobj;
37001 fail:
37002 return NULL;
37003 }
37004
37005
37006 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37007 PyObject *resultobj = 0;
37008 wxWindow *arg1 = (wxWindow *) 0 ;
37009 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37010 void *argp1 = 0 ;
37011 int res1 = 0 ;
37012 int res2 = 0 ;
37013 PyObject * obj0 = 0 ;
37014 PyObject * obj1 = 0 ;
37015 char * kwnames[] = {
37016 (char *) "self",(char *) "dropTarget", NULL
37017 };
37018
37019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37021 if (!SWIG_IsOK(res1)) {
37022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37023 }
37024 arg1 = reinterpret_cast< wxWindow * >(argp1);
37025 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37026 if (!SWIG_IsOK(res2)) {
37027 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37028 }
37029 {
37030 PyThreadState* __tstate = wxPyBeginAllowThreads();
37031 (arg1)->SetDropTarget(arg2);
37032 wxPyEndAllowThreads(__tstate);
37033 if (PyErr_Occurred()) SWIG_fail;
37034 }
37035 resultobj = SWIG_Py_Void();
37036 return resultobj;
37037 fail:
37038 return NULL;
37039 }
37040
37041
37042 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37043 PyObject *resultobj = 0;
37044 wxWindow *arg1 = (wxWindow *) 0 ;
37045 wxPyDropTarget *result = 0 ;
37046 void *argp1 = 0 ;
37047 int res1 = 0 ;
37048 PyObject *swig_obj[1] ;
37049
37050 if (!args) SWIG_fail;
37051 swig_obj[0] = args;
37052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37053 if (!SWIG_IsOK(res1)) {
37054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37055 }
37056 arg1 = reinterpret_cast< wxWindow * >(argp1);
37057 {
37058 PyThreadState* __tstate = wxPyBeginAllowThreads();
37059 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37060 wxPyEndAllowThreads(__tstate);
37061 if (PyErr_Occurred()) SWIG_fail;
37062 }
37063 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37064 return resultobj;
37065 fail:
37066 return NULL;
37067 }
37068
37069
37070 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37071 PyObject *resultobj = 0;
37072 wxWindow *arg1 = (wxWindow *) 0 ;
37073 bool arg2 ;
37074 void *argp1 = 0 ;
37075 int res1 = 0 ;
37076 bool val2 ;
37077 int ecode2 = 0 ;
37078 PyObject * obj0 = 0 ;
37079 PyObject * obj1 = 0 ;
37080 char * kwnames[] = {
37081 (char *) "self",(char *) "accept", NULL
37082 };
37083
37084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37086 if (!SWIG_IsOK(res1)) {
37087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37088 }
37089 arg1 = reinterpret_cast< wxWindow * >(argp1);
37090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37091 if (!SWIG_IsOK(ecode2)) {
37092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37093 }
37094 arg2 = static_cast< bool >(val2);
37095 {
37096 PyThreadState* __tstate = wxPyBeginAllowThreads();
37097 wxWindow_DragAcceptFiles(arg1,arg2);
37098 wxPyEndAllowThreads(__tstate);
37099 if (PyErr_Occurred()) SWIG_fail;
37100 }
37101 resultobj = SWIG_Py_Void();
37102 return resultobj;
37103 fail:
37104 return NULL;
37105 }
37106
37107
37108 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37109 PyObject *resultobj = 0;
37110 wxWindow *arg1 = (wxWindow *) 0 ;
37111 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37112 void *argp1 = 0 ;
37113 int res1 = 0 ;
37114 int res2 = 0 ;
37115 PyObject * obj0 = 0 ;
37116 PyObject * obj1 = 0 ;
37117 char * kwnames[] = {
37118 (char *) "self",(char *) "constraints", NULL
37119 };
37120
37121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37123 if (!SWIG_IsOK(res1)) {
37124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37125 }
37126 arg1 = reinterpret_cast< wxWindow * >(argp1);
37127 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37128 if (!SWIG_IsOK(res2)) {
37129 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37130 }
37131 {
37132 PyThreadState* __tstate = wxPyBeginAllowThreads();
37133 (arg1)->SetConstraints(arg2);
37134 wxPyEndAllowThreads(__tstate);
37135 if (PyErr_Occurred()) SWIG_fail;
37136 }
37137 resultobj = SWIG_Py_Void();
37138 return resultobj;
37139 fail:
37140 return NULL;
37141 }
37142
37143
37144 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37145 PyObject *resultobj = 0;
37146 wxWindow *arg1 = (wxWindow *) 0 ;
37147 wxLayoutConstraints *result = 0 ;
37148 void *argp1 = 0 ;
37149 int res1 = 0 ;
37150 PyObject *swig_obj[1] ;
37151
37152 if (!args) SWIG_fail;
37153 swig_obj[0] = args;
37154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37155 if (!SWIG_IsOK(res1)) {
37156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37157 }
37158 arg1 = reinterpret_cast< wxWindow * >(argp1);
37159 {
37160 PyThreadState* __tstate = wxPyBeginAllowThreads();
37161 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37162 wxPyEndAllowThreads(__tstate);
37163 if (PyErr_Occurred()) SWIG_fail;
37164 }
37165 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37173 PyObject *resultobj = 0;
37174 wxWindow *arg1 = (wxWindow *) 0 ;
37175 bool arg2 ;
37176 void *argp1 = 0 ;
37177 int res1 = 0 ;
37178 bool val2 ;
37179 int ecode2 = 0 ;
37180 PyObject * obj0 = 0 ;
37181 PyObject * obj1 = 0 ;
37182 char * kwnames[] = {
37183 (char *) "self",(char *) "autoLayout", NULL
37184 };
37185
37186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37188 if (!SWIG_IsOK(res1)) {
37189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37190 }
37191 arg1 = reinterpret_cast< wxWindow * >(argp1);
37192 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37193 if (!SWIG_IsOK(ecode2)) {
37194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37195 }
37196 arg2 = static_cast< bool >(val2);
37197 {
37198 PyThreadState* __tstate = wxPyBeginAllowThreads();
37199 (arg1)->SetAutoLayout(arg2);
37200 wxPyEndAllowThreads(__tstate);
37201 if (PyErr_Occurred()) SWIG_fail;
37202 }
37203 resultobj = SWIG_Py_Void();
37204 return resultobj;
37205 fail:
37206 return NULL;
37207 }
37208
37209
37210 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37211 PyObject *resultobj = 0;
37212 wxWindow *arg1 = (wxWindow *) 0 ;
37213 bool result;
37214 void *argp1 = 0 ;
37215 int res1 = 0 ;
37216 PyObject *swig_obj[1] ;
37217
37218 if (!args) SWIG_fail;
37219 swig_obj[0] = args;
37220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37221 if (!SWIG_IsOK(res1)) {
37222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37223 }
37224 arg1 = reinterpret_cast< wxWindow * >(argp1);
37225 {
37226 PyThreadState* __tstate = wxPyBeginAllowThreads();
37227 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37228 wxPyEndAllowThreads(__tstate);
37229 if (PyErr_Occurred()) SWIG_fail;
37230 }
37231 {
37232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37233 }
37234 return resultobj;
37235 fail:
37236 return NULL;
37237 }
37238
37239
37240 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37241 PyObject *resultobj = 0;
37242 wxWindow *arg1 = (wxWindow *) 0 ;
37243 bool result;
37244 void *argp1 = 0 ;
37245 int res1 = 0 ;
37246 PyObject *swig_obj[1] ;
37247
37248 if (!args) SWIG_fail;
37249 swig_obj[0] = args;
37250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37251 if (!SWIG_IsOK(res1)) {
37252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37253 }
37254 arg1 = reinterpret_cast< wxWindow * >(argp1);
37255 {
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 result = (bool)(arg1)->Layout();
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 {
37262 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37263 }
37264 return resultobj;
37265 fail:
37266 return NULL;
37267 }
37268
37269
37270 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37271 PyObject *resultobj = 0;
37272 wxWindow *arg1 = (wxWindow *) 0 ;
37273 wxSizer *arg2 = (wxSizer *) 0 ;
37274 bool arg3 = (bool) true ;
37275 void *argp1 = 0 ;
37276 int res1 = 0 ;
37277 int res2 = 0 ;
37278 bool val3 ;
37279 int ecode3 = 0 ;
37280 PyObject * obj0 = 0 ;
37281 PyObject * obj1 = 0 ;
37282 PyObject * obj2 = 0 ;
37283 char * kwnames[] = {
37284 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37285 };
37286
37287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37289 if (!SWIG_IsOK(res1)) {
37290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37291 }
37292 arg1 = reinterpret_cast< wxWindow * >(argp1);
37293 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37294 if (!SWIG_IsOK(res2)) {
37295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37296 }
37297 if (obj2) {
37298 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37299 if (!SWIG_IsOK(ecode3)) {
37300 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37301 }
37302 arg3 = static_cast< bool >(val3);
37303 }
37304 {
37305 PyThreadState* __tstate = wxPyBeginAllowThreads();
37306 (arg1)->SetSizer(arg2,arg3);
37307 wxPyEndAllowThreads(__tstate);
37308 if (PyErr_Occurred()) SWIG_fail;
37309 }
37310 resultobj = SWIG_Py_Void();
37311 return resultobj;
37312 fail:
37313 return NULL;
37314 }
37315
37316
37317 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37318 PyObject *resultobj = 0;
37319 wxWindow *arg1 = (wxWindow *) 0 ;
37320 wxSizer *arg2 = (wxSizer *) 0 ;
37321 bool arg3 = (bool) true ;
37322 void *argp1 = 0 ;
37323 int res1 = 0 ;
37324 int res2 = 0 ;
37325 bool val3 ;
37326 int ecode3 = 0 ;
37327 PyObject * obj0 = 0 ;
37328 PyObject * obj1 = 0 ;
37329 PyObject * obj2 = 0 ;
37330 char * kwnames[] = {
37331 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37332 };
37333
37334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37336 if (!SWIG_IsOK(res1)) {
37337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37338 }
37339 arg1 = reinterpret_cast< wxWindow * >(argp1);
37340 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37341 if (!SWIG_IsOK(res2)) {
37342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37343 }
37344 if (obj2) {
37345 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37346 if (!SWIG_IsOK(ecode3)) {
37347 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37348 }
37349 arg3 = static_cast< bool >(val3);
37350 }
37351 {
37352 PyThreadState* __tstate = wxPyBeginAllowThreads();
37353 (arg1)->SetSizerAndFit(arg2,arg3);
37354 wxPyEndAllowThreads(__tstate);
37355 if (PyErr_Occurred()) SWIG_fail;
37356 }
37357 resultobj = SWIG_Py_Void();
37358 return resultobj;
37359 fail:
37360 return NULL;
37361 }
37362
37363
37364 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37365 PyObject *resultobj = 0;
37366 wxWindow *arg1 = (wxWindow *) 0 ;
37367 wxSizer *result = 0 ;
37368 void *argp1 = 0 ;
37369 int res1 = 0 ;
37370 PyObject *swig_obj[1] ;
37371
37372 if (!args) SWIG_fail;
37373 swig_obj[0] = args;
37374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37375 if (!SWIG_IsOK(res1)) {
37376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37377 }
37378 arg1 = reinterpret_cast< wxWindow * >(argp1);
37379 {
37380 PyThreadState* __tstate = wxPyBeginAllowThreads();
37381 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37382 wxPyEndAllowThreads(__tstate);
37383 if (PyErr_Occurred()) SWIG_fail;
37384 }
37385 {
37386 resultobj = wxPyMake_wxObject(result, (bool)0);
37387 }
37388 return resultobj;
37389 fail:
37390 return NULL;
37391 }
37392
37393
37394 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37395 PyObject *resultobj = 0;
37396 wxWindow *arg1 = (wxWindow *) 0 ;
37397 wxSizer *arg2 = (wxSizer *) 0 ;
37398 void *argp1 = 0 ;
37399 int res1 = 0 ;
37400 void *argp2 = 0 ;
37401 int res2 = 0 ;
37402 PyObject * obj0 = 0 ;
37403 PyObject * obj1 = 0 ;
37404 char * kwnames[] = {
37405 (char *) "self",(char *) "sizer", NULL
37406 };
37407
37408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37410 if (!SWIG_IsOK(res1)) {
37411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37412 }
37413 arg1 = reinterpret_cast< wxWindow * >(argp1);
37414 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37415 if (!SWIG_IsOK(res2)) {
37416 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37417 }
37418 arg2 = reinterpret_cast< wxSizer * >(argp2);
37419 {
37420 PyThreadState* __tstate = wxPyBeginAllowThreads();
37421 (arg1)->SetContainingSizer(arg2);
37422 wxPyEndAllowThreads(__tstate);
37423 if (PyErr_Occurred()) SWIG_fail;
37424 }
37425 resultobj = SWIG_Py_Void();
37426 return resultobj;
37427 fail:
37428 return NULL;
37429 }
37430
37431
37432 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37433 PyObject *resultobj = 0;
37434 wxWindow *arg1 = (wxWindow *) 0 ;
37435 wxSizer *result = 0 ;
37436 void *argp1 = 0 ;
37437 int res1 = 0 ;
37438 PyObject *swig_obj[1] ;
37439
37440 if (!args) SWIG_fail;
37441 swig_obj[0] = args;
37442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37443 if (!SWIG_IsOK(res1)) {
37444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37445 }
37446 arg1 = reinterpret_cast< wxWindow * >(argp1);
37447 {
37448 PyThreadState* __tstate = wxPyBeginAllowThreads();
37449 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37450 wxPyEndAllowThreads(__tstate);
37451 if (PyErr_Occurred()) SWIG_fail;
37452 }
37453 {
37454 resultobj = wxPyMake_wxObject(result, (bool)0);
37455 }
37456 return resultobj;
37457 fail:
37458 return NULL;
37459 }
37460
37461
37462 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37463 PyObject *resultobj = 0;
37464 wxWindow *arg1 = (wxWindow *) 0 ;
37465 void *argp1 = 0 ;
37466 int res1 = 0 ;
37467 PyObject *swig_obj[1] ;
37468
37469 if (!args) SWIG_fail;
37470 swig_obj[0] = args;
37471 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37472 if (!SWIG_IsOK(res1)) {
37473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37474 }
37475 arg1 = reinterpret_cast< wxWindow * >(argp1);
37476 {
37477 PyThreadState* __tstate = wxPyBeginAllowThreads();
37478 (arg1)->InheritAttributes();
37479 wxPyEndAllowThreads(__tstate);
37480 if (PyErr_Occurred()) SWIG_fail;
37481 }
37482 resultobj = SWIG_Py_Void();
37483 return resultobj;
37484 fail:
37485 return NULL;
37486 }
37487
37488
37489 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37490 PyObject *resultobj = 0;
37491 wxWindow *arg1 = (wxWindow *) 0 ;
37492 bool result;
37493 void *argp1 = 0 ;
37494 int res1 = 0 ;
37495 PyObject *swig_obj[1] ;
37496
37497 if (!args) SWIG_fail;
37498 swig_obj[0] = args;
37499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37500 if (!SWIG_IsOK(res1)) {
37501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37502 }
37503 arg1 = reinterpret_cast< wxWindow * >(argp1);
37504 {
37505 PyThreadState* __tstate = wxPyBeginAllowThreads();
37506 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37507 wxPyEndAllowThreads(__tstate);
37508 if (PyErr_Occurred()) SWIG_fail;
37509 }
37510 {
37511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37512 }
37513 return resultobj;
37514 fail:
37515 return NULL;
37516 }
37517
37518
37519 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37520 PyObject *obj;
37521 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37522 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37523 return SWIG_Py_Void();
37524 }
37525
37526 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37527 return SWIG_Python_InitShadowInstance(args);
37528 }
37529
37530 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37531 PyObject *resultobj = 0;
37532 long arg1 ;
37533 wxWindow *arg2 = (wxWindow *) NULL ;
37534 wxWindow *result = 0 ;
37535 long val1 ;
37536 int ecode1 = 0 ;
37537 void *argp2 = 0 ;
37538 int res2 = 0 ;
37539 PyObject * obj0 = 0 ;
37540 PyObject * obj1 = 0 ;
37541 char * kwnames[] = {
37542 (char *) "id",(char *) "parent", NULL
37543 };
37544
37545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37546 ecode1 = SWIG_AsVal_long(obj0, &val1);
37547 if (!SWIG_IsOK(ecode1)) {
37548 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37549 }
37550 arg1 = static_cast< long >(val1);
37551 if (obj1) {
37552 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37553 if (!SWIG_IsOK(res2)) {
37554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37555 }
37556 arg2 = reinterpret_cast< wxWindow * >(argp2);
37557 }
37558 {
37559 if (!wxPyCheckForApp()) SWIG_fail;
37560 PyThreadState* __tstate = wxPyBeginAllowThreads();
37561 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37562 wxPyEndAllowThreads(__tstate);
37563 if (PyErr_Occurred()) SWIG_fail;
37564 }
37565 {
37566 resultobj = wxPyMake_wxObject(result, 0);
37567 }
37568 return resultobj;
37569 fail:
37570 return NULL;
37571 }
37572
37573
37574 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37575 PyObject *resultobj = 0;
37576 wxString *arg1 = 0 ;
37577 wxWindow *arg2 = (wxWindow *) NULL ;
37578 wxWindow *result = 0 ;
37579 bool temp1 = false ;
37580 void *argp2 = 0 ;
37581 int res2 = 0 ;
37582 PyObject * obj0 = 0 ;
37583 PyObject * obj1 = 0 ;
37584 char * kwnames[] = {
37585 (char *) "name",(char *) "parent", NULL
37586 };
37587
37588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37589 {
37590 arg1 = wxString_in_helper(obj0);
37591 if (arg1 == NULL) SWIG_fail;
37592 temp1 = true;
37593 }
37594 if (obj1) {
37595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37596 if (!SWIG_IsOK(res2)) {
37597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37598 }
37599 arg2 = reinterpret_cast< wxWindow * >(argp2);
37600 }
37601 {
37602 if (!wxPyCheckForApp()) SWIG_fail;
37603 PyThreadState* __tstate = wxPyBeginAllowThreads();
37604 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37605 wxPyEndAllowThreads(__tstate);
37606 if (PyErr_Occurred()) SWIG_fail;
37607 }
37608 {
37609 resultobj = wxPyMake_wxObject(result, 0);
37610 }
37611 {
37612 if (temp1)
37613 delete arg1;
37614 }
37615 return resultobj;
37616 fail:
37617 {
37618 if (temp1)
37619 delete arg1;
37620 }
37621 return NULL;
37622 }
37623
37624
37625 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37626 PyObject *resultobj = 0;
37627 wxString *arg1 = 0 ;
37628 wxWindow *arg2 = (wxWindow *) NULL ;
37629 wxWindow *result = 0 ;
37630 bool temp1 = false ;
37631 void *argp2 = 0 ;
37632 int res2 = 0 ;
37633 PyObject * obj0 = 0 ;
37634 PyObject * obj1 = 0 ;
37635 char * kwnames[] = {
37636 (char *) "label",(char *) "parent", NULL
37637 };
37638
37639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37640 {
37641 arg1 = wxString_in_helper(obj0);
37642 if (arg1 == NULL) SWIG_fail;
37643 temp1 = true;
37644 }
37645 if (obj1) {
37646 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37647 if (!SWIG_IsOK(res2)) {
37648 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37649 }
37650 arg2 = reinterpret_cast< wxWindow * >(argp2);
37651 }
37652 {
37653 if (!wxPyCheckForApp()) SWIG_fail;
37654 PyThreadState* __tstate = wxPyBeginAllowThreads();
37655 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37656 wxPyEndAllowThreads(__tstate);
37657 if (PyErr_Occurred()) SWIG_fail;
37658 }
37659 {
37660 resultobj = wxPyMake_wxObject(result, 0);
37661 }
37662 {
37663 if (temp1)
37664 delete arg1;
37665 }
37666 return resultobj;
37667 fail:
37668 {
37669 if (temp1)
37670 delete arg1;
37671 }
37672 return NULL;
37673 }
37674
37675
37676 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37677 PyObject *resultobj = 0;
37678 wxWindow *arg1 = (wxWindow *) 0 ;
37679 unsigned long arg2 ;
37680 wxWindow *result = 0 ;
37681 void *argp1 = 0 ;
37682 int res1 = 0 ;
37683 unsigned long val2 ;
37684 int ecode2 = 0 ;
37685 PyObject * obj0 = 0 ;
37686 PyObject * obj1 = 0 ;
37687 char * kwnames[] = {
37688 (char *) "parent",(char *) "_hWnd", NULL
37689 };
37690
37691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37693 if (!SWIG_IsOK(res1)) {
37694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37695 }
37696 arg1 = reinterpret_cast< wxWindow * >(argp1);
37697 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37698 if (!SWIG_IsOK(ecode2)) {
37699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37700 }
37701 arg2 = static_cast< unsigned long >(val2);
37702 {
37703 PyThreadState* __tstate = wxPyBeginAllowThreads();
37704 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37705 wxPyEndAllowThreads(__tstate);
37706 if (PyErr_Occurred()) SWIG_fail;
37707 }
37708 {
37709 resultobj = wxPyMake_wxObject(result, 0);
37710 }
37711 return resultobj;
37712 fail:
37713 return NULL;
37714 }
37715
37716
37717 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37718 PyObject *resultobj = 0;
37719 PyObject *result = 0 ;
37720
37721 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37722 {
37723 PyThreadState* __tstate = wxPyBeginAllowThreads();
37724 result = (PyObject *)GetTopLevelWindows();
37725 wxPyEndAllowThreads(__tstate);
37726 if (PyErr_Occurred()) SWIG_fail;
37727 }
37728 resultobj = result;
37729 return resultobj;
37730 fail:
37731 return NULL;
37732 }
37733
37734
37735 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37736 PyObject *resultobj = 0;
37737 wxValidator *result = 0 ;
37738
37739 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37740 {
37741 PyThreadState* __tstate = wxPyBeginAllowThreads();
37742 result = (wxValidator *)new wxValidator();
37743 wxPyEndAllowThreads(__tstate);
37744 if (PyErr_Occurred()) SWIG_fail;
37745 }
37746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37747 return resultobj;
37748 fail:
37749 return NULL;
37750 }
37751
37752
37753 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37754 PyObject *resultobj = 0;
37755 wxValidator *arg1 = (wxValidator *) 0 ;
37756 wxValidator *result = 0 ;
37757 void *argp1 = 0 ;
37758 int res1 = 0 ;
37759 PyObject *swig_obj[1] ;
37760
37761 if (!args) SWIG_fail;
37762 swig_obj[0] = args;
37763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37764 if (!SWIG_IsOK(res1)) {
37765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37766 }
37767 arg1 = reinterpret_cast< wxValidator * >(argp1);
37768 {
37769 PyThreadState* __tstate = wxPyBeginAllowThreads();
37770 result = (wxValidator *)(arg1)->Clone();
37771 wxPyEndAllowThreads(__tstate);
37772 if (PyErr_Occurred()) SWIG_fail;
37773 }
37774 {
37775 resultobj = wxPyMake_wxObject(result, 0);
37776 }
37777 return resultobj;
37778 fail:
37779 return NULL;
37780 }
37781
37782
37783 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37784 PyObject *resultobj = 0;
37785 wxValidator *arg1 = (wxValidator *) 0 ;
37786 wxWindow *arg2 = (wxWindow *) 0 ;
37787 bool result;
37788 void *argp1 = 0 ;
37789 int res1 = 0 ;
37790 void *argp2 = 0 ;
37791 int res2 = 0 ;
37792 PyObject * obj0 = 0 ;
37793 PyObject * obj1 = 0 ;
37794 char * kwnames[] = {
37795 (char *) "self",(char *) "parent", NULL
37796 };
37797
37798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37800 if (!SWIG_IsOK(res1)) {
37801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37802 }
37803 arg1 = reinterpret_cast< wxValidator * >(argp1);
37804 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37805 if (!SWIG_IsOK(res2)) {
37806 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37807 }
37808 arg2 = reinterpret_cast< wxWindow * >(argp2);
37809 {
37810 PyThreadState* __tstate = wxPyBeginAllowThreads();
37811 result = (bool)(arg1)->Validate(arg2);
37812 wxPyEndAllowThreads(__tstate);
37813 if (PyErr_Occurred()) SWIG_fail;
37814 }
37815 {
37816 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37817 }
37818 return resultobj;
37819 fail:
37820 return NULL;
37821 }
37822
37823
37824 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37825 PyObject *resultobj = 0;
37826 wxValidator *arg1 = (wxValidator *) 0 ;
37827 bool result;
37828 void *argp1 = 0 ;
37829 int res1 = 0 ;
37830 PyObject *swig_obj[1] ;
37831
37832 if (!args) SWIG_fail;
37833 swig_obj[0] = args;
37834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37837 }
37838 arg1 = reinterpret_cast< wxValidator * >(argp1);
37839 {
37840 PyThreadState* __tstate = wxPyBeginAllowThreads();
37841 result = (bool)(arg1)->TransferToWindow();
37842 wxPyEndAllowThreads(__tstate);
37843 if (PyErr_Occurred()) SWIG_fail;
37844 }
37845 {
37846 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37847 }
37848 return resultobj;
37849 fail:
37850 return NULL;
37851 }
37852
37853
37854 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37855 PyObject *resultobj = 0;
37856 wxValidator *arg1 = (wxValidator *) 0 ;
37857 bool result;
37858 void *argp1 = 0 ;
37859 int res1 = 0 ;
37860 PyObject *swig_obj[1] ;
37861
37862 if (!args) SWIG_fail;
37863 swig_obj[0] = args;
37864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37865 if (!SWIG_IsOK(res1)) {
37866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37867 }
37868 arg1 = reinterpret_cast< wxValidator * >(argp1);
37869 {
37870 PyThreadState* __tstate = wxPyBeginAllowThreads();
37871 result = (bool)(arg1)->TransferFromWindow();
37872 wxPyEndAllowThreads(__tstate);
37873 if (PyErr_Occurred()) SWIG_fail;
37874 }
37875 {
37876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37877 }
37878 return resultobj;
37879 fail:
37880 return NULL;
37881 }
37882
37883
37884 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37885 PyObject *resultobj = 0;
37886 wxValidator *arg1 = (wxValidator *) 0 ;
37887 wxWindow *result = 0 ;
37888 void *argp1 = 0 ;
37889 int res1 = 0 ;
37890 PyObject *swig_obj[1] ;
37891
37892 if (!args) SWIG_fail;
37893 swig_obj[0] = args;
37894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37895 if (!SWIG_IsOK(res1)) {
37896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37897 }
37898 arg1 = reinterpret_cast< wxValidator * >(argp1);
37899 {
37900 PyThreadState* __tstate = wxPyBeginAllowThreads();
37901 result = (wxWindow *)(arg1)->GetWindow();
37902 wxPyEndAllowThreads(__tstate);
37903 if (PyErr_Occurred()) SWIG_fail;
37904 }
37905 {
37906 resultobj = wxPyMake_wxObject(result, 0);
37907 }
37908 return resultobj;
37909 fail:
37910 return NULL;
37911 }
37912
37913
37914 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37915 PyObject *resultobj = 0;
37916 wxValidator *arg1 = (wxValidator *) 0 ;
37917 wxWindow *arg2 = (wxWindow *) 0 ;
37918 void *argp1 = 0 ;
37919 int res1 = 0 ;
37920 void *argp2 = 0 ;
37921 int res2 = 0 ;
37922 PyObject * obj0 = 0 ;
37923 PyObject * obj1 = 0 ;
37924 char * kwnames[] = {
37925 (char *) "self",(char *) "window", NULL
37926 };
37927
37928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
37929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37930 if (!SWIG_IsOK(res1)) {
37931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
37932 }
37933 arg1 = reinterpret_cast< wxValidator * >(argp1);
37934 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37935 if (!SWIG_IsOK(res2)) {
37936 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
37937 }
37938 arg2 = reinterpret_cast< wxWindow * >(argp2);
37939 {
37940 PyThreadState* __tstate = wxPyBeginAllowThreads();
37941 (arg1)->SetWindow(arg2);
37942 wxPyEndAllowThreads(__tstate);
37943 if (PyErr_Occurred()) SWIG_fail;
37944 }
37945 resultobj = SWIG_Py_Void();
37946 return resultobj;
37947 fail:
37948 return NULL;
37949 }
37950
37951
37952 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37953 PyObject *resultobj = 0;
37954 bool result;
37955
37956 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
37957 {
37958 PyThreadState* __tstate = wxPyBeginAllowThreads();
37959 result = (bool)wxValidator::IsSilent();
37960 wxPyEndAllowThreads(__tstate);
37961 if (PyErr_Occurred()) SWIG_fail;
37962 }
37963 {
37964 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37965 }
37966 return resultobj;
37967 fail:
37968 return NULL;
37969 }
37970
37971
37972 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37973 PyObject *resultobj = 0;
37974 int arg1 = (int) true ;
37975 int val1 ;
37976 int ecode1 = 0 ;
37977 PyObject * obj0 = 0 ;
37978 char * kwnames[] = {
37979 (char *) "doIt", NULL
37980 };
37981
37982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
37983 if (obj0) {
37984 ecode1 = SWIG_AsVal_int(obj0, &val1);
37985 if (!SWIG_IsOK(ecode1)) {
37986 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
37987 }
37988 arg1 = static_cast< int >(val1);
37989 }
37990 {
37991 PyThreadState* __tstate = wxPyBeginAllowThreads();
37992 wxValidator::SetBellOnError(arg1);
37993 wxPyEndAllowThreads(__tstate);
37994 if (PyErr_Occurred()) SWIG_fail;
37995 }
37996 resultobj = SWIG_Py_Void();
37997 return resultobj;
37998 fail:
37999 return NULL;
38000 }
38001
38002
38003 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38004 PyObject *obj;
38005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38006 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38007 return SWIG_Py_Void();
38008 }
38009
38010 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38011 return SWIG_Python_InitShadowInstance(args);
38012 }
38013
38014 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38015 PyObject *resultobj = 0;
38016 wxPyValidator *result = 0 ;
38017
38018 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38019 {
38020 PyThreadState* __tstate = wxPyBeginAllowThreads();
38021 result = (wxPyValidator *)new wxPyValidator();
38022 wxPyEndAllowThreads(__tstate);
38023 if (PyErr_Occurred()) SWIG_fail;
38024 }
38025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38026 return resultobj;
38027 fail:
38028 return NULL;
38029 }
38030
38031
38032 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38033 PyObject *resultobj = 0;
38034 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38035 PyObject *arg2 = (PyObject *) 0 ;
38036 PyObject *arg3 = (PyObject *) 0 ;
38037 int arg4 = (int) true ;
38038 void *argp1 = 0 ;
38039 int res1 = 0 ;
38040 int val4 ;
38041 int ecode4 = 0 ;
38042 PyObject * obj0 = 0 ;
38043 PyObject * obj1 = 0 ;
38044 PyObject * obj2 = 0 ;
38045 PyObject * obj3 = 0 ;
38046 char * kwnames[] = {
38047 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38048 };
38049
38050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38052 if (!SWIG_IsOK(res1)) {
38053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38054 }
38055 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38056 arg2 = obj1;
38057 arg3 = obj2;
38058 if (obj3) {
38059 ecode4 = SWIG_AsVal_int(obj3, &val4);
38060 if (!SWIG_IsOK(ecode4)) {
38061 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38062 }
38063 arg4 = static_cast< int >(val4);
38064 }
38065 {
38066 PyThreadState* __tstate = wxPyBeginAllowThreads();
38067 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38068 wxPyEndAllowThreads(__tstate);
38069 if (PyErr_Occurred()) SWIG_fail;
38070 }
38071 resultobj = SWIG_Py_Void();
38072 return resultobj;
38073 fail:
38074 return NULL;
38075 }
38076
38077
38078 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38079 PyObject *obj;
38080 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38081 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38082 return SWIG_Py_Void();
38083 }
38084
38085 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38086 return SWIG_Python_InitShadowInstance(args);
38087 }
38088
38089 SWIGINTERN int DefaultValidator_set(PyObject *) {
38090 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38091 return 1;
38092 }
38093
38094
38095 SWIGINTERN PyObject *DefaultValidator_get(void) {
38096 PyObject *pyobj = 0;
38097
38098 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38099 return pyobj;
38100 }
38101
38102
38103 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38104 PyObject *resultobj = 0;
38105 wxString const &arg1_defvalue = wxPyEmptyString ;
38106 wxString *arg1 = (wxString *) &arg1_defvalue ;
38107 long arg2 = (long) 0 ;
38108 wxMenu *result = 0 ;
38109 bool temp1 = false ;
38110 long val2 ;
38111 int ecode2 = 0 ;
38112 PyObject * obj0 = 0 ;
38113 PyObject * obj1 = 0 ;
38114 char * kwnames[] = {
38115 (char *) "title",(char *) "style", NULL
38116 };
38117
38118 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38119 if (obj0) {
38120 {
38121 arg1 = wxString_in_helper(obj0);
38122 if (arg1 == NULL) SWIG_fail;
38123 temp1 = true;
38124 }
38125 }
38126 if (obj1) {
38127 ecode2 = SWIG_AsVal_long(obj1, &val2);
38128 if (!SWIG_IsOK(ecode2)) {
38129 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38130 }
38131 arg2 = static_cast< long >(val2);
38132 }
38133 {
38134 if (!wxPyCheckForApp()) SWIG_fail;
38135 PyThreadState* __tstate = wxPyBeginAllowThreads();
38136 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38137 wxPyEndAllowThreads(__tstate);
38138 if (PyErr_Occurred()) SWIG_fail;
38139 }
38140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38141 {
38142 if (temp1)
38143 delete arg1;
38144 }
38145 return resultobj;
38146 fail:
38147 {
38148 if (temp1)
38149 delete arg1;
38150 }
38151 return NULL;
38152 }
38153
38154
38155 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38156 PyObject *resultobj = 0;
38157 wxMenu *arg1 = (wxMenu *) 0 ;
38158 int arg2 ;
38159 wxString *arg3 = 0 ;
38160 wxString const &arg4_defvalue = wxPyEmptyString ;
38161 wxString *arg4 = (wxString *) &arg4_defvalue ;
38162 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38163 wxMenuItem *result = 0 ;
38164 void *argp1 = 0 ;
38165 int res1 = 0 ;
38166 int val2 ;
38167 int ecode2 = 0 ;
38168 bool temp3 = false ;
38169 bool temp4 = false ;
38170 int val5 ;
38171 int ecode5 = 0 ;
38172 PyObject * obj0 = 0 ;
38173 PyObject * obj1 = 0 ;
38174 PyObject * obj2 = 0 ;
38175 PyObject * obj3 = 0 ;
38176 PyObject * obj4 = 0 ;
38177 char * kwnames[] = {
38178 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38179 };
38180
38181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38183 if (!SWIG_IsOK(res1)) {
38184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38185 }
38186 arg1 = reinterpret_cast< wxMenu * >(argp1);
38187 ecode2 = SWIG_AsVal_int(obj1, &val2);
38188 if (!SWIG_IsOK(ecode2)) {
38189 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38190 }
38191 arg2 = static_cast< int >(val2);
38192 {
38193 arg3 = wxString_in_helper(obj2);
38194 if (arg3 == NULL) SWIG_fail;
38195 temp3 = true;
38196 }
38197 if (obj3) {
38198 {
38199 arg4 = wxString_in_helper(obj3);
38200 if (arg4 == NULL) SWIG_fail;
38201 temp4 = true;
38202 }
38203 }
38204 if (obj4) {
38205 ecode5 = SWIG_AsVal_int(obj4, &val5);
38206 if (!SWIG_IsOK(ecode5)) {
38207 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38208 }
38209 arg5 = static_cast< wxItemKind >(val5);
38210 }
38211 {
38212 PyThreadState* __tstate = wxPyBeginAllowThreads();
38213 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38214 wxPyEndAllowThreads(__tstate);
38215 if (PyErr_Occurred()) SWIG_fail;
38216 }
38217 {
38218 resultobj = wxPyMake_wxObject(result, (bool)0);
38219 }
38220 {
38221 if (temp3)
38222 delete arg3;
38223 }
38224 {
38225 if (temp4)
38226 delete arg4;
38227 }
38228 return resultobj;
38229 fail:
38230 {
38231 if (temp3)
38232 delete arg3;
38233 }
38234 {
38235 if (temp4)
38236 delete arg4;
38237 }
38238 return NULL;
38239 }
38240
38241
38242 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38243 PyObject *resultobj = 0;
38244 wxMenu *arg1 = (wxMenu *) 0 ;
38245 wxMenuItem *result = 0 ;
38246 void *argp1 = 0 ;
38247 int res1 = 0 ;
38248 PyObject *swig_obj[1] ;
38249
38250 if (!args) SWIG_fail;
38251 swig_obj[0] = args;
38252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38253 if (!SWIG_IsOK(res1)) {
38254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38255 }
38256 arg1 = reinterpret_cast< wxMenu * >(argp1);
38257 {
38258 PyThreadState* __tstate = wxPyBeginAllowThreads();
38259 result = (wxMenuItem *)(arg1)->AppendSeparator();
38260 wxPyEndAllowThreads(__tstate);
38261 if (PyErr_Occurred()) SWIG_fail;
38262 }
38263 {
38264 resultobj = wxPyMake_wxObject(result, (bool)0);
38265 }
38266 return resultobj;
38267 fail:
38268 return NULL;
38269 }
38270
38271
38272 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38273 PyObject *resultobj = 0;
38274 wxMenu *arg1 = (wxMenu *) 0 ;
38275 int arg2 ;
38276 wxString *arg3 = 0 ;
38277 wxString const &arg4_defvalue = wxPyEmptyString ;
38278 wxString *arg4 = (wxString *) &arg4_defvalue ;
38279 wxMenuItem *result = 0 ;
38280 void *argp1 = 0 ;
38281 int res1 = 0 ;
38282 int val2 ;
38283 int ecode2 = 0 ;
38284 bool temp3 = false ;
38285 bool temp4 = false ;
38286 PyObject * obj0 = 0 ;
38287 PyObject * obj1 = 0 ;
38288 PyObject * obj2 = 0 ;
38289 PyObject * obj3 = 0 ;
38290 char * kwnames[] = {
38291 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38292 };
38293
38294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38296 if (!SWIG_IsOK(res1)) {
38297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38298 }
38299 arg1 = reinterpret_cast< wxMenu * >(argp1);
38300 ecode2 = SWIG_AsVal_int(obj1, &val2);
38301 if (!SWIG_IsOK(ecode2)) {
38302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38303 }
38304 arg2 = static_cast< int >(val2);
38305 {
38306 arg3 = wxString_in_helper(obj2);
38307 if (arg3 == NULL) SWIG_fail;
38308 temp3 = true;
38309 }
38310 if (obj3) {
38311 {
38312 arg4 = wxString_in_helper(obj3);
38313 if (arg4 == NULL) SWIG_fail;
38314 temp4 = true;
38315 }
38316 }
38317 {
38318 PyThreadState* __tstate = wxPyBeginAllowThreads();
38319 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38320 wxPyEndAllowThreads(__tstate);
38321 if (PyErr_Occurred()) SWIG_fail;
38322 }
38323 {
38324 resultobj = wxPyMake_wxObject(result, (bool)0);
38325 }
38326 {
38327 if (temp3)
38328 delete arg3;
38329 }
38330 {
38331 if (temp4)
38332 delete arg4;
38333 }
38334 return resultobj;
38335 fail:
38336 {
38337 if (temp3)
38338 delete arg3;
38339 }
38340 {
38341 if (temp4)
38342 delete arg4;
38343 }
38344 return NULL;
38345 }
38346
38347
38348 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38349 PyObject *resultobj = 0;
38350 wxMenu *arg1 = (wxMenu *) 0 ;
38351 int arg2 ;
38352 wxString *arg3 = 0 ;
38353 wxString const &arg4_defvalue = wxPyEmptyString ;
38354 wxString *arg4 = (wxString *) &arg4_defvalue ;
38355 wxMenuItem *result = 0 ;
38356 void *argp1 = 0 ;
38357 int res1 = 0 ;
38358 int val2 ;
38359 int ecode2 = 0 ;
38360 bool temp3 = false ;
38361 bool temp4 = false ;
38362 PyObject * obj0 = 0 ;
38363 PyObject * obj1 = 0 ;
38364 PyObject * obj2 = 0 ;
38365 PyObject * obj3 = 0 ;
38366 char * kwnames[] = {
38367 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38368 };
38369
38370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38372 if (!SWIG_IsOK(res1)) {
38373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38374 }
38375 arg1 = reinterpret_cast< wxMenu * >(argp1);
38376 ecode2 = SWIG_AsVal_int(obj1, &val2);
38377 if (!SWIG_IsOK(ecode2)) {
38378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38379 }
38380 arg2 = static_cast< int >(val2);
38381 {
38382 arg3 = wxString_in_helper(obj2);
38383 if (arg3 == NULL) SWIG_fail;
38384 temp3 = true;
38385 }
38386 if (obj3) {
38387 {
38388 arg4 = wxString_in_helper(obj3);
38389 if (arg4 == NULL) SWIG_fail;
38390 temp4 = true;
38391 }
38392 }
38393 {
38394 PyThreadState* __tstate = wxPyBeginAllowThreads();
38395 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38396 wxPyEndAllowThreads(__tstate);
38397 if (PyErr_Occurred()) SWIG_fail;
38398 }
38399 {
38400 resultobj = wxPyMake_wxObject(result, (bool)0);
38401 }
38402 {
38403 if (temp3)
38404 delete arg3;
38405 }
38406 {
38407 if (temp4)
38408 delete arg4;
38409 }
38410 return resultobj;
38411 fail:
38412 {
38413 if (temp3)
38414 delete arg3;
38415 }
38416 {
38417 if (temp4)
38418 delete arg4;
38419 }
38420 return NULL;
38421 }
38422
38423
38424 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38425 PyObject *resultobj = 0;
38426 wxMenu *arg1 = (wxMenu *) 0 ;
38427 int arg2 ;
38428 wxString *arg3 = 0 ;
38429 wxMenu *arg4 = (wxMenu *) 0 ;
38430 wxString const &arg5_defvalue = wxPyEmptyString ;
38431 wxString *arg5 = (wxString *) &arg5_defvalue ;
38432 wxMenuItem *result = 0 ;
38433 void *argp1 = 0 ;
38434 int res1 = 0 ;
38435 int val2 ;
38436 int ecode2 = 0 ;
38437 bool temp3 = false ;
38438 void *argp4 = 0 ;
38439 int res4 = 0 ;
38440 bool temp5 = false ;
38441 PyObject * obj0 = 0 ;
38442 PyObject * obj1 = 0 ;
38443 PyObject * obj2 = 0 ;
38444 PyObject * obj3 = 0 ;
38445 PyObject * obj4 = 0 ;
38446 char * kwnames[] = {
38447 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38448 };
38449
38450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38452 if (!SWIG_IsOK(res1)) {
38453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38454 }
38455 arg1 = reinterpret_cast< wxMenu * >(argp1);
38456 ecode2 = SWIG_AsVal_int(obj1, &val2);
38457 if (!SWIG_IsOK(ecode2)) {
38458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38459 }
38460 arg2 = static_cast< int >(val2);
38461 {
38462 arg3 = wxString_in_helper(obj2);
38463 if (arg3 == NULL) SWIG_fail;
38464 temp3 = true;
38465 }
38466 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38467 if (!SWIG_IsOK(res4)) {
38468 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38469 }
38470 arg4 = reinterpret_cast< wxMenu * >(argp4);
38471 if (obj4) {
38472 {
38473 arg5 = wxString_in_helper(obj4);
38474 if (arg5 == NULL) SWIG_fail;
38475 temp5 = true;
38476 }
38477 }
38478 {
38479 PyThreadState* __tstate = wxPyBeginAllowThreads();
38480 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38481 wxPyEndAllowThreads(__tstate);
38482 if (PyErr_Occurred()) SWIG_fail;
38483 }
38484 {
38485 resultobj = wxPyMake_wxObject(result, (bool)0);
38486 }
38487 {
38488 if (temp3)
38489 delete arg3;
38490 }
38491 {
38492 if (temp5)
38493 delete arg5;
38494 }
38495 return resultobj;
38496 fail:
38497 {
38498 if (temp3)
38499 delete arg3;
38500 }
38501 {
38502 if (temp5)
38503 delete arg5;
38504 }
38505 return NULL;
38506 }
38507
38508
38509 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38510 PyObject *resultobj = 0;
38511 wxMenu *arg1 = (wxMenu *) 0 ;
38512 wxMenu *arg2 = (wxMenu *) 0 ;
38513 wxString *arg3 = 0 ;
38514 wxString const &arg4_defvalue = wxPyEmptyString ;
38515 wxString *arg4 = (wxString *) &arg4_defvalue ;
38516 wxMenuItem *result = 0 ;
38517 void *argp1 = 0 ;
38518 int res1 = 0 ;
38519 void *argp2 = 0 ;
38520 int res2 = 0 ;
38521 bool temp3 = false ;
38522 bool temp4 = false ;
38523 PyObject * obj0 = 0 ;
38524 PyObject * obj1 = 0 ;
38525 PyObject * obj2 = 0 ;
38526 PyObject * obj3 = 0 ;
38527 char * kwnames[] = {
38528 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38529 };
38530
38531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38533 if (!SWIG_IsOK(res1)) {
38534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38535 }
38536 arg1 = reinterpret_cast< wxMenu * >(argp1);
38537 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38538 if (!SWIG_IsOK(res2)) {
38539 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38540 }
38541 arg2 = reinterpret_cast< wxMenu * >(argp2);
38542 {
38543 arg3 = wxString_in_helper(obj2);
38544 if (arg3 == NULL) SWIG_fail;
38545 temp3 = true;
38546 }
38547 if (obj3) {
38548 {
38549 arg4 = wxString_in_helper(obj3);
38550 if (arg4 == NULL) SWIG_fail;
38551 temp4 = true;
38552 }
38553 }
38554 {
38555 PyThreadState* __tstate = wxPyBeginAllowThreads();
38556 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38557 wxPyEndAllowThreads(__tstate);
38558 if (PyErr_Occurred()) SWIG_fail;
38559 }
38560 {
38561 resultobj = wxPyMake_wxObject(result, (bool)0);
38562 }
38563 {
38564 if (temp3)
38565 delete arg3;
38566 }
38567 {
38568 if (temp4)
38569 delete arg4;
38570 }
38571 return resultobj;
38572 fail:
38573 {
38574 if (temp3)
38575 delete arg3;
38576 }
38577 {
38578 if (temp4)
38579 delete arg4;
38580 }
38581 return NULL;
38582 }
38583
38584
38585 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38586 PyObject *resultobj = 0;
38587 wxMenu *arg1 = (wxMenu *) 0 ;
38588 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38589 wxMenuItem *result = 0 ;
38590 void *argp1 = 0 ;
38591 int res1 = 0 ;
38592 int res2 = 0 ;
38593 PyObject * obj0 = 0 ;
38594 PyObject * obj1 = 0 ;
38595 char * kwnames[] = {
38596 (char *) "self",(char *) "item", NULL
38597 };
38598
38599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38601 if (!SWIG_IsOK(res1)) {
38602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38603 }
38604 arg1 = reinterpret_cast< wxMenu * >(argp1);
38605 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38606 if (!SWIG_IsOK(res2)) {
38607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38608 }
38609 {
38610 PyThreadState* __tstate = wxPyBeginAllowThreads();
38611 result = (wxMenuItem *)(arg1)->Append(arg2);
38612 wxPyEndAllowThreads(__tstate);
38613 if (PyErr_Occurred()) SWIG_fail;
38614 }
38615 {
38616 resultobj = wxPyMake_wxObject(result, (bool)0);
38617 }
38618 return resultobj;
38619 fail:
38620 return NULL;
38621 }
38622
38623
38624 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38625 PyObject *resultobj = 0;
38626 wxMenu *arg1 = (wxMenu *) 0 ;
38627 size_t arg2 ;
38628 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38629 wxMenuItem *result = 0 ;
38630 void *argp1 = 0 ;
38631 int res1 = 0 ;
38632 size_t val2 ;
38633 int ecode2 = 0 ;
38634 int res3 = 0 ;
38635 PyObject * obj0 = 0 ;
38636 PyObject * obj1 = 0 ;
38637 PyObject * obj2 = 0 ;
38638 char * kwnames[] = {
38639 (char *) "self",(char *) "pos",(char *) "item", NULL
38640 };
38641
38642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38644 if (!SWIG_IsOK(res1)) {
38645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38646 }
38647 arg1 = reinterpret_cast< wxMenu * >(argp1);
38648 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38649 if (!SWIG_IsOK(ecode2)) {
38650 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38651 }
38652 arg2 = static_cast< size_t >(val2);
38653 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38654 if (!SWIG_IsOK(res3)) {
38655 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38656 }
38657 {
38658 PyThreadState* __tstate = wxPyBeginAllowThreads();
38659 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
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_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38673 PyObject *resultobj = 0;
38674 wxMenu *arg1 = (wxMenu *) 0 ;
38675 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38676 wxMenuItem *result = 0 ;
38677 void *argp1 = 0 ;
38678 int res1 = 0 ;
38679 int res2 = 0 ;
38680 PyObject * obj0 = 0 ;
38681 PyObject * obj1 = 0 ;
38682 char * kwnames[] = {
38683 (char *) "self",(char *) "item", NULL
38684 };
38685
38686 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38687 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38688 if (!SWIG_IsOK(res1)) {
38689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38690 }
38691 arg1 = reinterpret_cast< wxMenu * >(argp1);
38692 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38693 if (!SWIG_IsOK(res2)) {
38694 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38695 }
38696 {
38697 PyThreadState* __tstate = wxPyBeginAllowThreads();
38698 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38699 wxPyEndAllowThreads(__tstate);
38700 if (PyErr_Occurred()) SWIG_fail;
38701 }
38702 {
38703 resultobj = wxPyMake_wxObject(result, (bool)0);
38704 }
38705 return resultobj;
38706 fail:
38707 return NULL;
38708 }
38709
38710
38711 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38712 PyObject *resultobj = 0;
38713 wxMenu *arg1 = (wxMenu *) 0 ;
38714 void *argp1 = 0 ;
38715 int res1 = 0 ;
38716 PyObject *swig_obj[1] ;
38717
38718 if (!args) SWIG_fail;
38719 swig_obj[0] = args;
38720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38721 if (!SWIG_IsOK(res1)) {
38722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38723 }
38724 arg1 = reinterpret_cast< wxMenu * >(argp1);
38725 {
38726 PyThreadState* __tstate = wxPyBeginAllowThreads();
38727 (arg1)->Break();
38728 wxPyEndAllowThreads(__tstate);
38729 if (PyErr_Occurred()) SWIG_fail;
38730 }
38731 resultobj = SWIG_Py_Void();
38732 return resultobj;
38733 fail:
38734 return NULL;
38735 }
38736
38737
38738 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38739 PyObject *resultobj = 0;
38740 wxMenu *arg1 = (wxMenu *) 0 ;
38741 size_t arg2 ;
38742 int arg3 ;
38743 wxString *arg4 = 0 ;
38744 wxString const &arg5_defvalue = wxPyEmptyString ;
38745 wxString *arg5 = (wxString *) &arg5_defvalue ;
38746 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38747 wxMenuItem *result = 0 ;
38748 void *argp1 = 0 ;
38749 int res1 = 0 ;
38750 size_t val2 ;
38751 int ecode2 = 0 ;
38752 int val3 ;
38753 int ecode3 = 0 ;
38754 bool temp4 = false ;
38755 bool temp5 = false ;
38756 int val6 ;
38757 int ecode6 = 0 ;
38758 PyObject * obj0 = 0 ;
38759 PyObject * obj1 = 0 ;
38760 PyObject * obj2 = 0 ;
38761 PyObject * obj3 = 0 ;
38762 PyObject * obj4 = 0 ;
38763 PyObject * obj5 = 0 ;
38764 char * kwnames[] = {
38765 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38766 };
38767
38768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38770 if (!SWIG_IsOK(res1)) {
38771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38772 }
38773 arg1 = reinterpret_cast< wxMenu * >(argp1);
38774 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38775 if (!SWIG_IsOK(ecode2)) {
38776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38777 }
38778 arg2 = static_cast< size_t >(val2);
38779 ecode3 = SWIG_AsVal_int(obj2, &val3);
38780 if (!SWIG_IsOK(ecode3)) {
38781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38782 }
38783 arg3 = static_cast< int >(val3);
38784 {
38785 arg4 = wxString_in_helper(obj3);
38786 if (arg4 == NULL) SWIG_fail;
38787 temp4 = true;
38788 }
38789 if (obj4) {
38790 {
38791 arg5 = wxString_in_helper(obj4);
38792 if (arg5 == NULL) SWIG_fail;
38793 temp5 = true;
38794 }
38795 }
38796 if (obj5) {
38797 ecode6 = SWIG_AsVal_int(obj5, &val6);
38798 if (!SWIG_IsOK(ecode6)) {
38799 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38800 }
38801 arg6 = static_cast< wxItemKind >(val6);
38802 }
38803 {
38804 PyThreadState* __tstate = wxPyBeginAllowThreads();
38805 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38806 wxPyEndAllowThreads(__tstate);
38807 if (PyErr_Occurred()) SWIG_fail;
38808 }
38809 {
38810 resultobj = wxPyMake_wxObject(result, (bool)0);
38811 }
38812 {
38813 if (temp4)
38814 delete arg4;
38815 }
38816 {
38817 if (temp5)
38818 delete arg5;
38819 }
38820 return resultobj;
38821 fail:
38822 {
38823 if (temp4)
38824 delete arg4;
38825 }
38826 {
38827 if (temp5)
38828 delete arg5;
38829 }
38830 return NULL;
38831 }
38832
38833
38834 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38835 PyObject *resultobj = 0;
38836 wxMenu *arg1 = (wxMenu *) 0 ;
38837 size_t arg2 ;
38838 wxMenuItem *result = 0 ;
38839 void *argp1 = 0 ;
38840 int res1 = 0 ;
38841 size_t val2 ;
38842 int ecode2 = 0 ;
38843 PyObject * obj0 = 0 ;
38844 PyObject * obj1 = 0 ;
38845 char * kwnames[] = {
38846 (char *) "self",(char *) "pos", NULL
38847 };
38848
38849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
38850 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38851 if (!SWIG_IsOK(res1)) {
38852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38853 }
38854 arg1 = reinterpret_cast< wxMenu * >(argp1);
38855 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38856 if (!SWIG_IsOK(ecode2)) {
38857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
38858 }
38859 arg2 = static_cast< size_t >(val2);
38860 {
38861 PyThreadState* __tstate = wxPyBeginAllowThreads();
38862 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
38863 wxPyEndAllowThreads(__tstate);
38864 if (PyErr_Occurred()) SWIG_fail;
38865 }
38866 {
38867 resultobj = wxPyMake_wxObject(result, (bool)0);
38868 }
38869 return resultobj;
38870 fail:
38871 return NULL;
38872 }
38873
38874
38875 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38876 PyObject *resultobj = 0;
38877 wxMenu *arg1 = (wxMenu *) 0 ;
38878 size_t arg2 ;
38879 int arg3 ;
38880 wxString *arg4 = 0 ;
38881 wxString const &arg5_defvalue = wxPyEmptyString ;
38882 wxString *arg5 = (wxString *) &arg5_defvalue ;
38883 wxMenuItem *result = 0 ;
38884 void *argp1 = 0 ;
38885 int res1 = 0 ;
38886 size_t val2 ;
38887 int ecode2 = 0 ;
38888 int val3 ;
38889 int ecode3 = 0 ;
38890 bool temp4 = false ;
38891 bool temp5 = false ;
38892 PyObject * obj0 = 0 ;
38893 PyObject * obj1 = 0 ;
38894 PyObject * obj2 = 0 ;
38895 PyObject * obj3 = 0 ;
38896 PyObject * obj4 = 0 ;
38897 char * kwnames[] = {
38898 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38899 };
38900
38901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38903 if (!SWIG_IsOK(res1)) {
38904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38905 }
38906 arg1 = reinterpret_cast< wxMenu * >(argp1);
38907 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38908 if (!SWIG_IsOK(ecode2)) {
38909 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
38910 }
38911 arg2 = static_cast< size_t >(val2);
38912 ecode3 = SWIG_AsVal_int(obj2, &val3);
38913 if (!SWIG_IsOK(ecode3)) {
38914 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
38915 }
38916 arg3 = static_cast< int >(val3);
38917 {
38918 arg4 = wxString_in_helper(obj3);
38919 if (arg4 == NULL) SWIG_fail;
38920 temp4 = true;
38921 }
38922 if (obj4) {
38923 {
38924 arg5 = wxString_in_helper(obj4);
38925 if (arg5 == NULL) SWIG_fail;
38926 temp5 = true;
38927 }
38928 }
38929 {
38930 PyThreadState* __tstate = wxPyBeginAllowThreads();
38931 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
38932 wxPyEndAllowThreads(__tstate);
38933 if (PyErr_Occurred()) SWIG_fail;
38934 }
38935 {
38936 resultobj = wxPyMake_wxObject(result, (bool)0);
38937 }
38938 {
38939 if (temp4)
38940 delete arg4;
38941 }
38942 {
38943 if (temp5)
38944 delete arg5;
38945 }
38946 return resultobj;
38947 fail:
38948 {
38949 if (temp4)
38950 delete arg4;
38951 }
38952 {
38953 if (temp5)
38954 delete arg5;
38955 }
38956 return NULL;
38957 }
38958
38959
38960 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38961 PyObject *resultobj = 0;
38962 wxMenu *arg1 = (wxMenu *) 0 ;
38963 size_t arg2 ;
38964 int arg3 ;
38965 wxString *arg4 = 0 ;
38966 wxString const &arg5_defvalue = wxPyEmptyString ;
38967 wxString *arg5 = (wxString *) &arg5_defvalue ;
38968 wxMenuItem *result = 0 ;
38969 void *argp1 = 0 ;
38970 int res1 = 0 ;
38971 size_t val2 ;
38972 int ecode2 = 0 ;
38973 int val3 ;
38974 int ecode3 = 0 ;
38975 bool temp4 = false ;
38976 bool temp5 = false ;
38977 PyObject * obj0 = 0 ;
38978 PyObject * obj1 = 0 ;
38979 PyObject * obj2 = 0 ;
38980 PyObject * obj3 = 0 ;
38981 PyObject * obj4 = 0 ;
38982 char * kwnames[] = {
38983 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
38984 };
38985
38986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38988 if (!SWIG_IsOK(res1)) {
38989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38990 }
38991 arg1 = reinterpret_cast< wxMenu * >(argp1);
38992 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38993 if (!SWIG_IsOK(ecode2)) {
38994 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
38995 }
38996 arg2 = static_cast< size_t >(val2);
38997 ecode3 = SWIG_AsVal_int(obj2, &val3);
38998 if (!SWIG_IsOK(ecode3)) {
38999 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39000 }
39001 arg3 = static_cast< int >(val3);
39002 {
39003 arg4 = wxString_in_helper(obj3);
39004 if (arg4 == NULL) SWIG_fail;
39005 temp4 = true;
39006 }
39007 if (obj4) {
39008 {
39009 arg5 = wxString_in_helper(obj4);
39010 if (arg5 == NULL) SWIG_fail;
39011 temp5 = true;
39012 }
39013 }
39014 {
39015 PyThreadState* __tstate = wxPyBeginAllowThreads();
39016 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39017 wxPyEndAllowThreads(__tstate);
39018 if (PyErr_Occurred()) SWIG_fail;
39019 }
39020 {
39021 resultobj = wxPyMake_wxObject(result, (bool)0);
39022 }
39023 {
39024 if (temp4)
39025 delete arg4;
39026 }
39027 {
39028 if (temp5)
39029 delete arg5;
39030 }
39031 return resultobj;
39032 fail:
39033 {
39034 if (temp4)
39035 delete arg4;
39036 }
39037 {
39038 if (temp5)
39039 delete arg5;
39040 }
39041 return NULL;
39042 }
39043
39044
39045 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39046 PyObject *resultobj = 0;
39047 wxMenu *arg1 = (wxMenu *) 0 ;
39048 size_t arg2 ;
39049 int arg3 ;
39050 wxString *arg4 = 0 ;
39051 wxMenu *arg5 = (wxMenu *) 0 ;
39052 wxString const &arg6_defvalue = wxPyEmptyString ;
39053 wxString *arg6 = (wxString *) &arg6_defvalue ;
39054 wxMenuItem *result = 0 ;
39055 void *argp1 = 0 ;
39056 int res1 = 0 ;
39057 size_t val2 ;
39058 int ecode2 = 0 ;
39059 int val3 ;
39060 int ecode3 = 0 ;
39061 bool temp4 = false ;
39062 void *argp5 = 0 ;
39063 int res5 = 0 ;
39064 bool temp6 = false ;
39065 PyObject * obj0 = 0 ;
39066 PyObject * obj1 = 0 ;
39067 PyObject * obj2 = 0 ;
39068 PyObject * obj3 = 0 ;
39069 PyObject * obj4 = 0 ;
39070 PyObject * obj5 = 0 ;
39071 char * kwnames[] = {
39072 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39073 };
39074
39075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39077 if (!SWIG_IsOK(res1)) {
39078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39079 }
39080 arg1 = reinterpret_cast< wxMenu * >(argp1);
39081 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39082 if (!SWIG_IsOK(ecode2)) {
39083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39084 }
39085 arg2 = static_cast< size_t >(val2);
39086 ecode3 = SWIG_AsVal_int(obj2, &val3);
39087 if (!SWIG_IsOK(ecode3)) {
39088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39089 }
39090 arg3 = static_cast< int >(val3);
39091 {
39092 arg4 = wxString_in_helper(obj3);
39093 if (arg4 == NULL) SWIG_fail;
39094 temp4 = true;
39095 }
39096 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39097 if (!SWIG_IsOK(res5)) {
39098 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39099 }
39100 arg5 = reinterpret_cast< wxMenu * >(argp5);
39101 if (obj5) {
39102 {
39103 arg6 = wxString_in_helper(obj5);
39104 if (arg6 == NULL) SWIG_fail;
39105 temp6 = true;
39106 }
39107 }
39108 {
39109 PyThreadState* __tstate = wxPyBeginAllowThreads();
39110 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39111 wxPyEndAllowThreads(__tstate);
39112 if (PyErr_Occurred()) SWIG_fail;
39113 }
39114 {
39115 resultobj = wxPyMake_wxObject(result, (bool)0);
39116 }
39117 {
39118 if (temp4)
39119 delete arg4;
39120 }
39121 {
39122 if (temp6)
39123 delete arg6;
39124 }
39125 return resultobj;
39126 fail:
39127 {
39128 if (temp4)
39129 delete arg4;
39130 }
39131 {
39132 if (temp6)
39133 delete arg6;
39134 }
39135 return NULL;
39136 }
39137
39138
39139 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39140 PyObject *resultobj = 0;
39141 wxMenu *arg1 = (wxMenu *) 0 ;
39142 int arg2 ;
39143 wxString *arg3 = 0 ;
39144 wxString const &arg4_defvalue = wxPyEmptyString ;
39145 wxString *arg4 = (wxString *) &arg4_defvalue ;
39146 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39147 wxMenuItem *result = 0 ;
39148 void *argp1 = 0 ;
39149 int res1 = 0 ;
39150 int val2 ;
39151 int ecode2 = 0 ;
39152 bool temp3 = false ;
39153 bool temp4 = false ;
39154 int val5 ;
39155 int ecode5 = 0 ;
39156 PyObject * obj0 = 0 ;
39157 PyObject * obj1 = 0 ;
39158 PyObject * obj2 = 0 ;
39159 PyObject * obj3 = 0 ;
39160 PyObject * obj4 = 0 ;
39161 char * kwnames[] = {
39162 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39163 };
39164
39165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39167 if (!SWIG_IsOK(res1)) {
39168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39169 }
39170 arg1 = reinterpret_cast< wxMenu * >(argp1);
39171 ecode2 = SWIG_AsVal_int(obj1, &val2);
39172 if (!SWIG_IsOK(ecode2)) {
39173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39174 }
39175 arg2 = static_cast< int >(val2);
39176 {
39177 arg3 = wxString_in_helper(obj2);
39178 if (arg3 == NULL) SWIG_fail;
39179 temp3 = true;
39180 }
39181 if (obj3) {
39182 {
39183 arg4 = wxString_in_helper(obj3);
39184 if (arg4 == NULL) SWIG_fail;
39185 temp4 = true;
39186 }
39187 }
39188 if (obj4) {
39189 ecode5 = SWIG_AsVal_int(obj4, &val5);
39190 if (!SWIG_IsOK(ecode5)) {
39191 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39192 }
39193 arg5 = static_cast< wxItemKind >(val5);
39194 }
39195 {
39196 PyThreadState* __tstate = wxPyBeginAllowThreads();
39197 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39198 wxPyEndAllowThreads(__tstate);
39199 if (PyErr_Occurred()) SWIG_fail;
39200 }
39201 {
39202 resultobj = wxPyMake_wxObject(result, (bool)0);
39203 }
39204 {
39205 if (temp3)
39206 delete arg3;
39207 }
39208 {
39209 if (temp4)
39210 delete arg4;
39211 }
39212 return resultobj;
39213 fail:
39214 {
39215 if (temp3)
39216 delete arg3;
39217 }
39218 {
39219 if (temp4)
39220 delete arg4;
39221 }
39222 return NULL;
39223 }
39224
39225
39226 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39227 PyObject *resultobj = 0;
39228 wxMenu *arg1 = (wxMenu *) 0 ;
39229 wxMenuItem *result = 0 ;
39230 void *argp1 = 0 ;
39231 int res1 = 0 ;
39232 PyObject *swig_obj[1] ;
39233
39234 if (!args) SWIG_fail;
39235 swig_obj[0] = args;
39236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39237 if (!SWIG_IsOK(res1)) {
39238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39239 }
39240 arg1 = reinterpret_cast< wxMenu * >(argp1);
39241 {
39242 PyThreadState* __tstate = wxPyBeginAllowThreads();
39243 result = (wxMenuItem *)(arg1)->PrependSeparator();
39244 wxPyEndAllowThreads(__tstate);
39245 if (PyErr_Occurred()) SWIG_fail;
39246 }
39247 {
39248 resultobj = wxPyMake_wxObject(result, (bool)0);
39249 }
39250 return resultobj;
39251 fail:
39252 return NULL;
39253 }
39254
39255
39256 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39257 PyObject *resultobj = 0;
39258 wxMenu *arg1 = (wxMenu *) 0 ;
39259 int arg2 ;
39260 wxString *arg3 = 0 ;
39261 wxString const &arg4_defvalue = wxPyEmptyString ;
39262 wxString *arg4 = (wxString *) &arg4_defvalue ;
39263 wxMenuItem *result = 0 ;
39264 void *argp1 = 0 ;
39265 int res1 = 0 ;
39266 int val2 ;
39267 int ecode2 = 0 ;
39268 bool temp3 = false ;
39269 bool temp4 = false ;
39270 PyObject * obj0 = 0 ;
39271 PyObject * obj1 = 0 ;
39272 PyObject * obj2 = 0 ;
39273 PyObject * obj3 = 0 ;
39274 char * kwnames[] = {
39275 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39276 };
39277
39278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39279 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39280 if (!SWIG_IsOK(res1)) {
39281 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39282 }
39283 arg1 = reinterpret_cast< wxMenu * >(argp1);
39284 ecode2 = SWIG_AsVal_int(obj1, &val2);
39285 if (!SWIG_IsOK(ecode2)) {
39286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39287 }
39288 arg2 = static_cast< int >(val2);
39289 {
39290 arg3 = wxString_in_helper(obj2);
39291 if (arg3 == NULL) SWIG_fail;
39292 temp3 = true;
39293 }
39294 if (obj3) {
39295 {
39296 arg4 = wxString_in_helper(obj3);
39297 if (arg4 == NULL) SWIG_fail;
39298 temp4 = true;
39299 }
39300 }
39301 {
39302 PyThreadState* __tstate = wxPyBeginAllowThreads();
39303 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39304 wxPyEndAllowThreads(__tstate);
39305 if (PyErr_Occurred()) SWIG_fail;
39306 }
39307 {
39308 resultobj = wxPyMake_wxObject(result, (bool)0);
39309 }
39310 {
39311 if (temp3)
39312 delete arg3;
39313 }
39314 {
39315 if (temp4)
39316 delete arg4;
39317 }
39318 return resultobj;
39319 fail:
39320 {
39321 if (temp3)
39322 delete arg3;
39323 }
39324 {
39325 if (temp4)
39326 delete arg4;
39327 }
39328 return NULL;
39329 }
39330
39331
39332 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39333 PyObject *resultobj = 0;
39334 wxMenu *arg1 = (wxMenu *) 0 ;
39335 int arg2 ;
39336 wxString *arg3 = 0 ;
39337 wxString const &arg4_defvalue = wxPyEmptyString ;
39338 wxString *arg4 = (wxString *) &arg4_defvalue ;
39339 wxMenuItem *result = 0 ;
39340 void *argp1 = 0 ;
39341 int res1 = 0 ;
39342 int val2 ;
39343 int ecode2 = 0 ;
39344 bool temp3 = false ;
39345 bool temp4 = false ;
39346 PyObject * obj0 = 0 ;
39347 PyObject * obj1 = 0 ;
39348 PyObject * obj2 = 0 ;
39349 PyObject * obj3 = 0 ;
39350 char * kwnames[] = {
39351 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39352 };
39353
39354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39356 if (!SWIG_IsOK(res1)) {
39357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39358 }
39359 arg1 = reinterpret_cast< wxMenu * >(argp1);
39360 ecode2 = SWIG_AsVal_int(obj1, &val2);
39361 if (!SWIG_IsOK(ecode2)) {
39362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39363 }
39364 arg2 = static_cast< int >(val2);
39365 {
39366 arg3 = wxString_in_helper(obj2);
39367 if (arg3 == NULL) SWIG_fail;
39368 temp3 = true;
39369 }
39370 if (obj3) {
39371 {
39372 arg4 = wxString_in_helper(obj3);
39373 if (arg4 == NULL) SWIG_fail;
39374 temp4 = true;
39375 }
39376 }
39377 {
39378 PyThreadState* __tstate = wxPyBeginAllowThreads();
39379 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39380 wxPyEndAllowThreads(__tstate);
39381 if (PyErr_Occurred()) SWIG_fail;
39382 }
39383 {
39384 resultobj = wxPyMake_wxObject(result, (bool)0);
39385 }
39386 {
39387 if (temp3)
39388 delete arg3;
39389 }
39390 {
39391 if (temp4)
39392 delete arg4;
39393 }
39394 return resultobj;
39395 fail:
39396 {
39397 if (temp3)
39398 delete arg3;
39399 }
39400 {
39401 if (temp4)
39402 delete arg4;
39403 }
39404 return NULL;
39405 }
39406
39407
39408 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39409 PyObject *resultobj = 0;
39410 wxMenu *arg1 = (wxMenu *) 0 ;
39411 int arg2 ;
39412 wxString *arg3 = 0 ;
39413 wxMenu *arg4 = (wxMenu *) 0 ;
39414 wxString const &arg5_defvalue = wxPyEmptyString ;
39415 wxString *arg5 = (wxString *) &arg5_defvalue ;
39416 wxMenuItem *result = 0 ;
39417 void *argp1 = 0 ;
39418 int res1 = 0 ;
39419 int val2 ;
39420 int ecode2 = 0 ;
39421 bool temp3 = false ;
39422 void *argp4 = 0 ;
39423 int res4 = 0 ;
39424 bool temp5 = false ;
39425 PyObject * obj0 = 0 ;
39426 PyObject * obj1 = 0 ;
39427 PyObject * obj2 = 0 ;
39428 PyObject * obj3 = 0 ;
39429 PyObject * obj4 = 0 ;
39430 char * kwnames[] = {
39431 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39432 };
39433
39434 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39435 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39436 if (!SWIG_IsOK(res1)) {
39437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39438 }
39439 arg1 = reinterpret_cast< wxMenu * >(argp1);
39440 ecode2 = SWIG_AsVal_int(obj1, &val2);
39441 if (!SWIG_IsOK(ecode2)) {
39442 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39443 }
39444 arg2 = static_cast< int >(val2);
39445 {
39446 arg3 = wxString_in_helper(obj2);
39447 if (arg3 == NULL) SWIG_fail;
39448 temp3 = true;
39449 }
39450 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39451 if (!SWIG_IsOK(res4)) {
39452 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39453 }
39454 arg4 = reinterpret_cast< wxMenu * >(argp4);
39455 if (obj4) {
39456 {
39457 arg5 = wxString_in_helper(obj4);
39458 if (arg5 == NULL) SWIG_fail;
39459 temp5 = true;
39460 }
39461 }
39462 {
39463 PyThreadState* __tstate = wxPyBeginAllowThreads();
39464 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39465 wxPyEndAllowThreads(__tstate);
39466 if (PyErr_Occurred()) SWIG_fail;
39467 }
39468 {
39469 resultobj = wxPyMake_wxObject(result, (bool)0);
39470 }
39471 {
39472 if (temp3)
39473 delete arg3;
39474 }
39475 {
39476 if (temp5)
39477 delete arg5;
39478 }
39479 return resultobj;
39480 fail:
39481 {
39482 if (temp3)
39483 delete arg3;
39484 }
39485 {
39486 if (temp5)
39487 delete arg5;
39488 }
39489 return NULL;
39490 }
39491
39492
39493 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39494 PyObject *resultobj = 0;
39495 wxMenu *arg1 = (wxMenu *) 0 ;
39496 int arg2 ;
39497 wxMenuItem *result = 0 ;
39498 void *argp1 = 0 ;
39499 int res1 = 0 ;
39500 int val2 ;
39501 int ecode2 = 0 ;
39502 PyObject * obj0 = 0 ;
39503 PyObject * obj1 = 0 ;
39504 char * kwnames[] = {
39505 (char *) "self",(char *) "id", NULL
39506 };
39507
39508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39510 if (!SWIG_IsOK(res1)) {
39511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39512 }
39513 arg1 = reinterpret_cast< wxMenu * >(argp1);
39514 ecode2 = SWIG_AsVal_int(obj1, &val2);
39515 if (!SWIG_IsOK(ecode2)) {
39516 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39517 }
39518 arg2 = static_cast< int >(val2);
39519 {
39520 PyThreadState* __tstate = wxPyBeginAllowThreads();
39521 result = (wxMenuItem *)(arg1)->Remove(arg2);
39522 wxPyEndAllowThreads(__tstate);
39523 if (PyErr_Occurred()) SWIG_fail;
39524 }
39525 {
39526 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39527 }
39528 return resultobj;
39529 fail:
39530 return NULL;
39531 }
39532
39533
39534 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39535 PyObject *resultobj = 0;
39536 wxMenu *arg1 = (wxMenu *) 0 ;
39537 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39538 wxMenuItem *result = 0 ;
39539 void *argp1 = 0 ;
39540 int res1 = 0 ;
39541 void *argp2 = 0 ;
39542 int res2 = 0 ;
39543 PyObject * obj0 = 0 ;
39544 PyObject * obj1 = 0 ;
39545 char * kwnames[] = {
39546 (char *) "self",(char *) "item", NULL
39547 };
39548
39549 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39550 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39551 if (!SWIG_IsOK(res1)) {
39552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39553 }
39554 arg1 = reinterpret_cast< wxMenu * >(argp1);
39555 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39556 if (!SWIG_IsOK(res2)) {
39557 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39558 }
39559 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39560 {
39561 PyThreadState* __tstate = wxPyBeginAllowThreads();
39562 result = (wxMenuItem *)(arg1)->Remove(arg2);
39563 wxPyEndAllowThreads(__tstate);
39564 if (PyErr_Occurred()) SWIG_fail;
39565 }
39566 {
39567 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39568 }
39569 return resultobj;
39570 fail:
39571 return NULL;
39572 }
39573
39574
39575 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39576 PyObject *resultobj = 0;
39577 wxMenu *arg1 = (wxMenu *) 0 ;
39578 int arg2 ;
39579 bool result;
39580 void *argp1 = 0 ;
39581 int res1 = 0 ;
39582 int val2 ;
39583 int ecode2 = 0 ;
39584 PyObject * obj0 = 0 ;
39585 PyObject * obj1 = 0 ;
39586 char * kwnames[] = {
39587 (char *) "self",(char *) "id", NULL
39588 };
39589
39590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39592 if (!SWIG_IsOK(res1)) {
39593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39594 }
39595 arg1 = reinterpret_cast< wxMenu * >(argp1);
39596 ecode2 = SWIG_AsVal_int(obj1, &val2);
39597 if (!SWIG_IsOK(ecode2)) {
39598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39599 }
39600 arg2 = static_cast< int >(val2);
39601 {
39602 PyThreadState* __tstate = wxPyBeginAllowThreads();
39603 result = (bool)(arg1)->Delete(arg2);
39604 wxPyEndAllowThreads(__tstate);
39605 if (PyErr_Occurred()) SWIG_fail;
39606 }
39607 {
39608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39609 }
39610 return resultobj;
39611 fail:
39612 return NULL;
39613 }
39614
39615
39616 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39617 PyObject *resultobj = 0;
39618 wxMenu *arg1 = (wxMenu *) 0 ;
39619 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39620 bool result;
39621 void *argp1 = 0 ;
39622 int res1 = 0 ;
39623 void *argp2 = 0 ;
39624 int res2 = 0 ;
39625 PyObject * obj0 = 0 ;
39626 PyObject * obj1 = 0 ;
39627 char * kwnames[] = {
39628 (char *) "self",(char *) "item", NULL
39629 };
39630
39631 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39632 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39633 if (!SWIG_IsOK(res1)) {
39634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39635 }
39636 arg1 = reinterpret_cast< wxMenu * >(argp1);
39637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39638 if (!SWIG_IsOK(res2)) {
39639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39640 }
39641 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39642 {
39643 PyThreadState* __tstate = wxPyBeginAllowThreads();
39644 result = (bool)(arg1)->Delete(arg2);
39645 wxPyEndAllowThreads(__tstate);
39646 if (PyErr_Occurred()) SWIG_fail;
39647 }
39648 {
39649 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39650 }
39651 return resultobj;
39652 fail:
39653 return NULL;
39654 }
39655
39656
39657 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39658 PyObject *resultobj = 0;
39659 wxMenu *arg1 = (wxMenu *) 0 ;
39660 void *argp1 = 0 ;
39661 int res1 = 0 ;
39662 PyObject *swig_obj[1] ;
39663
39664 if (!args) SWIG_fail;
39665 swig_obj[0] = args;
39666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39667 if (!SWIG_IsOK(res1)) {
39668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39669 }
39670 arg1 = reinterpret_cast< wxMenu * >(argp1);
39671 {
39672 PyThreadState* __tstate = wxPyBeginAllowThreads();
39673 wxMenu_Destroy(arg1);
39674 wxPyEndAllowThreads(__tstate);
39675 if (PyErr_Occurred()) SWIG_fail;
39676 }
39677 resultobj = SWIG_Py_Void();
39678 return resultobj;
39679 fail:
39680 return NULL;
39681 }
39682
39683
39684 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39685 PyObject *resultobj = 0;
39686 wxMenu *arg1 = (wxMenu *) 0 ;
39687 int arg2 ;
39688 bool result;
39689 void *argp1 = 0 ;
39690 int res1 = 0 ;
39691 int val2 ;
39692 int ecode2 = 0 ;
39693 PyObject * obj0 = 0 ;
39694 PyObject * obj1 = 0 ;
39695 char * kwnames[] = {
39696 (char *) "self",(char *) "id", NULL
39697 };
39698
39699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39701 if (!SWIG_IsOK(res1)) {
39702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39703 }
39704 arg1 = reinterpret_cast< wxMenu * >(argp1);
39705 ecode2 = SWIG_AsVal_int(obj1, &val2);
39706 if (!SWIG_IsOK(ecode2)) {
39707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39708 }
39709 arg2 = static_cast< int >(val2);
39710 {
39711 PyThreadState* __tstate = wxPyBeginAllowThreads();
39712 result = (bool)(arg1)->Destroy(arg2);
39713 wxPyEndAllowThreads(__tstate);
39714 if (PyErr_Occurred()) SWIG_fail;
39715 }
39716 {
39717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39718 }
39719 return resultobj;
39720 fail:
39721 return NULL;
39722 }
39723
39724
39725 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39726 PyObject *resultobj = 0;
39727 wxMenu *arg1 = (wxMenu *) 0 ;
39728 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39729 bool result;
39730 void *argp1 = 0 ;
39731 int res1 = 0 ;
39732 void *argp2 = 0 ;
39733 int res2 = 0 ;
39734 PyObject * obj0 = 0 ;
39735 PyObject * obj1 = 0 ;
39736 char * kwnames[] = {
39737 (char *) "self",(char *) "item", NULL
39738 };
39739
39740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39742 if (!SWIG_IsOK(res1)) {
39743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39744 }
39745 arg1 = reinterpret_cast< wxMenu * >(argp1);
39746 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39747 if (!SWIG_IsOK(res2)) {
39748 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39749 }
39750 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39751 {
39752 PyThreadState* __tstate = wxPyBeginAllowThreads();
39753 result = (bool)(arg1)->Destroy(arg2);
39754 wxPyEndAllowThreads(__tstate);
39755 if (PyErr_Occurred()) SWIG_fail;
39756 }
39757 {
39758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39759 }
39760 return resultobj;
39761 fail:
39762 return NULL;
39763 }
39764
39765
39766 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39767 PyObject *resultobj = 0;
39768 wxMenu *arg1 = (wxMenu *) 0 ;
39769 size_t result;
39770 void *argp1 = 0 ;
39771 int res1 = 0 ;
39772 PyObject *swig_obj[1] ;
39773
39774 if (!args) SWIG_fail;
39775 swig_obj[0] = args;
39776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39777 if (!SWIG_IsOK(res1)) {
39778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39779 }
39780 arg1 = reinterpret_cast< wxMenu * >(argp1);
39781 {
39782 PyThreadState* __tstate = wxPyBeginAllowThreads();
39783 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39784 wxPyEndAllowThreads(__tstate);
39785 if (PyErr_Occurred()) SWIG_fail;
39786 }
39787 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39788 return resultobj;
39789 fail:
39790 return NULL;
39791 }
39792
39793
39794 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39795 PyObject *resultobj = 0;
39796 wxMenu *arg1 = (wxMenu *) 0 ;
39797 PyObject *result = 0 ;
39798 void *argp1 = 0 ;
39799 int res1 = 0 ;
39800 PyObject *swig_obj[1] ;
39801
39802 if (!args) SWIG_fail;
39803 swig_obj[0] = args;
39804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39805 if (!SWIG_IsOK(res1)) {
39806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39807 }
39808 arg1 = reinterpret_cast< wxMenu * >(argp1);
39809 {
39810 PyThreadState* __tstate = wxPyBeginAllowThreads();
39811 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39812 wxPyEndAllowThreads(__tstate);
39813 if (PyErr_Occurred()) SWIG_fail;
39814 }
39815 resultobj = result;
39816 return resultobj;
39817 fail:
39818 return NULL;
39819 }
39820
39821
39822 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39823 PyObject *resultobj = 0;
39824 wxMenu *arg1 = (wxMenu *) 0 ;
39825 wxString *arg2 = 0 ;
39826 int result;
39827 void *argp1 = 0 ;
39828 int res1 = 0 ;
39829 bool temp2 = false ;
39830 PyObject * obj0 = 0 ;
39831 PyObject * obj1 = 0 ;
39832 char * kwnames[] = {
39833 (char *) "self",(char *) "item", NULL
39834 };
39835
39836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
39837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39838 if (!SWIG_IsOK(res1)) {
39839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
39840 }
39841 arg1 = reinterpret_cast< wxMenu * >(argp1);
39842 {
39843 arg2 = wxString_in_helper(obj1);
39844 if (arg2 == NULL) SWIG_fail;
39845 temp2 = true;
39846 }
39847 {
39848 PyThreadState* __tstate = wxPyBeginAllowThreads();
39849 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
39850 wxPyEndAllowThreads(__tstate);
39851 if (PyErr_Occurred()) SWIG_fail;
39852 }
39853 resultobj = SWIG_From_int(static_cast< int >(result));
39854 {
39855 if (temp2)
39856 delete arg2;
39857 }
39858 return resultobj;
39859 fail:
39860 {
39861 if (temp2)
39862 delete arg2;
39863 }
39864 return NULL;
39865 }
39866
39867
39868 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39869 PyObject *resultobj = 0;
39870 wxMenu *arg1 = (wxMenu *) 0 ;
39871 int arg2 ;
39872 wxMenuItem *result = 0 ;
39873 void *argp1 = 0 ;
39874 int res1 = 0 ;
39875 int val2 ;
39876 int ecode2 = 0 ;
39877 PyObject * obj0 = 0 ;
39878 PyObject * obj1 = 0 ;
39879 char * kwnames[] = {
39880 (char *) "self",(char *) "id", NULL
39881 };
39882
39883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
39884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39885 if (!SWIG_IsOK(res1)) {
39886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
39887 }
39888 arg1 = reinterpret_cast< wxMenu * >(argp1);
39889 ecode2 = SWIG_AsVal_int(obj1, &val2);
39890 if (!SWIG_IsOK(ecode2)) {
39891 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
39892 }
39893 arg2 = static_cast< int >(val2);
39894 {
39895 PyThreadState* __tstate = wxPyBeginAllowThreads();
39896 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
39897 wxPyEndAllowThreads(__tstate);
39898 if (PyErr_Occurred()) SWIG_fail;
39899 }
39900 {
39901 resultobj = wxPyMake_wxObject(result, (bool)0);
39902 }
39903 return resultobj;
39904 fail:
39905 return NULL;
39906 }
39907
39908
39909 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39910 PyObject *resultobj = 0;
39911 wxMenu *arg1 = (wxMenu *) 0 ;
39912 size_t arg2 ;
39913 wxMenuItem *result = 0 ;
39914 void *argp1 = 0 ;
39915 int res1 = 0 ;
39916 size_t val2 ;
39917 int ecode2 = 0 ;
39918 PyObject * obj0 = 0 ;
39919 PyObject * obj1 = 0 ;
39920 char * kwnames[] = {
39921 (char *) "self",(char *) "position", NULL
39922 };
39923
39924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
39925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39926 if (!SWIG_IsOK(res1)) {
39927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
39928 }
39929 arg1 = reinterpret_cast< wxMenu * >(argp1);
39930 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39931 if (!SWIG_IsOK(ecode2)) {
39932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
39933 }
39934 arg2 = static_cast< size_t >(val2);
39935 {
39936 PyThreadState* __tstate = wxPyBeginAllowThreads();
39937 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
39938 wxPyEndAllowThreads(__tstate);
39939 if (PyErr_Occurred()) SWIG_fail;
39940 }
39941 {
39942 resultobj = wxPyMake_wxObject(result, (bool)0);
39943 }
39944 return resultobj;
39945 fail:
39946 return NULL;
39947 }
39948
39949
39950 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39951 PyObject *resultobj = 0;
39952 wxMenu *arg1 = (wxMenu *) 0 ;
39953 int arg2 ;
39954 bool arg3 ;
39955 void *argp1 = 0 ;
39956 int res1 = 0 ;
39957 int val2 ;
39958 int ecode2 = 0 ;
39959 bool val3 ;
39960 int ecode3 = 0 ;
39961 PyObject * obj0 = 0 ;
39962 PyObject * obj1 = 0 ;
39963 PyObject * obj2 = 0 ;
39964 char * kwnames[] = {
39965 (char *) "self",(char *) "id",(char *) "enable", NULL
39966 };
39967
39968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
39972 }
39973 arg1 = reinterpret_cast< wxMenu * >(argp1);
39974 ecode2 = SWIG_AsVal_int(obj1, &val2);
39975 if (!SWIG_IsOK(ecode2)) {
39976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
39977 }
39978 arg2 = static_cast< int >(val2);
39979 ecode3 = SWIG_AsVal_bool(obj2, &val3);
39980 if (!SWIG_IsOK(ecode3)) {
39981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
39982 }
39983 arg3 = static_cast< bool >(val3);
39984 {
39985 PyThreadState* __tstate = wxPyBeginAllowThreads();
39986 (arg1)->Enable(arg2,arg3);
39987 wxPyEndAllowThreads(__tstate);
39988 if (PyErr_Occurred()) SWIG_fail;
39989 }
39990 resultobj = SWIG_Py_Void();
39991 return resultobj;
39992 fail:
39993 return NULL;
39994 }
39995
39996
39997 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39998 PyObject *resultobj = 0;
39999 wxMenu *arg1 = (wxMenu *) 0 ;
40000 int arg2 ;
40001 bool result;
40002 void *argp1 = 0 ;
40003 int res1 = 0 ;
40004 int val2 ;
40005 int ecode2 = 0 ;
40006 PyObject * obj0 = 0 ;
40007 PyObject * obj1 = 0 ;
40008 char * kwnames[] = {
40009 (char *) "self",(char *) "id", NULL
40010 };
40011
40012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40014 if (!SWIG_IsOK(res1)) {
40015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40016 }
40017 arg1 = reinterpret_cast< wxMenu * >(argp1);
40018 ecode2 = SWIG_AsVal_int(obj1, &val2);
40019 if (!SWIG_IsOK(ecode2)) {
40020 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40021 }
40022 arg2 = static_cast< int >(val2);
40023 {
40024 PyThreadState* __tstate = wxPyBeginAllowThreads();
40025 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40026 wxPyEndAllowThreads(__tstate);
40027 if (PyErr_Occurred()) SWIG_fail;
40028 }
40029 {
40030 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40031 }
40032 return resultobj;
40033 fail:
40034 return NULL;
40035 }
40036
40037
40038 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40039 PyObject *resultobj = 0;
40040 wxMenu *arg1 = (wxMenu *) 0 ;
40041 int arg2 ;
40042 bool arg3 ;
40043 void *argp1 = 0 ;
40044 int res1 = 0 ;
40045 int val2 ;
40046 int ecode2 = 0 ;
40047 bool val3 ;
40048 int ecode3 = 0 ;
40049 PyObject * obj0 = 0 ;
40050 PyObject * obj1 = 0 ;
40051 PyObject * obj2 = 0 ;
40052 char * kwnames[] = {
40053 (char *) "self",(char *) "id",(char *) "check", NULL
40054 };
40055
40056 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40057 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40058 if (!SWIG_IsOK(res1)) {
40059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40060 }
40061 arg1 = reinterpret_cast< wxMenu * >(argp1);
40062 ecode2 = SWIG_AsVal_int(obj1, &val2);
40063 if (!SWIG_IsOK(ecode2)) {
40064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40065 }
40066 arg2 = static_cast< int >(val2);
40067 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40068 if (!SWIG_IsOK(ecode3)) {
40069 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40070 }
40071 arg3 = static_cast< bool >(val3);
40072 {
40073 PyThreadState* __tstate = wxPyBeginAllowThreads();
40074 (arg1)->Check(arg2,arg3);
40075 wxPyEndAllowThreads(__tstate);
40076 if (PyErr_Occurred()) SWIG_fail;
40077 }
40078 resultobj = SWIG_Py_Void();
40079 return resultobj;
40080 fail:
40081 return NULL;
40082 }
40083
40084
40085 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40086 PyObject *resultobj = 0;
40087 wxMenu *arg1 = (wxMenu *) 0 ;
40088 int arg2 ;
40089 bool result;
40090 void *argp1 = 0 ;
40091 int res1 = 0 ;
40092 int val2 ;
40093 int ecode2 = 0 ;
40094 PyObject * obj0 = 0 ;
40095 PyObject * obj1 = 0 ;
40096 char * kwnames[] = {
40097 (char *) "self",(char *) "id", NULL
40098 };
40099
40100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40102 if (!SWIG_IsOK(res1)) {
40103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40104 }
40105 arg1 = reinterpret_cast< wxMenu * >(argp1);
40106 ecode2 = SWIG_AsVal_int(obj1, &val2);
40107 if (!SWIG_IsOK(ecode2)) {
40108 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40109 }
40110 arg2 = static_cast< int >(val2);
40111 {
40112 PyThreadState* __tstate = wxPyBeginAllowThreads();
40113 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40114 wxPyEndAllowThreads(__tstate);
40115 if (PyErr_Occurred()) SWIG_fail;
40116 }
40117 {
40118 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40119 }
40120 return resultobj;
40121 fail:
40122 return NULL;
40123 }
40124
40125
40126 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40127 PyObject *resultobj = 0;
40128 wxMenu *arg1 = (wxMenu *) 0 ;
40129 int arg2 ;
40130 wxString *arg3 = 0 ;
40131 void *argp1 = 0 ;
40132 int res1 = 0 ;
40133 int val2 ;
40134 int ecode2 = 0 ;
40135 bool temp3 = false ;
40136 PyObject * obj0 = 0 ;
40137 PyObject * obj1 = 0 ;
40138 PyObject * obj2 = 0 ;
40139 char * kwnames[] = {
40140 (char *) "self",(char *) "id",(char *) "label", NULL
40141 };
40142
40143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40145 if (!SWIG_IsOK(res1)) {
40146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40147 }
40148 arg1 = reinterpret_cast< wxMenu * >(argp1);
40149 ecode2 = SWIG_AsVal_int(obj1, &val2);
40150 if (!SWIG_IsOK(ecode2)) {
40151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40152 }
40153 arg2 = static_cast< int >(val2);
40154 {
40155 arg3 = wxString_in_helper(obj2);
40156 if (arg3 == NULL) SWIG_fail;
40157 temp3 = true;
40158 }
40159 {
40160 PyThreadState* __tstate = wxPyBeginAllowThreads();
40161 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40162 wxPyEndAllowThreads(__tstate);
40163 if (PyErr_Occurred()) SWIG_fail;
40164 }
40165 resultobj = SWIG_Py_Void();
40166 {
40167 if (temp3)
40168 delete arg3;
40169 }
40170 return resultobj;
40171 fail:
40172 {
40173 if (temp3)
40174 delete arg3;
40175 }
40176 return NULL;
40177 }
40178
40179
40180 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40181 PyObject *resultobj = 0;
40182 wxMenu *arg1 = (wxMenu *) 0 ;
40183 int arg2 ;
40184 wxString result;
40185 void *argp1 = 0 ;
40186 int res1 = 0 ;
40187 int val2 ;
40188 int ecode2 = 0 ;
40189 PyObject * obj0 = 0 ;
40190 PyObject * obj1 = 0 ;
40191 char * kwnames[] = {
40192 (char *) "self",(char *) "id", NULL
40193 };
40194
40195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40197 if (!SWIG_IsOK(res1)) {
40198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40199 }
40200 arg1 = reinterpret_cast< wxMenu * >(argp1);
40201 ecode2 = SWIG_AsVal_int(obj1, &val2);
40202 if (!SWIG_IsOK(ecode2)) {
40203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40204 }
40205 arg2 = static_cast< int >(val2);
40206 {
40207 PyThreadState* __tstate = wxPyBeginAllowThreads();
40208 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40209 wxPyEndAllowThreads(__tstate);
40210 if (PyErr_Occurred()) SWIG_fail;
40211 }
40212 {
40213 #if wxUSE_UNICODE
40214 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40215 #else
40216 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40217 #endif
40218 }
40219 return resultobj;
40220 fail:
40221 return NULL;
40222 }
40223
40224
40225 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40226 PyObject *resultobj = 0;
40227 wxMenu *arg1 = (wxMenu *) 0 ;
40228 int arg2 ;
40229 wxString *arg3 = 0 ;
40230 void *argp1 = 0 ;
40231 int res1 = 0 ;
40232 int val2 ;
40233 int ecode2 = 0 ;
40234 bool temp3 = false ;
40235 PyObject * obj0 = 0 ;
40236 PyObject * obj1 = 0 ;
40237 PyObject * obj2 = 0 ;
40238 char * kwnames[] = {
40239 (char *) "self",(char *) "id",(char *) "helpString", NULL
40240 };
40241
40242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40244 if (!SWIG_IsOK(res1)) {
40245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40246 }
40247 arg1 = reinterpret_cast< wxMenu * >(argp1);
40248 ecode2 = SWIG_AsVal_int(obj1, &val2);
40249 if (!SWIG_IsOK(ecode2)) {
40250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40251 }
40252 arg2 = static_cast< int >(val2);
40253 {
40254 arg3 = wxString_in_helper(obj2);
40255 if (arg3 == NULL) SWIG_fail;
40256 temp3 = true;
40257 }
40258 {
40259 PyThreadState* __tstate = wxPyBeginAllowThreads();
40260 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40261 wxPyEndAllowThreads(__tstate);
40262 if (PyErr_Occurred()) SWIG_fail;
40263 }
40264 resultobj = SWIG_Py_Void();
40265 {
40266 if (temp3)
40267 delete arg3;
40268 }
40269 return resultobj;
40270 fail:
40271 {
40272 if (temp3)
40273 delete arg3;
40274 }
40275 return NULL;
40276 }
40277
40278
40279 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40280 PyObject *resultobj = 0;
40281 wxMenu *arg1 = (wxMenu *) 0 ;
40282 int arg2 ;
40283 wxString result;
40284 void *argp1 = 0 ;
40285 int res1 = 0 ;
40286 int val2 ;
40287 int ecode2 = 0 ;
40288 PyObject * obj0 = 0 ;
40289 PyObject * obj1 = 0 ;
40290 char * kwnames[] = {
40291 (char *) "self",(char *) "id", NULL
40292 };
40293
40294 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40295 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40296 if (!SWIG_IsOK(res1)) {
40297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40298 }
40299 arg1 = reinterpret_cast< wxMenu * >(argp1);
40300 ecode2 = SWIG_AsVal_int(obj1, &val2);
40301 if (!SWIG_IsOK(ecode2)) {
40302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40303 }
40304 arg2 = static_cast< int >(val2);
40305 {
40306 PyThreadState* __tstate = wxPyBeginAllowThreads();
40307 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40308 wxPyEndAllowThreads(__tstate);
40309 if (PyErr_Occurred()) SWIG_fail;
40310 }
40311 {
40312 #if wxUSE_UNICODE
40313 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40314 #else
40315 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40316 #endif
40317 }
40318 return resultobj;
40319 fail:
40320 return NULL;
40321 }
40322
40323
40324 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40325 PyObject *resultobj = 0;
40326 wxMenu *arg1 = (wxMenu *) 0 ;
40327 wxString *arg2 = 0 ;
40328 void *argp1 = 0 ;
40329 int res1 = 0 ;
40330 bool temp2 = false ;
40331 PyObject * obj0 = 0 ;
40332 PyObject * obj1 = 0 ;
40333 char * kwnames[] = {
40334 (char *) "self",(char *) "title", NULL
40335 };
40336
40337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40339 if (!SWIG_IsOK(res1)) {
40340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40341 }
40342 arg1 = reinterpret_cast< wxMenu * >(argp1);
40343 {
40344 arg2 = wxString_in_helper(obj1);
40345 if (arg2 == NULL) SWIG_fail;
40346 temp2 = true;
40347 }
40348 {
40349 PyThreadState* __tstate = wxPyBeginAllowThreads();
40350 (arg1)->SetTitle((wxString const &)*arg2);
40351 wxPyEndAllowThreads(__tstate);
40352 if (PyErr_Occurred()) SWIG_fail;
40353 }
40354 resultobj = SWIG_Py_Void();
40355 {
40356 if (temp2)
40357 delete arg2;
40358 }
40359 return resultobj;
40360 fail:
40361 {
40362 if (temp2)
40363 delete arg2;
40364 }
40365 return NULL;
40366 }
40367
40368
40369 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40370 PyObject *resultobj = 0;
40371 wxMenu *arg1 = (wxMenu *) 0 ;
40372 wxString result;
40373 void *argp1 = 0 ;
40374 int res1 = 0 ;
40375 PyObject *swig_obj[1] ;
40376
40377 if (!args) SWIG_fail;
40378 swig_obj[0] = args;
40379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40380 if (!SWIG_IsOK(res1)) {
40381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40382 }
40383 arg1 = reinterpret_cast< wxMenu * >(argp1);
40384 {
40385 PyThreadState* __tstate = wxPyBeginAllowThreads();
40386 result = ((wxMenu const *)arg1)->GetTitle();
40387 wxPyEndAllowThreads(__tstate);
40388 if (PyErr_Occurred()) SWIG_fail;
40389 }
40390 {
40391 #if wxUSE_UNICODE
40392 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40393 #else
40394 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40395 #endif
40396 }
40397 return resultobj;
40398 fail:
40399 return NULL;
40400 }
40401
40402
40403 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40404 PyObject *resultobj = 0;
40405 wxMenu *arg1 = (wxMenu *) 0 ;
40406 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40407 void *argp1 = 0 ;
40408 int res1 = 0 ;
40409 void *argp2 = 0 ;
40410 int res2 = 0 ;
40411 PyObject * obj0 = 0 ;
40412 PyObject * obj1 = 0 ;
40413 char * kwnames[] = {
40414 (char *) "self",(char *) "handler", NULL
40415 };
40416
40417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40418 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40419 if (!SWIG_IsOK(res1)) {
40420 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40421 }
40422 arg1 = reinterpret_cast< wxMenu * >(argp1);
40423 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40424 if (!SWIG_IsOK(res2)) {
40425 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40426 }
40427 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40428 {
40429 PyThreadState* __tstate = wxPyBeginAllowThreads();
40430 (arg1)->SetEventHandler(arg2);
40431 wxPyEndAllowThreads(__tstate);
40432 if (PyErr_Occurred()) SWIG_fail;
40433 }
40434 resultobj = SWIG_Py_Void();
40435 return resultobj;
40436 fail:
40437 return NULL;
40438 }
40439
40440
40441 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40442 PyObject *resultobj = 0;
40443 wxMenu *arg1 = (wxMenu *) 0 ;
40444 wxEvtHandler *result = 0 ;
40445 void *argp1 = 0 ;
40446 int res1 = 0 ;
40447 PyObject *swig_obj[1] ;
40448
40449 if (!args) SWIG_fail;
40450 swig_obj[0] = args;
40451 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40452 if (!SWIG_IsOK(res1)) {
40453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40454 }
40455 arg1 = reinterpret_cast< wxMenu * >(argp1);
40456 {
40457 PyThreadState* __tstate = wxPyBeginAllowThreads();
40458 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40459 wxPyEndAllowThreads(__tstate);
40460 if (PyErr_Occurred()) SWIG_fail;
40461 }
40462 {
40463 resultobj = wxPyMake_wxObject(result, 0);
40464 }
40465 return resultobj;
40466 fail:
40467 return NULL;
40468 }
40469
40470
40471 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40472 PyObject *resultobj = 0;
40473 wxMenu *arg1 = (wxMenu *) 0 ;
40474 wxWindow *arg2 = (wxWindow *) 0 ;
40475 void *argp1 = 0 ;
40476 int res1 = 0 ;
40477 void *argp2 = 0 ;
40478 int res2 = 0 ;
40479 PyObject * obj0 = 0 ;
40480 PyObject * obj1 = 0 ;
40481 char * kwnames[] = {
40482 (char *) "self",(char *) "win", NULL
40483 };
40484
40485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40487 if (!SWIG_IsOK(res1)) {
40488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40489 }
40490 arg1 = reinterpret_cast< wxMenu * >(argp1);
40491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40492 if (!SWIG_IsOK(res2)) {
40493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40494 }
40495 arg2 = reinterpret_cast< wxWindow * >(argp2);
40496 {
40497 PyThreadState* __tstate = wxPyBeginAllowThreads();
40498 (arg1)->SetInvokingWindow(arg2);
40499 wxPyEndAllowThreads(__tstate);
40500 if (PyErr_Occurred()) SWIG_fail;
40501 }
40502 resultobj = SWIG_Py_Void();
40503 return resultobj;
40504 fail:
40505 return NULL;
40506 }
40507
40508
40509 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40510 PyObject *resultobj = 0;
40511 wxMenu *arg1 = (wxMenu *) 0 ;
40512 wxWindow *result = 0 ;
40513 void *argp1 = 0 ;
40514 int res1 = 0 ;
40515 PyObject *swig_obj[1] ;
40516
40517 if (!args) SWIG_fail;
40518 swig_obj[0] = args;
40519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40520 if (!SWIG_IsOK(res1)) {
40521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40522 }
40523 arg1 = reinterpret_cast< wxMenu * >(argp1);
40524 {
40525 PyThreadState* __tstate = wxPyBeginAllowThreads();
40526 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40527 wxPyEndAllowThreads(__tstate);
40528 if (PyErr_Occurred()) SWIG_fail;
40529 }
40530 {
40531 resultobj = wxPyMake_wxObject(result, 0);
40532 }
40533 return resultobj;
40534 fail:
40535 return NULL;
40536 }
40537
40538
40539 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40540 PyObject *resultobj = 0;
40541 wxMenu *arg1 = (wxMenu *) 0 ;
40542 long result;
40543 void *argp1 = 0 ;
40544 int res1 = 0 ;
40545 PyObject *swig_obj[1] ;
40546
40547 if (!args) SWIG_fail;
40548 swig_obj[0] = args;
40549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40550 if (!SWIG_IsOK(res1)) {
40551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40552 }
40553 arg1 = reinterpret_cast< wxMenu * >(argp1);
40554 {
40555 PyThreadState* __tstate = wxPyBeginAllowThreads();
40556 result = (long)((wxMenu const *)arg1)->GetStyle();
40557 wxPyEndAllowThreads(__tstate);
40558 if (PyErr_Occurred()) SWIG_fail;
40559 }
40560 resultobj = SWIG_From_long(static_cast< long >(result));
40561 return resultobj;
40562 fail:
40563 return NULL;
40564 }
40565
40566
40567 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40568 PyObject *resultobj = 0;
40569 wxMenu *arg1 = (wxMenu *) 0 ;
40570 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40571 void *argp1 = 0 ;
40572 int res1 = 0 ;
40573 void *argp2 = 0 ;
40574 int res2 = 0 ;
40575 PyObject * obj0 = 0 ;
40576 PyObject * obj1 = 0 ;
40577 char * kwnames[] = {
40578 (char *) "self",(char *) "source", NULL
40579 };
40580
40581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40583 if (!SWIG_IsOK(res1)) {
40584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40585 }
40586 arg1 = reinterpret_cast< wxMenu * >(argp1);
40587 if (obj1) {
40588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40589 if (!SWIG_IsOK(res2)) {
40590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40591 }
40592 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40593 }
40594 {
40595 PyThreadState* __tstate = wxPyBeginAllowThreads();
40596 (arg1)->UpdateUI(arg2);
40597 wxPyEndAllowThreads(__tstate);
40598 if (PyErr_Occurred()) SWIG_fail;
40599 }
40600 resultobj = SWIG_Py_Void();
40601 return resultobj;
40602 fail:
40603 return NULL;
40604 }
40605
40606
40607 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40608 PyObject *resultobj = 0;
40609 wxMenu *arg1 = (wxMenu *) 0 ;
40610 wxMenuBar *result = 0 ;
40611 void *argp1 = 0 ;
40612 int res1 = 0 ;
40613 PyObject *swig_obj[1] ;
40614
40615 if (!args) SWIG_fail;
40616 swig_obj[0] = args;
40617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40618 if (!SWIG_IsOK(res1)) {
40619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40620 }
40621 arg1 = reinterpret_cast< wxMenu * >(argp1);
40622 {
40623 PyThreadState* __tstate = wxPyBeginAllowThreads();
40624 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40625 wxPyEndAllowThreads(__tstate);
40626 if (PyErr_Occurred()) SWIG_fail;
40627 }
40628 {
40629 resultobj = wxPyMake_wxObject(result, (bool)0);
40630 }
40631 return resultobj;
40632 fail:
40633 return NULL;
40634 }
40635
40636
40637 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40638 PyObject *resultobj = 0;
40639 wxMenu *arg1 = (wxMenu *) 0 ;
40640 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40641 void *argp1 = 0 ;
40642 int res1 = 0 ;
40643 void *argp2 = 0 ;
40644 int res2 = 0 ;
40645 PyObject * obj0 = 0 ;
40646 PyObject * obj1 = 0 ;
40647 char * kwnames[] = {
40648 (char *) "self",(char *) "menubar", NULL
40649 };
40650
40651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40653 if (!SWIG_IsOK(res1)) {
40654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40655 }
40656 arg1 = reinterpret_cast< wxMenu * >(argp1);
40657 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40658 if (!SWIG_IsOK(res2)) {
40659 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40660 }
40661 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40662 {
40663 PyThreadState* __tstate = wxPyBeginAllowThreads();
40664 (arg1)->Attach(arg2);
40665 wxPyEndAllowThreads(__tstate);
40666 if (PyErr_Occurred()) SWIG_fail;
40667 }
40668 resultobj = SWIG_Py_Void();
40669 return resultobj;
40670 fail:
40671 return NULL;
40672 }
40673
40674
40675 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40676 PyObject *resultobj = 0;
40677 wxMenu *arg1 = (wxMenu *) 0 ;
40678 void *argp1 = 0 ;
40679 int res1 = 0 ;
40680 PyObject *swig_obj[1] ;
40681
40682 if (!args) SWIG_fail;
40683 swig_obj[0] = args;
40684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40685 if (!SWIG_IsOK(res1)) {
40686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40687 }
40688 arg1 = reinterpret_cast< wxMenu * >(argp1);
40689 {
40690 PyThreadState* __tstate = wxPyBeginAllowThreads();
40691 (arg1)->Detach();
40692 wxPyEndAllowThreads(__tstate);
40693 if (PyErr_Occurred()) SWIG_fail;
40694 }
40695 resultobj = SWIG_Py_Void();
40696 return resultobj;
40697 fail:
40698 return NULL;
40699 }
40700
40701
40702 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40703 PyObject *resultobj = 0;
40704 wxMenu *arg1 = (wxMenu *) 0 ;
40705 bool result;
40706 void *argp1 = 0 ;
40707 int res1 = 0 ;
40708 PyObject *swig_obj[1] ;
40709
40710 if (!args) SWIG_fail;
40711 swig_obj[0] = args;
40712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40713 if (!SWIG_IsOK(res1)) {
40714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40715 }
40716 arg1 = reinterpret_cast< wxMenu * >(argp1);
40717 {
40718 PyThreadState* __tstate = wxPyBeginAllowThreads();
40719 result = (bool)((wxMenu const *)arg1)->IsAttached();
40720 wxPyEndAllowThreads(__tstate);
40721 if (PyErr_Occurred()) SWIG_fail;
40722 }
40723 {
40724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40725 }
40726 return resultobj;
40727 fail:
40728 return NULL;
40729 }
40730
40731
40732 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40733 PyObject *resultobj = 0;
40734 wxMenu *arg1 = (wxMenu *) 0 ;
40735 wxMenu *arg2 = (wxMenu *) 0 ;
40736 void *argp1 = 0 ;
40737 int res1 = 0 ;
40738 void *argp2 = 0 ;
40739 int res2 = 0 ;
40740 PyObject * obj0 = 0 ;
40741 PyObject * obj1 = 0 ;
40742 char * kwnames[] = {
40743 (char *) "self",(char *) "parent", NULL
40744 };
40745
40746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40748 if (!SWIG_IsOK(res1)) {
40749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40750 }
40751 arg1 = reinterpret_cast< wxMenu * >(argp1);
40752 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40753 if (!SWIG_IsOK(res2)) {
40754 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40755 }
40756 arg2 = reinterpret_cast< wxMenu * >(argp2);
40757 {
40758 PyThreadState* __tstate = wxPyBeginAllowThreads();
40759 (arg1)->SetParent(arg2);
40760 wxPyEndAllowThreads(__tstate);
40761 if (PyErr_Occurred()) SWIG_fail;
40762 }
40763 resultobj = SWIG_Py_Void();
40764 return resultobj;
40765 fail:
40766 return NULL;
40767 }
40768
40769
40770 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40771 PyObject *resultobj = 0;
40772 wxMenu *arg1 = (wxMenu *) 0 ;
40773 wxMenu *result = 0 ;
40774 void *argp1 = 0 ;
40775 int res1 = 0 ;
40776 PyObject *swig_obj[1] ;
40777
40778 if (!args) SWIG_fail;
40779 swig_obj[0] = args;
40780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40781 if (!SWIG_IsOK(res1)) {
40782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40783 }
40784 arg1 = reinterpret_cast< wxMenu * >(argp1);
40785 {
40786 PyThreadState* __tstate = wxPyBeginAllowThreads();
40787 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40788 wxPyEndAllowThreads(__tstate);
40789 if (PyErr_Occurred()) SWIG_fail;
40790 }
40791 {
40792 resultobj = wxPyMake_wxObject(result, 0);
40793 }
40794 return resultobj;
40795 fail:
40796 return NULL;
40797 }
40798
40799
40800 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40801 PyObject *obj;
40802 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40803 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40804 return SWIG_Py_Void();
40805 }
40806
40807 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40808 return SWIG_Python_InitShadowInstance(args);
40809 }
40810
40811 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40812 PyObject *resultobj = 0;
40813 long arg1 = (long) 0 ;
40814 wxMenuBar *result = 0 ;
40815 long val1 ;
40816 int ecode1 = 0 ;
40817 PyObject * obj0 = 0 ;
40818 char * kwnames[] = {
40819 (char *) "style", NULL
40820 };
40821
40822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40823 if (obj0) {
40824 ecode1 = SWIG_AsVal_long(obj0, &val1);
40825 if (!SWIG_IsOK(ecode1)) {
40826 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
40827 }
40828 arg1 = static_cast< long >(val1);
40829 }
40830 {
40831 if (!wxPyCheckForApp()) SWIG_fail;
40832 PyThreadState* __tstate = wxPyBeginAllowThreads();
40833 result = (wxMenuBar *)new wxMenuBar(arg1);
40834 wxPyEndAllowThreads(__tstate);
40835 if (PyErr_Occurred()) SWIG_fail;
40836 }
40837 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
40838 return resultobj;
40839 fail:
40840 return NULL;
40841 }
40842
40843
40844 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40845 PyObject *resultobj = 0;
40846 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40847 wxMenu *arg2 = (wxMenu *) 0 ;
40848 wxString *arg3 = 0 ;
40849 bool result;
40850 void *argp1 = 0 ;
40851 int res1 = 0 ;
40852 void *argp2 = 0 ;
40853 int res2 = 0 ;
40854 bool temp3 = false ;
40855 PyObject * obj0 = 0 ;
40856 PyObject * obj1 = 0 ;
40857 PyObject * obj2 = 0 ;
40858 char * kwnames[] = {
40859 (char *) "self",(char *) "menu",(char *) "title", NULL
40860 };
40861
40862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40864 if (!SWIG_IsOK(res1)) {
40865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40866 }
40867 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40868 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40869 if (!SWIG_IsOK(res2)) {
40870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
40871 }
40872 arg2 = reinterpret_cast< wxMenu * >(argp2);
40873 {
40874 arg3 = wxString_in_helper(obj2);
40875 if (arg3 == NULL) SWIG_fail;
40876 temp3 = true;
40877 }
40878 {
40879 PyThreadState* __tstate = wxPyBeginAllowThreads();
40880 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
40881 wxPyEndAllowThreads(__tstate);
40882 if (PyErr_Occurred()) SWIG_fail;
40883 }
40884 {
40885 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40886 }
40887 {
40888 if (temp3)
40889 delete arg3;
40890 }
40891 return resultobj;
40892 fail:
40893 {
40894 if (temp3)
40895 delete arg3;
40896 }
40897 return NULL;
40898 }
40899
40900
40901 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40902 PyObject *resultobj = 0;
40903 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40904 size_t arg2 ;
40905 wxMenu *arg3 = (wxMenu *) 0 ;
40906 wxString *arg4 = 0 ;
40907 bool result;
40908 void *argp1 = 0 ;
40909 int res1 = 0 ;
40910 size_t val2 ;
40911 int ecode2 = 0 ;
40912 void *argp3 = 0 ;
40913 int res3 = 0 ;
40914 bool temp4 = false ;
40915 PyObject * obj0 = 0 ;
40916 PyObject * obj1 = 0 ;
40917 PyObject * obj2 = 0 ;
40918 PyObject * obj3 = 0 ;
40919 char * kwnames[] = {
40920 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
40921 };
40922
40923 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40924 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40925 if (!SWIG_IsOK(res1)) {
40926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
40927 }
40928 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40929 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40930 if (!SWIG_IsOK(ecode2)) {
40931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
40932 }
40933 arg2 = static_cast< size_t >(val2);
40934 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
40935 if (!SWIG_IsOK(res3)) {
40936 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
40937 }
40938 arg3 = reinterpret_cast< wxMenu * >(argp3);
40939 {
40940 arg4 = wxString_in_helper(obj3);
40941 if (arg4 == NULL) SWIG_fail;
40942 temp4 = true;
40943 }
40944 {
40945 PyThreadState* __tstate = wxPyBeginAllowThreads();
40946 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
40947 wxPyEndAllowThreads(__tstate);
40948 if (PyErr_Occurred()) SWIG_fail;
40949 }
40950 {
40951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40952 }
40953 {
40954 if (temp4)
40955 delete arg4;
40956 }
40957 return resultobj;
40958 fail:
40959 {
40960 if (temp4)
40961 delete arg4;
40962 }
40963 return NULL;
40964 }
40965
40966
40967 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40968 PyObject *resultobj = 0;
40969 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40970 size_t result;
40971 void *argp1 = 0 ;
40972 int res1 = 0 ;
40973 PyObject *swig_obj[1] ;
40974
40975 if (!args) SWIG_fail;
40976 swig_obj[0] = args;
40977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
40978 if (!SWIG_IsOK(res1)) {
40979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
40980 }
40981 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
40982 {
40983 PyThreadState* __tstate = wxPyBeginAllowThreads();
40984 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
40985 wxPyEndAllowThreads(__tstate);
40986 if (PyErr_Occurred()) SWIG_fail;
40987 }
40988 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
40989 return resultobj;
40990 fail:
40991 return NULL;
40992 }
40993
40994
40995 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40996 PyObject *resultobj = 0;
40997 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
40998 size_t arg2 ;
40999 wxMenu *result = 0 ;
41000 void *argp1 = 0 ;
41001 int res1 = 0 ;
41002 size_t val2 ;
41003 int ecode2 = 0 ;
41004 PyObject * obj0 = 0 ;
41005 PyObject * obj1 = 0 ;
41006 char * kwnames[] = {
41007 (char *) "self",(char *) "pos", NULL
41008 };
41009
41010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41012 if (!SWIG_IsOK(res1)) {
41013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41014 }
41015 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41016 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41017 if (!SWIG_IsOK(ecode2)) {
41018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41019 }
41020 arg2 = static_cast< size_t >(val2);
41021 {
41022 PyThreadState* __tstate = wxPyBeginAllowThreads();
41023 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41024 wxPyEndAllowThreads(__tstate);
41025 if (PyErr_Occurred()) SWIG_fail;
41026 }
41027 {
41028 resultobj = wxPyMake_wxObject(result, 0);
41029 }
41030 return resultobj;
41031 fail:
41032 return NULL;
41033 }
41034
41035
41036 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41037 PyObject *resultobj = 0;
41038 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41039 size_t arg2 ;
41040 wxMenu *arg3 = (wxMenu *) 0 ;
41041 wxString *arg4 = 0 ;
41042 wxMenu *result = 0 ;
41043 void *argp1 = 0 ;
41044 int res1 = 0 ;
41045 size_t val2 ;
41046 int ecode2 = 0 ;
41047 void *argp3 = 0 ;
41048 int res3 = 0 ;
41049 bool temp4 = false ;
41050 PyObject * obj0 = 0 ;
41051 PyObject * obj1 = 0 ;
41052 PyObject * obj2 = 0 ;
41053 PyObject * obj3 = 0 ;
41054 char * kwnames[] = {
41055 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41056 };
41057
41058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41060 if (!SWIG_IsOK(res1)) {
41061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41062 }
41063 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41064 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41065 if (!SWIG_IsOK(ecode2)) {
41066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41067 }
41068 arg2 = static_cast< size_t >(val2);
41069 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41070 if (!SWIG_IsOK(res3)) {
41071 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41072 }
41073 arg3 = reinterpret_cast< wxMenu * >(argp3);
41074 {
41075 arg4 = wxString_in_helper(obj3);
41076 if (arg4 == NULL) SWIG_fail;
41077 temp4 = true;
41078 }
41079 {
41080 PyThreadState* __tstate = wxPyBeginAllowThreads();
41081 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41082 wxPyEndAllowThreads(__tstate);
41083 if (PyErr_Occurred()) SWIG_fail;
41084 }
41085 {
41086 resultobj = wxPyMake_wxObject(result, 0);
41087 }
41088 {
41089 if (temp4)
41090 delete arg4;
41091 }
41092 return resultobj;
41093 fail:
41094 {
41095 if (temp4)
41096 delete arg4;
41097 }
41098 return NULL;
41099 }
41100
41101
41102 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41103 PyObject *resultobj = 0;
41104 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41105 size_t arg2 ;
41106 wxMenu *result = 0 ;
41107 void *argp1 = 0 ;
41108 int res1 = 0 ;
41109 size_t val2 ;
41110 int ecode2 = 0 ;
41111 PyObject * obj0 = 0 ;
41112 PyObject * obj1 = 0 ;
41113 char * kwnames[] = {
41114 (char *) "self",(char *) "pos", NULL
41115 };
41116
41117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41119 if (!SWIG_IsOK(res1)) {
41120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41121 }
41122 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41123 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41124 if (!SWIG_IsOK(ecode2)) {
41125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41126 }
41127 arg2 = static_cast< size_t >(val2);
41128 {
41129 PyThreadState* __tstate = wxPyBeginAllowThreads();
41130 result = (wxMenu *)(arg1)->Remove(arg2);
41131 wxPyEndAllowThreads(__tstate);
41132 if (PyErr_Occurred()) SWIG_fail;
41133 }
41134 {
41135 resultobj = wxPyMake_wxObject(result, 0);
41136 }
41137 return resultobj;
41138 fail:
41139 return NULL;
41140 }
41141
41142
41143 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41144 PyObject *resultobj = 0;
41145 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41146 size_t arg2 ;
41147 bool arg3 ;
41148 void *argp1 = 0 ;
41149 int res1 = 0 ;
41150 size_t val2 ;
41151 int ecode2 = 0 ;
41152 bool val3 ;
41153 int ecode3 = 0 ;
41154 PyObject * obj0 = 0 ;
41155 PyObject * obj1 = 0 ;
41156 PyObject * obj2 = 0 ;
41157 char * kwnames[] = {
41158 (char *) "self",(char *) "pos",(char *) "enable", NULL
41159 };
41160
41161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41163 if (!SWIG_IsOK(res1)) {
41164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41165 }
41166 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41167 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41168 if (!SWIG_IsOK(ecode2)) {
41169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41170 }
41171 arg2 = static_cast< size_t >(val2);
41172 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41173 if (!SWIG_IsOK(ecode3)) {
41174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41175 }
41176 arg3 = static_cast< bool >(val3);
41177 {
41178 PyThreadState* __tstate = wxPyBeginAllowThreads();
41179 (arg1)->EnableTop(arg2,arg3);
41180 wxPyEndAllowThreads(__tstate);
41181 if (PyErr_Occurred()) SWIG_fail;
41182 }
41183 resultobj = SWIG_Py_Void();
41184 return resultobj;
41185 fail:
41186 return NULL;
41187 }
41188
41189
41190 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41191 PyObject *resultobj = 0;
41192 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41193 size_t arg2 ;
41194 bool result;
41195 void *argp1 = 0 ;
41196 int res1 = 0 ;
41197 size_t val2 ;
41198 int ecode2 = 0 ;
41199 PyObject * obj0 = 0 ;
41200 PyObject * obj1 = 0 ;
41201 char * kwnames[] = {
41202 (char *) "self",(char *) "pos", NULL
41203 };
41204
41205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41207 if (!SWIG_IsOK(res1)) {
41208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41209 }
41210 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41211 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41212 if (!SWIG_IsOK(ecode2)) {
41213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41214 }
41215 arg2 = static_cast< size_t >(val2);
41216 {
41217 PyThreadState* __tstate = wxPyBeginAllowThreads();
41218 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41219 wxPyEndAllowThreads(__tstate);
41220 if (PyErr_Occurred()) SWIG_fail;
41221 }
41222 {
41223 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41224 }
41225 return resultobj;
41226 fail:
41227 return NULL;
41228 }
41229
41230
41231 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41232 PyObject *resultobj = 0;
41233 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41234 size_t arg2 ;
41235 wxString *arg3 = 0 ;
41236 void *argp1 = 0 ;
41237 int res1 = 0 ;
41238 size_t val2 ;
41239 int ecode2 = 0 ;
41240 bool temp3 = false ;
41241 PyObject * obj0 = 0 ;
41242 PyObject * obj1 = 0 ;
41243 PyObject * obj2 = 0 ;
41244 char * kwnames[] = {
41245 (char *) "self",(char *) "pos",(char *) "label", NULL
41246 };
41247
41248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41250 if (!SWIG_IsOK(res1)) {
41251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41252 }
41253 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41254 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41255 if (!SWIG_IsOK(ecode2)) {
41256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41257 }
41258 arg2 = static_cast< size_t >(val2);
41259 {
41260 arg3 = wxString_in_helper(obj2);
41261 if (arg3 == NULL) SWIG_fail;
41262 temp3 = true;
41263 }
41264 {
41265 PyThreadState* __tstate = wxPyBeginAllowThreads();
41266 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41267 wxPyEndAllowThreads(__tstate);
41268 if (PyErr_Occurred()) SWIG_fail;
41269 }
41270 resultobj = SWIG_Py_Void();
41271 {
41272 if (temp3)
41273 delete arg3;
41274 }
41275 return resultobj;
41276 fail:
41277 {
41278 if (temp3)
41279 delete arg3;
41280 }
41281 return NULL;
41282 }
41283
41284
41285 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41286 PyObject *resultobj = 0;
41287 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41288 size_t arg2 ;
41289 wxString result;
41290 void *argp1 = 0 ;
41291 int res1 = 0 ;
41292 size_t val2 ;
41293 int ecode2 = 0 ;
41294 PyObject * obj0 = 0 ;
41295 PyObject * obj1 = 0 ;
41296 char * kwnames[] = {
41297 (char *) "self",(char *) "pos", NULL
41298 };
41299
41300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41302 if (!SWIG_IsOK(res1)) {
41303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41304 }
41305 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41306 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41307 if (!SWIG_IsOK(ecode2)) {
41308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41309 }
41310 arg2 = static_cast< size_t >(val2);
41311 {
41312 PyThreadState* __tstate = wxPyBeginAllowThreads();
41313 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41314 wxPyEndAllowThreads(__tstate);
41315 if (PyErr_Occurred()) SWIG_fail;
41316 }
41317 {
41318 #if wxUSE_UNICODE
41319 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41320 #else
41321 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41322 #endif
41323 }
41324 return resultobj;
41325 fail:
41326 return NULL;
41327 }
41328
41329
41330 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41331 PyObject *resultobj = 0;
41332 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41333 wxString *arg2 = 0 ;
41334 wxString *arg3 = 0 ;
41335 int result;
41336 void *argp1 = 0 ;
41337 int res1 = 0 ;
41338 bool temp2 = false ;
41339 bool temp3 = false ;
41340 PyObject * obj0 = 0 ;
41341 PyObject * obj1 = 0 ;
41342 PyObject * obj2 = 0 ;
41343 char * kwnames[] = {
41344 (char *) "self",(char *) "menu",(char *) "item", NULL
41345 };
41346
41347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41349 if (!SWIG_IsOK(res1)) {
41350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41351 }
41352 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41353 {
41354 arg2 = wxString_in_helper(obj1);
41355 if (arg2 == NULL) SWIG_fail;
41356 temp2 = true;
41357 }
41358 {
41359 arg3 = wxString_in_helper(obj2);
41360 if (arg3 == NULL) SWIG_fail;
41361 temp3 = true;
41362 }
41363 {
41364 PyThreadState* __tstate = wxPyBeginAllowThreads();
41365 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41366 wxPyEndAllowThreads(__tstate);
41367 if (PyErr_Occurred()) SWIG_fail;
41368 }
41369 resultobj = SWIG_From_int(static_cast< int >(result));
41370 {
41371 if (temp2)
41372 delete arg2;
41373 }
41374 {
41375 if (temp3)
41376 delete arg3;
41377 }
41378 return resultobj;
41379 fail:
41380 {
41381 if (temp2)
41382 delete arg2;
41383 }
41384 {
41385 if (temp3)
41386 delete arg3;
41387 }
41388 return NULL;
41389 }
41390
41391
41392 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41393 PyObject *resultobj = 0;
41394 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41395 int arg2 ;
41396 wxMenuItem *result = 0 ;
41397 void *argp1 = 0 ;
41398 int res1 = 0 ;
41399 int val2 ;
41400 int ecode2 = 0 ;
41401 PyObject * obj0 = 0 ;
41402 PyObject * obj1 = 0 ;
41403 char * kwnames[] = {
41404 (char *) "self",(char *) "id", NULL
41405 };
41406
41407 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41408 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41409 if (!SWIG_IsOK(res1)) {
41410 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41411 }
41412 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41413 ecode2 = SWIG_AsVal_int(obj1, &val2);
41414 if (!SWIG_IsOK(ecode2)) {
41415 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41416 }
41417 arg2 = static_cast< int >(val2);
41418 {
41419 PyThreadState* __tstate = wxPyBeginAllowThreads();
41420 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41421 wxPyEndAllowThreads(__tstate);
41422 if (PyErr_Occurred()) SWIG_fail;
41423 }
41424 {
41425 resultobj = wxPyMake_wxObject(result, (bool)0);
41426 }
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41434 PyObject *resultobj = 0;
41435 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41436 wxString *arg2 = 0 ;
41437 int result;
41438 void *argp1 = 0 ;
41439 int res1 = 0 ;
41440 bool temp2 = false ;
41441 PyObject * obj0 = 0 ;
41442 PyObject * obj1 = 0 ;
41443 char * kwnames[] = {
41444 (char *) "self",(char *) "title", NULL
41445 };
41446
41447 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41448 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41449 if (!SWIG_IsOK(res1)) {
41450 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41451 }
41452 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41453 {
41454 arg2 = wxString_in_helper(obj1);
41455 if (arg2 == NULL) SWIG_fail;
41456 temp2 = true;
41457 }
41458 {
41459 PyThreadState* __tstate = wxPyBeginAllowThreads();
41460 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41461 wxPyEndAllowThreads(__tstate);
41462 if (PyErr_Occurred()) SWIG_fail;
41463 }
41464 resultobj = SWIG_From_int(static_cast< int >(result));
41465 {
41466 if (temp2)
41467 delete arg2;
41468 }
41469 return resultobj;
41470 fail:
41471 {
41472 if (temp2)
41473 delete arg2;
41474 }
41475 return NULL;
41476 }
41477
41478
41479 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41480 PyObject *resultobj = 0;
41481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41482 int arg2 ;
41483 bool arg3 ;
41484 void *argp1 = 0 ;
41485 int res1 = 0 ;
41486 int val2 ;
41487 int ecode2 = 0 ;
41488 bool val3 ;
41489 int ecode3 = 0 ;
41490 PyObject * obj0 = 0 ;
41491 PyObject * obj1 = 0 ;
41492 PyObject * obj2 = 0 ;
41493 char * kwnames[] = {
41494 (char *) "self",(char *) "id",(char *) "enable", NULL
41495 };
41496
41497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41499 if (!SWIG_IsOK(res1)) {
41500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41501 }
41502 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41503 ecode2 = SWIG_AsVal_int(obj1, &val2);
41504 if (!SWIG_IsOK(ecode2)) {
41505 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41506 }
41507 arg2 = static_cast< int >(val2);
41508 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41509 if (!SWIG_IsOK(ecode3)) {
41510 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41511 }
41512 arg3 = static_cast< bool >(val3);
41513 {
41514 PyThreadState* __tstate = wxPyBeginAllowThreads();
41515 (arg1)->Enable(arg2,arg3);
41516 wxPyEndAllowThreads(__tstate);
41517 if (PyErr_Occurred()) SWIG_fail;
41518 }
41519 resultobj = SWIG_Py_Void();
41520 return resultobj;
41521 fail:
41522 return NULL;
41523 }
41524
41525
41526 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41527 PyObject *resultobj = 0;
41528 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41529 int arg2 ;
41530 bool arg3 ;
41531 void *argp1 = 0 ;
41532 int res1 = 0 ;
41533 int val2 ;
41534 int ecode2 = 0 ;
41535 bool val3 ;
41536 int ecode3 = 0 ;
41537 PyObject * obj0 = 0 ;
41538 PyObject * obj1 = 0 ;
41539 PyObject * obj2 = 0 ;
41540 char * kwnames[] = {
41541 (char *) "self",(char *) "id",(char *) "check", NULL
41542 };
41543
41544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41546 if (!SWIG_IsOK(res1)) {
41547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41548 }
41549 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41550 ecode2 = SWIG_AsVal_int(obj1, &val2);
41551 if (!SWIG_IsOK(ecode2)) {
41552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41553 }
41554 arg2 = static_cast< int >(val2);
41555 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41556 if (!SWIG_IsOK(ecode3)) {
41557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41558 }
41559 arg3 = static_cast< bool >(val3);
41560 {
41561 PyThreadState* __tstate = wxPyBeginAllowThreads();
41562 (arg1)->Check(arg2,arg3);
41563 wxPyEndAllowThreads(__tstate);
41564 if (PyErr_Occurred()) SWIG_fail;
41565 }
41566 resultobj = SWIG_Py_Void();
41567 return resultobj;
41568 fail:
41569 return NULL;
41570 }
41571
41572
41573 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41574 PyObject *resultobj = 0;
41575 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41576 int arg2 ;
41577 bool result;
41578 void *argp1 = 0 ;
41579 int res1 = 0 ;
41580 int val2 ;
41581 int ecode2 = 0 ;
41582 PyObject * obj0 = 0 ;
41583 PyObject * obj1 = 0 ;
41584 char * kwnames[] = {
41585 (char *) "self",(char *) "id", NULL
41586 };
41587
41588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41590 if (!SWIG_IsOK(res1)) {
41591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41592 }
41593 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41594 ecode2 = SWIG_AsVal_int(obj1, &val2);
41595 if (!SWIG_IsOK(ecode2)) {
41596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41597 }
41598 arg2 = static_cast< int >(val2);
41599 {
41600 PyThreadState* __tstate = wxPyBeginAllowThreads();
41601 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41602 wxPyEndAllowThreads(__tstate);
41603 if (PyErr_Occurred()) SWIG_fail;
41604 }
41605 {
41606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41607 }
41608 return resultobj;
41609 fail:
41610 return NULL;
41611 }
41612
41613
41614 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41615 PyObject *resultobj = 0;
41616 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41617 int arg2 ;
41618 bool result;
41619 void *argp1 = 0 ;
41620 int res1 = 0 ;
41621 int val2 ;
41622 int ecode2 = 0 ;
41623 PyObject * obj0 = 0 ;
41624 PyObject * obj1 = 0 ;
41625 char * kwnames[] = {
41626 (char *) "self",(char *) "id", NULL
41627 };
41628
41629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41631 if (!SWIG_IsOK(res1)) {
41632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41633 }
41634 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41635 ecode2 = SWIG_AsVal_int(obj1, &val2);
41636 if (!SWIG_IsOK(ecode2)) {
41637 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41638 }
41639 arg2 = static_cast< int >(val2);
41640 {
41641 PyThreadState* __tstate = wxPyBeginAllowThreads();
41642 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41643 wxPyEndAllowThreads(__tstate);
41644 if (PyErr_Occurred()) SWIG_fail;
41645 }
41646 {
41647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41648 }
41649 return resultobj;
41650 fail:
41651 return NULL;
41652 }
41653
41654
41655 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41656 PyObject *resultobj = 0;
41657 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41658 int arg2 ;
41659 wxString *arg3 = 0 ;
41660 void *argp1 = 0 ;
41661 int res1 = 0 ;
41662 int val2 ;
41663 int ecode2 = 0 ;
41664 bool temp3 = false ;
41665 PyObject * obj0 = 0 ;
41666 PyObject * obj1 = 0 ;
41667 PyObject * obj2 = 0 ;
41668 char * kwnames[] = {
41669 (char *) "self",(char *) "id",(char *) "label", NULL
41670 };
41671
41672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41674 if (!SWIG_IsOK(res1)) {
41675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41676 }
41677 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41678 ecode2 = SWIG_AsVal_int(obj1, &val2);
41679 if (!SWIG_IsOK(ecode2)) {
41680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41681 }
41682 arg2 = static_cast< int >(val2);
41683 {
41684 arg3 = wxString_in_helper(obj2);
41685 if (arg3 == NULL) SWIG_fail;
41686 temp3 = true;
41687 }
41688 {
41689 PyThreadState* __tstate = wxPyBeginAllowThreads();
41690 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41691 wxPyEndAllowThreads(__tstate);
41692 if (PyErr_Occurred()) SWIG_fail;
41693 }
41694 resultobj = SWIG_Py_Void();
41695 {
41696 if (temp3)
41697 delete arg3;
41698 }
41699 return resultobj;
41700 fail:
41701 {
41702 if (temp3)
41703 delete arg3;
41704 }
41705 return NULL;
41706 }
41707
41708
41709 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41710 PyObject *resultobj = 0;
41711 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41712 int arg2 ;
41713 wxString result;
41714 void *argp1 = 0 ;
41715 int res1 = 0 ;
41716 int val2 ;
41717 int ecode2 = 0 ;
41718 PyObject * obj0 = 0 ;
41719 PyObject * obj1 = 0 ;
41720 char * kwnames[] = {
41721 (char *) "self",(char *) "id", NULL
41722 };
41723
41724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41726 if (!SWIG_IsOK(res1)) {
41727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41728 }
41729 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41730 ecode2 = SWIG_AsVal_int(obj1, &val2);
41731 if (!SWIG_IsOK(ecode2)) {
41732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41733 }
41734 arg2 = static_cast< int >(val2);
41735 {
41736 PyThreadState* __tstate = wxPyBeginAllowThreads();
41737 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41738 wxPyEndAllowThreads(__tstate);
41739 if (PyErr_Occurred()) SWIG_fail;
41740 }
41741 {
41742 #if wxUSE_UNICODE
41743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41744 #else
41745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41746 #endif
41747 }
41748 return resultobj;
41749 fail:
41750 return NULL;
41751 }
41752
41753
41754 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41755 PyObject *resultobj = 0;
41756 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41757 int arg2 ;
41758 wxString *arg3 = 0 ;
41759 void *argp1 = 0 ;
41760 int res1 = 0 ;
41761 int val2 ;
41762 int ecode2 = 0 ;
41763 bool temp3 = false ;
41764 PyObject * obj0 = 0 ;
41765 PyObject * obj1 = 0 ;
41766 PyObject * obj2 = 0 ;
41767 char * kwnames[] = {
41768 (char *) "self",(char *) "id",(char *) "helpString", NULL
41769 };
41770
41771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41773 if (!SWIG_IsOK(res1)) {
41774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41775 }
41776 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41777 ecode2 = SWIG_AsVal_int(obj1, &val2);
41778 if (!SWIG_IsOK(ecode2)) {
41779 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41780 }
41781 arg2 = static_cast< int >(val2);
41782 {
41783 arg3 = wxString_in_helper(obj2);
41784 if (arg3 == NULL) SWIG_fail;
41785 temp3 = true;
41786 }
41787 {
41788 PyThreadState* __tstate = wxPyBeginAllowThreads();
41789 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41790 wxPyEndAllowThreads(__tstate);
41791 if (PyErr_Occurred()) SWIG_fail;
41792 }
41793 resultobj = SWIG_Py_Void();
41794 {
41795 if (temp3)
41796 delete arg3;
41797 }
41798 return resultobj;
41799 fail:
41800 {
41801 if (temp3)
41802 delete arg3;
41803 }
41804 return NULL;
41805 }
41806
41807
41808 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41809 PyObject *resultobj = 0;
41810 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41811 int arg2 ;
41812 wxString result;
41813 void *argp1 = 0 ;
41814 int res1 = 0 ;
41815 int val2 ;
41816 int ecode2 = 0 ;
41817 PyObject * obj0 = 0 ;
41818 PyObject * obj1 = 0 ;
41819 char * kwnames[] = {
41820 (char *) "self",(char *) "id", NULL
41821 };
41822
41823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41825 if (!SWIG_IsOK(res1)) {
41826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41827 }
41828 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41829 ecode2 = SWIG_AsVal_int(obj1, &val2);
41830 if (!SWIG_IsOK(ecode2)) {
41831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
41832 }
41833 arg2 = static_cast< int >(val2);
41834 {
41835 PyThreadState* __tstate = wxPyBeginAllowThreads();
41836 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
41837 wxPyEndAllowThreads(__tstate);
41838 if (PyErr_Occurred()) SWIG_fail;
41839 }
41840 {
41841 #if wxUSE_UNICODE
41842 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41843 #else
41844 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41845 #endif
41846 }
41847 return resultobj;
41848 fail:
41849 return NULL;
41850 }
41851
41852
41853 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41854 PyObject *resultobj = 0;
41855 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41856 wxFrame *result = 0 ;
41857 void *argp1 = 0 ;
41858 int res1 = 0 ;
41859 PyObject *swig_obj[1] ;
41860
41861 if (!args) SWIG_fail;
41862 swig_obj[0] = args;
41863 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41864 if (!SWIG_IsOK(res1)) {
41865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41866 }
41867 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41868 {
41869 PyThreadState* __tstate = wxPyBeginAllowThreads();
41870 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
41871 wxPyEndAllowThreads(__tstate);
41872 if (PyErr_Occurred()) SWIG_fail;
41873 }
41874 {
41875 resultobj = wxPyMake_wxObject(result, (bool)0);
41876 }
41877 return resultobj;
41878 fail:
41879 return NULL;
41880 }
41881
41882
41883 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41884 PyObject *resultobj = 0;
41885 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41886 bool result;
41887 void *argp1 = 0 ;
41888 int res1 = 0 ;
41889 PyObject *swig_obj[1] ;
41890
41891 if (!args) SWIG_fail;
41892 swig_obj[0] = args;
41893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41894 if (!SWIG_IsOK(res1)) {
41895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41896 }
41897 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41898 {
41899 PyThreadState* __tstate = wxPyBeginAllowThreads();
41900 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
41901 wxPyEndAllowThreads(__tstate);
41902 if (PyErr_Occurred()) SWIG_fail;
41903 }
41904 {
41905 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41906 }
41907 return resultobj;
41908 fail:
41909 return NULL;
41910 }
41911
41912
41913 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41914 PyObject *resultobj = 0;
41915 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41916 wxFrame *arg2 = (wxFrame *) 0 ;
41917 void *argp1 = 0 ;
41918 int res1 = 0 ;
41919 void *argp2 = 0 ;
41920 int res2 = 0 ;
41921 PyObject * obj0 = 0 ;
41922 PyObject * obj1 = 0 ;
41923 char * kwnames[] = {
41924 (char *) "self",(char *) "frame", NULL
41925 };
41926
41927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
41928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41929 if (!SWIG_IsOK(res1)) {
41930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41931 }
41932 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41933 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
41934 if (!SWIG_IsOK(res2)) {
41935 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
41936 }
41937 arg2 = reinterpret_cast< wxFrame * >(argp2);
41938 {
41939 PyThreadState* __tstate = wxPyBeginAllowThreads();
41940 (arg1)->Attach(arg2);
41941 wxPyEndAllowThreads(__tstate);
41942 if (PyErr_Occurred()) SWIG_fail;
41943 }
41944 resultobj = SWIG_Py_Void();
41945 return resultobj;
41946 fail:
41947 return NULL;
41948 }
41949
41950
41951 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41952 PyObject *resultobj = 0;
41953 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41954 void *argp1 = 0 ;
41955 int res1 = 0 ;
41956 PyObject *swig_obj[1] ;
41957
41958 if (!args) SWIG_fail;
41959 swig_obj[0] = args;
41960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41961 if (!SWIG_IsOK(res1)) {
41962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41963 }
41964 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41965 {
41966 PyThreadState* __tstate = wxPyBeginAllowThreads();
41967 (arg1)->Detach();
41968 wxPyEndAllowThreads(__tstate);
41969 if (PyErr_Occurred()) SWIG_fail;
41970 }
41971 resultobj = SWIG_Py_Void();
41972 return resultobj;
41973 fail:
41974 return NULL;
41975 }
41976
41977
41978 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41979 PyObject *resultobj = 0;
41980 bool arg1 ;
41981 bool val1 ;
41982 int ecode1 = 0 ;
41983 PyObject * obj0 = 0 ;
41984 char * kwnames[] = {
41985 (char *) "enable", NULL
41986 };
41987
41988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
41989 ecode1 = SWIG_AsVal_bool(obj0, &val1);
41990 if (!SWIG_IsOK(ecode1)) {
41991 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
41992 }
41993 arg1 = static_cast< bool >(val1);
41994 {
41995 PyThreadState* __tstate = wxPyBeginAllowThreads();
41996 wxMenuBar::SetAutoWindowMenu(arg1);
41997 wxPyEndAllowThreads(__tstate);
41998 if (PyErr_Occurred()) SWIG_fail;
41999 }
42000 resultobj = SWIG_Py_Void();
42001 return resultobj;
42002 fail:
42003 return NULL;
42004 }
42005
42006
42007 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42008 PyObject *resultobj = 0;
42009 bool result;
42010
42011 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42012 {
42013 PyThreadState* __tstate = wxPyBeginAllowThreads();
42014 result = (bool)wxMenuBar::GetAutoWindowMenu();
42015 wxPyEndAllowThreads(__tstate);
42016 if (PyErr_Occurred()) SWIG_fail;
42017 }
42018 {
42019 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42020 }
42021 return resultobj;
42022 fail:
42023 return NULL;
42024 }
42025
42026
42027 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42028 PyObject *obj;
42029 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42030 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42031 return SWIG_Py_Void();
42032 }
42033
42034 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42035 return SWIG_Python_InitShadowInstance(args);
42036 }
42037
42038 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42039 PyObject *resultobj = 0;
42040 wxMenu *arg1 = (wxMenu *) NULL ;
42041 int arg2 = (int) wxID_ANY ;
42042 wxString const &arg3_defvalue = wxPyEmptyString ;
42043 wxString *arg3 = (wxString *) &arg3_defvalue ;
42044 wxString const &arg4_defvalue = wxPyEmptyString ;
42045 wxString *arg4 = (wxString *) &arg4_defvalue ;
42046 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42047 wxMenu *arg6 = (wxMenu *) NULL ;
42048 wxMenuItem *result = 0 ;
42049 void *argp1 = 0 ;
42050 int res1 = 0 ;
42051 int val2 ;
42052 int ecode2 = 0 ;
42053 bool temp3 = false ;
42054 bool temp4 = false ;
42055 int val5 ;
42056 int ecode5 = 0 ;
42057 void *argp6 = 0 ;
42058 int res6 = 0 ;
42059 PyObject * obj0 = 0 ;
42060 PyObject * obj1 = 0 ;
42061 PyObject * obj2 = 0 ;
42062 PyObject * obj3 = 0 ;
42063 PyObject * obj4 = 0 ;
42064 PyObject * obj5 = 0 ;
42065 char * kwnames[] = {
42066 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42067 };
42068
42069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42070 if (obj0) {
42071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42072 if (!SWIG_IsOK(res1)) {
42073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42074 }
42075 arg1 = reinterpret_cast< wxMenu * >(argp1);
42076 }
42077 if (obj1) {
42078 ecode2 = SWIG_AsVal_int(obj1, &val2);
42079 if (!SWIG_IsOK(ecode2)) {
42080 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42081 }
42082 arg2 = static_cast< int >(val2);
42083 }
42084 if (obj2) {
42085 {
42086 arg3 = wxString_in_helper(obj2);
42087 if (arg3 == NULL) SWIG_fail;
42088 temp3 = true;
42089 }
42090 }
42091 if (obj3) {
42092 {
42093 arg4 = wxString_in_helper(obj3);
42094 if (arg4 == NULL) SWIG_fail;
42095 temp4 = true;
42096 }
42097 }
42098 if (obj4) {
42099 ecode5 = SWIG_AsVal_int(obj4, &val5);
42100 if (!SWIG_IsOK(ecode5)) {
42101 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42102 }
42103 arg5 = static_cast< wxItemKind >(val5);
42104 }
42105 if (obj5) {
42106 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42107 if (!SWIG_IsOK(res6)) {
42108 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42109 }
42110 arg6 = reinterpret_cast< wxMenu * >(argp6);
42111 }
42112 {
42113 PyThreadState* __tstate = wxPyBeginAllowThreads();
42114 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42115 wxPyEndAllowThreads(__tstate);
42116 if (PyErr_Occurred()) SWIG_fail;
42117 }
42118 {
42119 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42120 }
42121 {
42122 if (temp3)
42123 delete arg3;
42124 }
42125 {
42126 if (temp4)
42127 delete arg4;
42128 }
42129 return resultobj;
42130 fail:
42131 {
42132 if (temp3)
42133 delete arg3;
42134 }
42135 {
42136 if (temp4)
42137 delete arg4;
42138 }
42139 return NULL;
42140 }
42141
42142
42143 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42144 PyObject *resultobj = 0;
42145 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42146 void *argp1 = 0 ;
42147 int res1 = 0 ;
42148 PyObject *swig_obj[1] ;
42149
42150 if (!args) SWIG_fail;
42151 swig_obj[0] = args;
42152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42153 if (!SWIG_IsOK(res1)) {
42154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42155 }
42156 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42157 {
42158 PyThreadState* __tstate = wxPyBeginAllowThreads();
42159 delete arg1;
42160
42161 wxPyEndAllowThreads(__tstate);
42162 if (PyErr_Occurred()) SWIG_fail;
42163 }
42164 resultobj = SWIG_Py_Void();
42165 return resultobj;
42166 fail:
42167 return NULL;
42168 }
42169
42170
42171 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42172 PyObject *resultobj = 0;
42173 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42174 wxMenu *result = 0 ;
42175 void *argp1 = 0 ;
42176 int res1 = 0 ;
42177 PyObject *swig_obj[1] ;
42178
42179 if (!args) SWIG_fail;
42180 swig_obj[0] = args;
42181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42182 if (!SWIG_IsOK(res1)) {
42183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42184 }
42185 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42186 {
42187 PyThreadState* __tstate = wxPyBeginAllowThreads();
42188 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42189 wxPyEndAllowThreads(__tstate);
42190 if (PyErr_Occurred()) SWIG_fail;
42191 }
42192 {
42193 resultobj = wxPyMake_wxObject(result, 0);
42194 }
42195 return resultobj;
42196 fail:
42197 return NULL;
42198 }
42199
42200
42201 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42202 PyObject *resultobj = 0;
42203 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42204 wxMenu *arg2 = (wxMenu *) 0 ;
42205 void *argp1 = 0 ;
42206 int res1 = 0 ;
42207 void *argp2 = 0 ;
42208 int res2 = 0 ;
42209 PyObject * obj0 = 0 ;
42210 PyObject * obj1 = 0 ;
42211 char * kwnames[] = {
42212 (char *) "self",(char *) "menu", NULL
42213 };
42214
42215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42217 if (!SWIG_IsOK(res1)) {
42218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42219 }
42220 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42222 if (!SWIG_IsOK(res2)) {
42223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42224 }
42225 arg2 = reinterpret_cast< wxMenu * >(argp2);
42226 {
42227 PyThreadState* __tstate = wxPyBeginAllowThreads();
42228 (arg1)->SetMenu(arg2);
42229 wxPyEndAllowThreads(__tstate);
42230 if (PyErr_Occurred()) SWIG_fail;
42231 }
42232 resultobj = SWIG_Py_Void();
42233 return resultobj;
42234 fail:
42235 return NULL;
42236 }
42237
42238
42239 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42240 PyObject *resultobj = 0;
42241 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42242 int arg2 ;
42243 void *argp1 = 0 ;
42244 int res1 = 0 ;
42245 int val2 ;
42246 int ecode2 = 0 ;
42247 PyObject * obj0 = 0 ;
42248 PyObject * obj1 = 0 ;
42249 char * kwnames[] = {
42250 (char *) "self",(char *) "id", NULL
42251 };
42252
42253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42255 if (!SWIG_IsOK(res1)) {
42256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42257 }
42258 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42259 ecode2 = SWIG_AsVal_int(obj1, &val2);
42260 if (!SWIG_IsOK(ecode2)) {
42261 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42262 }
42263 arg2 = static_cast< int >(val2);
42264 {
42265 PyThreadState* __tstate = wxPyBeginAllowThreads();
42266 (arg1)->SetId(arg2);
42267 wxPyEndAllowThreads(__tstate);
42268 if (PyErr_Occurred()) SWIG_fail;
42269 }
42270 resultobj = SWIG_Py_Void();
42271 return resultobj;
42272 fail:
42273 return NULL;
42274 }
42275
42276
42277 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42278 PyObject *resultobj = 0;
42279 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42280 int result;
42281 void *argp1 = 0 ;
42282 int res1 = 0 ;
42283 PyObject *swig_obj[1] ;
42284
42285 if (!args) SWIG_fail;
42286 swig_obj[0] = args;
42287 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42288 if (!SWIG_IsOK(res1)) {
42289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42290 }
42291 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42292 {
42293 PyThreadState* __tstate = wxPyBeginAllowThreads();
42294 result = (int)((wxMenuItem const *)arg1)->GetId();
42295 wxPyEndAllowThreads(__tstate);
42296 if (PyErr_Occurred()) SWIG_fail;
42297 }
42298 resultobj = SWIG_From_int(static_cast< int >(result));
42299 return resultobj;
42300 fail:
42301 return NULL;
42302 }
42303
42304
42305 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42306 PyObject *resultobj = 0;
42307 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42308 bool result;
42309 void *argp1 = 0 ;
42310 int res1 = 0 ;
42311 PyObject *swig_obj[1] ;
42312
42313 if (!args) SWIG_fail;
42314 swig_obj[0] = args;
42315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42316 if (!SWIG_IsOK(res1)) {
42317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42318 }
42319 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42320 {
42321 PyThreadState* __tstate = wxPyBeginAllowThreads();
42322 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42323 wxPyEndAllowThreads(__tstate);
42324 if (PyErr_Occurred()) SWIG_fail;
42325 }
42326 {
42327 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42328 }
42329 return resultobj;
42330 fail:
42331 return NULL;
42332 }
42333
42334
42335 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42336 PyObject *resultobj = 0;
42337 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42338 wxString *arg2 = 0 ;
42339 void *argp1 = 0 ;
42340 int res1 = 0 ;
42341 bool temp2 = false ;
42342 PyObject * obj0 = 0 ;
42343 PyObject * obj1 = 0 ;
42344 char * kwnames[] = {
42345 (char *) "self",(char *) "str", NULL
42346 };
42347
42348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42350 if (!SWIG_IsOK(res1)) {
42351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42352 }
42353 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42354 {
42355 arg2 = wxString_in_helper(obj1);
42356 if (arg2 == NULL) SWIG_fail;
42357 temp2 = true;
42358 }
42359 {
42360 PyThreadState* __tstate = wxPyBeginAllowThreads();
42361 (arg1)->SetText((wxString const &)*arg2);
42362 wxPyEndAllowThreads(__tstate);
42363 if (PyErr_Occurred()) SWIG_fail;
42364 }
42365 resultobj = SWIG_Py_Void();
42366 {
42367 if (temp2)
42368 delete arg2;
42369 }
42370 return resultobj;
42371 fail:
42372 {
42373 if (temp2)
42374 delete arg2;
42375 }
42376 return NULL;
42377 }
42378
42379
42380 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42381 PyObject *resultobj = 0;
42382 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42383 wxString result;
42384 void *argp1 = 0 ;
42385 int res1 = 0 ;
42386 PyObject *swig_obj[1] ;
42387
42388 if (!args) SWIG_fail;
42389 swig_obj[0] = args;
42390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42391 if (!SWIG_IsOK(res1)) {
42392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42393 }
42394 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42395 {
42396 PyThreadState* __tstate = wxPyBeginAllowThreads();
42397 result = ((wxMenuItem const *)arg1)->GetLabel();
42398 wxPyEndAllowThreads(__tstate);
42399 if (PyErr_Occurred()) SWIG_fail;
42400 }
42401 {
42402 #if wxUSE_UNICODE
42403 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42404 #else
42405 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42406 #endif
42407 }
42408 return resultobj;
42409 fail:
42410 return NULL;
42411 }
42412
42413
42414 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42415 PyObject *resultobj = 0;
42416 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42417 wxString *result = 0 ;
42418 void *argp1 = 0 ;
42419 int res1 = 0 ;
42420 PyObject *swig_obj[1] ;
42421
42422 if (!args) SWIG_fail;
42423 swig_obj[0] = args;
42424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42425 if (!SWIG_IsOK(res1)) {
42426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42427 }
42428 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42429 {
42430 PyThreadState* __tstate = wxPyBeginAllowThreads();
42431 {
42432 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42433 result = (wxString *) &_result_ref;
42434 }
42435 wxPyEndAllowThreads(__tstate);
42436 if (PyErr_Occurred()) SWIG_fail;
42437 }
42438 {
42439 #if wxUSE_UNICODE
42440 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42441 #else
42442 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42443 #endif
42444 }
42445 return resultobj;
42446 fail:
42447 return NULL;
42448 }
42449
42450
42451 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42452 PyObject *resultobj = 0;
42453 wxString *arg1 = 0 ;
42454 wxString result;
42455 bool temp1 = false ;
42456 PyObject * obj0 = 0 ;
42457 char * kwnames[] = {
42458 (char *) "text", NULL
42459 };
42460
42461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42462 {
42463 arg1 = wxString_in_helper(obj0);
42464 if (arg1 == NULL) SWIG_fail;
42465 temp1 = true;
42466 }
42467 {
42468 PyThreadState* __tstate = wxPyBeginAllowThreads();
42469 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42470 wxPyEndAllowThreads(__tstate);
42471 if (PyErr_Occurred()) SWIG_fail;
42472 }
42473 {
42474 #if wxUSE_UNICODE
42475 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42476 #else
42477 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42478 #endif
42479 }
42480 {
42481 if (temp1)
42482 delete arg1;
42483 }
42484 return resultobj;
42485 fail:
42486 {
42487 if (temp1)
42488 delete arg1;
42489 }
42490 return NULL;
42491 }
42492
42493
42494 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42495 PyObject *resultobj = 0;
42496 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42497 wxItemKind result;
42498 void *argp1 = 0 ;
42499 int res1 = 0 ;
42500 PyObject *swig_obj[1] ;
42501
42502 if (!args) SWIG_fail;
42503 swig_obj[0] = args;
42504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42505 if (!SWIG_IsOK(res1)) {
42506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42507 }
42508 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42509 {
42510 PyThreadState* __tstate = wxPyBeginAllowThreads();
42511 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42512 wxPyEndAllowThreads(__tstate);
42513 if (PyErr_Occurred()) SWIG_fail;
42514 }
42515 resultobj = SWIG_From_int(static_cast< int >(result));
42516 return resultobj;
42517 fail:
42518 return NULL;
42519 }
42520
42521
42522 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42523 PyObject *resultobj = 0;
42524 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42525 wxItemKind arg2 ;
42526 void *argp1 = 0 ;
42527 int res1 = 0 ;
42528 int val2 ;
42529 int ecode2 = 0 ;
42530 PyObject * obj0 = 0 ;
42531 PyObject * obj1 = 0 ;
42532 char * kwnames[] = {
42533 (char *) "self",(char *) "kind", NULL
42534 };
42535
42536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42538 if (!SWIG_IsOK(res1)) {
42539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42540 }
42541 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42542 ecode2 = SWIG_AsVal_int(obj1, &val2);
42543 if (!SWIG_IsOK(ecode2)) {
42544 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42545 }
42546 arg2 = static_cast< wxItemKind >(val2);
42547 {
42548 PyThreadState* __tstate = wxPyBeginAllowThreads();
42549 (arg1)->SetKind(arg2);
42550 wxPyEndAllowThreads(__tstate);
42551 if (PyErr_Occurred()) SWIG_fail;
42552 }
42553 resultobj = SWIG_Py_Void();
42554 return resultobj;
42555 fail:
42556 return NULL;
42557 }
42558
42559
42560 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42561 PyObject *resultobj = 0;
42562 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42563 bool arg2 ;
42564 void *argp1 = 0 ;
42565 int res1 = 0 ;
42566 bool val2 ;
42567 int ecode2 = 0 ;
42568 PyObject * obj0 = 0 ;
42569 PyObject * obj1 = 0 ;
42570 char * kwnames[] = {
42571 (char *) "self",(char *) "checkable", NULL
42572 };
42573
42574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42576 if (!SWIG_IsOK(res1)) {
42577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42578 }
42579 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42580 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42581 if (!SWIG_IsOK(ecode2)) {
42582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42583 }
42584 arg2 = static_cast< bool >(val2);
42585 {
42586 PyThreadState* __tstate = wxPyBeginAllowThreads();
42587 (arg1)->SetCheckable(arg2);
42588 wxPyEndAllowThreads(__tstate);
42589 if (PyErr_Occurred()) SWIG_fail;
42590 }
42591 resultobj = SWIG_Py_Void();
42592 return resultobj;
42593 fail:
42594 return NULL;
42595 }
42596
42597
42598 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42599 PyObject *resultobj = 0;
42600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42601 bool result;
42602 void *argp1 = 0 ;
42603 int res1 = 0 ;
42604 PyObject *swig_obj[1] ;
42605
42606 if (!args) SWIG_fail;
42607 swig_obj[0] = args;
42608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42609 if (!SWIG_IsOK(res1)) {
42610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42611 }
42612 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42613 {
42614 PyThreadState* __tstate = wxPyBeginAllowThreads();
42615 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42616 wxPyEndAllowThreads(__tstate);
42617 if (PyErr_Occurred()) SWIG_fail;
42618 }
42619 {
42620 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42621 }
42622 return resultobj;
42623 fail:
42624 return NULL;
42625 }
42626
42627
42628 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42629 PyObject *resultobj = 0;
42630 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42631 bool result;
42632 void *argp1 = 0 ;
42633 int res1 = 0 ;
42634 PyObject *swig_obj[1] ;
42635
42636 if (!args) SWIG_fail;
42637 swig_obj[0] = args;
42638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42639 if (!SWIG_IsOK(res1)) {
42640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42641 }
42642 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42643 {
42644 PyThreadState* __tstate = wxPyBeginAllowThreads();
42645 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42646 wxPyEndAllowThreads(__tstate);
42647 if (PyErr_Occurred()) SWIG_fail;
42648 }
42649 {
42650 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42651 }
42652 return resultobj;
42653 fail:
42654 return NULL;
42655 }
42656
42657
42658 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42659 PyObject *resultobj = 0;
42660 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42661 wxMenu *arg2 = (wxMenu *) 0 ;
42662 void *argp1 = 0 ;
42663 int res1 = 0 ;
42664 void *argp2 = 0 ;
42665 int res2 = 0 ;
42666 PyObject * obj0 = 0 ;
42667 PyObject * obj1 = 0 ;
42668 char * kwnames[] = {
42669 (char *) "self",(char *) "menu", NULL
42670 };
42671
42672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42674 if (!SWIG_IsOK(res1)) {
42675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42676 }
42677 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42679 if (!SWIG_IsOK(res2)) {
42680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42681 }
42682 arg2 = reinterpret_cast< wxMenu * >(argp2);
42683 {
42684 PyThreadState* __tstate = wxPyBeginAllowThreads();
42685 (arg1)->SetSubMenu(arg2);
42686 wxPyEndAllowThreads(__tstate);
42687 if (PyErr_Occurred()) SWIG_fail;
42688 }
42689 resultobj = SWIG_Py_Void();
42690 return resultobj;
42691 fail:
42692 return NULL;
42693 }
42694
42695
42696 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42697 PyObject *resultobj = 0;
42698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42699 wxMenu *result = 0 ;
42700 void *argp1 = 0 ;
42701 int res1 = 0 ;
42702 PyObject *swig_obj[1] ;
42703
42704 if (!args) SWIG_fail;
42705 swig_obj[0] = args;
42706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42707 if (!SWIG_IsOK(res1)) {
42708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42709 }
42710 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42711 {
42712 PyThreadState* __tstate = wxPyBeginAllowThreads();
42713 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42714 wxPyEndAllowThreads(__tstate);
42715 if (PyErr_Occurred()) SWIG_fail;
42716 }
42717 {
42718 resultobj = wxPyMake_wxObject(result, 0);
42719 }
42720 return resultobj;
42721 fail:
42722 return NULL;
42723 }
42724
42725
42726 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42727 PyObject *resultobj = 0;
42728 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42729 bool arg2 = (bool) true ;
42730 void *argp1 = 0 ;
42731 int res1 = 0 ;
42732 bool val2 ;
42733 int ecode2 = 0 ;
42734 PyObject * obj0 = 0 ;
42735 PyObject * obj1 = 0 ;
42736 char * kwnames[] = {
42737 (char *) "self",(char *) "enable", NULL
42738 };
42739
42740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42742 if (!SWIG_IsOK(res1)) {
42743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42744 }
42745 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42746 if (obj1) {
42747 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42748 if (!SWIG_IsOK(ecode2)) {
42749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42750 }
42751 arg2 = static_cast< bool >(val2);
42752 }
42753 {
42754 PyThreadState* __tstate = wxPyBeginAllowThreads();
42755 (arg1)->Enable(arg2);
42756 wxPyEndAllowThreads(__tstate);
42757 if (PyErr_Occurred()) SWIG_fail;
42758 }
42759 resultobj = SWIG_Py_Void();
42760 return resultobj;
42761 fail:
42762 return NULL;
42763 }
42764
42765
42766 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42767 PyObject *resultobj = 0;
42768 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42769 bool result;
42770 void *argp1 = 0 ;
42771 int res1 = 0 ;
42772 PyObject *swig_obj[1] ;
42773
42774 if (!args) SWIG_fail;
42775 swig_obj[0] = args;
42776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42777 if (!SWIG_IsOK(res1)) {
42778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42779 }
42780 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42781 {
42782 PyThreadState* __tstate = wxPyBeginAllowThreads();
42783 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42784 wxPyEndAllowThreads(__tstate);
42785 if (PyErr_Occurred()) SWIG_fail;
42786 }
42787 {
42788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42789 }
42790 return resultobj;
42791 fail:
42792 return NULL;
42793 }
42794
42795
42796 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42797 PyObject *resultobj = 0;
42798 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42799 bool arg2 = (bool) true ;
42800 void *argp1 = 0 ;
42801 int res1 = 0 ;
42802 bool val2 ;
42803 int ecode2 = 0 ;
42804 PyObject * obj0 = 0 ;
42805 PyObject * obj1 = 0 ;
42806 char * kwnames[] = {
42807 (char *) "self",(char *) "check", NULL
42808 };
42809
42810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42812 if (!SWIG_IsOK(res1)) {
42813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42814 }
42815 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42816 if (obj1) {
42817 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42818 if (!SWIG_IsOK(ecode2)) {
42819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42820 }
42821 arg2 = static_cast< bool >(val2);
42822 }
42823 {
42824 PyThreadState* __tstate = wxPyBeginAllowThreads();
42825 (arg1)->Check(arg2);
42826 wxPyEndAllowThreads(__tstate);
42827 if (PyErr_Occurred()) SWIG_fail;
42828 }
42829 resultobj = SWIG_Py_Void();
42830 return resultobj;
42831 fail:
42832 return NULL;
42833 }
42834
42835
42836 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42837 PyObject *resultobj = 0;
42838 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42839 bool result;
42840 void *argp1 = 0 ;
42841 int res1 = 0 ;
42842 PyObject *swig_obj[1] ;
42843
42844 if (!args) SWIG_fail;
42845 swig_obj[0] = args;
42846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42847 if (!SWIG_IsOK(res1)) {
42848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42849 }
42850 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42851 {
42852 PyThreadState* __tstate = wxPyBeginAllowThreads();
42853 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
42854 wxPyEndAllowThreads(__tstate);
42855 if (PyErr_Occurred()) SWIG_fail;
42856 }
42857 {
42858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42859 }
42860 return resultobj;
42861 fail:
42862 return NULL;
42863 }
42864
42865
42866 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42867 PyObject *resultobj = 0;
42868 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42869 void *argp1 = 0 ;
42870 int res1 = 0 ;
42871 PyObject *swig_obj[1] ;
42872
42873 if (!args) SWIG_fail;
42874 swig_obj[0] = args;
42875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42876 if (!SWIG_IsOK(res1)) {
42877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42878 }
42879 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42880 {
42881 PyThreadState* __tstate = wxPyBeginAllowThreads();
42882 (arg1)->Toggle();
42883 wxPyEndAllowThreads(__tstate);
42884 if (PyErr_Occurred()) SWIG_fail;
42885 }
42886 resultobj = SWIG_Py_Void();
42887 return resultobj;
42888 fail:
42889 return NULL;
42890 }
42891
42892
42893 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42894 PyObject *resultobj = 0;
42895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42896 wxString *arg2 = 0 ;
42897 void *argp1 = 0 ;
42898 int res1 = 0 ;
42899 bool temp2 = false ;
42900 PyObject * obj0 = 0 ;
42901 PyObject * obj1 = 0 ;
42902 char * kwnames[] = {
42903 (char *) "self",(char *) "str", NULL
42904 };
42905
42906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
42907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42908 if (!SWIG_IsOK(res1)) {
42909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42910 }
42911 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42912 {
42913 arg2 = wxString_in_helper(obj1);
42914 if (arg2 == NULL) SWIG_fail;
42915 temp2 = true;
42916 }
42917 {
42918 PyThreadState* __tstate = wxPyBeginAllowThreads();
42919 (arg1)->SetHelp((wxString const &)*arg2);
42920 wxPyEndAllowThreads(__tstate);
42921 if (PyErr_Occurred()) SWIG_fail;
42922 }
42923 resultobj = SWIG_Py_Void();
42924 {
42925 if (temp2)
42926 delete arg2;
42927 }
42928 return resultobj;
42929 fail:
42930 {
42931 if (temp2)
42932 delete arg2;
42933 }
42934 return NULL;
42935 }
42936
42937
42938 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42939 PyObject *resultobj = 0;
42940 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42941 wxString *result = 0 ;
42942 void *argp1 = 0 ;
42943 int res1 = 0 ;
42944 PyObject *swig_obj[1] ;
42945
42946 if (!args) SWIG_fail;
42947 swig_obj[0] = args;
42948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42949 if (!SWIG_IsOK(res1)) {
42950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42951 }
42952 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42953 {
42954 PyThreadState* __tstate = wxPyBeginAllowThreads();
42955 {
42956 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
42957 result = (wxString *) &_result_ref;
42958 }
42959 wxPyEndAllowThreads(__tstate);
42960 if (PyErr_Occurred()) SWIG_fail;
42961 }
42962 {
42963 #if wxUSE_UNICODE
42964 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42965 #else
42966 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42967 #endif
42968 }
42969 return resultobj;
42970 fail:
42971 return NULL;
42972 }
42973
42974
42975 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42976 PyObject *resultobj = 0;
42977 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42978 wxAcceleratorEntry *result = 0 ;
42979 void *argp1 = 0 ;
42980 int res1 = 0 ;
42981 PyObject *swig_obj[1] ;
42982
42983 if (!args) SWIG_fail;
42984 swig_obj[0] = args;
42985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42986 if (!SWIG_IsOK(res1)) {
42987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42988 }
42989 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42990 {
42991 PyThreadState* __tstate = wxPyBeginAllowThreads();
42992 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
42993 wxPyEndAllowThreads(__tstate);
42994 if (PyErr_Occurred()) SWIG_fail;
42995 }
42996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
42997 return resultobj;
42998 fail:
42999 return NULL;
43000 }
43001
43002
43003 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43004 PyObject *resultobj = 0;
43005 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43006 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43007 void *argp1 = 0 ;
43008 int res1 = 0 ;
43009 void *argp2 = 0 ;
43010 int res2 = 0 ;
43011 PyObject * obj0 = 0 ;
43012 PyObject * obj1 = 0 ;
43013 char * kwnames[] = {
43014 (char *) "self",(char *) "accel", NULL
43015 };
43016
43017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43018 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43019 if (!SWIG_IsOK(res1)) {
43020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43021 }
43022 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43023 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43024 if (!SWIG_IsOK(res2)) {
43025 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43026 }
43027 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43028 {
43029 PyThreadState* __tstate = wxPyBeginAllowThreads();
43030 (arg1)->SetAccel(arg2);
43031 wxPyEndAllowThreads(__tstate);
43032 if (PyErr_Occurred()) SWIG_fail;
43033 }
43034 resultobj = SWIG_Py_Void();
43035 return resultobj;
43036 fail:
43037 return NULL;
43038 }
43039
43040
43041 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43042 PyObject *resultobj = 0;
43043 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43044 wxBitmap *arg2 = 0 ;
43045 void *argp1 = 0 ;
43046 int res1 = 0 ;
43047 void *argp2 = 0 ;
43048 int res2 = 0 ;
43049 PyObject * obj0 = 0 ;
43050 PyObject * obj1 = 0 ;
43051 char * kwnames[] = {
43052 (char *) "self",(char *) "bitmap", NULL
43053 };
43054
43055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43057 if (!SWIG_IsOK(res1)) {
43058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43059 }
43060 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43061 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43062 if (!SWIG_IsOK(res2)) {
43063 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43064 }
43065 if (!argp2) {
43066 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43067 }
43068 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43069 {
43070 PyThreadState* __tstate = wxPyBeginAllowThreads();
43071 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43072 wxPyEndAllowThreads(__tstate);
43073 if (PyErr_Occurred()) SWIG_fail;
43074 }
43075 resultobj = SWIG_Py_Void();
43076 return resultobj;
43077 fail:
43078 return NULL;
43079 }
43080
43081
43082 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43083 PyObject *resultobj = 0;
43084 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43085 wxBitmap *result = 0 ;
43086 void *argp1 = 0 ;
43087 int res1 = 0 ;
43088 PyObject *swig_obj[1] ;
43089
43090 if (!args) SWIG_fail;
43091 swig_obj[0] = args;
43092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43093 if (!SWIG_IsOK(res1)) {
43094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43095 }
43096 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43097 {
43098 PyThreadState* __tstate = wxPyBeginAllowThreads();
43099 {
43100 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43101 result = (wxBitmap *) &_result_ref;
43102 }
43103 wxPyEndAllowThreads(__tstate);
43104 if (PyErr_Occurred()) SWIG_fail;
43105 }
43106 {
43107 wxBitmap* resultptr = new wxBitmap(*result);
43108 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43109 }
43110 return resultobj;
43111 fail:
43112 return NULL;
43113 }
43114
43115
43116 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43117 PyObject *resultobj = 0;
43118 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43119 wxFont *arg2 = 0 ;
43120 void *argp1 = 0 ;
43121 int res1 = 0 ;
43122 void *argp2 = 0 ;
43123 int res2 = 0 ;
43124 PyObject * obj0 = 0 ;
43125 PyObject * obj1 = 0 ;
43126 char * kwnames[] = {
43127 (char *) "self",(char *) "font", NULL
43128 };
43129
43130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43132 if (!SWIG_IsOK(res1)) {
43133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43134 }
43135 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43136 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43137 if (!SWIG_IsOK(res2)) {
43138 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43139 }
43140 if (!argp2) {
43141 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43142 }
43143 arg2 = reinterpret_cast< wxFont * >(argp2);
43144 {
43145 PyThreadState* __tstate = wxPyBeginAllowThreads();
43146 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43147 wxPyEndAllowThreads(__tstate);
43148 if (PyErr_Occurred()) SWIG_fail;
43149 }
43150 resultobj = SWIG_Py_Void();
43151 return resultobj;
43152 fail:
43153 return NULL;
43154 }
43155
43156
43157 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43158 PyObject *resultobj = 0;
43159 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43160 wxFont result;
43161 void *argp1 = 0 ;
43162 int res1 = 0 ;
43163 PyObject *swig_obj[1] ;
43164
43165 if (!args) SWIG_fail;
43166 swig_obj[0] = args;
43167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43168 if (!SWIG_IsOK(res1)) {
43169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43170 }
43171 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43172 {
43173 PyThreadState* __tstate = wxPyBeginAllowThreads();
43174 result = wxMenuItem_GetFont(arg1);
43175 wxPyEndAllowThreads(__tstate);
43176 if (PyErr_Occurred()) SWIG_fail;
43177 }
43178 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43179 return resultobj;
43180 fail:
43181 return NULL;
43182 }
43183
43184
43185 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43186 PyObject *resultobj = 0;
43187 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43188 wxColour *arg2 = 0 ;
43189 void *argp1 = 0 ;
43190 int res1 = 0 ;
43191 wxColour temp2 ;
43192 PyObject * obj0 = 0 ;
43193 PyObject * obj1 = 0 ;
43194 char * kwnames[] = {
43195 (char *) "self",(char *) "colText", NULL
43196 };
43197
43198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43200 if (!SWIG_IsOK(res1)) {
43201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43202 }
43203 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43204 {
43205 arg2 = &temp2;
43206 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43207 }
43208 {
43209 PyThreadState* __tstate = wxPyBeginAllowThreads();
43210 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43211 wxPyEndAllowThreads(__tstate);
43212 if (PyErr_Occurred()) SWIG_fail;
43213 }
43214 resultobj = SWIG_Py_Void();
43215 return resultobj;
43216 fail:
43217 return NULL;
43218 }
43219
43220
43221 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43222 PyObject *resultobj = 0;
43223 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43224 wxColour result;
43225 void *argp1 = 0 ;
43226 int res1 = 0 ;
43227 PyObject *swig_obj[1] ;
43228
43229 if (!args) SWIG_fail;
43230 swig_obj[0] = args;
43231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43232 if (!SWIG_IsOK(res1)) {
43233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43234 }
43235 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43236 {
43237 PyThreadState* __tstate = wxPyBeginAllowThreads();
43238 result = wxMenuItem_GetTextColour(arg1);
43239 wxPyEndAllowThreads(__tstate);
43240 if (PyErr_Occurred()) SWIG_fail;
43241 }
43242 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43243 return resultobj;
43244 fail:
43245 return NULL;
43246 }
43247
43248
43249 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43250 PyObject *resultobj = 0;
43251 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43252 wxColour *arg2 = 0 ;
43253 void *argp1 = 0 ;
43254 int res1 = 0 ;
43255 wxColour temp2 ;
43256 PyObject * obj0 = 0 ;
43257 PyObject * obj1 = 0 ;
43258 char * kwnames[] = {
43259 (char *) "self",(char *) "colBack", NULL
43260 };
43261
43262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43264 if (!SWIG_IsOK(res1)) {
43265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43266 }
43267 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43268 {
43269 arg2 = &temp2;
43270 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43271 }
43272 {
43273 PyThreadState* __tstate = wxPyBeginAllowThreads();
43274 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43275 wxPyEndAllowThreads(__tstate);
43276 if (PyErr_Occurred()) SWIG_fail;
43277 }
43278 resultobj = SWIG_Py_Void();
43279 return resultobj;
43280 fail:
43281 return NULL;
43282 }
43283
43284
43285 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43286 PyObject *resultobj = 0;
43287 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43288 wxColour result;
43289 void *argp1 = 0 ;
43290 int res1 = 0 ;
43291 PyObject *swig_obj[1] ;
43292
43293 if (!args) SWIG_fail;
43294 swig_obj[0] = args;
43295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43296 if (!SWIG_IsOK(res1)) {
43297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43298 }
43299 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43300 {
43301 PyThreadState* __tstate = wxPyBeginAllowThreads();
43302 result = wxMenuItem_GetBackgroundColour(arg1);
43303 wxPyEndAllowThreads(__tstate);
43304 if (PyErr_Occurred()) SWIG_fail;
43305 }
43306 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43307 return resultobj;
43308 fail:
43309 return NULL;
43310 }
43311
43312
43313 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43314 PyObject *resultobj = 0;
43315 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43316 wxBitmap *arg2 = 0 ;
43317 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43318 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43319 void *argp1 = 0 ;
43320 int res1 = 0 ;
43321 void *argp2 = 0 ;
43322 int res2 = 0 ;
43323 void *argp3 = 0 ;
43324 int res3 = 0 ;
43325 PyObject * obj0 = 0 ;
43326 PyObject * obj1 = 0 ;
43327 PyObject * obj2 = 0 ;
43328 char * kwnames[] = {
43329 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43330 };
43331
43332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43334 if (!SWIG_IsOK(res1)) {
43335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43336 }
43337 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43339 if (!SWIG_IsOK(res2)) {
43340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43341 }
43342 if (!argp2) {
43343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43344 }
43345 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43346 if (obj2) {
43347 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43348 if (!SWIG_IsOK(res3)) {
43349 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43350 }
43351 if (!argp3) {
43352 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43353 }
43354 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43355 }
43356 {
43357 PyThreadState* __tstate = wxPyBeginAllowThreads();
43358 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43359 wxPyEndAllowThreads(__tstate);
43360 if (PyErr_Occurred()) SWIG_fail;
43361 }
43362 resultobj = SWIG_Py_Void();
43363 return resultobj;
43364 fail:
43365 return NULL;
43366 }
43367
43368
43369 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43370 PyObject *resultobj = 0;
43371 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43372 wxBitmap *arg2 = 0 ;
43373 void *argp1 = 0 ;
43374 int res1 = 0 ;
43375 void *argp2 = 0 ;
43376 int res2 = 0 ;
43377 PyObject * obj0 = 0 ;
43378 PyObject * obj1 = 0 ;
43379 char * kwnames[] = {
43380 (char *) "self",(char *) "bmpDisabled", NULL
43381 };
43382
43383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43385 if (!SWIG_IsOK(res1)) {
43386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43387 }
43388 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43389 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43390 if (!SWIG_IsOK(res2)) {
43391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43392 }
43393 if (!argp2) {
43394 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43395 }
43396 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43397 {
43398 PyThreadState* __tstate = wxPyBeginAllowThreads();
43399 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43400 wxPyEndAllowThreads(__tstate);
43401 if (PyErr_Occurred()) SWIG_fail;
43402 }
43403 resultobj = SWIG_Py_Void();
43404 return resultobj;
43405 fail:
43406 return NULL;
43407 }
43408
43409
43410 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43411 PyObject *resultobj = 0;
43412 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43413 wxBitmap *result = 0 ;
43414 void *argp1 = 0 ;
43415 int res1 = 0 ;
43416 PyObject *swig_obj[1] ;
43417
43418 if (!args) SWIG_fail;
43419 swig_obj[0] = args;
43420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43421 if (!SWIG_IsOK(res1)) {
43422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43423 }
43424 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43425 {
43426 PyThreadState* __tstate = wxPyBeginAllowThreads();
43427 {
43428 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43429 result = (wxBitmap *) &_result_ref;
43430 }
43431 wxPyEndAllowThreads(__tstate);
43432 if (PyErr_Occurred()) SWIG_fail;
43433 }
43434 {
43435 wxBitmap* resultptr = new wxBitmap(*result);
43436 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43437 }
43438 return resultobj;
43439 fail:
43440 return NULL;
43441 }
43442
43443
43444 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43445 PyObject *resultobj = 0;
43446 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43447 int arg2 ;
43448 void *argp1 = 0 ;
43449 int res1 = 0 ;
43450 int val2 ;
43451 int ecode2 = 0 ;
43452 PyObject * obj0 = 0 ;
43453 PyObject * obj1 = 0 ;
43454 char * kwnames[] = {
43455 (char *) "self",(char *) "nWidth", NULL
43456 };
43457
43458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43459 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43460 if (!SWIG_IsOK(res1)) {
43461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43462 }
43463 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43464 ecode2 = SWIG_AsVal_int(obj1, &val2);
43465 if (!SWIG_IsOK(ecode2)) {
43466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43467 }
43468 arg2 = static_cast< int >(val2);
43469 {
43470 PyThreadState* __tstate = wxPyBeginAllowThreads();
43471 wxMenuItem_SetMarginWidth(arg1,arg2);
43472 wxPyEndAllowThreads(__tstate);
43473 if (PyErr_Occurred()) SWIG_fail;
43474 }
43475 resultobj = SWIG_Py_Void();
43476 return resultobj;
43477 fail:
43478 return NULL;
43479 }
43480
43481
43482 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43483 PyObject *resultobj = 0;
43484 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43485 int result;
43486 void *argp1 = 0 ;
43487 int res1 = 0 ;
43488 PyObject *swig_obj[1] ;
43489
43490 if (!args) SWIG_fail;
43491 swig_obj[0] = args;
43492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43493 if (!SWIG_IsOK(res1)) {
43494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43495 }
43496 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43497 {
43498 PyThreadState* __tstate = wxPyBeginAllowThreads();
43499 result = (int)wxMenuItem_GetMarginWidth(arg1);
43500 wxPyEndAllowThreads(__tstate);
43501 if (PyErr_Occurred()) SWIG_fail;
43502 }
43503 resultobj = SWIG_From_int(static_cast< int >(result));
43504 return resultobj;
43505 fail:
43506 return NULL;
43507 }
43508
43509
43510 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43511 PyObject *resultobj = 0;
43512 int result;
43513
43514 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43515 {
43516 PyThreadState* __tstate = wxPyBeginAllowThreads();
43517 result = (int)wxMenuItem_GetDefaultMarginWidth();
43518 wxPyEndAllowThreads(__tstate);
43519 if (PyErr_Occurred()) SWIG_fail;
43520 }
43521 resultobj = SWIG_From_int(static_cast< int >(result));
43522 return resultobj;
43523 fail:
43524 return NULL;
43525 }
43526
43527
43528 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43529 PyObject *resultobj = 0;
43530 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43531 bool result;
43532 void *argp1 = 0 ;
43533 int res1 = 0 ;
43534 PyObject *swig_obj[1] ;
43535
43536 if (!args) SWIG_fail;
43537 swig_obj[0] = args;
43538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43539 if (!SWIG_IsOK(res1)) {
43540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43541 }
43542 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43543 {
43544 PyThreadState* __tstate = wxPyBeginAllowThreads();
43545 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43546 wxPyEndAllowThreads(__tstate);
43547 if (PyErr_Occurred()) SWIG_fail;
43548 }
43549 {
43550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43551 }
43552 return resultobj;
43553 fail:
43554 return NULL;
43555 }
43556
43557
43558 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43559 PyObject *resultobj = 0;
43560 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43561 bool arg2 = (bool) true ;
43562 void *argp1 = 0 ;
43563 int res1 = 0 ;
43564 bool val2 ;
43565 int ecode2 = 0 ;
43566 PyObject * obj0 = 0 ;
43567 PyObject * obj1 = 0 ;
43568 char * kwnames[] = {
43569 (char *) "self",(char *) "ownerDrawn", NULL
43570 };
43571
43572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43574 if (!SWIG_IsOK(res1)) {
43575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43576 }
43577 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43578 if (obj1) {
43579 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43580 if (!SWIG_IsOK(ecode2)) {
43581 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43582 }
43583 arg2 = static_cast< bool >(val2);
43584 }
43585 {
43586 PyThreadState* __tstate = wxPyBeginAllowThreads();
43587 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43588 wxPyEndAllowThreads(__tstate);
43589 if (PyErr_Occurred()) SWIG_fail;
43590 }
43591 resultobj = SWIG_Py_Void();
43592 return resultobj;
43593 fail:
43594 return NULL;
43595 }
43596
43597
43598 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43599 PyObject *resultobj = 0;
43600 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43601 void *argp1 = 0 ;
43602 int res1 = 0 ;
43603 PyObject *swig_obj[1] ;
43604
43605 if (!args) SWIG_fail;
43606 swig_obj[0] = args;
43607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43608 if (!SWIG_IsOK(res1)) {
43609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43610 }
43611 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43612 {
43613 PyThreadState* __tstate = wxPyBeginAllowThreads();
43614 wxMenuItem_ResetOwnerDrawn(arg1);
43615 wxPyEndAllowThreads(__tstate);
43616 if (PyErr_Occurred()) SWIG_fail;
43617 }
43618 resultobj = SWIG_Py_Void();
43619 return resultobj;
43620 fail:
43621 return NULL;
43622 }
43623
43624
43625 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43626 PyObject *obj;
43627 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43628 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43629 return SWIG_Py_Void();
43630 }
43631
43632 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43633 return SWIG_Python_InitShadowInstance(args);
43634 }
43635
43636 SWIGINTERN int ControlNameStr_set(PyObject *) {
43637 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43638 return 1;
43639 }
43640
43641
43642 SWIGINTERN PyObject *ControlNameStr_get(void) {
43643 PyObject *pyobj = 0;
43644
43645 {
43646 #if wxUSE_UNICODE
43647 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43648 #else
43649 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43650 #endif
43651 }
43652 return pyobj;
43653 }
43654
43655
43656 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43657 PyObject *resultobj = 0;
43658 wxWindow *arg1 = (wxWindow *) 0 ;
43659 int arg2 = (int) -1 ;
43660 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43661 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43662 wxSize const &arg4_defvalue = wxDefaultSize ;
43663 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43664 long arg5 = (long) 0 ;
43665 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43666 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43667 wxString const &arg7_defvalue = wxPyControlNameStr ;
43668 wxString *arg7 = (wxString *) &arg7_defvalue ;
43669 wxControl *result = 0 ;
43670 void *argp1 = 0 ;
43671 int res1 = 0 ;
43672 int val2 ;
43673 int ecode2 = 0 ;
43674 wxPoint temp3 ;
43675 wxSize temp4 ;
43676 long val5 ;
43677 int ecode5 = 0 ;
43678 void *argp6 = 0 ;
43679 int res6 = 0 ;
43680 bool temp7 = false ;
43681 PyObject * obj0 = 0 ;
43682 PyObject * obj1 = 0 ;
43683 PyObject * obj2 = 0 ;
43684 PyObject * obj3 = 0 ;
43685 PyObject * obj4 = 0 ;
43686 PyObject * obj5 = 0 ;
43687 PyObject * obj6 = 0 ;
43688 char * kwnames[] = {
43689 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43690 };
43691
43692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43693 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43694 if (!SWIG_IsOK(res1)) {
43695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43696 }
43697 arg1 = reinterpret_cast< wxWindow * >(argp1);
43698 if (obj1) {
43699 ecode2 = SWIG_AsVal_int(obj1, &val2);
43700 if (!SWIG_IsOK(ecode2)) {
43701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43702 }
43703 arg2 = static_cast< int >(val2);
43704 }
43705 if (obj2) {
43706 {
43707 arg3 = &temp3;
43708 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43709 }
43710 }
43711 if (obj3) {
43712 {
43713 arg4 = &temp4;
43714 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43715 }
43716 }
43717 if (obj4) {
43718 ecode5 = SWIG_AsVal_long(obj4, &val5);
43719 if (!SWIG_IsOK(ecode5)) {
43720 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43721 }
43722 arg5 = static_cast< long >(val5);
43723 }
43724 if (obj5) {
43725 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43726 if (!SWIG_IsOK(res6)) {
43727 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43728 }
43729 if (!argp6) {
43730 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43731 }
43732 arg6 = reinterpret_cast< wxValidator * >(argp6);
43733 }
43734 if (obj6) {
43735 {
43736 arg7 = wxString_in_helper(obj6);
43737 if (arg7 == NULL) SWIG_fail;
43738 temp7 = true;
43739 }
43740 }
43741 {
43742 if (!wxPyCheckForApp()) SWIG_fail;
43743 PyThreadState* __tstate = wxPyBeginAllowThreads();
43744 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43745 wxPyEndAllowThreads(__tstate);
43746 if (PyErr_Occurred()) SWIG_fail;
43747 }
43748 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43749 {
43750 if (temp7)
43751 delete arg7;
43752 }
43753 return resultobj;
43754 fail:
43755 {
43756 if (temp7)
43757 delete arg7;
43758 }
43759 return NULL;
43760 }
43761
43762
43763 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43764 PyObject *resultobj = 0;
43765 wxControl *result = 0 ;
43766
43767 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43768 {
43769 if (!wxPyCheckForApp()) SWIG_fail;
43770 PyThreadState* __tstate = wxPyBeginAllowThreads();
43771 result = (wxControl *)new wxControl();
43772 wxPyEndAllowThreads(__tstate);
43773 if (PyErr_Occurred()) SWIG_fail;
43774 }
43775 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43776 return resultobj;
43777 fail:
43778 return NULL;
43779 }
43780
43781
43782 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43783 PyObject *resultobj = 0;
43784 wxControl *arg1 = (wxControl *) 0 ;
43785 wxWindow *arg2 = (wxWindow *) 0 ;
43786 int arg3 = (int) -1 ;
43787 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43788 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43789 wxSize const &arg5_defvalue = wxDefaultSize ;
43790 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43791 long arg6 = (long) 0 ;
43792 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43793 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43794 wxString const &arg8_defvalue = wxPyControlNameStr ;
43795 wxString *arg8 = (wxString *) &arg8_defvalue ;
43796 bool result;
43797 void *argp1 = 0 ;
43798 int res1 = 0 ;
43799 void *argp2 = 0 ;
43800 int res2 = 0 ;
43801 int val3 ;
43802 int ecode3 = 0 ;
43803 wxPoint temp4 ;
43804 wxSize temp5 ;
43805 long val6 ;
43806 int ecode6 = 0 ;
43807 void *argp7 = 0 ;
43808 int res7 = 0 ;
43809 bool temp8 = false ;
43810 PyObject * obj0 = 0 ;
43811 PyObject * obj1 = 0 ;
43812 PyObject * obj2 = 0 ;
43813 PyObject * obj3 = 0 ;
43814 PyObject * obj4 = 0 ;
43815 PyObject * obj5 = 0 ;
43816 PyObject * obj6 = 0 ;
43817 PyObject * obj7 = 0 ;
43818 char * kwnames[] = {
43819 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43820 };
43821
43822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43824 if (!SWIG_IsOK(res1)) {
43825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
43826 }
43827 arg1 = reinterpret_cast< wxControl * >(argp1);
43828 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
43829 if (!SWIG_IsOK(res2)) {
43830 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
43831 }
43832 arg2 = reinterpret_cast< wxWindow * >(argp2);
43833 if (obj2) {
43834 ecode3 = SWIG_AsVal_int(obj2, &val3);
43835 if (!SWIG_IsOK(ecode3)) {
43836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
43837 }
43838 arg3 = static_cast< int >(val3);
43839 }
43840 if (obj3) {
43841 {
43842 arg4 = &temp4;
43843 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
43844 }
43845 }
43846 if (obj4) {
43847 {
43848 arg5 = &temp5;
43849 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
43850 }
43851 }
43852 if (obj5) {
43853 ecode6 = SWIG_AsVal_long(obj5, &val6);
43854 if (!SWIG_IsOK(ecode6)) {
43855 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
43856 }
43857 arg6 = static_cast< long >(val6);
43858 }
43859 if (obj6) {
43860 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
43861 if (!SWIG_IsOK(res7)) {
43862 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43863 }
43864 if (!argp7) {
43865 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
43866 }
43867 arg7 = reinterpret_cast< wxValidator * >(argp7);
43868 }
43869 if (obj7) {
43870 {
43871 arg8 = wxString_in_helper(obj7);
43872 if (arg8 == NULL) SWIG_fail;
43873 temp8 = true;
43874 }
43875 }
43876 {
43877 PyThreadState* __tstate = wxPyBeginAllowThreads();
43878 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
43879 wxPyEndAllowThreads(__tstate);
43880 if (PyErr_Occurred()) SWIG_fail;
43881 }
43882 {
43883 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43884 }
43885 {
43886 if (temp8)
43887 delete arg8;
43888 }
43889 return resultobj;
43890 fail:
43891 {
43892 if (temp8)
43893 delete arg8;
43894 }
43895 return NULL;
43896 }
43897
43898
43899 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43900 PyObject *resultobj = 0;
43901 wxControl *arg1 = (wxControl *) 0 ;
43902 wxCommandEvent *arg2 = 0 ;
43903 void *argp1 = 0 ;
43904 int res1 = 0 ;
43905 void *argp2 = 0 ;
43906 int res2 = 0 ;
43907 PyObject * obj0 = 0 ;
43908 PyObject * obj1 = 0 ;
43909 char * kwnames[] = {
43910 (char *) "self",(char *) "event", NULL
43911 };
43912
43913 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
43914 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43915 if (!SWIG_IsOK(res1)) {
43916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
43917 }
43918 arg1 = reinterpret_cast< wxControl * >(argp1);
43919 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
43920 if (!SWIG_IsOK(res2)) {
43921 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43922 }
43923 if (!argp2) {
43924 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
43925 }
43926 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
43927 {
43928 PyThreadState* __tstate = wxPyBeginAllowThreads();
43929 (arg1)->Command(*arg2);
43930 wxPyEndAllowThreads(__tstate);
43931 if (PyErr_Occurred()) SWIG_fail;
43932 }
43933 resultobj = SWIG_Py_Void();
43934 return resultobj;
43935 fail:
43936 return NULL;
43937 }
43938
43939
43940 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43941 PyObject *resultobj = 0;
43942 wxControl *arg1 = (wxControl *) 0 ;
43943 wxString result;
43944 void *argp1 = 0 ;
43945 int res1 = 0 ;
43946 PyObject *swig_obj[1] ;
43947
43948 if (!args) SWIG_fail;
43949 swig_obj[0] = args;
43950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43951 if (!SWIG_IsOK(res1)) {
43952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
43953 }
43954 arg1 = reinterpret_cast< wxControl * >(argp1);
43955 {
43956 PyThreadState* __tstate = wxPyBeginAllowThreads();
43957 result = (arg1)->GetLabel();
43958 wxPyEndAllowThreads(__tstate);
43959 if (PyErr_Occurred()) SWIG_fail;
43960 }
43961 {
43962 #if wxUSE_UNICODE
43963 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43964 #else
43965 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43966 #endif
43967 }
43968 return resultobj;
43969 fail:
43970 return NULL;
43971 }
43972
43973
43974 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43975 PyObject *resultobj = 0;
43976 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
43977 SwigValueWrapper<wxVisualAttributes > result;
43978 int val1 ;
43979 int ecode1 = 0 ;
43980 PyObject * obj0 = 0 ;
43981 char * kwnames[] = {
43982 (char *) "variant", NULL
43983 };
43984
43985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
43986 if (obj0) {
43987 ecode1 = SWIG_AsVal_int(obj0, &val1);
43988 if (!SWIG_IsOK(ecode1)) {
43989 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
43990 }
43991 arg1 = static_cast< wxWindowVariant >(val1);
43992 }
43993 {
43994 if (!wxPyCheckForApp()) SWIG_fail;
43995 PyThreadState* __tstate = wxPyBeginAllowThreads();
43996 result = wxControl::GetClassDefaultAttributes(arg1);
43997 wxPyEndAllowThreads(__tstate);
43998 if (PyErr_Occurred()) SWIG_fail;
43999 }
44000 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44001 return resultobj;
44002 fail:
44003 return NULL;
44004 }
44005
44006
44007 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44008 PyObject *obj;
44009 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44010 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44011 return SWIG_Py_Void();
44012 }
44013
44014 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44015 return SWIG_Python_InitShadowInstance(args);
44016 }
44017
44018 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44019 PyObject *resultobj = 0;
44020 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44021 wxString *arg2 = 0 ;
44022 PyObject *arg3 = (PyObject *) NULL ;
44023 int result;
44024 void *argp1 = 0 ;
44025 int res1 = 0 ;
44026 bool temp2 = false ;
44027 PyObject * obj0 = 0 ;
44028 PyObject * obj1 = 0 ;
44029 PyObject * obj2 = 0 ;
44030 char * kwnames[] = {
44031 (char *) "self",(char *) "item",(char *) "clientData", NULL
44032 };
44033
44034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44036 if (!SWIG_IsOK(res1)) {
44037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44038 }
44039 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44040 {
44041 arg2 = wxString_in_helper(obj1);
44042 if (arg2 == NULL) SWIG_fail;
44043 temp2 = true;
44044 }
44045 if (obj2) {
44046 arg3 = obj2;
44047 }
44048 {
44049 PyThreadState* __tstate = wxPyBeginAllowThreads();
44050 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44051 wxPyEndAllowThreads(__tstate);
44052 if (PyErr_Occurred()) SWIG_fail;
44053 }
44054 resultobj = SWIG_From_int(static_cast< int >(result));
44055 {
44056 if (temp2)
44057 delete arg2;
44058 }
44059 return resultobj;
44060 fail:
44061 {
44062 if (temp2)
44063 delete arg2;
44064 }
44065 return NULL;
44066 }
44067
44068
44069 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44070 PyObject *resultobj = 0;
44071 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44072 wxArrayString *arg2 = 0 ;
44073 void *argp1 = 0 ;
44074 int res1 = 0 ;
44075 bool temp2 = false ;
44076 PyObject * obj0 = 0 ;
44077 PyObject * obj1 = 0 ;
44078 char * kwnames[] = {
44079 (char *) "self",(char *) "strings", NULL
44080 };
44081
44082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44084 if (!SWIG_IsOK(res1)) {
44085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44086 }
44087 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44088 {
44089 if (! PySequence_Check(obj1)) {
44090 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44091 SWIG_fail;
44092 }
44093 arg2 = new wxArrayString;
44094 temp2 = true;
44095 int i, len=PySequence_Length(obj1);
44096 for (i=0; i<len; i++) {
44097 PyObject* item = PySequence_GetItem(obj1, i);
44098 wxString* s = wxString_in_helper(item);
44099 if (PyErr_Occurred()) SWIG_fail;
44100 arg2->Add(*s);
44101 delete s;
44102 Py_DECREF(item);
44103 }
44104 }
44105 {
44106 PyThreadState* __tstate = wxPyBeginAllowThreads();
44107 (arg1)->Append((wxArrayString const &)*arg2);
44108 wxPyEndAllowThreads(__tstate);
44109 if (PyErr_Occurred()) SWIG_fail;
44110 }
44111 resultobj = SWIG_Py_Void();
44112 {
44113 if (temp2) delete arg2;
44114 }
44115 return resultobj;
44116 fail:
44117 {
44118 if (temp2) delete arg2;
44119 }
44120 return NULL;
44121 }
44122
44123
44124 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44125 PyObject *resultobj = 0;
44126 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44127 wxString *arg2 = 0 ;
44128 unsigned int arg3 ;
44129 PyObject *arg4 = (PyObject *) NULL ;
44130 int result;
44131 void *argp1 = 0 ;
44132 int res1 = 0 ;
44133 bool temp2 = false ;
44134 unsigned int val3 ;
44135 int ecode3 = 0 ;
44136 PyObject * obj0 = 0 ;
44137 PyObject * obj1 = 0 ;
44138 PyObject * obj2 = 0 ;
44139 PyObject * obj3 = 0 ;
44140 char * kwnames[] = {
44141 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44142 };
44143
44144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44146 if (!SWIG_IsOK(res1)) {
44147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44148 }
44149 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44150 {
44151 arg2 = wxString_in_helper(obj1);
44152 if (arg2 == NULL) SWIG_fail;
44153 temp2 = true;
44154 }
44155 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44156 if (!SWIG_IsOK(ecode3)) {
44157 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44158 }
44159 arg3 = static_cast< unsigned int >(val3);
44160 if (obj3) {
44161 arg4 = obj3;
44162 }
44163 {
44164 PyThreadState* __tstate = wxPyBeginAllowThreads();
44165 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44166 wxPyEndAllowThreads(__tstate);
44167 if (PyErr_Occurred()) SWIG_fail;
44168 }
44169 resultobj = SWIG_From_int(static_cast< int >(result));
44170 {
44171 if (temp2)
44172 delete arg2;
44173 }
44174 return resultobj;
44175 fail:
44176 {
44177 if (temp2)
44178 delete arg2;
44179 }
44180 return NULL;
44181 }
44182
44183
44184 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44185 PyObject *resultobj = 0;
44186 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44187 void *argp1 = 0 ;
44188 int res1 = 0 ;
44189 PyObject *swig_obj[1] ;
44190
44191 if (!args) SWIG_fail;
44192 swig_obj[0] = args;
44193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44194 if (!SWIG_IsOK(res1)) {
44195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44196 }
44197 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44198 {
44199 PyThreadState* __tstate = wxPyBeginAllowThreads();
44200 (arg1)->Clear();
44201 wxPyEndAllowThreads(__tstate);
44202 if (PyErr_Occurred()) SWIG_fail;
44203 }
44204 resultobj = SWIG_Py_Void();
44205 return resultobj;
44206 fail:
44207 return NULL;
44208 }
44209
44210
44211 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44212 PyObject *resultobj = 0;
44213 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44214 unsigned int arg2 ;
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_Delete",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_Delete" "', 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_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44234 }
44235 arg2 = static_cast< unsigned int >(val2);
44236 {
44237 PyThreadState* __tstate = wxPyBeginAllowThreads();
44238 (arg1)->Delete(arg2);
44239 wxPyEndAllowThreads(__tstate);
44240 if (PyErr_Occurred()) SWIG_fail;
44241 }
44242 resultobj = SWIG_Py_Void();
44243 return resultobj;
44244 fail:
44245 return NULL;
44246 }
44247
44248
44249 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44250 PyObject *resultobj = 0;
44251 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44252 unsigned int arg2 ;
44253 PyObject *result = 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 char * kwnames[] = {
44261 (char *) "self",(char *) "n", NULL
44262 };
44263
44264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44266 if (!SWIG_IsOK(res1)) {
44267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44268 }
44269 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44270 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44271 if (!SWIG_IsOK(ecode2)) {
44272 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44273 }
44274 arg2 = static_cast< unsigned int >(val2);
44275 {
44276 PyThreadState* __tstate = wxPyBeginAllowThreads();
44277 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 resultobj = result;
44282 return resultobj;
44283 fail:
44284 return NULL;
44285 }
44286
44287
44288 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44289 PyObject *resultobj = 0;
44290 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44291 unsigned int arg2 ;
44292 PyObject *arg3 = (PyObject *) 0 ;
44293 void *argp1 = 0 ;
44294 int res1 = 0 ;
44295 unsigned int val2 ;
44296 int ecode2 = 0 ;
44297 PyObject * obj0 = 0 ;
44298 PyObject * obj1 = 0 ;
44299 PyObject * obj2 = 0 ;
44300 char * kwnames[] = {
44301 (char *) "self",(char *) "n",(char *) "clientData", NULL
44302 };
44303
44304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44306 if (!SWIG_IsOK(res1)) {
44307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44308 }
44309 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44310 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44311 if (!SWIG_IsOK(ecode2)) {
44312 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44313 }
44314 arg2 = static_cast< unsigned int >(val2);
44315 arg3 = obj2;
44316 {
44317 PyThreadState* __tstate = wxPyBeginAllowThreads();
44318 wxItemContainer_SetClientData(arg1,arg2,arg3);
44319 wxPyEndAllowThreads(__tstate);
44320 if (PyErr_Occurred()) SWIG_fail;
44321 }
44322 resultobj = SWIG_Py_Void();
44323 return resultobj;
44324 fail:
44325 return NULL;
44326 }
44327
44328
44329 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44330 PyObject *resultobj = 0;
44331 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44332 unsigned int result;
44333 void *argp1 = 0 ;
44334 int res1 = 0 ;
44335 PyObject *swig_obj[1] ;
44336
44337 if (!args) SWIG_fail;
44338 swig_obj[0] = args;
44339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44340 if (!SWIG_IsOK(res1)) {
44341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44342 }
44343 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44344 {
44345 PyThreadState* __tstate = wxPyBeginAllowThreads();
44346 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44347 wxPyEndAllowThreads(__tstate);
44348 if (PyErr_Occurred()) SWIG_fail;
44349 }
44350 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44351 return resultobj;
44352 fail:
44353 return NULL;
44354 }
44355
44356
44357 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44358 PyObject *resultobj = 0;
44359 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44360 bool result;
44361 void *argp1 = 0 ;
44362 int res1 = 0 ;
44363 PyObject *swig_obj[1] ;
44364
44365 if (!args) SWIG_fail;
44366 swig_obj[0] = args;
44367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44368 if (!SWIG_IsOK(res1)) {
44369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44370 }
44371 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44372 {
44373 PyThreadState* __tstate = wxPyBeginAllowThreads();
44374 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44375 wxPyEndAllowThreads(__tstate);
44376 if (PyErr_Occurred()) SWIG_fail;
44377 }
44378 {
44379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44380 }
44381 return resultobj;
44382 fail:
44383 return NULL;
44384 }
44385
44386
44387 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44388 PyObject *resultobj = 0;
44389 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44390 unsigned int arg2 ;
44391 wxString result;
44392 void *argp1 = 0 ;
44393 int res1 = 0 ;
44394 unsigned int val2 ;
44395 int ecode2 = 0 ;
44396 PyObject * obj0 = 0 ;
44397 PyObject * obj1 = 0 ;
44398 char * kwnames[] = {
44399 (char *) "self",(char *) "n", NULL
44400 };
44401
44402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44404 if (!SWIG_IsOK(res1)) {
44405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44406 }
44407 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44408 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44409 if (!SWIG_IsOK(ecode2)) {
44410 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44411 }
44412 arg2 = static_cast< unsigned int >(val2);
44413 {
44414 PyThreadState* __tstate = wxPyBeginAllowThreads();
44415 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44416 wxPyEndAllowThreads(__tstate);
44417 if (PyErr_Occurred()) SWIG_fail;
44418 }
44419 {
44420 #if wxUSE_UNICODE
44421 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44422 #else
44423 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44424 #endif
44425 }
44426 return resultobj;
44427 fail:
44428 return NULL;
44429 }
44430
44431
44432 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44433 PyObject *resultobj = 0;
44434 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44435 wxArrayString result;
44436 void *argp1 = 0 ;
44437 int res1 = 0 ;
44438 PyObject *swig_obj[1] ;
44439
44440 if (!args) SWIG_fail;
44441 swig_obj[0] = args;
44442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44443 if (!SWIG_IsOK(res1)) {
44444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44445 }
44446 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44447 {
44448 PyThreadState* __tstate = wxPyBeginAllowThreads();
44449 result = ((wxItemContainer const *)arg1)->GetStrings();
44450 wxPyEndAllowThreads(__tstate);
44451 if (PyErr_Occurred()) SWIG_fail;
44452 }
44453 {
44454 resultobj = wxArrayString2PyList_helper(result);
44455 }
44456 return resultobj;
44457 fail:
44458 return NULL;
44459 }
44460
44461
44462 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44463 PyObject *resultobj = 0;
44464 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44465 unsigned int arg2 ;
44466 wxString *arg3 = 0 ;
44467 void *argp1 = 0 ;
44468 int res1 = 0 ;
44469 unsigned int val2 ;
44470 int ecode2 = 0 ;
44471 bool temp3 = false ;
44472 PyObject * obj0 = 0 ;
44473 PyObject * obj1 = 0 ;
44474 PyObject * obj2 = 0 ;
44475 char * kwnames[] = {
44476 (char *) "self",(char *) "n",(char *) "s", NULL
44477 };
44478
44479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44481 if (!SWIG_IsOK(res1)) {
44482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44483 }
44484 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44485 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44486 if (!SWIG_IsOK(ecode2)) {
44487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44488 }
44489 arg2 = static_cast< unsigned int >(val2);
44490 {
44491 arg3 = wxString_in_helper(obj2);
44492 if (arg3 == NULL) SWIG_fail;
44493 temp3 = true;
44494 }
44495 {
44496 PyThreadState* __tstate = wxPyBeginAllowThreads();
44497 (arg1)->SetString(arg2,(wxString const &)*arg3);
44498 wxPyEndAllowThreads(__tstate);
44499 if (PyErr_Occurred()) SWIG_fail;
44500 }
44501 resultobj = SWIG_Py_Void();
44502 {
44503 if (temp3)
44504 delete arg3;
44505 }
44506 return resultobj;
44507 fail:
44508 {
44509 if (temp3)
44510 delete arg3;
44511 }
44512 return NULL;
44513 }
44514
44515
44516 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44517 PyObject *resultobj = 0;
44518 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44519 wxString *arg2 = 0 ;
44520 int result;
44521 void *argp1 = 0 ;
44522 int res1 = 0 ;
44523 bool temp2 = false ;
44524 PyObject * obj0 = 0 ;
44525 PyObject * obj1 = 0 ;
44526 char * kwnames[] = {
44527 (char *) "self",(char *) "s", NULL
44528 };
44529
44530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44532 if (!SWIG_IsOK(res1)) {
44533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44534 }
44535 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44536 {
44537 arg2 = wxString_in_helper(obj1);
44538 if (arg2 == NULL) SWIG_fail;
44539 temp2 = true;
44540 }
44541 {
44542 PyThreadState* __tstate = wxPyBeginAllowThreads();
44543 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44544 wxPyEndAllowThreads(__tstate);
44545 if (PyErr_Occurred()) SWIG_fail;
44546 }
44547 resultobj = SWIG_From_int(static_cast< int >(result));
44548 {
44549 if (temp2)
44550 delete arg2;
44551 }
44552 return resultobj;
44553 fail:
44554 {
44555 if (temp2)
44556 delete arg2;
44557 }
44558 return NULL;
44559 }
44560
44561
44562 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44563 PyObject *resultobj = 0;
44564 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44565 int arg2 ;
44566 void *argp1 = 0 ;
44567 int res1 = 0 ;
44568 int val2 ;
44569 int ecode2 = 0 ;
44570 PyObject * obj0 = 0 ;
44571 PyObject * obj1 = 0 ;
44572 char * kwnames[] = {
44573 (char *) "self",(char *) "n", NULL
44574 };
44575
44576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44578 if (!SWIG_IsOK(res1)) {
44579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44580 }
44581 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44582 ecode2 = SWIG_AsVal_int(obj1, &val2);
44583 if (!SWIG_IsOK(ecode2)) {
44584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44585 }
44586 arg2 = static_cast< int >(val2);
44587 {
44588 PyThreadState* __tstate = wxPyBeginAllowThreads();
44589 (arg1)->SetSelection(arg2);
44590 wxPyEndAllowThreads(__tstate);
44591 if (PyErr_Occurred()) SWIG_fail;
44592 }
44593 resultobj = SWIG_Py_Void();
44594 return resultobj;
44595 fail:
44596 return NULL;
44597 }
44598
44599
44600 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44601 PyObject *resultobj = 0;
44602 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44603 int result;
44604 void *argp1 = 0 ;
44605 int res1 = 0 ;
44606 PyObject *swig_obj[1] ;
44607
44608 if (!args) SWIG_fail;
44609 swig_obj[0] = args;
44610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44611 if (!SWIG_IsOK(res1)) {
44612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44613 }
44614 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44615 {
44616 PyThreadState* __tstate = wxPyBeginAllowThreads();
44617 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44618 wxPyEndAllowThreads(__tstate);
44619 if (PyErr_Occurred()) SWIG_fail;
44620 }
44621 resultobj = SWIG_From_int(static_cast< int >(result));
44622 return resultobj;
44623 fail:
44624 return NULL;
44625 }
44626
44627
44628 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44629 PyObject *resultobj = 0;
44630 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44631 wxString *arg2 = 0 ;
44632 bool result;
44633 void *argp1 = 0 ;
44634 int res1 = 0 ;
44635 bool temp2 = false ;
44636 PyObject * obj0 = 0 ;
44637 PyObject * obj1 = 0 ;
44638 char * kwnames[] = {
44639 (char *) "self",(char *) "s", NULL
44640 };
44641
44642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44644 if (!SWIG_IsOK(res1)) {
44645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44646 }
44647 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44648 {
44649 arg2 = wxString_in_helper(obj1);
44650 if (arg2 == NULL) SWIG_fail;
44651 temp2 = true;
44652 }
44653 {
44654 PyThreadState* __tstate = wxPyBeginAllowThreads();
44655 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44656 wxPyEndAllowThreads(__tstate);
44657 if (PyErr_Occurred()) SWIG_fail;
44658 }
44659 {
44660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44661 }
44662 {
44663 if (temp2)
44664 delete arg2;
44665 }
44666 return resultobj;
44667 fail:
44668 {
44669 if (temp2)
44670 delete arg2;
44671 }
44672 return NULL;
44673 }
44674
44675
44676 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44677 PyObject *resultobj = 0;
44678 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44679 wxString result;
44680 void *argp1 = 0 ;
44681 int res1 = 0 ;
44682 PyObject *swig_obj[1] ;
44683
44684 if (!args) SWIG_fail;
44685 swig_obj[0] = args;
44686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44687 if (!SWIG_IsOK(res1)) {
44688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44689 }
44690 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44691 {
44692 PyThreadState* __tstate = wxPyBeginAllowThreads();
44693 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44694 wxPyEndAllowThreads(__tstate);
44695 if (PyErr_Occurred()) SWIG_fail;
44696 }
44697 {
44698 #if wxUSE_UNICODE
44699 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44700 #else
44701 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44702 #endif
44703 }
44704 return resultobj;
44705 fail:
44706 return NULL;
44707 }
44708
44709
44710 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44711 PyObject *resultobj = 0;
44712 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44713 int arg2 ;
44714 void *argp1 = 0 ;
44715 int res1 = 0 ;
44716 int val2 ;
44717 int ecode2 = 0 ;
44718 PyObject * obj0 = 0 ;
44719 PyObject * obj1 = 0 ;
44720 char * kwnames[] = {
44721 (char *) "self",(char *) "n", NULL
44722 };
44723
44724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44726 if (!SWIG_IsOK(res1)) {
44727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44728 }
44729 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44730 ecode2 = SWIG_AsVal_int(obj1, &val2);
44731 if (!SWIG_IsOK(ecode2)) {
44732 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44733 }
44734 arg2 = static_cast< int >(val2);
44735 {
44736 PyThreadState* __tstate = wxPyBeginAllowThreads();
44737 (arg1)->Select(arg2);
44738 wxPyEndAllowThreads(__tstate);
44739 if (PyErr_Occurred()) SWIG_fail;
44740 }
44741 resultobj = SWIG_Py_Void();
44742 return resultobj;
44743 fail:
44744 return NULL;
44745 }
44746
44747
44748 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44749 PyObject *obj;
44750 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44751 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44752 return SWIG_Py_Void();
44753 }
44754
44755 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44756 PyObject *obj;
44757 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44758 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44759 return SWIG_Py_Void();
44760 }
44761
44762 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44763 PyObject *resultobj = 0;
44764 wxSizerItem *result = 0 ;
44765
44766 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
44767 {
44768 PyThreadState* __tstate = wxPyBeginAllowThreads();
44769 result = (wxSizerItem *)new wxSizerItem();
44770 wxPyEndAllowThreads(__tstate);
44771 if (PyErr_Occurred()) SWIG_fail;
44772 }
44773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
44774 return resultobj;
44775 fail:
44776 return NULL;
44777 }
44778
44779
44780 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44781 PyObject *resultobj = 0;
44782 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
44783 void *argp1 = 0 ;
44784 int res1 = 0 ;
44785 PyObject *swig_obj[1] ;
44786
44787 if (!args) SWIG_fail;
44788 swig_obj[0] = args;
44789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
44790 if (!SWIG_IsOK(res1)) {
44791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
44792 }
44793 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
44794 {
44795 PyThreadState* __tstate = wxPyBeginAllowThreads();
44796 delete arg1;
44797
44798 wxPyEndAllowThreads(__tstate);
44799 if (PyErr_Occurred()) SWIG_fail;
44800 }
44801 resultobj = SWIG_Py_Void();
44802 return resultobj;
44803 fail:
44804 return NULL;
44805 }
44806
44807
44808 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44809 PyObject *resultobj = 0;
44810 wxWindow *arg1 = (wxWindow *) 0 ;
44811 int arg2 ;
44812 int arg3 ;
44813 int arg4 ;
44814 PyObject *arg5 = (PyObject *) NULL ;
44815 wxSizerItem *result = 0 ;
44816 void *argp1 = 0 ;
44817 int res1 = 0 ;
44818 int val2 ;
44819 int ecode2 = 0 ;
44820 int val3 ;
44821 int ecode3 = 0 ;
44822 int val4 ;
44823 int ecode4 = 0 ;
44824 PyObject * obj0 = 0 ;
44825 PyObject * obj1 = 0 ;
44826 PyObject * obj2 = 0 ;
44827 PyObject * obj3 = 0 ;
44828 PyObject * obj4 = 0 ;
44829 char * kwnames[] = {
44830 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44831 };
44832
44833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
44835 if (!SWIG_IsOK(res1)) {
44836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
44837 }
44838 arg1 = reinterpret_cast< wxWindow * >(argp1);
44839 ecode2 = SWIG_AsVal_int(obj1, &val2);
44840 if (!SWIG_IsOK(ecode2)) {
44841 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
44842 }
44843 arg2 = static_cast< int >(val2);
44844 ecode3 = SWIG_AsVal_int(obj2, &val3);
44845 if (!SWIG_IsOK(ecode3)) {
44846 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
44847 }
44848 arg3 = static_cast< int >(val3);
44849 ecode4 = SWIG_AsVal_int(obj3, &val4);
44850 if (!SWIG_IsOK(ecode4)) {
44851 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
44852 }
44853 arg4 = static_cast< int >(val4);
44854 if (obj4) {
44855 arg5 = obj4;
44856 }
44857 {
44858 PyThreadState* __tstate = wxPyBeginAllowThreads();
44859 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44860 wxPyEndAllowThreads(__tstate);
44861 if (PyErr_Occurred()) SWIG_fail;
44862 }
44863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44864 return resultobj;
44865 fail:
44866 return NULL;
44867 }
44868
44869
44870 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44871 PyObject *resultobj = 0;
44872 int arg1 ;
44873 int arg2 ;
44874 int arg3 ;
44875 int arg4 ;
44876 int arg5 ;
44877 PyObject *arg6 = (PyObject *) NULL ;
44878 wxSizerItem *result = 0 ;
44879 int val1 ;
44880 int ecode1 = 0 ;
44881 int val2 ;
44882 int ecode2 = 0 ;
44883 int val3 ;
44884 int ecode3 = 0 ;
44885 int val4 ;
44886 int ecode4 = 0 ;
44887 int val5 ;
44888 int ecode5 = 0 ;
44889 PyObject * obj0 = 0 ;
44890 PyObject * obj1 = 0 ;
44891 PyObject * obj2 = 0 ;
44892 PyObject * obj3 = 0 ;
44893 PyObject * obj4 = 0 ;
44894 PyObject * obj5 = 0 ;
44895 char * kwnames[] = {
44896 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44897 };
44898
44899 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
44900 ecode1 = SWIG_AsVal_int(obj0, &val1);
44901 if (!SWIG_IsOK(ecode1)) {
44902 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
44903 }
44904 arg1 = static_cast< int >(val1);
44905 ecode2 = SWIG_AsVal_int(obj1, &val2);
44906 if (!SWIG_IsOK(ecode2)) {
44907 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
44908 }
44909 arg2 = static_cast< int >(val2);
44910 ecode3 = SWIG_AsVal_int(obj2, &val3);
44911 if (!SWIG_IsOK(ecode3)) {
44912 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
44913 }
44914 arg3 = static_cast< int >(val3);
44915 ecode4 = SWIG_AsVal_int(obj3, &val4);
44916 if (!SWIG_IsOK(ecode4)) {
44917 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
44918 }
44919 arg4 = static_cast< int >(val4);
44920 ecode5 = SWIG_AsVal_int(obj4, &val5);
44921 if (!SWIG_IsOK(ecode5)) {
44922 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
44923 }
44924 arg5 = static_cast< int >(val5);
44925 if (obj5) {
44926 arg6 = obj5;
44927 }
44928 {
44929 PyThreadState* __tstate = wxPyBeginAllowThreads();
44930 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44935 return resultobj;
44936 fail:
44937 return NULL;
44938 }
44939
44940
44941 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44942 PyObject *resultobj = 0;
44943 wxSizer *arg1 = (wxSizer *) 0 ;
44944 int arg2 ;
44945 int arg3 ;
44946 int arg4 ;
44947 PyObject *arg5 = (PyObject *) NULL ;
44948 wxSizerItem *result = 0 ;
44949 int res1 = 0 ;
44950 int val2 ;
44951 int ecode2 = 0 ;
44952 int val3 ;
44953 int ecode3 = 0 ;
44954 int val4 ;
44955 int ecode4 = 0 ;
44956 PyObject * obj0 = 0 ;
44957 PyObject * obj1 = 0 ;
44958 PyObject * obj2 = 0 ;
44959 PyObject * obj3 = 0 ;
44960 PyObject * obj4 = 0 ;
44961 char * kwnames[] = {
44962 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
44963 };
44964
44965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
44966 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
44967 if (!SWIG_IsOK(res1)) {
44968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
44969 }
44970 ecode2 = SWIG_AsVal_int(obj1, &val2);
44971 if (!SWIG_IsOK(ecode2)) {
44972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
44973 }
44974 arg2 = static_cast< int >(val2);
44975 ecode3 = SWIG_AsVal_int(obj2, &val3);
44976 if (!SWIG_IsOK(ecode3)) {
44977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
44978 }
44979 arg3 = static_cast< int >(val3);
44980 ecode4 = SWIG_AsVal_int(obj3, &val4);
44981 if (!SWIG_IsOK(ecode4)) {
44982 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
44983 }
44984 arg4 = static_cast< int >(val4);
44985 if (obj4) {
44986 arg5 = obj4;
44987 }
44988 {
44989 PyThreadState* __tstate = wxPyBeginAllowThreads();
44990 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
44991 wxPyEndAllowThreads(__tstate);
44992 if (PyErr_Occurred()) SWIG_fail;
44993 }
44994 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
44995 return resultobj;
44996 fail:
44997 return NULL;
44998 }
44999
45000
45001 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45002 PyObject *resultobj = 0;
45003 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45004 void *argp1 = 0 ;
45005 int res1 = 0 ;
45006 PyObject *swig_obj[1] ;
45007
45008 if (!args) SWIG_fail;
45009 swig_obj[0] = args;
45010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45011 if (!SWIG_IsOK(res1)) {
45012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45013 }
45014 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45015 {
45016 PyThreadState* __tstate = wxPyBeginAllowThreads();
45017 (arg1)->DeleteWindows();
45018 wxPyEndAllowThreads(__tstate);
45019 if (PyErr_Occurred()) SWIG_fail;
45020 }
45021 resultobj = SWIG_Py_Void();
45022 return resultobj;
45023 fail:
45024 return NULL;
45025 }
45026
45027
45028 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45029 PyObject *resultobj = 0;
45030 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45031 void *argp1 = 0 ;
45032 int res1 = 0 ;
45033 PyObject *swig_obj[1] ;
45034
45035 if (!args) SWIG_fail;
45036 swig_obj[0] = args;
45037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45038 if (!SWIG_IsOK(res1)) {
45039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45040 }
45041 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45042 {
45043 PyThreadState* __tstate = wxPyBeginAllowThreads();
45044 (arg1)->DetachSizer();
45045 wxPyEndAllowThreads(__tstate);
45046 if (PyErr_Occurred()) SWIG_fail;
45047 }
45048 resultobj = SWIG_Py_Void();
45049 return resultobj;
45050 fail:
45051 return NULL;
45052 }
45053
45054
45055 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45056 PyObject *resultobj = 0;
45057 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45058 wxSize result;
45059 void *argp1 = 0 ;
45060 int res1 = 0 ;
45061 PyObject *swig_obj[1] ;
45062
45063 if (!args) SWIG_fail;
45064 swig_obj[0] = args;
45065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45066 if (!SWIG_IsOK(res1)) {
45067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45068 }
45069 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45070 {
45071 PyThreadState* __tstate = wxPyBeginAllowThreads();
45072 result = (arg1)->GetSize();
45073 wxPyEndAllowThreads(__tstate);
45074 if (PyErr_Occurred()) SWIG_fail;
45075 }
45076 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45077 return resultobj;
45078 fail:
45079 return NULL;
45080 }
45081
45082
45083 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45084 PyObject *resultobj = 0;
45085 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45086 wxSize result;
45087 void *argp1 = 0 ;
45088 int res1 = 0 ;
45089 PyObject *swig_obj[1] ;
45090
45091 if (!args) SWIG_fail;
45092 swig_obj[0] = args;
45093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45094 if (!SWIG_IsOK(res1)) {
45095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45096 }
45097 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45098 {
45099 PyThreadState* __tstate = wxPyBeginAllowThreads();
45100 result = (arg1)->CalcMin();
45101 wxPyEndAllowThreads(__tstate);
45102 if (PyErr_Occurred()) SWIG_fail;
45103 }
45104 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45105 return resultobj;
45106 fail:
45107 return NULL;
45108 }
45109
45110
45111 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45112 PyObject *resultobj = 0;
45113 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45114 wxPoint *arg2 = 0 ;
45115 wxSize *arg3 = 0 ;
45116 void *argp1 = 0 ;
45117 int res1 = 0 ;
45118 wxPoint temp2 ;
45119 wxSize temp3 ;
45120 PyObject * obj0 = 0 ;
45121 PyObject * obj1 = 0 ;
45122 PyObject * obj2 = 0 ;
45123 char * kwnames[] = {
45124 (char *) "self",(char *) "pos",(char *) "size", NULL
45125 };
45126
45127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45129 if (!SWIG_IsOK(res1)) {
45130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45131 }
45132 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45133 {
45134 arg2 = &temp2;
45135 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45136 }
45137 {
45138 arg3 = &temp3;
45139 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45140 }
45141 {
45142 PyThreadState* __tstate = wxPyBeginAllowThreads();
45143 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45144 wxPyEndAllowThreads(__tstate);
45145 if (PyErr_Occurred()) SWIG_fail;
45146 }
45147 resultobj = SWIG_Py_Void();
45148 return resultobj;
45149 fail:
45150 return NULL;
45151 }
45152
45153
45154 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45155 PyObject *resultobj = 0;
45156 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45157 wxSize result;
45158 void *argp1 = 0 ;
45159 int res1 = 0 ;
45160 PyObject *swig_obj[1] ;
45161
45162 if (!args) SWIG_fail;
45163 swig_obj[0] = args;
45164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45165 if (!SWIG_IsOK(res1)) {
45166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45167 }
45168 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45169 {
45170 PyThreadState* __tstate = wxPyBeginAllowThreads();
45171 result = (arg1)->GetMinSize();
45172 wxPyEndAllowThreads(__tstate);
45173 if (PyErr_Occurred()) SWIG_fail;
45174 }
45175 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45176 return resultobj;
45177 fail:
45178 return NULL;
45179 }
45180
45181
45182 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45183 PyObject *resultobj = 0;
45184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45185 wxSize result;
45186 void *argp1 = 0 ;
45187 int res1 = 0 ;
45188 PyObject *swig_obj[1] ;
45189
45190 if (!args) SWIG_fail;
45191 swig_obj[0] = args;
45192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45193 if (!SWIG_IsOK(res1)) {
45194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45195 }
45196 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45197 {
45198 PyThreadState* __tstate = wxPyBeginAllowThreads();
45199 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45200 wxPyEndAllowThreads(__tstate);
45201 if (PyErr_Occurred()) SWIG_fail;
45202 }
45203 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45204 return resultobj;
45205 fail:
45206 return NULL;
45207 }
45208
45209
45210 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45211 PyObject *resultobj = 0;
45212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45213 int arg2 ;
45214 int arg3 ;
45215 void *argp1 = 0 ;
45216 int res1 = 0 ;
45217 int val2 ;
45218 int ecode2 = 0 ;
45219 int val3 ;
45220 int ecode3 = 0 ;
45221 PyObject * obj0 = 0 ;
45222 PyObject * obj1 = 0 ;
45223 PyObject * obj2 = 0 ;
45224 char * kwnames[] = {
45225 (char *) "self",(char *) "x",(char *) "y", NULL
45226 };
45227
45228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45230 if (!SWIG_IsOK(res1)) {
45231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45232 }
45233 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45234 ecode2 = SWIG_AsVal_int(obj1, &val2);
45235 if (!SWIG_IsOK(ecode2)) {
45236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45237 }
45238 arg2 = static_cast< int >(val2);
45239 ecode3 = SWIG_AsVal_int(obj2, &val3);
45240 if (!SWIG_IsOK(ecode3)) {
45241 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45242 }
45243 arg3 = static_cast< int >(val3);
45244 {
45245 PyThreadState* __tstate = wxPyBeginAllowThreads();
45246 (arg1)->SetInitSize(arg2,arg3);
45247 wxPyEndAllowThreads(__tstate);
45248 if (PyErr_Occurred()) SWIG_fail;
45249 }
45250 resultobj = SWIG_Py_Void();
45251 return resultobj;
45252 fail:
45253 return NULL;
45254 }
45255
45256
45257 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45258 PyObject *resultobj = 0;
45259 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45260 int arg2 ;
45261 int arg3 ;
45262 void *argp1 = 0 ;
45263 int res1 = 0 ;
45264 int val2 ;
45265 int ecode2 = 0 ;
45266 int val3 ;
45267 int ecode3 = 0 ;
45268 PyObject * obj0 = 0 ;
45269 PyObject * obj1 = 0 ;
45270 PyObject * obj2 = 0 ;
45271 char * kwnames[] = {
45272 (char *) "self",(char *) "width",(char *) "height", NULL
45273 };
45274
45275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45276 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45277 if (!SWIG_IsOK(res1)) {
45278 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45279 }
45280 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45281 ecode2 = SWIG_AsVal_int(obj1, &val2);
45282 if (!SWIG_IsOK(ecode2)) {
45283 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45284 }
45285 arg2 = static_cast< int >(val2);
45286 ecode3 = SWIG_AsVal_int(obj2, &val3);
45287 if (!SWIG_IsOK(ecode3)) {
45288 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45289 }
45290 arg3 = static_cast< int >(val3);
45291 {
45292 PyThreadState* __tstate = wxPyBeginAllowThreads();
45293 (arg1)->SetRatio(arg2,arg3);
45294 wxPyEndAllowThreads(__tstate);
45295 if (PyErr_Occurred()) SWIG_fail;
45296 }
45297 resultobj = SWIG_Py_Void();
45298 return resultobj;
45299 fail:
45300 return NULL;
45301 }
45302
45303
45304 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45305 PyObject *resultobj = 0;
45306 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45307 wxSize *arg2 = 0 ;
45308 void *argp1 = 0 ;
45309 int res1 = 0 ;
45310 wxSize temp2 ;
45311 PyObject * obj0 = 0 ;
45312 PyObject * obj1 = 0 ;
45313 char * kwnames[] = {
45314 (char *) "self",(char *) "size", NULL
45315 };
45316
45317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45319 if (!SWIG_IsOK(res1)) {
45320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45321 }
45322 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45323 {
45324 arg2 = &temp2;
45325 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45326 }
45327 {
45328 PyThreadState* __tstate = wxPyBeginAllowThreads();
45329 (arg1)->SetRatio((wxSize const &)*arg2);
45330 wxPyEndAllowThreads(__tstate);
45331 if (PyErr_Occurred()) SWIG_fail;
45332 }
45333 resultobj = SWIG_Py_Void();
45334 return resultobj;
45335 fail:
45336 return NULL;
45337 }
45338
45339
45340 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45341 PyObject *resultobj = 0;
45342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45343 float arg2 ;
45344 void *argp1 = 0 ;
45345 int res1 = 0 ;
45346 float val2 ;
45347 int ecode2 = 0 ;
45348 PyObject * obj0 = 0 ;
45349 PyObject * obj1 = 0 ;
45350 char * kwnames[] = {
45351 (char *) "self",(char *) "ratio", NULL
45352 };
45353
45354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45356 if (!SWIG_IsOK(res1)) {
45357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45358 }
45359 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45360 ecode2 = SWIG_AsVal_float(obj1, &val2);
45361 if (!SWIG_IsOK(ecode2)) {
45362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45363 }
45364 arg2 = static_cast< float >(val2);
45365 {
45366 PyThreadState* __tstate = wxPyBeginAllowThreads();
45367 (arg1)->SetRatio(arg2);
45368 wxPyEndAllowThreads(__tstate);
45369 if (PyErr_Occurred()) SWIG_fail;
45370 }
45371 resultobj = SWIG_Py_Void();
45372 return resultobj;
45373 fail:
45374 return NULL;
45375 }
45376
45377
45378 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45379 PyObject *resultobj = 0;
45380 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45381 float result;
45382 void *argp1 = 0 ;
45383 int res1 = 0 ;
45384 PyObject *swig_obj[1] ;
45385
45386 if (!args) SWIG_fail;
45387 swig_obj[0] = args;
45388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45389 if (!SWIG_IsOK(res1)) {
45390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45391 }
45392 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45393 {
45394 PyThreadState* __tstate = wxPyBeginAllowThreads();
45395 result = (float)(arg1)->GetRatio();
45396 wxPyEndAllowThreads(__tstate);
45397 if (PyErr_Occurred()) SWIG_fail;
45398 }
45399 resultobj = SWIG_From_float(static_cast< float >(result));
45400 return resultobj;
45401 fail:
45402 return NULL;
45403 }
45404
45405
45406 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45407 PyObject *resultobj = 0;
45408 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45409 wxRect result;
45410 void *argp1 = 0 ;
45411 int res1 = 0 ;
45412 PyObject *swig_obj[1] ;
45413
45414 if (!args) SWIG_fail;
45415 swig_obj[0] = args;
45416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45417 if (!SWIG_IsOK(res1)) {
45418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45419 }
45420 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45421 {
45422 PyThreadState* __tstate = wxPyBeginAllowThreads();
45423 result = (arg1)->GetRect();
45424 wxPyEndAllowThreads(__tstate);
45425 if (PyErr_Occurred()) SWIG_fail;
45426 }
45427 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45428 return resultobj;
45429 fail:
45430 return NULL;
45431 }
45432
45433
45434 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45435 PyObject *resultobj = 0;
45436 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45437 bool result;
45438 void *argp1 = 0 ;
45439 int res1 = 0 ;
45440 PyObject *swig_obj[1] ;
45441
45442 if (!args) SWIG_fail;
45443 swig_obj[0] = args;
45444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45445 if (!SWIG_IsOK(res1)) {
45446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45447 }
45448 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45449 {
45450 PyThreadState* __tstate = wxPyBeginAllowThreads();
45451 result = (bool)(arg1)->IsWindow();
45452 wxPyEndAllowThreads(__tstate);
45453 if (PyErr_Occurred()) SWIG_fail;
45454 }
45455 {
45456 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45457 }
45458 return resultobj;
45459 fail:
45460 return NULL;
45461 }
45462
45463
45464 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45465 PyObject *resultobj = 0;
45466 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45467 bool result;
45468 void *argp1 = 0 ;
45469 int res1 = 0 ;
45470 PyObject *swig_obj[1] ;
45471
45472 if (!args) SWIG_fail;
45473 swig_obj[0] = args;
45474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45475 if (!SWIG_IsOK(res1)) {
45476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45477 }
45478 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45479 {
45480 PyThreadState* __tstate = wxPyBeginAllowThreads();
45481 result = (bool)(arg1)->IsSizer();
45482 wxPyEndAllowThreads(__tstate);
45483 if (PyErr_Occurred()) SWIG_fail;
45484 }
45485 {
45486 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45487 }
45488 return resultobj;
45489 fail:
45490 return NULL;
45491 }
45492
45493
45494 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45495 PyObject *resultobj = 0;
45496 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45497 bool result;
45498 void *argp1 = 0 ;
45499 int res1 = 0 ;
45500 PyObject *swig_obj[1] ;
45501
45502 if (!args) SWIG_fail;
45503 swig_obj[0] = args;
45504 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45505 if (!SWIG_IsOK(res1)) {
45506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45507 }
45508 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45509 {
45510 PyThreadState* __tstate = wxPyBeginAllowThreads();
45511 result = (bool)(arg1)->IsSpacer();
45512 wxPyEndAllowThreads(__tstate);
45513 if (PyErr_Occurred()) SWIG_fail;
45514 }
45515 {
45516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45517 }
45518 return resultobj;
45519 fail:
45520 return NULL;
45521 }
45522
45523
45524 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45525 PyObject *resultobj = 0;
45526 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45527 int arg2 ;
45528 void *argp1 = 0 ;
45529 int res1 = 0 ;
45530 int val2 ;
45531 int ecode2 = 0 ;
45532 PyObject * obj0 = 0 ;
45533 PyObject * obj1 = 0 ;
45534 char * kwnames[] = {
45535 (char *) "self",(char *) "proportion", NULL
45536 };
45537
45538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45540 if (!SWIG_IsOK(res1)) {
45541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45542 }
45543 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45544 ecode2 = SWIG_AsVal_int(obj1, &val2);
45545 if (!SWIG_IsOK(ecode2)) {
45546 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45547 }
45548 arg2 = static_cast< int >(val2);
45549 {
45550 PyThreadState* __tstate = wxPyBeginAllowThreads();
45551 (arg1)->SetProportion(arg2);
45552 wxPyEndAllowThreads(__tstate);
45553 if (PyErr_Occurred()) SWIG_fail;
45554 }
45555 resultobj = SWIG_Py_Void();
45556 return resultobj;
45557 fail:
45558 return NULL;
45559 }
45560
45561
45562 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45563 PyObject *resultobj = 0;
45564 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45565 int result;
45566 void *argp1 = 0 ;
45567 int res1 = 0 ;
45568 PyObject *swig_obj[1] ;
45569
45570 if (!args) SWIG_fail;
45571 swig_obj[0] = args;
45572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45573 if (!SWIG_IsOK(res1)) {
45574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45575 }
45576 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45577 {
45578 PyThreadState* __tstate = wxPyBeginAllowThreads();
45579 result = (int)(arg1)->GetProportion();
45580 wxPyEndAllowThreads(__tstate);
45581 if (PyErr_Occurred()) SWIG_fail;
45582 }
45583 resultobj = SWIG_From_int(static_cast< int >(result));
45584 return resultobj;
45585 fail:
45586 return NULL;
45587 }
45588
45589
45590 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45591 PyObject *resultobj = 0;
45592 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45593 int arg2 ;
45594 void *argp1 = 0 ;
45595 int res1 = 0 ;
45596 int val2 ;
45597 int ecode2 = 0 ;
45598 PyObject * obj0 = 0 ;
45599 PyObject * obj1 = 0 ;
45600 char * kwnames[] = {
45601 (char *) "self",(char *) "flag", NULL
45602 };
45603
45604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45606 if (!SWIG_IsOK(res1)) {
45607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45608 }
45609 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45610 ecode2 = SWIG_AsVal_int(obj1, &val2);
45611 if (!SWIG_IsOK(ecode2)) {
45612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45613 }
45614 arg2 = static_cast< int >(val2);
45615 {
45616 PyThreadState* __tstate = wxPyBeginAllowThreads();
45617 (arg1)->SetFlag(arg2);
45618 wxPyEndAllowThreads(__tstate);
45619 if (PyErr_Occurred()) SWIG_fail;
45620 }
45621 resultobj = SWIG_Py_Void();
45622 return resultobj;
45623 fail:
45624 return NULL;
45625 }
45626
45627
45628 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45629 PyObject *resultobj = 0;
45630 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45631 int result;
45632 void *argp1 = 0 ;
45633 int res1 = 0 ;
45634 PyObject *swig_obj[1] ;
45635
45636 if (!args) SWIG_fail;
45637 swig_obj[0] = args;
45638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45639 if (!SWIG_IsOK(res1)) {
45640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45641 }
45642 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45643 {
45644 PyThreadState* __tstate = wxPyBeginAllowThreads();
45645 result = (int)(arg1)->GetFlag();
45646 wxPyEndAllowThreads(__tstate);
45647 if (PyErr_Occurred()) SWIG_fail;
45648 }
45649 resultobj = SWIG_From_int(static_cast< int >(result));
45650 return resultobj;
45651 fail:
45652 return NULL;
45653 }
45654
45655
45656 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45657 PyObject *resultobj = 0;
45658 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45659 int arg2 ;
45660 void *argp1 = 0 ;
45661 int res1 = 0 ;
45662 int val2 ;
45663 int ecode2 = 0 ;
45664 PyObject * obj0 = 0 ;
45665 PyObject * obj1 = 0 ;
45666 char * kwnames[] = {
45667 (char *) "self",(char *) "border", NULL
45668 };
45669
45670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45672 if (!SWIG_IsOK(res1)) {
45673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45674 }
45675 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45676 ecode2 = SWIG_AsVal_int(obj1, &val2);
45677 if (!SWIG_IsOK(ecode2)) {
45678 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45679 }
45680 arg2 = static_cast< int >(val2);
45681 {
45682 PyThreadState* __tstate = wxPyBeginAllowThreads();
45683 (arg1)->SetBorder(arg2);
45684 wxPyEndAllowThreads(__tstate);
45685 if (PyErr_Occurred()) SWIG_fail;
45686 }
45687 resultobj = SWIG_Py_Void();
45688 return resultobj;
45689 fail:
45690 return NULL;
45691 }
45692
45693
45694 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45695 PyObject *resultobj = 0;
45696 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45697 int result;
45698 void *argp1 = 0 ;
45699 int res1 = 0 ;
45700 PyObject *swig_obj[1] ;
45701
45702 if (!args) SWIG_fail;
45703 swig_obj[0] = args;
45704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45705 if (!SWIG_IsOK(res1)) {
45706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45707 }
45708 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45709 {
45710 PyThreadState* __tstate = wxPyBeginAllowThreads();
45711 result = (int)(arg1)->GetBorder();
45712 wxPyEndAllowThreads(__tstate);
45713 if (PyErr_Occurred()) SWIG_fail;
45714 }
45715 resultobj = SWIG_From_int(static_cast< int >(result));
45716 return resultobj;
45717 fail:
45718 return NULL;
45719 }
45720
45721
45722 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45723 PyObject *resultobj = 0;
45724 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45725 wxWindow *result = 0 ;
45726 void *argp1 = 0 ;
45727 int res1 = 0 ;
45728 PyObject *swig_obj[1] ;
45729
45730 if (!args) SWIG_fail;
45731 swig_obj[0] = args;
45732 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45733 if (!SWIG_IsOK(res1)) {
45734 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45735 }
45736 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45737 {
45738 PyThreadState* __tstate = wxPyBeginAllowThreads();
45739 result = (wxWindow *)(arg1)->GetWindow();
45740 wxPyEndAllowThreads(__tstate);
45741 if (PyErr_Occurred()) SWIG_fail;
45742 }
45743 {
45744 resultobj = wxPyMake_wxObject(result, 0);
45745 }
45746 return resultobj;
45747 fail:
45748 return NULL;
45749 }
45750
45751
45752 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45753 PyObject *resultobj = 0;
45754 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45755 wxWindow *arg2 = (wxWindow *) 0 ;
45756 void *argp1 = 0 ;
45757 int res1 = 0 ;
45758 void *argp2 = 0 ;
45759 int res2 = 0 ;
45760 PyObject * obj0 = 0 ;
45761 PyObject * obj1 = 0 ;
45762 char * kwnames[] = {
45763 (char *) "self",(char *) "window", NULL
45764 };
45765
45766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
45767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45768 if (!SWIG_IsOK(res1)) {
45769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45770 }
45771 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45772 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
45773 if (!SWIG_IsOK(res2)) {
45774 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
45775 }
45776 arg2 = reinterpret_cast< wxWindow * >(argp2);
45777 {
45778 PyThreadState* __tstate = wxPyBeginAllowThreads();
45779 (arg1)->SetWindow(arg2);
45780 wxPyEndAllowThreads(__tstate);
45781 if (PyErr_Occurred()) SWIG_fail;
45782 }
45783 resultobj = SWIG_Py_Void();
45784 return resultobj;
45785 fail:
45786 return NULL;
45787 }
45788
45789
45790 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45791 PyObject *resultobj = 0;
45792 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45793 wxSizer *result = 0 ;
45794 void *argp1 = 0 ;
45795 int res1 = 0 ;
45796 PyObject *swig_obj[1] ;
45797
45798 if (!args) SWIG_fail;
45799 swig_obj[0] = args;
45800 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45801 if (!SWIG_IsOK(res1)) {
45802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45803 }
45804 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45805 {
45806 PyThreadState* __tstate = wxPyBeginAllowThreads();
45807 result = (wxSizer *)(arg1)->GetSizer();
45808 wxPyEndAllowThreads(__tstate);
45809 if (PyErr_Occurred()) SWIG_fail;
45810 }
45811 {
45812 resultobj = wxPyMake_wxObject(result, (bool)0);
45813 }
45814 return resultobj;
45815 fail:
45816 return NULL;
45817 }
45818
45819
45820 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45821 PyObject *resultobj = 0;
45822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45823 wxSizer *arg2 = (wxSizer *) 0 ;
45824 void *argp1 = 0 ;
45825 int res1 = 0 ;
45826 int res2 = 0 ;
45827 PyObject * obj0 = 0 ;
45828 PyObject * obj1 = 0 ;
45829 char * kwnames[] = {
45830 (char *) "self",(char *) "sizer", NULL
45831 };
45832
45833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
45834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45835 if (!SWIG_IsOK(res1)) {
45836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45837 }
45838 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45839 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45840 if (!SWIG_IsOK(res2)) {
45841 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
45842 }
45843 {
45844 PyThreadState* __tstate = wxPyBeginAllowThreads();
45845 (arg1)->SetSizer(arg2);
45846 wxPyEndAllowThreads(__tstate);
45847 if (PyErr_Occurred()) SWIG_fail;
45848 }
45849 resultobj = SWIG_Py_Void();
45850 return resultobj;
45851 fail:
45852 return NULL;
45853 }
45854
45855
45856 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45857 PyObject *resultobj = 0;
45858 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45859 wxSize *result = 0 ;
45860 void *argp1 = 0 ;
45861 int res1 = 0 ;
45862 PyObject *swig_obj[1] ;
45863
45864 if (!args) SWIG_fail;
45865 swig_obj[0] = args;
45866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45867 if (!SWIG_IsOK(res1)) {
45868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45869 }
45870 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45871 {
45872 PyThreadState* __tstate = wxPyBeginAllowThreads();
45873 {
45874 wxSize const &_result_ref = (arg1)->GetSpacer();
45875 result = (wxSize *) &_result_ref;
45876 }
45877 wxPyEndAllowThreads(__tstate);
45878 if (PyErr_Occurred()) SWIG_fail;
45879 }
45880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
45881 return resultobj;
45882 fail:
45883 return NULL;
45884 }
45885
45886
45887 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45888 PyObject *resultobj = 0;
45889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45890 wxSize *arg2 = 0 ;
45891 void *argp1 = 0 ;
45892 int res1 = 0 ;
45893 wxSize temp2 ;
45894 PyObject * obj0 = 0 ;
45895 PyObject * obj1 = 0 ;
45896 char * kwnames[] = {
45897 (char *) "self",(char *) "size", NULL
45898 };
45899
45900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
45901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45902 if (!SWIG_IsOK(res1)) {
45903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45904 }
45905 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45906 {
45907 arg2 = &temp2;
45908 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45909 }
45910 {
45911 PyThreadState* __tstate = wxPyBeginAllowThreads();
45912 (arg1)->SetSpacer((wxSize const &)*arg2);
45913 wxPyEndAllowThreads(__tstate);
45914 if (PyErr_Occurred()) SWIG_fail;
45915 }
45916 resultobj = SWIG_Py_Void();
45917 return resultobj;
45918 fail:
45919 return NULL;
45920 }
45921
45922
45923 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45924 PyObject *resultobj = 0;
45925 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45926 bool arg2 ;
45927 void *argp1 = 0 ;
45928 int res1 = 0 ;
45929 bool val2 ;
45930 int ecode2 = 0 ;
45931 PyObject * obj0 = 0 ;
45932 PyObject * obj1 = 0 ;
45933 char * kwnames[] = {
45934 (char *) "self",(char *) "show", NULL
45935 };
45936
45937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
45938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45939 if (!SWIG_IsOK(res1)) {
45940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45941 }
45942 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45943 ecode2 = SWIG_AsVal_bool(obj1, &val2);
45944 if (!SWIG_IsOK(ecode2)) {
45945 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
45946 }
45947 arg2 = static_cast< bool >(val2);
45948 {
45949 PyThreadState* __tstate = wxPyBeginAllowThreads();
45950 (arg1)->Show(arg2);
45951 wxPyEndAllowThreads(__tstate);
45952 if (PyErr_Occurred()) SWIG_fail;
45953 }
45954 resultobj = SWIG_Py_Void();
45955 return resultobj;
45956 fail:
45957 return NULL;
45958 }
45959
45960
45961 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45962 PyObject *resultobj = 0;
45963 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45964 bool result;
45965 void *argp1 = 0 ;
45966 int res1 = 0 ;
45967 PyObject *swig_obj[1] ;
45968
45969 if (!args) SWIG_fail;
45970 swig_obj[0] = args;
45971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45972 if (!SWIG_IsOK(res1)) {
45973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45974 }
45975 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45976 {
45977 PyThreadState* __tstate = wxPyBeginAllowThreads();
45978 result = (bool)(arg1)->IsShown();
45979 wxPyEndAllowThreads(__tstate);
45980 if (PyErr_Occurred()) SWIG_fail;
45981 }
45982 {
45983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45984 }
45985 return resultobj;
45986 fail:
45987 return NULL;
45988 }
45989
45990
45991 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45992 PyObject *resultobj = 0;
45993 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45994 wxPoint result;
45995 void *argp1 = 0 ;
45996 int res1 = 0 ;
45997 PyObject *swig_obj[1] ;
45998
45999 if (!args) SWIG_fail;
46000 swig_obj[0] = args;
46001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46002 if (!SWIG_IsOK(res1)) {
46003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46004 }
46005 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46006 {
46007 PyThreadState* __tstate = wxPyBeginAllowThreads();
46008 result = (arg1)->GetPosition();
46009 wxPyEndAllowThreads(__tstate);
46010 if (PyErr_Occurred()) SWIG_fail;
46011 }
46012 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46013 return resultobj;
46014 fail:
46015 return NULL;
46016 }
46017
46018
46019 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46020 PyObject *resultobj = 0;
46021 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46022 PyObject *result = 0 ;
46023 void *argp1 = 0 ;
46024 int res1 = 0 ;
46025 PyObject *swig_obj[1] ;
46026
46027 if (!args) SWIG_fail;
46028 swig_obj[0] = args;
46029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46030 if (!SWIG_IsOK(res1)) {
46031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46032 }
46033 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46034 {
46035 PyThreadState* __tstate = wxPyBeginAllowThreads();
46036 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46037 wxPyEndAllowThreads(__tstate);
46038 if (PyErr_Occurred()) SWIG_fail;
46039 }
46040 resultobj = result;
46041 return resultobj;
46042 fail:
46043 return NULL;
46044 }
46045
46046
46047 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46048 PyObject *resultobj = 0;
46049 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46050 PyObject *arg2 = (PyObject *) 0 ;
46051 void *argp1 = 0 ;
46052 int res1 = 0 ;
46053 PyObject * obj0 = 0 ;
46054 PyObject * obj1 = 0 ;
46055 char * kwnames[] = {
46056 (char *) "self",(char *) "userData", NULL
46057 };
46058
46059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46061 if (!SWIG_IsOK(res1)) {
46062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46063 }
46064 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46065 arg2 = obj1;
46066 {
46067 PyThreadState* __tstate = wxPyBeginAllowThreads();
46068 wxSizerItem_SetUserData(arg1,arg2);
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 *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46080 PyObject *obj;
46081 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46082 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46083 return SWIG_Py_Void();
46084 }
46085
46086 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46087 return SWIG_Python_InitShadowInstance(args);
46088 }
46089
46090 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46091 PyObject *resultobj = 0;
46092 wxSizer *arg1 = (wxSizer *) 0 ;
46093 void *argp1 = 0 ;
46094 int res1 = 0 ;
46095 PyObject *swig_obj[1] ;
46096
46097 if (!args) SWIG_fail;
46098 swig_obj[0] = args;
46099 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46100 if (!SWIG_IsOK(res1)) {
46101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46102 }
46103 arg1 = reinterpret_cast< wxSizer * >(argp1);
46104 {
46105 PyThreadState* __tstate = wxPyBeginAllowThreads();
46106 delete arg1;
46107
46108 wxPyEndAllowThreads(__tstate);
46109 if (PyErr_Occurred()) SWIG_fail;
46110 }
46111 resultobj = SWIG_Py_Void();
46112 return resultobj;
46113 fail:
46114 return NULL;
46115 }
46116
46117
46118 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46119 PyObject *resultobj = 0;
46120 wxSizer *arg1 = (wxSizer *) 0 ;
46121 PyObject *arg2 = (PyObject *) 0 ;
46122 void *argp1 = 0 ;
46123 int res1 = 0 ;
46124 PyObject * obj0 = 0 ;
46125 PyObject * obj1 = 0 ;
46126 char * kwnames[] = {
46127 (char *) "self",(char *) "_self", NULL
46128 };
46129
46130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46132 if (!SWIG_IsOK(res1)) {
46133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46134 }
46135 arg1 = reinterpret_cast< wxSizer * >(argp1);
46136 arg2 = obj1;
46137 {
46138 PyThreadState* __tstate = wxPyBeginAllowThreads();
46139 wxSizer__setOORInfo(arg1,arg2);
46140 wxPyEndAllowThreads(__tstate);
46141 if (PyErr_Occurred()) SWIG_fail;
46142 }
46143 resultobj = SWIG_Py_Void();
46144 return resultobj;
46145 fail:
46146 return NULL;
46147 }
46148
46149
46150 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46151 PyObject *resultobj = 0;
46152 wxSizer *arg1 = (wxSizer *) 0 ;
46153 PyObject *arg2 = (PyObject *) 0 ;
46154 int arg3 = (int) 0 ;
46155 int arg4 = (int) 0 ;
46156 int arg5 = (int) 0 ;
46157 PyObject *arg6 = (PyObject *) NULL ;
46158 wxSizerItem *result = 0 ;
46159 void *argp1 = 0 ;
46160 int res1 = 0 ;
46161 int val3 ;
46162 int ecode3 = 0 ;
46163 int val4 ;
46164 int ecode4 = 0 ;
46165 int val5 ;
46166 int ecode5 = 0 ;
46167 PyObject * obj0 = 0 ;
46168 PyObject * obj1 = 0 ;
46169 PyObject * obj2 = 0 ;
46170 PyObject * obj3 = 0 ;
46171 PyObject * obj4 = 0 ;
46172 PyObject * obj5 = 0 ;
46173 char * kwnames[] = {
46174 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46175 };
46176
46177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46179 if (!SWIG_IsOK(res1)) {
46180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46181 }
46182 arg1 = reinterpret_cast< wxSizer * >(argp1);
46183 arg2 = obj1;
46184 if (obj2) {
46185 ecode3 = SWIG_AsVal_int(obj2, &val3);
46186 if (!SWIG_IsOK(ecode3)) {
46187 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46188 }
46189 arg3 = static_cast< int >(val3);
46190 }
46191 if (obj3) {
46192 ecode4 = SWIG_AsVal_int(obj3, &val4);
46193 if (!SWIG_IsOK(ecode4)) {
46194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46195 }
46196 arg4 = static_cast< int >(val4);
46197 }
46198 if (obj4) {
46199 ecode5 = SWIG_AsVal_int(obj4, &val5);
46200 if (!SWIG_IsOK(ecode5)) {
46201 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46202 }
46203 arg5 = static_cast< int >(val5);
46204 }
46205 if (obj5) {
46206 arg6 = obj5;
46207 }
46208 {
46209 PyThreadState* __tstate = wxPyBeginAllowThreads();
46210 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46211 wxPyEndAllowThreads(__tstate);
46212 if (PyErr_Occurred()) SWIG_fail;
46213 }
46214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46215 return resultobj;
46216 fail:
46217 return NULL;
46218 }
46219
46220
46221 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46222 PyObject *resultobj = 0;
46223 wxSizer *arg1 = (wxSizer *) 0 ;
46224 int arg2 ;
46225 PyObject *arg3 = (PyObject *) 0 ;
46226 int arg4 = (int) 0 ;
46227 int arg5 = (int) 0 ;
46228 int arg6 = (int) 0 ;
46229 PyObject *arg7 = (PyObject *) NULL ;
46230 wxSizerItem *result = 0 ;
46231 void *argp1 = 0 ;
46232 int res1 = 0 ;
46233 int val2 ;
46234 int ecode2 = 0 ;
46235 int val4 ;
46236 int ecode4 = 0 ;
46237 int val5 ;
46238 int ecode5 = 0 ;
46239 int val6 ;
46240 int ecode6 = 0 ;
46241 PyObject * obj0 = 0 ;
46242 PyObject * obj1 = 0 ;
46243 PyObject * obj2 = 0 ;
46244 PyObject * obj3 = 0 ;
46245 PyObject * obj4 = 0 ;
46246 PyObject * obj5 = 0 ;
46247 PyObject * obj6 = 0 ;
46248 char * kwnames[] = {
46249 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46250 };
46251
46252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46254 if (!SWIG_IsOK(res1)) {
46255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46256 }
46257 arg1 = reinterpret_cast< wxSizer * >(argp1);
46258 ecode2 = SWIG_AsVal_int(obj1, &val2);
46259 if (!SWIG_IsOK(ecode2)) {
46260 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46261 }
46262 arg2 = static_cast< int >(val2);
46263 arg3 = obj2;
46264 if (obj3) {
46265 ecode4 = SWIG_AsVal_int(obj3, &val4);
46266 if (!SWIG_IsOK(ecode4)) {
46267 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46268 }
46269 arg4 = static_cast< int >(val4);
46270 }
46271 if (obj4) {
46272 ecode5 = SWIG_AsVal_int(obj4, &val5);
46273 if (!SWIG_IsOK(ecode5)) {
46274 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46275 }
46276 arg5 = static_cast< int >(val5);
46277 }
46278 if (obj5) {
46279 ecode6 = SWIG_AsVal_int(obj5, &val6);
46280 if (!SWIG_IsOK(ecode6)) {
46281 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46282 }
46283 arg6 = static_cast< int >(val6);
46284 }
46285 if (obj6) {
46286 arg7 = obj6;
46287 }
46288 {
46289 PyThreadState* __tstate = wxPyBeginAllowThreads();
46290 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46291 wxPyEndAllowThreads(__tstate);
46292 if (PyErr_Occurred()) SWIG_fail;
46293 }
46294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46295 return resultobj;
46296 fail:
46297 return NULL;
46298 }
46299
46300
46301 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46302 PyObject *resultobj = 0;
46303 wxSizer *arg1 = (wxSizer *) 0 ;
46304 PyObject *arg2 = (PyObject *) 0 ;
46305 int arg3 = (int) 0 ;
46306 int arg4 = (int) 0 ;
46307 int arg5 = (int) 0 ;
46308 PyObject *arg6 = (PyObject *) NULL ;
46309 wxSizerItem *result = 0 ;
46310 void *argp1 = 0 ;
46311 int res1 = 0 ;
46312 int val3 ;
46313 int ecode3 = 0 ;
46314 int val4 ;
46315 int ecode4 = 0 ;
46316 int val5 ;
46317 int ecode5 = 0 ;
46318 PyObject * obj0 = 0 ;
46319 PyObject * obj1 = 0 ;
46320 PyObject * obj2 = 0 ;
46321 PyObject * obj3 = 0 ;
46322 PyObject * obj4 = 0 ;
46323 PyObject * obj5 = 0 ;
46324 char * kwnames[] = {
46325 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46326 };
46327
46328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46330 if (!SWIG_IsOK(res1)) {
46331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46332 }
46333 arg1 = reinterpret_cast< wxSizer * >(argp1);
46334 arg2 = obj1;
46335 if (obj2) {
46336 ecode3 = SWIG_AsVal_int(obj2, &val3);
46337 if (!SWIG_IsOK(ecode3)) {
46338 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46339 }
46340 arg3 = static_cast< int >(val3);
46341 }
46342 if (obj3) {
46343 ecode4 = SWIG_AsVal_int(obj3, &val4);
46344 if (!SWIG_IsOK(ecode4)) {
46345 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46346 }
46347 arg4 = static_cast< int >(val4);
46348 }
46349 if (obj4) {
46350 ecode5 = SWIG_AsVal_int(obj4, &val5);
46351 if (!SWIG_IsOK(ecode5)) {
46352 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46353 }
46354 arg5 = static_cast< int >(val5);
46355 }
46356 if (obj5) {
46357 arg6 = obj5;
46358 }
46359 {
46360 PyThreadState* __tstate = wxPyBeginAllowThreads();
46361 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46362 wxPyEndAllowThreads(__tstate);
46363 if (PyErr_Occurred()) SWIG_fail;
46364 }
46365 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46366 return resultobj;
46367 fail:
46368 return NULL;
46369 }
46370
46371
46372 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46373 PyObject *resultobj = 0;
46374 wxSizer *arg1 = (wxSizer *) 0 ;
46375 PyObject *arg2 = (PyObject *) 0 ;
46376 bool result;
46377 void *argp1 = 0 ;
46378 int res1 = 0 ;
46379 PyObject * obj0 = 0 ;
46380 PyObject * obj1 = 0 ;
46381 char * kwnames[] = {
46382 (char *) "self",(char *) "item", NULL
46383 };
46384
46385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46387 if (!SWIG_IsOK(res1)) {
46388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46389 }
46390 arg1 = reinterpret_cast< wxSizer * >(argp1);
46391 arg2 = obj1;
46392 {
46393 PyThreadState* __tstate = wxPyBeginAllowThreads();
46394 result = (bool)wxSizer_Remove(arg1,arg2);
46395 wxPyEndAllowThreads(__tstate);
46396 if (PyErr_Occurred()) SWIG_fail;
46397 }
46398 {
46399 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46400 }
46401 return resultobj;
46402 fail:
46403 return NULL;
46404 }
46405
46406
46407 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46408 PyObject *resultobj = 0;
46409 wxSizer *arg1 = (wxSizer *) 0 ;
46410 PyObject *arg2 = (PyObject *) 0 ;
46411 bool result;
46412 void *argp1 = 0 ;
46413 int res1 = 0 ;
46414 PyObject * obj0 = 0 ;
46415 PyObject * obj1 = 0 ;
46416 char * kwnames[] = {
46417 (char *) "self",(char *) "item", NULL
46418 };
46419
46420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46422 if (!SWIG_IsOK(res1)) {
46423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46424 }
46425 arg1 = reinterpret_cast< wxSizer * >(argp1);
46426 arg2 = obj1;
46427 {
46428 PyThreadState* __tstate = wxPyBeginAllowThreads();
46429 result = (bool)wxSizer_Detach(arg1,arg2);
46430 wxPyEndAllowThreads(__tstate);
46431 if (PyErr_Occurred()) SWIG_fail;
46432 }
46433 {
46434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46435 }
46436 return resultobj;
46437 fail:
46438 return NULL;
46439 }
46440
46441
46442 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46443 PyObject *resultobj = 0;
46444 wxSizer *arg1 = (wxSizer *) 0 ;
46445 PyObject *arg2 = (PyObject *) 0 ;
46446 wxSizerItem *result = 0 ;
46447 void *argp1 = 0 ;
46448 int res1 = 0 ;
46449 PyObject * obj0 = 0 ;
46450 PyObject * obj1 = 0 ;
46451 char * kwnames[] = {
46452 (char *) "self",(char *) "item", NULL
46453 };
46454
46455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46457 if (!SWIG_IsOK(res1)) {
46458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46459 }
46460 arg1 = reinterpret_cast< wxSizer * >(argp1);
46461 arg2 = obj1;
46462 {
46463 PyThreadState* __tstate = wxPyBeginAllowThreads();
46464 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46465 wxPyEndAllowThreads(__tstate);
46466 if (PyErr_Occurred()) SWIG_fail;
46467 }
46468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46469 return resultobj;
46470 fail:
46471 return NULL;
46472 }
46473
46474
46475 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46476 PyObject *resultobj = 0;
46477 wxSizer *arg1 = (wxSizer *) 0 ;
46478 PyObject *arg2 = (PyObject *) 0 ;
46479 wxSize *arg3 = 0 ;
46480 void *argp1 = 0 ;
46481 int res1 = 0 ;
46482 wxSize temp3 ;
46483 PyObject * obj0 = 0 ;
46484 PyObject * obj1 = 0 ;
46485 PyObject * obj2 = 0 ;
46486 char * kwnames[] = {
46487 (char *) "self",(char *) "item",(char *) "size", NULL
46488 };
46489
46490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46492 if (!SWIG_IsOK(res1)) {
46493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46494 }
46495 arg1 = reinterpret_cast< wxSizer * >(argp1);
46496 arg2 = obj1;
46497 {
46498 arg3 = &temp3;
46499 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46500 }
46501 {
46502 PyThreadState* __tstate = wxPyBeginAllowThreads();
46503 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46504 wxPyEndAllowThreads(__tstate);
46505 if (PyErr_Occurred()) SWIG_fail;
46506 }
46507 resultobj = SWIG_Py_Void();
46508 return resultobj;
46509 fail:
46510 return NULL;
46511 }
46512
46513
46514 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46515 PyObject *resultobj = 0;
46516 wxSizer *arg1 = (wxSizer *) 0 ;
46517 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46518 wxSizerItem *result = 0 ;
46519 void *argp1 = 0 ;
46520 int res1 = 0 ;
46521 int res2 = 0 ;
46522 PyObject * obj0 = 0 ;
46523 PyObject * obj1 = 0 ;
46524 char * kwnames[] = {
46525 (char *) "self",(char *) "item", NULL
46526 };
46527
46528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46530 if (!SWIG_IsOK(res1)) {
46531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46532 }
46533 arg1 = reinterpret_cast< wxSizer * >(argp1);
46534 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46535 if (!SWIG_IsOK(res2)) {
46536 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46537 }
46538 {
46539 PyThreadState* __tstate = wxPyBeginAllowThreads();
46540 result = (wxSizerItem *)(arg1)->Add(arg2);
46541 wxPyEndAllowThreads(__tstate);
46542 if (PyErr_Occurred()) SWIG_fail;
46543 }
46544 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46545 return resultobj;
46546 fail:
46547 return NULL;
46548 }
46549
46550
46551 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46552 PyObject *resultobj = 0;
46553 wxSizer *arg1 = (wxSizer *) 0 ;
46554 size_t arg2 ;
46555 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46556 wxSizerItem *result = 0 ;
46557 void *argp1 = 0 ;
46558 int res1 = 0 ;
46559 size_t val2 ;
46560 int ecode2 = 0 ;
46561 int res3 = 0 ;
46562 PyObject * obj0 = 0 ;
46563 PyObject * obj1 = 0 ;
46564 PyObject * obj2 = 0 ;
46565 char * kwnames[] = {
46566 (char *) "self",(char *) "index",(char *) "item", NULL
46567 };
46568
46569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46571 if (!SWIG_IsOK(res1)) {
46572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46573 }
46574 arg1 = reinterpret_cast< wxSizer * >(argp1);
46575 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46576 if (!SWIG_IsOK(ecode2)) {
46577 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46578 }
46579 arg2 = static_cast< size_t >(val2);
46580 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46581 if (!SWIG_IsOK(res3)) {
46582 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46583 }
46584 {
46585 PyThreadState* __tstate = wxPyBeginAllowThreads();
46586 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46587 wxPyEndAllowThreads(__tstate);
46588 if (PyErr_Occurred()) SWIG_fail;
46589 }
46590 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46591 return resultobj;
46592 fail:
46593 return NULL;
46594 }
46595
46596
46597 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46598 PyObject *resultobj = 0;
46599 wxSizer *arg1 = (wxSizer *) 0 ;
46600 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46601 wxSizerItem *result = 0 ;
46602 void *argp1 = 0 ;
46603 int res1 = 0 ;
46604 int res2 = 0 ;
46605 PyObject * obj0 = 0 ;
46606 PyObject * obj1 = 0 ;
46607 char * kwnames[] = {
46608 (char *) "self",(char *) "item", NULL
46609 };
46610
46611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46613 if (!SWIG_IsOK(res1)) {
46614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46615 }
46616 arg1 = reinterpret_cast< wxSizer * >(argp1);
46617 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46618 if (!SWIG_IsOK(res2)) {
46619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46620 }
46621 {
46622 PyThreadState* __tstate = wxPyBeginAllowThreads();
46623 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46624 wxPyEndAllowThreads(__tstate);
46625 if (PyErr_Occurred()) SWIG_fail;
46626 }
46627 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46628 return resultobj;
46629 fail:
46630 return NULL;
46631 }
46632
46633
46634 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46635 PyObject *resultobj = 0;
46636 wxSizer *arg1 = (wxSizer *) 0 ;
46637 int arg2 ;
46638 int arg3 ;
46639 int arg4 ;
46640 int arg5 ;
46641 void *argp1 = 0 ;
46642 int res1 = 0 ;
46643 int val2 ;
46644 int ecode2 = 0 ;
46645 int val3 ;
46646 int ecode3 = 0 ;
46647 int val4 ;
46648 int ecode4 = 0 ;
46649 int val5 ;
46650 int ecode5 = 0 ;
46651 PyObject * obj0 = 0 ;
46652 PyObject * obj1 = 0 ;
46653 PyObject * obj2 = 0 ;
46654 PyObject * obj3 = 0 ;
46655 PyObject * obj4 = 0 ;
46656 char * kwnames[] = {
46657 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46658 };
46659
46660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46662 if (!SWIG_IsOK(res1)) {
46663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46664 }
46665 arg1 = reinterpret_cast< wxSizer * >(argp1);
46666 ecode2 = SWIG_AsVal_int(obj1, &val2);
46667 if (!SWIG_IsOK(ecode2)) {
46668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46669 }
46670 arg2 = static_cast< int >(val2);
46671 ecode3 = SWIG_AsVal_int(obj2, &val3);
46672 if (!SWIG_IsOK(ecode3)) {
46673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46674 }
46675 arg3 = static_cast< int >(val3);
46676 ecode4 = SWIG_AsVal_int(obj3, &val4);
46677 if (!SWIG_IsOK(ecode4)) {
46678 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46679 }
46680 arg4 = static_cast< int >(val4);
46681 ecode5 = SWIG_AsVal_int(obj4, &val5);
46682 if (!SWIG_IsOK(ecode5)) {
46683 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46684 }
46685 arg5 = static_cast< int >(val5);
46686 {
46687 PyThreadState* __tstate = wxPyBeginAllowThreads();
46688 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46689 wxPyEndAllowThreads(__tstate);
46690 if (PyErr_Occurred()) SWIG_fail;
46691 }
46692 resultobj = SWIG_Py_Void();
46693 return resultobj;
46694 fail:
46695 return NULL;
46696 }
46697
46698
46699 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46700 PyObject *resultobj = 0;
46701 wxSizer *arg1 = (wxSizer *) 0 ;
46702 wxSize *arg2 = 0 ;
46703 void *argp1 = 0 ;
46704 int res1 = 0 ;
46705 wxSize temp2 ;
46706 PyObject * obj0 = 0 ;
46707 PyObject * obj1 = 0 ;
46708 char * kwnames[] = {
46709 (char *) "self",(char *) "size", NULL
46710 };
46711
46712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46714 if (!SWIG_IsOK(res1)) {
46715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46716 }
46717 arg1 = reinterpret_cast< wxSizer * >(argp1);
46718 {
46719 arg2 = &temp2;
46720 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46721 }
46722 {
46723 PyThreadState* __tstate = wxPyBeginAllowThreads();
46724 (arg1)->SetMinSize((wxSize const &)*arg2);
46725 wxPyEndAllowThreads(__tstate);
46726 if (PyErr_Occurred()) SWIG_fail;
46727 }
46728 resultobj = SWIG_Py_Void();
46729 return resultobj;
46730 fail:
46731 return NULL;
46732 }
46733
46734
46735 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46736 PyObject *resultobj = 0;
46737 wxSizer *arg1 = (wxSizer *) 0 ;
46738 wxSize result;
46739 void *argp1 = 0 ;
46740 int res1 = 0 ;
46741 PyObject *swig_obj[1] ;
46742
46743 if (!args) SWIG_fail;
46744 swig_obj[0] = args;
46745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46746 if (!SWIG_IsOK(res1)) {
46747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46748 }
46749 arg1 = reinterpret_cast< wxSizer * >(argp1);
46750 {
46751 PyThreadState* __tstate = wxPyBeginAllowThreads();
46752 result = (arg1)->GetSize();
46753 wxPyEndAllowThreads(__tstate);
46754 if (PyErr_Occurred()) SWIG_fail;
46755 }
46756 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46757 return resultobj;
46758 fail:
46759 return NULL;
46760 }
46761
46762
46763 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46764 PyObject *resultobj = 0;
46765 wxSizer *arg1 = (wxSizer *) 0 ;
46766 wxPoint result;
46767 void *argp1 = 0 ;
46768 int res1 = 0 ;
46769 PyObject *swig_obj[1] ;
46770
46771 if (!args) SWIG_fail;
46772 swig_obj[0] = args;
46773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46774 if (!SWIG_IsOK(res1)) {
46775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
46776 }
46777 arg1 = reinterpret_cast< wxSizer * >(argp1);
46778 {
46779 PyThreadState* __tstate = wxPyBeginAllowThreads();
46780 result = (arg1)->GetPosition();
46781 wxPyEndAllowThreads(__tstate);
46782 if (PyErr_Occurred()) SWIG_fail;
46783 }
46784 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46785 return resultobj;
46786 fail:
46787 return NULL;
46788 }
46789
46790
46791 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46792 PyObject *resultobj = 0;
46793 wxSizer *arg1 = (wxSizer *) 0 ;
46794 wxSize result;
46795 void *argp1 = 0 ;
46796 int res1 = 0 ;
46797 PyObject *swig_obj[1] ;
46798
46799 if (!args) SWIG_fail;
46800 swig_obj[0] = args;
46801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46802 if (!SWIG_IsOK(res1)) {
46803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46804 }
46805 arg1 = reinterpret_cast< wxSizer * >(argp1);
46806 {
46807 PyThreadState* __tstate = wxPyBeginAllowThreads();
46808 result = (arg1)->GetMinSize();
46809 wxPyEndAllowThreads(__tstate);
46810 if (PyErr_Occurred()) SWIG_fail;
46811 }
46812 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46813 return resultobj;
46814 fail:
46815 return NULL;
46816 }
46817
46818
46819 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46820 PyObject *resultobj = 0;
46821 wxSizer *arg1 = (wxSizer *) 0 ;
46822 void *argp1 = 0 ;
46823 int res1 = 0 ;
46824 PyObject *swig_obj[1] ;
46825
46826 if (!args) SWIG_fail;
46827 swig_obj[0] = args;
46828 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46829 if (!SWIG_IsOK(res1)) {
46830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
46831 }
46832 arg1 = reinterpret_cast< wxSizer * >(argp1);
46833 {
46834 PyThreadState* __tstate = wxPyBeginAllowThreads();
46835 (arg1)->RecalcSizes();
46836 wxPyEndAllowThreads(__tstate);
46837 if (PyErr_Occurred()) SWIG_fail;
46838 }
46839 resultobj = SWIG_Py_Void();
46840 return resultobj;
46841 fail:
46842 return NULL;
46843 }
46844
46845
46846 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46847 PyObject *resultobj = 0;
46848 wxSizer *arg1 = (wxSizer *) 0 ;
46849 wxSize result;
46850 void *argp1 = 0 ;
46851 int res1 = 0 ;
46852 PyObject *swig_obj[1] ;
46853
46854 if (!args) SWIG_fail;
46855 swig_obj[0] = args;
46856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46857 if (!SWIG_IsOK(res1)) {
46858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
46859 }
46860 arg1 = reinterpret_cast< wxSizer * >(argp1);
46861 {
46862 PyThreadState* __tstate = wxPyBeginAllowThreads();
46863 result = (arg1)->CalcMin();
46864 wxPyEndAllowThreads(__tstate);
46865 if (PyErr_Occurred()) SWIG_fail;
46866 }
46867 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46868 return resultobj;
46869 fail:
46870 return NULL;
46871 }
46872
46873
46874 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46875 PyObject *resultobj = 0;
46876 wxSizer *arg1 = (wxSizer *) 0 ;
46877 void *argp1 = 0 ;
46878 int res1 = 0 ;
46879 PyObject *swig_obj[1] ;
46880
46881 if (!args) SWIG_fail;
46882 swig_obj[0] = args;
46883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46884 if (!SWIG_IsOK(res1)) {
46885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
46886 }
46887 arg1 = reinterpret_cast< wxSizer * >(argp1);
46888 {
46889 PyThreadState* __tstate = wxPyBeginAllowThreads();
46890 (arg1)->Layout();
46891 wxPyEndAllowThreads(__tstate);
46892 if (PyErr_Occurred()) SWIG_fail;
46893 }
46894 resultobj = SWIG_Py_Void();
46895 return resultobj;
46896 fail:
46897 return NULL;
46898 }
46899
46900
46901 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46902 PyObject *resultobj = 0;
46903 wxSizer *arg1 = (wxSizer *) 0 ;
46904 wxWindow *arg2 = (wxWindow *) 0 ;
46905 wxSize result;
46906 void *argp1 = 0 ;
46907 int res1 = 0 ;
46908 void *argp2 = 0 ;
46909 int res2 = 0 ;
46910 PyObject * obj0 = 0 ;
46911 PyObject * obj1 = 0 ;
46912 char * kwnames[] = {
46913 (char *) "self",(char *) "window", NULL
46914 };
46915
46916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
46917 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46918 if (!SWIG_IsOK(res1)) {
46919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
46920 }
46921 arg1 = reinterpret_cast< wxSizer * >(argp1);
46922 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46923 if (!SWIG_IsOK(res2)) {
46924 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
46925 }
46926 arg2 = reinterpret_cast< wxWindow * >(argp2);
46927 {
46928 PyThreadState* __tstate = wxPyBeginAllowThreads();
46929 result = (arg1)->Fit(arg2);
46930 wxPyEndAllowThreads(__tstate);
46931 if (PyErr_Occurred()) SWIG_fail;
46932 }
46933 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46934 return resultobj;
46935 fail:
46936 return NULL;
46937 }
46938
46939
46940 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46941 PyObject *resultobj = 0;
46942 wxSizer *arg1 = (wxSizer *) 0 ;
46943 wxWindow *arg2 = (wxWindow *) 0 ;
46944 void *argp1 = 0 ;
46945 int res1 = 0 ;
46946 void *argp2 = 0 ;
46947 int res2 = 0 ;
46948 PyObject * obj0 = 0 ;
46949 PyObject * obj1 = 0 ;
46950 char * kwnames[] = {
46951 (char *) "self",(char *) "window", NULL
46952 };
46953
46954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
46955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46956 if (!SWIG_IsOK(res1)) {
46957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
46958 }
46959 arg1 = reinterpret_cast< wxSizer * >(argp1);
46960 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46961 if (!SWIG_IsOK(res2)) {
46962 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
46963 }
46964 arg2 = reinterpret_cast< wxWindow * >(argp2);
46965 {
46966 PyThreadState* __tstate = wxPyBeginAllowThreads();
46967 (arg1)->FitInside(arg2);
46968 wxPyEndAllowThreads(__tstate);
46969 if (PyErr_Occurred()) SWIG_fail;
46970 }
46971 resultobj = SWIG_Py_Void();
46972 return resultobj;
46973 fail:
46974 return NULL;
46975 }
46976
46977
46978 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46979 PyObject *resultobj = 0;
46980 wxSizer *arg1 = (wxSizer *) 0 ;
46981 wxWindow *arg2 = (wxWindow *) 0 ;
46982 void *argp1 = 0 ;
46983 int res1 = 0 ;
46984 void *argp2 = 0 ;
46985 int res2 = 0 ;
46986 PyObject * obj0 = 0 ;
46987 PyObject * obj1 = 0 ;
46988 char * kwnames[] = {
46989 (char *) "self",(char *) "window", NULL
46990 };
46991
46992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
46993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46994 if (!SWIG_IsOK(res1)) {
46995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
46996 }
46997 arg1 = reinterpret_cast< wxSizer * >(argp1);
46998 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46999 if (!SWIG_IsOK(res2)) {
47000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47001 }
47002 arg2 = reinterpret_cast< wxWindow * >(argp2);
47003 {
47004 PyThreadState* __tstate = wxPyBeginAllowThreads();
47005 (arg1)->SetSizeHints(arg2);
47006 wxPyEndAllowThreads(__tstate);
47007 if (PyErr_Occurred()) SWIG_fail;
47008 }
47009 resultobj = SWIG_Py_Void();
47010 return resultobj;
47011 fail:
47012 return NULL;
47013 }
47014
47015
47016 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47017 PyObject *resultobj = 0;
47018 wxSizer *arg1 = (wxSizer *) 0 ;
47019 wxWindow *arg2 = (wxWindow *) 0 ;
47020 void *argp1 = 0 ;
47021 int res1 = 0 ;
47022 void *argp2 = 0 ;
47023 int res2 = 0 ;
47024 PyObject * obj0 = 0 ;
47025 PyObject * obj1 = 0 ;
47026 char * kwnames[] = {
47027 (char *) "self",(char *) "window", NULL
47028 };
47029
47030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47032 if (!SWIG_IsOK(res1)) {
47033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47034 }
47035 arg1 = reinterpret_cast< wxSizer * >(argp1);
47036 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47037 if (!SWIG_IsOK(res2)) {
47038 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47039 }
47040 arg2 = reinterpret_cast< wxWindow * >(argp2);
47041 {
47042 PyThreadState* __tstate = wxPyBeginAllowThreads();
47043 (arg1)->SetVirtualSizeHints(arg2);
47044 wxPyEndAllowThreads(__tstate);
47045 if (PyErr_Occurred()) SWIG_fail;
47046 }
47047 resultobj = SWIG_Py_Void();
47048 return resultobj;
47049 fail:
47050 return NULL;
47051 }
47052
47053
47054 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47055 PyObject *resultobj = 0;
47056 wxSizer *arg1 = (wxSizer *) 0 ;
47057 bool arg2 = (bool) false ;
47058 void *argp1 = 0 ;
47059 int res1 = 0 ;
47060 bool val2 ;
47061 int ecode2 = 0 ;
47062 PyObject * obj0 = 0 ;
47063 PyObject * obj1 = 0 ;
47064 char * kwnames[] = {
47065 (char *) "self",(char *) "deleteWindows", NULL
47066 };
47067
47068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47070 if (!SWIG_IsOK(res1)) {
47071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47072 }
47073 arg1 = reinterpret_cast< wxSizer * >(argp1);
47074 if (obj1) {
47075 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47076 if (!SWIG_IsOK(ecode2)) {
47077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47078 }
47079 arg2 = static_cast< bool >(val2);
47080 }
47081 {
47082 PyThreadState* __tstate = wxPyBeginAllowThreads();
47083 (arg1)->Clear(arg2);
47084 wxPyEndAllowThreads(__tstate);
47085 if (PyErr_Occurred()) SWIG_fail;
47086 }
47087 resultobj = SWIG_Py_Void();
47088 return resultobj;
47089 fail:
47090 return NULL;
47091 }
47092
47093
47094 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47095 PyObject *resultobj = 0;
47096 wxSizer *arg1 = (wxSizer *) 0 ;
47097 void *argp1 = 0 ;
47098 int res1 = 0 ;
47099 PyObject *swig_obj[1] ;
47100
47101 if (!args) SWIG_fail;
47102 swig_obj[0] = args;
47103 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47104 if (!SWIG_IsOK(res1)) {
47105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47106 }
47107 arg1 = reinterpret_cast< wxSizer * >(argp1);
47108 {
47109 PyThreadState* __tstate = wxPyBeginAllowThreads();
47110 (arg1)->DeleteWindows();
47111 wxPyEndAllowThreads(__tstate);
47112 if (PyErr_Occurred()) SWIG_fail;
47113 }
47114 resultobj = SWIG_Py_Void();
47115 return resultobj;
47116 fail:
47117 return NULL;
47118 }
47119
47120
47121 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47122 PyObject *resultobj = 0;
47123 wxSizer *arg1 = (wxSizer *) 0 ;
47124 PyObject *result = 0 ;
47125 void *argp1 = 0 ;
47126 int res1 = 0 ;
47127 PyObject *swig_obj[1] ;
47128
47129 if (!args) SWIG_fail;
47130 swig_obj[0] = args;
47131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47132 if (!SWIG_IsOK(res1)) {
47133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47134 }
47135 arg1 = reinterpret_cast< wxSizer * >(argp1);
47136 {
47137 PyThreadState* __tstate = wxPyBeginAllowThreads();
47138 result = (PyObject *)wxSizer_GetChildren(arg1);
47139 wxPyEndAllowThreads(__tstate);
47140 if (PyErr_Occurred()) SWIG_fail;
47141 }
47142 resultobj = result;
47143 return resultobj;
47144 fail:
47145 return NULL;
47146 }
47147
47148
47149 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47150 PyObject *resultobj = 0;
47151 wxSizer *arg1 = (wxSizer *) 0 ;
47152 PyObject *arg2 = (PyObject *) 0 ;
47153 bool arg3 = (bool) true ;
47154 bool arg4 = (bool) false ;
47155 bool result;
47156 void *argp1 = 0 ;
47157 int res1 = 0 ;
47158 bool val3 ;
47159 int ecode3 = 0 ;
47160 bool val4 ;
47161 int ecode4 = 0 ;
47162 PyObject * obj0 = 0 ;
47163 PyObject * obj1 = 0 ;
47164 PyObject * obj2 = 0 ;
47165 PyObject * obj3 = 0 ;
47166 char * kwnames[] = {
47167 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47168 };
47169
47170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47172 if (!SWIG_IsOK(res1)) {
47173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47174 }
47175 arg1 = reinterpret_cast< wxSizer * >(argp1);
47176 arg2 = obj1;
47177 if (obj2) {
47178 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47179 if (!SWIG_IsOK(ecode3)) {
47180 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47181 }
47182 arg3 = static_cast< bool >(val3);
47183 }
47184 if (obj3) {
47185 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47186 if (!SWIG_IsOK(ecode4)) {
47187 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47188 }
47189 arg4 = static_cast< bool >(val4);
47190 }
47191 {
47192 PyThreadState* __tstate = wxPyBeginAllowThreads();
47193 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47194 wxPyEndAllowThreads(__tstate);
47195 if (PyErr_Occurred()) SWIG_fail;
47196 }
47197 {
47198 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47199 }
47200 return resultobj;
47201 fail:
47202 return NULL;
47203 }
47204
47205
47206 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47207 PyObject *resultobj = 0;
47208 wxSizer *arg1 = (wxSizer *) 0 ;
47209 PyObject *arg2 = (PyObject *) 0 ;
47210 bool result;
47211 void *argp1 = 0 ;
47212 int res1 = 0 ;
47213 PyObject * obj0 = 0 ;
47214 PyObject * obj1 = 0 ;
47215 char * kwnames[] = {
47216 (char *) "self",(char *) "item", NULL
47217 };
47218
47219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47221 if (!SWIG_IsOK(res1)) {
47222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47223 }
47224 arg1 = reinterpret_cast< wxSizer * >(argp1);
47225 arg2 = obj1;
47226 {
47227 PyThreadState* __tstate = wxPyBeginAllowThreads();
47228 result = (bool)wxSizer_IsShown(arg1,arg2);
47229 wxPyEndAllowThreads(__tstate);
47230 if (PyErr_Occurred()) SWIG_fail;
47231 }
47232 {
47233 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47234 }
47235 return resultobj;
47236 fail:
47237 return NULL;
47238 }
47239
47240
47241 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47242 PyObject *resultobj = 0;
47243 wxSizer *arg1 = (wxSizer *) 0 ;
47244 bool arg2 ;
47245 void *argp1 = 0 ;
47246 int res1 = 0 ;
47247 bool val2 ;
47248 int ecode2 = 0 ;
47249 PyObject * obj0 = 0 ;
47250 PyObject * obj1 = 0 ;
47251 char * kwnames[] = {
47252 (char *) "self",(char *) "show", NULL
47253 };
47254
47255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47257 if (!SWIG_IsOK(res1)) {
47258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47259 }
47260 arg1 = reinterpret_cast< wxSizer * >(argp1);
47261 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47262 if (!SWIG_IsOK(ecode2)) {
47263 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47264 }
47265 arg2 = static_cast< bool >(val2);
47266 {
47267 PyThreadState* __tstate = wxPyBeginAllowThreads();
47268 (arg1)->ShowItems(arg2);
47269 wxPyEndAllowThreads(__tstate);
47270 if (PyErr_Occurred()) SWIG_fail;
47271 }
47272 resultobj = SWIG_Py_Void();
47273 return resultobj;
47274 fail:
47275 return NULL;
47276 }
47277
47278
47279 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47280 PyObject *obj;
47281 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47282 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47283 return SWIG_Py_Void();
47284 }
47285
47286 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47287 PyObject *resultobj = 0;
47288 wxPySizer *result = 0 ;
47289
47290 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47291 {
47292 PyThreadState* __tstate = wxPyBeginAllowThreads();
47293 result = (wxPySizer *)new wxPySizer();
47294 wxPyEndAllowThreads(__tstate);
47295 if (PyErr_Occurred()) SWIG_fail;
47296 }
47297 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47298 return resultobj;
47299 fail:
47300 return NULL;
47301 }
47302
47303
47304 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47305 PyObject *resultobj = 0;
47306 wxPySizer *arg1 = (wxPySizer *) 0 ;
47307 PyObject *arg2 = (PyObject *) 0 ;
47308 PyObject *arg3 = (PyObject *) 0 ;
47309 void *argp1 = 0 ;
47310 int res1 = 0 ;
47311 PyObject * obj0 = 0 ;
47312 PyObject * obj1 = 0 ;
47313 PyObject * obj2 = 0 ;
47314 char * kwnames[] = {
47315 (char *) "self",(char *) "self",(char *) "_class", NULL
47316 };
47317
47318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47320 if (!SWIG_IsOK(res1)) {
47321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47322 }
47323 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47324 arg2 = obj1;
47325 arg3 = obj2;
47326 {
47327 PyThreadState* __tstate = wxPyBeginAllowThreads();
47328 (arg1)->_setCallbackInfo(arg2,arg3);
47329 wxPyEndAllowThreads(__tstate);
47330 if (PyErr_Occurred()) SWIG_fail;
47331 }
47332 resultobj = SWIG_Py_Void();
47333 return resultobj;
47334 fail:
47335 return NULL;
47336 }
47337
47338
47339 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47340 PyObject *obj;
47341 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47342 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47343 return SWIG_Py_Void();
47344 }
47345
47346 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47347 return SWIG_Python_InitShadowInstance(args);
47348 }
47349
47350 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47351 PyObject *resultobj = 0;
47352 int arg1 = (int) wxHORIZONTAL ;
47353 wxBoxSizer *result = 0 ;
47354 int val1 ;
47355 int ecode1 = 0 ;
47356 PyObject * obj0 = 0 ;
47357 char * kwnames[] = {
47358 (char *) "orient", NULL
47359 };
47360
47361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47362 if (obj0) {
47363 ecode1 = SWIG_AsVal_int(obj0, &val1);
47364 if (!SWIG_IsOK(ecode1)) {
47365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47366 }
47367 arg1 = static_cast< int >(val1);
47368 }
47369 {
47370 PyThreadState* __tstate = wxPyBeginAllowThreads();
47371 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47372 wxPyEndAllowThreads(__tstate);
47373 if (PyErr_Occurred()) SWIG_fail;
47374 }
47375 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47376 return resultobj;
47377 fail:
47378 return NULL;
47379 }
47380
47381
47382 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47383 PyObject *resultobj = 0;
47384 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47385 int result;
47386 void *argp1 = 0 ;
47387 int res1 = 0 ;
47388 PyObject *swig_obj[1] ;
47389
47390 if (!args) SWIG_fail;
47391 swig_obj[0] = args;
47392 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47393 if (!SWIG_IsOK(res1)) {
47394 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47395 }
47396 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47397 {
47398 PyThreadState* __tstate = wxPyBeginAllowThreads();
47399 result = (int)(arg1)->GetOrientation();
47400 wxPyEndAllowThreads(__tstate);
47401 if (PyErr_Occurred()) SWIG_fail;
47402 }
47403 resultobj = SWIG_From_int(static_cast< int >(result));
47404 return resultobj;
47405 fail:
47406 return NULL;
47407 }
47408
47409
47410 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47411 PyObject *resultobj = 0;
47412 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47413 int arg2 ;
47414 void *argp1 = 0 ;
47415 int res1 = 0 ;
47416 int val2 ;
47417 int ecode2 = 0 ;
47418 PyObject * obj0 = 0 ;
47419 PyObject * obj1 = 0 ;
47420 char * kwnames[] = {
47421 (char *) "self",(char *) "orient", NULL
47422 };
47423
47424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47426 if (!SWIG_IsOK(res1)) {
47427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47428 }
47429 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47430 ecode2 = SWIG_AsVal_int(obj1, &val2);
47431 if (!SWIG_IsOK(ecode2)) {
47432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47433 }
47434 arg2 = static_cast< int >(val2);
47435 {
47436 PyThreadState* __tstate = wxPyBeginAllowThreads();
47437 (arg1)->SetOrientation(arg2);
47438 wxPyEndAllowThreads(__tstate);
47439 if (PyErr_Occurred()) SWIG_fail;
47440 }
47441 resultobj = SWIG_Py_Void();
47442 return resultobj;
47443 fail:
47444 return NULL;
47445 }
47446
47447
47448 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47449 PyObject *obj;
47450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47451 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47452 return SWIG_Py_Void();
47453 }
47454
47455 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47456 return SWIG_Python_InitShadowInstance(args);
47457 }
47458
47459 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47460 PyObject *resultobj = 0;
47461 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47462 int arg2 = (int) wxHORIZONTAL ;
47463 wxStaticBoxSizer *result = 0 ;
47464 void *argp1 = 0 ;
47465 int res1 = 0 ;
47466 int val2 ;
47467 int ecode2 = 0 ;
47468 PyObject * obj0 = 0 ;
47469 PyObject * obj1 = 0 ;
47470 char * kwnames[] = {
47471 (char *) "box",(char *) "orient", NULL
47472 };
47473
47474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47476 if (!SWIG_IsOK(res1)) {
47477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47478 }
47479 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47480 if (obj1) {
47481 ecode2 = SWIG_AsVal_int(obj1, &val2);
47482 if (!SWIG_IsOK(ecode2)) {
47483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47484 }
47485 arg2 = static_cast< int >(val2);
47486 }
47487 {
47488 PyThreadState* __tstate = wxPyBeginAllowThreads();
47489 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47490 wxPyEndAllowThreads(__tstate);
47491 if (PyErr_Occurred()) SWIG_fail;
47492 }
47493 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47494 return resultobj;
47495 fail:
47496 return NULL;
47497 }
47498
47499
47500 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47501 PyObject *resultobj = 0;
47502 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47503 wxStaticBox *result = 0 ;
47504 void *argp1 = 0 ;
47505 int res1 = 0 ;
47506 PyObject *swig_obj[1] ;
47507
47508 if (!args) SWIG_fail;
47509 swig_obj[0] = args;
47510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47511 if (!SWIG_IsOK(res1)) {
47512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47513 }
47514 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47515 {
47516 PyThreadState* __tstate = wxPyBeginAllowThreads();
47517 result = (wxStaticBox *)(arg1)->GetStaticBox();
47518 wxPyEndAllowThreads(__tstate);
47519 if (PyErr_Occurred()) SWIG_fail;
47520 }
47521 {
47522 resultobj = wxPyMake_wxObject(result, (bool)0);
47523 }
47524 return resultobj;
47525 fail:
47526 return NULL;
47527 }
47528
47529
47530 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47531 PyObject *obj;
47532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47533 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47534 return SWIG_Py_Void();
47535 }
47536
47537 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47538 return SWIG_Python_InitShadowInstance(args);
47539 }
47540
47541 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47542 PyObject *resultobj = 0;
47543 int arg1 = (int) 1 ;
47544 int arg2 = (int) 0 ;
47545 int arg3 = (int) 0 ;
47546 int arg4 = (int) 0 ;
47547 wxGridSizer *result = 0 ;
47548 int val1 ;
47549 int ecode1 = 0 ;
47550 int val2 ;
47551 int ecode2 = 0 ;
47552 int val3 ;
47553 int ecode3 = 0 ;
47554 int val4 ;
47555 int ecode4 = 0 ;
47556 PyObject * obj0 = 0 ;
47557 PyObject * obj1 = 0 ;
47558 PyObject * obj2 = 0 ;
47559 PyObject * obj3 = 0 ;
47560 char * kwnames[] = {
47561 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47562 };
47563
47564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47565 if (obj0) {
47566 ecode1 = SWIG_AsVal_int(obj0, &val1);
47567 if (!SWIG_IsOK(ecode1)) {
47568 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47569 }
47570 arg1 = static_cast< int >(val1);
47571 }
47572 if (obj1) {
47573 ecode2 = SWIG_AsVal_int(obj1, &val2);
47574 if (!SWIG_IsOK(ecode2)) {
47575 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47576 }
47577 arg2 = static_cast< int >(val2);
47578 }
47579 if (obj2) {
47580 ecode3 = SWIG_AsVal_int(obj2, &val3);
47581 if (!SWIG_IsOK(ecode3)) {
47582 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47583 }
47584 arg3 = static_cast< int >(val3);
47585 }
47586 if (obj3) {
47587 ecode4 = SWIG_AsVal_int(obj3, &val4);
47588 if (!SWIG_IsOK(ecode4)) {
47589 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47590 }
47591 arg4 = static_cast< int >(val4);
47592 }
47593 {
47594 PyThreadState* __tstate = wxPyBeginAllowThreads();
47595 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47596 wxPyEndAllowThreads(__tstate);
47597 if (PyErr_Occurred()) SWIG_fail;
47598 }
47599 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47600 return resultobj;
47601 fail:
47602 return NULL;
47603 }
47604
47605
47606 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47607 PyObject *resultobj = 0;
47608 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47609 int arg2 ;
47610 void *argp1 = 0 ;
47611 int res1 = 0 ;
47612 int val2 ;
47613 int ecode2 = 0 ;
47614 PyObject * obj0 = 0 ;
47615 PyObject * obj1 = 0 ;
47616 char * kwnames[] = {
47617 (char *) "self",(char *) "cols", NULL
47618 };
47619
47620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47622 if (!SWIG_IsOK(res1)) {
47623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47624 }
47625 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47626 ecode2 = SWIG_AsVal_int(obj1, &val2);
47627 if (!SWIG_IsOK(ecode2)) {
47628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47629 }
47630 arg2 = static_cast< int >(val2);
47631 {
47632 PyThreadState* __tstate = wxPyBeginAllowThreads();
47633 (arg1)->SetCols(arg2);
47634 wxPyEndAllowThreads(__tstate);
47635 if (PyErr_Occurred()) SWIG_fail;
47636 }
47637 resultobj = SWIG_Py_Void();
47638 return resultobj;
47639 fail:
47640 return NULL;
47641 }
47642
47643
47644 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47645 PyObject *resultobj = 0;
47646 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47647 int arg2 ;
47648 void *argp1 = 0 ;
47649 int res1 = 0 ;
47650 int val2 ;
47651 int ecode2 = 0 ;
47652 PyObject * obj0 = 0 ;
47653 PyObject * obj1 = 0 ;
47654 char * kwnames[] = {
47655 (char *) "self",(char *) "rows", NULL
47656 };
47657
47658 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47659 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47660 if (!SWIG_IsOK(res1)) {
47661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47662 }
47663 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47664 ecode2 = SWIG_AsVal_int(obj1, &val2);
47665 if (!SWIG_IsOK(ecode2)) {
47666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47667 }
47668 arg2 = static_cast< int >(val2);
47669 {
47670 PyThreadState* __tstate = wxPyBeginAllowThreads();
47671 (arg1)->SetRows(arg2);
47672 wxPyEndAllowThreads(__tstate);
47673 if (PyErr_Occurred()) SWIG_fail;
47674 }
47675 resultobj = SWIG_Py_Void();
47676 return resultobj;
47677 fail:
47678 return NULL;
47679 }
47680
47681
47682 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47683 PyObject *resultobj = 0;
47684 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47685 int arg2 ;
47686 void *argp1 = 0 ;
47687 int res1 = 0 ;
47688 int val2 ;
47689 int ecode2 = 0 ;
47690 PyObject * obj0 = 0 ;
47691 PyObject * obj1 = 0 ;
47692 char * kwnames[] = {
47693 (char *) "self",(char *) "gap", NULL
47694 };
47695
47696 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47697 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47698 if (!SWIG_IsOK(res1)) {
47699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47700 }
47701 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47702 ecode2 = SWIG_AsVal_int(obj1, &val2);
47703 if (!SWIG_IsOK(ecode2)) {
47704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47705 }
47706 arg2 = static_cast< int >(val2);
47707 {
47708 PyThreadState* __tstate = wxPyBeginAllowThreads();
47709 (arg1)->SetVGap(arg2);
47710 wxPyEndAllowThreads(__tstate);
47711 if (PyErr_Occurred()) SWIG_fail;
47712 }
47713 resultobj = SWIG_Py_Void();
47714 return resultobj;
47715 fail:
47716 return NULL;
47717 }
47718
47719
47720 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47721 PyObject *resultobj = 0;
47722 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47723 int arg2 ;
47724 void *argp1 = 0 ;
47725 int res1 = 0 ;
47726 int val2 ;
47727 int ecode2 = 0 ;
47728 PyObject * obj0 = 0 ;
47729 PyObject * obj1 = 0 ;
47730 char * kwnames[] = {
47731 (char *) "self",(char *) "gap", NULL
47732 };
47733
47734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47736 if (!SWIG_IsOK(res1)) {
47737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47738 }
47739 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47740 ecode2 = SWIG_AsVal_int(obj1, &val2);
47741 if (!SWIG_IsOK(ecode2)) {
47742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47743 }
47744 arg2 = static_cast< int >(val2);
47745 {
47746 PyThreadState* __tstate = wxPyBeginAllowThreads();
47747 (arg1)->SetHGap(arg2);
47748 wxPyEndAllowThreads(__tstate);
47749 if (PyErr_Occurred()) SWIG_fail;
47750 }
47751 resultobj = SWIG_Py_Void();
47752 return resultobj;
47753 fail:
47754 return NULL;
47755 }
47756
47757
47758 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47759 PyObject *resultobj = 0;
47760 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47761 int result;
47762 void *argp1 = 0 ;
47763 int res1 = 0 ;
47764 PyObject *swig_obj[1] ;
47765
47766 if (!args) SWIG_fail;
47767 swig_obj[0] = args;
47768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47769 if (!SWIG_IsOK(res1)) {
47770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47771 }
47772 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47773 {
47774 PyThreadState* __tstate = wxPyBeginAllowThreads();
47775 result = (int)(arg1)->GetCols();
47776 wxPyEndAllowThreads(__tstate);
47777 if (PyErr_Occurred()) SWIG_fail;
47778 }
47779 resultobj = SWIG_From_int(static_cast< int >(result));
47780 return resultobj;
47781 fail:
47782 return NULL;
47783 }
47784
47785
47786 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47787 PyObject *resultobj = 0;
47788 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47789 int result;
47790 void *argp1 = 0 ;
47791 int res1 = 0 ;
47792 PyObject *swig_obj[1] ;
47793
47794 if (!args) SWIG_fail;
47795 swig_obj[0] = args;
47796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47797 if (!SWIG_IsOK(res1)) {
47798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47799 }
47800 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47801 {
47802 PyThreadState* __tstate = wxPyBeginAllowThreads();
47803 result = (int)(arg1)->GetRows();
47804 wxPyEndAllowThreads(__tstate);
47805 if (PyErr_Occurred()) SWIG_fail;
47806 }
47807 resultobj = SWIG_From_int(static_cast< int >(result));
47808 return resultobj;
47809 fail:
47810 return NULL;
47811 }
47812
47813
47814 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47815 PyObject *resultobj = 0;
47816 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47817 int result;
47818 void *argp1 = 0 ;
47819 int res1 = 0 ;
47820 PyObject *swig_obj[1] ;
47821
47822 if (!args) SWIG_fail;
47823 swig_obj[0] = args;
47824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47825 if (!SWIG_IsOK(res1)) {
47826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47827 }
47828 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47829 {
47830 PyThreadState* __tstate = wxPyBeginAllowThreads();
47831 result = (int)(arg1)->GetVGap();
47832 wxPyEndAllowThreads(__tstate);
47833 if (PyErr_Occurred()) SWIG_fail;
47834 }
47835 resultobj = SWIG_From_int(static_cast< int >(result));
47836 return resultobj;
47837 fail:
47838 return NULL;
47839 }
47840
47841
47842 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47843 PyObject *resultobj = 0;
47844 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47845 int result;
47846 void *argp1 = 0 ;
47847 int res1 = 0 ;
47848 PyObject *swig_obj[1] ;
47849
47850 if (!args) SWIG_fail;
47851 swig_obj[0] = args;
47852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47853 if (!SWIG_IsOK(res1)) {
47854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47855 }
47856 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47857 {
47858 PyThreadState* __tstate = wxPyBeginAllowThreads();
47859 result = (int)(arg1)->GetHGap();
47860 wxPyEndAllowThreads(__tstate);
47861 if (PyErr_Occurred()) SWIG_fail;
47862 }
47863 resultobj = SWIG_From_int(static_cast< int >(result));
47864 return resultobj;
47865 fail:
47866 return NULL;
47867 }
47868
47869
47870 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47871 PyObject *obj;
47872 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47873 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
47874 return SWIG_Py_Void();
47875 }
47876
47877 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47878 return SWIG_Python_InitShadowInstance(args);
47879 }
47880
47881 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47882 PyObject *resultobj = 0;
47883 int arg1 = (int) 1 ;
47884 int arg2 = (int) 0 ;
47885 int arg3 = (int) 0 ;
47886 int arg4 = (int) 0 ;
47887 wxFlexGridSizer *result = 0 ;
47888 int val1 ;
47889 int ecode1 = 0 ;
47890 int val2 ;
47891 int ecode2 = 0 ;
47892 int val3 ;
47893 int ecode3 = 0 ;
47894 int val4 ;
47895 int ecode4 = 0 ;
47896 PyObject * obj0 = 0 ;
47897 PyObject * obj1 = 0 ;
47898 PyObject * obj2 = 0 ;
47899 PyObject * obj3 = 0 ;
47900 char * kwnames[] = {
47901 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47902 };
47903
47904 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47905 if (obj0) {
47906 ecode1 = SWIG_AsVal_int(obj0, &val1);
47907 if (!SWIG_IsOK(ecode1)) {
47908 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
47909 }
47910 arg1 = static_cast< int >(val1);
47911 }
47912 if (obj1) {
47913 ecode2 = SWIG_AsVal_int(obj1, &val2);
47914 if (!SWIG_IsOK(ecode2)) {
47915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
47916 }
47917 arg2 = static_cast< int >(val2);
47918 }
47919 if (obj2) {
47920 ecode3 = SWIG_AsVal_int(obj2, &val3);
47921 if (!SWIG_IsOK(ecode3)) {
47922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
47923 }
47924 arg3 = static_cast< int >(val3);
47925 }
47926 if (obj3) {
47927 ecode4 = SWIG_AsVal_int(obj3, &val4);
47928 if (!SWIG_IsOK(ecode4)) {
47929 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
47930 }
47931 arg4 = static_cast< int >(val4);
47932 }
47933 {
47934 PyThreadState* __tstate = wxPyBeginAllowThreads();
47935 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
47936 wxPyEndAllowThreads(__tstate);
47937 if (PyErr_Occurred()) SWIG_fail;
47938 }
47939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
47940 return resultobj;
47941 fail:
47942 return NULL;
47943 }
47944
47945
47946 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47947 PyObject *resultobj = 0;
47948 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47949 size_t arg2 ;
47950 int arg3 = (int) 0 ;
47951 void *argp1 = 0 ;
47952 int res1 = 0 ;
47953 size_t val2 ;
47954 int ecode2 = 0 ;
47955 int val3 ;
47956 int ecode3 = 0 ;
47957 PyObject * obj0 = 0 ;
47958 PyObject * obj1 = 0 ;
47959 PyObject * obj2 = 0 ;
47960 char * kwnames[] = {
47961 (char *) "self",(char *) "idx",(char *) "proportion", NULL
47962 };
47963
47964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
47966 if (!SWIG_IsOK(res1)) {
47967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
47968 }
47969 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
47970 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
47971 if (!SWIG_IsOK(ecode2)) {
47972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
47973 }
47974 arg2 = static_cast< size_t >(val2);
47975 if (obj2) {
47976 ecode3 = SWIG_AsVal_int(obj2, &val3);
47977 if (!SWIG_IsOK(ecode3)) {
47978 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
47979 }
47980 arg3 = static_cast< int >(val3);
47981 }
47982 {
47983 PyThreadState* __tstate = wxPyBeginAllowThreads();
47984 (arg1)->AddGrowableRow(arg2,arg3);
47985 wxPyEndAllowThreads(__tstate);
47986 if (PyErr_Occurred()) SWIG_fail;
47987 }
47988 resultobj = SWIG_Py_Void();
47989 return resultobj;
47990 fail:
47991 return NULL;
47992 }
47993
47994
47995 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47996 PyObject *resultobj = 0;
47997 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
47998 size_t arg2 ;
47999 void *argp1 = 0 ;
48000 int res1 = 0 ;
48001 size_t val2 ;
48002 int ecode2 = 0 ;
48003 PyObject * obj0 = 0 ;
48004 PyObject * obj1 = 0 ;
48005 char * kwnames[] = {
48006 (char *) "self",(char *) "idx", NULL
48007 };
48008
48009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48011 if (!SWIG_IsOK(res1)) {
48012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48013 }
48014 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48015 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48016 if (!SWIG_IsOK(ecode2)) {
48017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48018 }
48019 arg2 = static_cast< size_t >(val2);
48020 {
48021 PyThreadState* __tstate = wxPyBeginAllowThreads();
48022 (arg1)->RemoveGrowableRow(arg2);
48023 wxPyEndAllowThreads(__tstate);
48024 if (PyErr_Occurred()) SWIG_fail;
48025 }
48026 resultobj = SWIG_Py_Void();
48027 return resultobj;
48028 fail:
48029 return NULL;
48030 }
48031
48032
48033 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48034 PyObject *resultobj = 0;
48035 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48036 size_t arg2 ;
48037 int arg3 = (int) 0 ;
48038 void *argp1 = 0 ;
48039 int res1 = 0 ;
48040 size_t val2 ;
48041 int ecode2 = 0 ;
48042 int val3 ;
48043 int ecode3 = 0 ;
48044 PyObject * obj0 = 0 ;
48045 PyObject * obj1 = 0 ;
48046 PyObject * obj2 = 0 ;
48047 char * kwnames[] = {
48048 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48049 };
48050
48051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48053 if (!SWIG_IsOK(res1)) {
48054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48055 }
48056 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48057 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48058 if (!SWIG_IsOK(ecode2)) {
48059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48060 }
48061 arg2 = static_cast< size_t >(val2);
48062 if (obj2) {
48063 ecode3 = SWIG_AsVal_int(obj2, &val3);
48064 if (!SWIG_IsOK(ecode3)) {
48065 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48066 }
48067 arg3 = static_cast< int >(val3);
48068 }
48069 {
48070 PyThreadState* __tstate = wxPyBeginAllowThreads();
48071 (arg1)->AddGrowableCol(arg2,arg3);
48072 wxPyEndAllowThreads(__tstate);
48073 if (PyErr_Occurred()) SWIG_fail;
48074 }
48075 resultobj = SWIG_Py_Void();
48076 return resultobj;
48077 fail:
48078 return NULL;
48079 }
48080
48081
48082 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48083 PyObject *resultobj = 0;
48084 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48085 size_t arg2 ;
48086 void *argp1 = 0 ;
48087 int res1 = 0 ;
48088 size_t val2 ;
48089 int ecode2 = 0 ;
48090 PyObject * obj0 = 0 ;
48091 PyObject * obj1 = 0 ;
48092 char * kwnames[] = {
48093 (char *) "self",(char *) "idx", NULL
48094 };
48095
48096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48098 if (!SWIG_IsOK(res1)) {
48099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48100 }
48101 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48102 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48103 if (!SWIG_IsOK(ecode2)) {
48104 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48105 }
48106 arg2 = static_cast< size_t >(val2);
48107 {
48108 PyThreadState* __tstate = wxPyBeginAllowThreads();
48109 (arg1)->RemoveGrowableCol(arg2);
48110 wxPyEndAllowThreads(__tstate);
48111 if (PyErr_Occurred()) SWIG_fail;
48112 }
48113 resultobj = SWIG_Py_Void();
48114 return resultobj;
48115 fail:
48116 return NULL;
48117 }
48118
48119
48120 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48121 PyObject *resultobj = 0;
48122 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48123 int arg2 ;
48124 void *argp1 = 0 ;
48125 int res1 = 0 ;
48126 int val2 ;
48127 int ecode2 = 0 ;
48128 PyObject * obj0 = 0 ;
48129 PyObject * obj1 = 0 ;
48130 char * kwnames[] = {
48131 (char *) "self",(char *) "direction", NULL
48132 };
48133
48134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48136 if (!SWIG_IsOK(res1)) {
48137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48138 }
48139 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48140 ecode2 = SWIG_AsVal_int(obj1, &val2);
48141 if (!SWIG_IsOK(ecode2)) {
48142 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48143 }
48144 arg2 = static_cast< int >(val2);
48145 {
48146 PyThreadState* __tstate = wxPyBeginAllowThreads();
48147 (arg1)->SetFlexibleDirection(arg2);
48148 wxPyEndAllowThreads(__tstate);
48149 if (PyErr_Occurred()) SWIG_fail;
48150 }
48151 resultobj = SWIG_Py_Void();
48152 return resultobj;
48153 fail:
48154 return NULL;
48155 }
48156
48157
48158 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48159 PyObject *resultobj = 0;
48160 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48161 int result;
48162 void *argp1 = 0 ;
48163 int res1 = 0 ;
48164 PyObject *swig_obj[1] ;
48165
48166 if (!args) SWIG_fail;
48167 swig_obj[0] = args;
48168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48169 if (!SWIG_IsOK(res1)) {
48170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48171 }
48172 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48173 {
48174 PyThreadState* __tstate = wxPyBeginAllowThreads();
48175 result = (int)(arg1)->GetFlexibleDirection();
48176 wxPyEndAllowThreads(__tstate);
48177 if (PyErr_Occurred()) SWIG_fail;
48178 }
48179 resultobj = SWIG_From_int(static_cast< int >(result));
48180 return resultobj;
48181 fail:
48182 return NULL;
48183 }
48184
48185
48186 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48187 PyObject *resultobj = 0;
48188 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48189 wxFlexSizerGrowMode arg2 ;
48190 void *argp1 = 0 ;
48191 int res1 = 0 ;
48192 int val2 ;
48193 int ecode2 = 0 ;
48194 PyObject * obj0 = 0 ;
48195 PyObject * obj1 = 0 ;
48196 char * kwnames[] = {
48197 (char *) "self",(char *) "mode", NULL
48198 };
48199
48200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48202 if (!SWIG_IsOK(res1)) {
48203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48204 }
48205 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48206 ecode2 = SWIG_AsVal_int(obj1, &val2);
48207 if (!SWIG_IsOK(ecode2)) {
48208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48209 }
48210 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48211 {
48212 PyThreadState* __tstate = wxPyBeginAllowThreads();
48213 (arg1)->SetNonFlexibleGrowMode(arg2);
48214 wxPyEndAllowThreads(__tstate);
48215 if (PyErr_Occurred()) SWIG_fail;
48216 }
48217 resultobj = SWIG_Py_Void();
48218 return resultobj;
48219 fail:
48220 return NULL;
48221 }
48222
48223
48224 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48225 PyObject *resultobj = 0;
48226 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48227 wxFlexSizerGrowMode result;
48228 void *argp1 = 0 ;
48229 int res1 = 0 ;
48230 PyObject *swig_obj[1] ;
48231
48232 if (!args) SWIG_fail;
48233 swig_obj[0] = args;
48234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48235 if (!SWIG_IsOK(res1)) {
48236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48237 }
48238 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48239 {
48240 PyThreadState* __tstate = wxPyBeginAllowThreads();
48241 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48242 wxPyEndAllowThreads(__tstate);
48243 if (PyErr_Occurred()) SWIG_fail;
48244 }
48245 resultobj = SWIG_From_int(static_cast< int >(result));
48246 return resultobj;
48247 fail:
48248 return NULL;
48249 }
48250
48251
48252 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(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_GetRowHeights" "', 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)->GetRowHeights();
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 *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48292 PyObject *resultobj = 0;
48293 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48294 wxArrayInt *result = 0 ;
48295 void *argp1 = 0 ;
48296 int res1 = 0 ;
48297 PyObject *swig_obj[1] ;
48298
48299 if (!args) SWIG_fail;
48300 swig_obj[0] = args;
48301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48302 if (!SWIG_IsOK(res1)) {
48303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48304 }
48305 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48306 {
48307 PyThreadState* __tstate = wxPyBeginAllowThreads();
48308 {
48309 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48310 result = (wxArrayInt *) &_result_ref;
48311 }
48312 wxPyEndAllowThreads(__tstate);
48313 if (PyErr_Occurred()) SWIG_fail;
48314 }
48315 {
48316 resultobj = PyList_New(0);
48317 size_t idx;
48318 for (idx = 0; idx < result->GetCount(); idx += 1) {
48319 PyObject* val = PyInt_FromLong( result->Item(idx) );
48320 PyList_Append(resultobj, val);
48321 Py_DECREF(val);
48322 }
48323 }
48324 return resultobj;
48325 fail:
48326 return NULL;
48327 }
48328
48329
48330 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48331 PyObject *obj;
48332 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48333 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48334 return SWIG_Py_Void();
48335 }
48336
48337 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48338 return SWIG_Python_InitShadowInstance(args);
48339 }
48340
48341 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48342 PyObject *resultobj = 0;
48343 wxStdDialogButtonSizer *result = 0 ;
48344
48345 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48346 {
48347 PyThreadState* __tstate = wxPyBeginAllowThreads();
48348 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48349 wxPyEndAllowThreads(__tstate);
48350 if (PyErr_Occurred()) SWIG_fail;
48351 }
48352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48353 return resultobj;
48354 fail:
48355 return NULL;
48356 }
48357
48358
48359 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48360 PyObject *resultobj = 0;
48361 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48362 wxButton *arg2 = (wxButton *) 0 ;
48363 void *argp1 = 0 ;
48364 int res1 = 0 ;
48365 void *argp2 = 0 ;
48366 int res2 = 0 ;
48367 PyObject * obj0 = 0 ;
48368 PyObject * obj1 = 0 ;
48369 char * kwnames[] = {
48370 (char *) "self",(char *) "button", NULL
48371 };
48372
48373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48375 if (!SWIG_IsOK(res1)) {
48376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48377 }
48378 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48380 if (!SWIG_IsOK(res2)) {
48381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48382 }
48383 arg2 = reinterpret_cast< wxButton * >(argp2);
48384 {
48385 PyThreadState* __tstate = wxPyBeginAllowThreads();
48386 (arg1)->AddButton(arg2);
48387 wxPyEndAllowThreads(__tstate);
48388 if (PyErr_Occurred()) SWIG_fail;
48389 }
48390 resultobj = SWIG_Py_Void();
48391 return resultobj;
48392 fail:
48393 return NULL;
48394 }
48395
48396
48397 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48398 PyObject *resultobj = 0;
48399 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48400 void *argp1 = 0 ;
48401 int res1 = 0 ;
48402 PyObject *swig_obj[1] ;
48403
48404 if (!args) SWIG_fail;
48405 swig_obj[0] = args;
48406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48407 if (!SWIG_IsOK(res1)) {
48408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48409 }
48410 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48411 {
48412 PyThreadState* __tstate = wxPyBeginAllowThreads();
48413 (arg1)->Realize();
48414 wxPyEndAllowThreads(__tstate);
48415 if (PyErr_Occurred()) SWIG_fail;
48416 }
48417 resultobj = SWIG_Py_Void();
48418 return resultobj;
48419 fail:
48420 return NULL;
48421 }
48422
48423
48424 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48425 PyObject *resultobj = 0;
48426 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48427 wxButton *arg2 = (wxButton *) 0 ;
48428 void *argp1 = 0 ;
48429 int res1 = 0 ;
48430 void *argp2 = 0 ;
48431 int res2 = 0 ;
48432 PyObject * obj0 = 0 ;
48433 PyObject * obj1 = 0 ;
48434 char * kwnames[] = {
48435 (char *) "self",(char *) "button", NULL
48436 };
48437
48438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48440 if (!SWIG_IsOK(res1)) {
48441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48442 }
48443 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48444 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48445 if (!SWIG_IsOK(res2)) {
48446 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48447 }
48448 arg2 = reinterpret_cast< wxButton * >(argp2);
48449 {
48450 PyThreadState* __tstate = wxPyBeginAllowThreads();
48451 (arg1)->SetAffirmativeButton(arg2);
48452 wxPyEndAllowThreads(__tstate);
48453 if (PyErr_Occurred()) SWIG_fail;
48454 }
48455 resultobj = SWIG_Py_Void();
48456 return resultobj;
48457 fail:
48458 return NULL;
48459 }
48460
48461
48462 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48463 PyObject *resultobj = 0;
48464 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48465 wxButton *arg2 = (wxButton *) 0 ;
48466 void *argp1 = 0 ;
48467 int res1 = 0 ;
48468 void *argp2 = 0 ;
48469 int res2 = 0 ;
48470 PyObject * obj0 = 0 ;
48471 PyObject * obj1 = 0 ;
48472 char * kwnames[] = {
48473 (char *) "self",(char *) "button", NULL
48474 };
48475
48476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48478 if (!SWIG_IsOK(res1)) {
48479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48480 }
48481 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48483 if (!SWIG_IsOK(res2)) {
48484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48485 }
48486 arg2 = reinterpret_cast< wxButton * >(argp2);
48487 {
48488 PyThreadState* __tstate = wxPyBeginAllowThreads();
48489 (arg1)->SetNegativeButton(arg2);
48490 wxPyEndAllowThreads(__tstate);
48491 if (PyErr_Occurred()) SWIG_fail;
48492 }
48493 resultobj = SWIG_Py_Void();
48494 return resultobj;
48495 fail:
48496 return NULL;
48497 }
48498
48499
48500 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48501 PyObject *resultobj = 0;
48502 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48503 wxButton *arg2 = (wxButton *) 0 ;
48504 void *argp1 = 0 ;
48505 int res1 = 0 ;
48506 void *argp2 = 0 ;
48507 int res2 = 0 ;
48508 PyObject * obj0 = 0 ;
48509 PyObject * obj1 = 0 ;
48510 char * kwnames[] = {
48511 (char *) "self",(char *) "button", NULL
48512 };
48513
48514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48516 if (!SWIG_IsOK(res1)) {
48517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48518 }
48519 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48520 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48521 if (!SWIG_IsOK(res2)) {
48522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48523 }
48524 arg2 = reinterpret_cast< wxButton * >(argp2);
48525 {
48526 PyThreadState* __tstate = wxPyBeginAllowThreads();
48527 (arg1)->SetCancelButton(arg2);
48528 wxPyEndAllowThreads(__tstate);
48529 if (PyErr_Occurred()) SWIG_fail;
48530 }
48531 resultobj = SWIG_Py_Void();
48532 return resultobj;
48533 fail:
48534 return NULL;
48535 }
48536
48537
48538 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48539 PyObject *resultobj = 0;
48540 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48541 wxButton *result = 0 ;
48542 void *argp1 = 0 ;
48543 int res1 = 0 ;
48544 PyObject *swig_obj[1] ;
48545
48546 if (!args) SWIG_fail;
48547 swig_obj[0] = args;
48548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48549 if (!SWIG_IsOK(res1)) {
48550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48551 }
48552 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48553 {
48554 PyThreadState* __tstate = wxPyBeginAllowThreads();
48555 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48556 wxPyEndAllowThreads(__tstate);
48557 if (PyErr_Occurred()) SWIG_fail;
48558 }
48559 {
48560 resultobj = wxPyMake_wxObject(result, (bool)0);
48561 }
48562 return resultobj;
48563 fail:
48564 return NULL;
48565 }
48566
48567
48568 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48569 PyObject *resultobj = 0;
48570 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48571 wxButton *result = 0 ;
48572 void *argp1 = 0 ;
48573 int res1 = 0 ;
48574 PyObject *swig_obj[1] ;
48575
48576 if (!args) SWIG_fail;
48577 swig_obj[0] = args;
48578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48579 if (!SWIG_IsOK(res1)) {
48580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48581 }
48582 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48583 {
48584 PyThreadState* __tstate = wxPyBeginAllowThreads();
48585 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48586 wxPyEndAllowThreads(__tstate);
48587 if (PyErr_Occurred()) SWIG_fail;
48588 }
48589 {
48590 resultobj = wxPyMake_wxObject(result, (bool)0);
48591 }
48592 return resultobj;
48593 fail:
48594 return NULL;
48595 }
48596
48597
48598 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48599 PyObject *resultobj = 0;
48600 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48601 wxButton *result = 0 ;
48602 void *argp1 = 0 ;
48603 int res1 = 0 ;
48604 PyObject *swig_obj[1] ;
48605
48606 if (!args) SWIG_fail;
48607 swig_obj[0] = args;
48608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48609 if (!SWIG_IsOK(res1)) {
48610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48611 }
48612 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48613 {
48614 PyThreadState* __tstate = wxPyBeginAllowThreads();
48615 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48616 wxPyEndAllowThreads(__tstate);
48617 if (PyErr_Occurred()) SWIG_fail;
48618 }
48619 {
48620 resultobj = wxPyMake_wxObject(result, (bool)0);
48621 }
48622 return resultobj;
48623 fail:
48624 return NULL;
48625 }
48626
48627
48628 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48629 PyObject *resultobj = 0;
48630 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48631 wxButton *result = 0 ;
48632 void *argp1 = 0 ;
48633 int res1 = 0 ;
48634 PyObject *swig_obj[1] ;
48635
48636 if (!args) SWIG_fail;
48637 swig_obj[0] = args;
48638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48639 if (!SWIG_IsOK(res1)) {
48640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48641 }
48642 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48643 {
48644 PyThreadState* __tstate = wxPyBeginAllowThreads();
48645 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48646 wxPyEndAllowThreads(__tstate);
48647 if (PyErr_Occurred()) SWIG_fail;
48648 }
48649 {
48650 resultobj = wxPyMake_wxObject(result, (bool)0);
48651 }
48652 return resultobj;
48653 fail:
48654 return NULL;
48655 }
48656
48657
48658 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48659 PyObject *resultobj = 0;
48660 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48661 wxButton *result = 0 ;
48662 void *argp1 = 0 ;
48663 int res1 = 0 ;
48664 PyObject *swig_obj[1] ;
48665
48666 if (!args) SWIG_fail;
48667 swig_obj[0] = args;
48668 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48669 if (!SWIG_IsOK(res1)) {
48670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48671 }
48672 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48673 {
48674 PyThreadState* __tstate = wxPyBeginAllowThreads();
48675 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48676 wxPyEndAllowThreads(__tstate);
48677 if (PyErr_Occurred()) SWIG_fail;
48678 }
48679 {
48680 resultobj = wxPyMake_wxObject(result, (bool)0);
48681 }
48682 return resultobj;
48683 fail:
48684 return NULL;
48685 }
48686
48687
48688 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48689 PyObject *obj;
48690 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48691 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48692 return SWIG_Py_Void();
48693 }
48694
48695 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48696 return SWIG_Python_InitShadowInstance(args);
48697 }
48698
48699 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48700 PyObject *resultobj = 0;
48701 int arg1 = (int) 0 ;
48702 int arg2 = (int) 0 ;
48703 wxGBPosition *result = 0 ;
48704 int val1 ;
48705 int ecode1 = 0 ;
48706 int val2 ;
48707 int ecode2 = 0 ;
48708 PyObject * obj0 = 0 ;
48709 PyObject * obj1 = 0 ;
48710 char * kwnames[] = {
48711 (char *) "row",(char *) "col", NULL
48712 };
48713
48714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48715 if (obj0) {
48716 ecode1 = SWIG_AsVal_int(obj0, &val1);
48717 if (!SWIG_IsOK(ecode1)) {
48718 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48719 }
48720 arg1 = static_cast< int >(val1);
48721 }
48722 if (obj1) {
48723 ecode2 = SWIG_AsVal_int(obj1, &val2);
48724 if (!SWIG_IsOK(ecode2)) {
48725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48726 }
48727 arg2 = static_cast< int >(val2);
48728 }
48729 {
48730 PyThreadState* __tstate = wxPyBeginAllowThreads();
48731 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48732 wxPyEndAllowThreads(__tstate);
48733 if (PyErr_Occurred()) SWIG_fail;
48734 }
48735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48736 return resultobj;
48737 fail:
48738 return NULL;
48739 }
48740
48741
48742 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48743 PyObject *resultobj = 0;
48744 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48745 void *argp1 = 0 ;
48746 int res1 = 0 ;
48747 PyObject *swig_obj[1] ;
48748
48749 if (!args) SWIG_fail;
48750 swig_obj[0] = args;
48751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48752 if (!SWIG_IsOK(res1)) {
48753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48754 }
48755 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48756 {
48757 PyThreadState* __tstate = wxPyBeginAllowThreads();
48758 delete arg1;
48759
48760 wxPyEndAllowThreads(__tstate);
48761 if (PyErr_Occurred()) SWIG_fail;
48762 }
48763 resultobj = SWIG_Py_Void();
48764 return resultobj;
48765 fail:
48766 return NULL;
48767 }
48768
48769
48770 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48771 PyObject *resultobj = 0;
48772 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48773 int result;
48774 void *argp1 = 0 ;
48775 int res1 = 0 ;
48776 PyObject *swig_obj[1] ;
48777
48778 if (!args) SWIG_fail;
48779 swig_obj[0] = args;
48780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48781 if (!SWIG_IsOK(res1)) {
48782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48783 }
48784 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48785 {
48786 PyThreadState* __tstate = wxPyBeginAllowThreads();
48787 result = (int)((wxGBPosition const *)arg1)->GetRow();
48788 wxPyEndAllowThreads(__tstate);
48789 if (PyErr_Occurred()) SWIG_fail;
48790 }
48791 resultobj = SWIG_From_int(static_cast< int >(result));
48792 return resultobj;
48793 fail:
48794 return NULL;
48795 }
48796
48797
48798 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48799 PyObject *resultobj = 0;
48800 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48801 int result;
48802 void *argp1 = 0 ;
48803 int res1 = 0 ;
48804 PyObject *swig_obj[1] ;
48805
48806 if (!args) SWIG_fail;
48807 swig_obj[0] = args;
48808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48809 if (!SWIG_IsOK(res1)) {
48810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
48811 }
48812 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48813 {
48814 PyThreadState* __tstate = wxPyBeginAllowThreads();
48815 result = (int)((wxGBPosition const *)arg1)->GetCol();
48816 wxPyEndAllowThreads(__tstate);
48817 if (PyErr_Occurred()) SWIG_fail;
48818 }
48819 resultobj = SWIG_From_int(static_cast< int >(result));
48820 return resultobj;
48821 fail:
48822 return NULL;
48823 }
48824
48825
48826 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48827 PyObject *resultobj = 0;
48828 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48829 int arg2 ;
48830 void *argp1 = 0 ;
48831 int res1 = 0 ;
48832 int val2 ;
48833 int ecode2 = 0 ;
48834 PyObject * obj0 = 0 ;
48835 PyObject * obj1 = 0 ;
48836 char * kwnames[] = {
48837 (char *) "self",(char *) "row", NULL
48838 };
48839
48840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
48841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48842 if (!SWIG_IsOK(res1)) {
48843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48844 }
48845 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48846 ecode2 = SWIG_AsVal_int(obj1, &val2);
48847 if (!SWIG_IsOK(ecode2)) {
48848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
48849 }
48850 arg2 = static_cast< int >(val2);
48851 {
48852 PyThreadState* __tstate = wxPyBeginAllowThreads();
48853 (arg1)->SetRow(arg2);
48854 wxPyEndAllowThreads(__tstate);
48855 if (PyErr_Occurred()) SWIG_fail;
48856 }
48857 resultobj = SWIG_Py_Void();
48858 return resultobj;
48859 fail:
48860 return NULL;
48861 }
48862
48863
48864 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48865 PyObject *resultobj = 0;
48866 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48867 int arg2 ;
48868 void *argp1 = 0 ;
48869 int res1 = 0 ;
48870 int val2 ;
48871 int ecode2 = 0 ;
48872 PyObject * obj0 = 0 ;
48873 PyObject * obj1 = 0 ;
48874 char * kwnames[] = {
48875 (char *) "self",(char *) "col", NULL
48876 };
48877
48878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
48879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48880 if (!SWIG_IsOK(res1)) {
48881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48882 }
48883 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48884 ecode2 = SWIG_AsVal_int(obj1, &val2);
48885 if (!SWIG_IsOK(ecode2)) {
48886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
48887 }
48888 arg2 = static_cast< int >(val2);
48889 {
48890 PyThreadState* __tstate = wxPyBeginAllowThreads();
48891 (arg1)->SetCol(arg2);
48892 wxPyEndAllowThreads(__tstate);
48893 if (PyErr_Occurred()) SWIG_fail;
48894 }
48895 resultobj = SWIG_Py_Void();
48896 return resultobj;
48897 fail:
48898 return NULL;
48899 }
48900
48901
48902 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48903 PyObject *resultobj = 0;
48904 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48905 PyObject *arg2 = (PyObject *) 0 ;
48906 bool result;
48907 void *argp1 = 0 ;
48908 int res1 = 0 ;
48909 PyObject * obj0 = 0 ;
48910 PyObject * obj1 = 0 ;
48911 char * kwnames[] = {
48912 (char *) "self",(char *) "other", NULL
48913 };
48914
48915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
48916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48917 if (!SWIG_IsOK(res1)) {
48918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48919 }
48920 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48921 arg2 = obj1;
48922 {
48923 result = (bool)wxGBPosition___eq__(arg1,arg2);
48924 if (PyErr_Occurred()) SWIG_fail;
48925 }
48926 {
48927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48928 }
48929 return resultobj;
48930 fail:
48931 return NULL;
48932 }
48933
48934
48935 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48936 PyObject *resultobj = 0;
48937 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48938 PyObject *arg2 = (PyObject *) 0 ;
48939 bool result;
48940 void *argp1 = 0 ;
48941 int res1 = 0 ;
48942 PyObject * obj0 = 0 ;
48943 PyObject * obj1 = 0 ;
48944 char * kwnames[] = {
48945 (char *) "self",(char *) "other", NULL
48946 };
48947
48948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
48949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48950 if (!SWIG_IsOK(res1)) {
48951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48952 }
48953 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48954 arg2 = obj1;
48955 {
48956 result = (bool)wxGBPosition___ne__(arg1,arg2);
48957 if (PyErr_Occurred()) SWIG_fail;
48958 }
48959 {
48960 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48961 }
48962 return resultobj;
48963 fail:
48964 return NULL;
48965 }
48966
48967
48968 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48969 PyObject *resultobj = 0;
48970 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48971 int arg2 = (int) 0 ;
48972 int arg3 = (int) 0 ;
48973 void *argp1 = 0 ;
48974 int res1 = 0 ;
48975 int val2 ;
48976 int ecode2 = 0 ;
48977 int val3 ;
48978 int ecode3 = 0 ;
48979 PyObject * obj0 = 0 ;
48980 PyObject * obj1 = 0 ;
48981 PyObject * obj2 = 0 ;
48982 char * kwnames[] = {
48983 (char *) "self",(char *) "row",(char *) "col", NULL
48984 };
48985
48986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
48988 if (!SWIG_IsOK(res1)) {
48989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48990 }
48991 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48992 if (obj1) {
48993 ecode2 = SWIG_AsVal_int(obj1, &val2);
48994 if (!SWIG_IsOK(ecode2)) {
48995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
48996 }
48997 arg2 = static_cast< int >(val2);
48998 }
48999 if (obj2) {
49000 ecode3 = SWIG_AsVal_int(obj2, &val3);
49001 if (!SWIG_IsOK(ecode3)) {
49002 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49003 }
49004 arg3 = static_cast< int >(val3);
49005 }
49006 {
49007 PyThreadState* __tstate = wxPyBeginAllowThreads();
49008 wxGBPosition_Set(arg1,arg2,arg3);
49009 wxPyEndAllowThreads(__tstate);
49010 if (PyErr_Occurred()) SWIG_fail;
49011 }
49012 resultobj = SWIG_Py_Void();
49013 return resultobj;
49014 fail:
49015 return NULL;
49016 }
49017
49018
49019 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49020 PyObject *resultobj = 0;
49021 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49022 PyObject *result = 0 ;
49023 void *argp1 = 0 ;
49024 int res1 = 0 ;
49025 PyObject *swig_obj[1] ;
49026
49027 if (!args) SWIG_fail;
49028 swig_obj[0] = args;
49029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49030 if (!SWIG_IsOK(res1)) {
49031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49032 }
49033 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49034 {
49035 PyThreadState* __tstate = wxPyBeginAllowThreads();
49036 result = (PyObject *)wxGBPosition_Get(arg1);
49037 wxPyEndAllowThreads(__tstate);
49038 if (PyErr_Occurred()) SWIG_fail;
49039 }
49040 resultobj = result;
49041 return resultobj;
49042 fail:
49043 return NULL;
49044 }
49045
49046
49047 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49048 PyObject *obj;
49049 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49050 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49051 return SWIG_Py_Void();
49052 }
49053
49054 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49055 return SWIG_Python_InitShadowInstance(args);
49056 }
49057
49058 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49059 PyObject *resultobj = 0;
49060 int arg1 = (int) 1 ;
49061 int arg2 = (int) 1 ;
49062 wxGBSpan *result = 0 ;
49063 int val1 ;
49064 int ecode1 = 0 ;
49065 int val2 ;
49066 int ecode2 = 0 ;
49067 PyObject * obj0 = 0 ;
49068 PyObject * obj1 = 0 ;
49069 char * kwnames[] = {
49070 (char *) "rowspan",(char *) "colspan", NULL
49071 };
49072
49073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49074 if (obj0) {
49075 ecode1 = SWIG_AsVal_int(obj0, &val1);
49076 if (!SWIG_IsOK(ecode1)) {
49077 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49078 }
49079 arg1 = static_cast< int >(val1);
49080 }
49081 if (obj1) {
49082 ecode2 = SWIG_AsVal_int(obj1, &val2);
49083 if (!SWIG_IsOK(ecode2)) {
49084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49085 }
49086 arg2 = static_cast< int >(val2);
49087 }
49088 {
49089 PyThreadState* __tstate = wxPyBeginAllowThreads();
49090 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49091 wxPyEndAllowThreads(__tstate);
49092 if (PyErr_Occurred()) SWIG_fail;
49093 }
49094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49095 return resultobj;
49096 fail:
49097 return NULL;
49098 }
49099
49100
49101 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49102 PyObject *resultobj = 0;
49103 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49104 void *argp1 = 0 ;
49105 int res1 = 0 ;
49106 PyObject *swig_obj[1] ;
49107
49108 if (!args) SWIG_fail;
49109 swig_obj[0] = args;
49110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49111 if (!SWIG_IsOK(res1)) {
49112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49113 }
49114 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49115 {
49116 PyThreadState* __tstate = wxPyBeginAllowThreads();
49117 delete arg1;
49118
49119 wxPyEndAllowThreads(__tstate);
49120 if (PyErr_Occurred()) SWIG_fail;
49121 }
49122 resultobj = SWIG_Py_Void();
49123 return resultobj;
49124 fail:
49125 return NULL;
49126 }
49127
49128
49129 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49130 PyObject *resultobj = 0;
49131 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49132 int result;
49133 void *argp1 = 0 ;
49134 int res1 = 0 ;
49135 PyObject *swig_obj[1] ;
49136
49137 if (!args) SWIG_fail;
49138 swig_obj[0] = args;
49139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49140 if (!SWIG_IsOK(res1)) {
49141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49142 }
49143 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49144 {
49145 PyThreadState* __tstate = wxPyBeginAllowThreads();
49146 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49147 wxPyEndAllowThreads(__tstate);
49148 if (PyErr_Occurred()) SWIG_fail;
49149 }
49150 resultobj = SWIG_From_int(static_cast< int >(result));
49151 return resultobj;
49152 fail:
49153 return NULL;
49154 }
49155
49156
49157 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49158 PyObject *resultobj = 0;
49159 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49160 int result;
49161 void *argp1 = 0 ;
49162 int res1 = 0 ;
49163 PyObject *swig_obj[1] ;
49164
49165 if (!args) SWIG_fail;
49166 swig_obj[0] = args;
49167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49168 if (!SWIG_IsOK(res1)) {
49169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49170 }
49171 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49172 {
49173 PyThreadState* __tstate = wxPyBeginAllowThreads();
49174 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49175 wxPyEndAllowThreads(__tstate);
49176 if (PyErr_Occurred()) SWIG_fail;
49177 }
49178 resultobj = SWIG_From_int(static_cast< int >(result));
49179 return resultobj;
49180 fail:
49181 return NULL;
49182 }
49183
49184
49185 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49186 PyObject *resultobj = 0;
49187 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49188 int arg2 ;
49189 void *argp1 = 0 ;
49190 int res1 = 0 ;
49191 int val2 ;
49192 int ecode2 = 0 ;
49193 PyObject * obj0 = 0 ;
49194 PyObject * obj1 = 0 ;
49195 char * kwnames[] = {
49196 (char *) "self",(char *) "rowspan", NULL
49197 };
49198
49199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49201 if (!SWIG_IsOK(res1)) {
49202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49203 }
49204 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49205 ecode2 = SWIG_AsVal_int(obj1, &val2);
49206 if (!SWIG_IsOK(ecode2)) {
49207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49208 }
49209 arg2 = static_cast< int >(val2);
49210 {
49211 PyThreadState* __tstate = wxPyBeginAllowThreads();
49212 (arg1)->SetRowspan(arg2);
49213 wxPyEndAllowThreads(__tstate);
49214 if (PyErr_Occurred()) SWIG_fail;
49215 }
49216 resultobj = SWIG_Py_Void();
49217 return resultobj;
49218 fail:
49219 return NULL;
49220 }
49221
49222
49223 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49224 PyObject *resultobj = 0;
49225 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49226 int arg2 ;
49227 void *argp1 = 0 ;
49228 int res1 = 0 ;
49229 int val2 ;
49230 int ecode2 = 0 ;
49231 PyObject * obj0 = 0 ;
49232 PyObject * obj1 = 0 ;
49233 char * kwnames[] = {
49234 (char *) "self",(char *) "colspan", NULL
49235 };
49236
49237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49239 if (!SWIG_IsOK(res1)) {
49240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49241 }
49242 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49243 ecode2 = SWIG_AsVal_int(obj1, &val2);
49244 if (!SWIG_IsOK(ecode2)) {
49245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49246 }
49247 arg2 = static_cast< int >(val2);
49248 {
49249 PyThreadState* __tstate = wxPyBeginAllowThreads();
49250 (arg1)->SetColspan(arg2);
49251 wxPyEndAllowThreads(__tstate);
49252 if (PyErr_Occurred()) SWIG_fail;
49253 }
49254 resultobj = SWIG_Py_Void();
49255 return resultobj;
49256 fail:
49257 return NULL;
49258 }
49259
49260
49261 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49262 PyObject *resultobj = 0;
49263 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49264 PyObject *arg2 = (PyObject *) 0 ;
49265 bool result;
49266 void *argp1 = 0 ;
49267 int res1 = 0 ;
49268 PyObject * obj0 = 0 ;
49269 PyObject * obj1 = 0 ;
49270 char * kwnames[] = {
49271 (char *) "self",(char *) "other", NULL
49272 };
49273
49274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49276 if (!SWIG_IsOK(res1)) {
49277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49278 }
49279 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49280 arg2 = obj1;
49281 {
49282 result = (bool)wxGBSpan___eq__(arg1,arg2);
49283 if (PyErr_Occurred()) SWIG_fail;
49284 }
49285 {
49286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49287 }
49288 return resultobj;
49289 fail:
49290 return NULL;
49291 }
49292
49293
49294 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49295 PyObject *resultobj = 0;
49296 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49297 PyObject *arg2 = (PyObject *) 0 ;
49298 bool result;
49299 void *argp1 = 0 ;
49300 int res1 = 0 ;
49301 PyObject * obj0 = 0 ;
49302 PyObject * obj1 = 0 ;
49303 char * kwnames[] = {
49304 (char *) "self",(char *) "other", NULL
49305 };
49306
49307 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49308 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49309 if (!SWIG_IsOK(res1)) {
49310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49311 }
49312 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49313 arg2 = obj1;
49314 {
49315 result = (bool)wxGBSpan___ne__(arg1,arg2);
49316 if (PyErr_Occurred()) SWIG_fail;
49317 }
49318 {
49319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49320 }
49321 return resultobj;
49322 fail:
49323 return NULL;
49324 }
49325
49326
49327 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49328 PyObject *resultobj = 0;
49329 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49330 int arg2 = (int) 1 ;
49331 int arg3 = (int) 1 ;
49332 void *argp1 = 0 ;
49333 int res1 = 0 ;
49334 int val2 ;
49335 int ecode2 = 0 ;
49336 int val3 ;
49337 int ecode3 = 0 ;
49338 PyObject * obj0 = 0 ;
49339 PyObject * obj1 = 0 ;
49340 PyObject * obj2 = 0 ;
49341 char * kwnames[] = {
49342 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49343 };
49344
49345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49347 if (!SWIG_IsOK(res1)) {
49348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49349 }
49350 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49351 if (obj1) {
49352 ecode2 = SWIG_AsVal_int(obj1, &val2);
49353 if (!SWIG_IsOK(ecode2)) {
49354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49355 }
49356 arg2 = static_cast< int >(val2);
49357 }
49358 if (obj2) {
49359 ecode3 = SWIG_AsVal_int(obj2, &val3);
49360 if (!SWIG_IsOK(ecode3)) {
49361 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49362 }
49363 arg3 = static_cast< int >(val3);
49364 }
49365 {
49366 PyThreadState* __tstate = wxPyBeginAllowThreads();
49367 wxGBSpan_Set(arg1,arg2,arg3);
49368 wxPyEndAllowThreads(__tstate);
49369 if (PyErr_Occurred()) SWIG_fail;
49370 }
49371 resultobj = SWIG_Py_Void();
49372 return resultobj;
49373 fail:
49374 return NULL;
49375 }
49376
49377
49378 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49379 PyObject *resultobj = 0;
49380 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49381 PyObject *result = 0 ;
49382 void *argp1 = 0 ;
49383 int res1 = 0 ;
49384 PyObject *swig_obj[1] ;
49385
49386 if (!args) SWIG_fail;
49387 swig_obj[0] = args;
49388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49389 if (!SWIG_IsOK(res1)) {
49390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49391 }
49392 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49393 {
49394 PyThreadState* __tstate = wxPyBeginAllowThreads();
49395 result = (PyObject *)wxGBSpan_Get(arg1);
49396 wxPyEndAllowThreads(__tstate);
49397 if (PyErr_Occurred()) SWIG_fail;
49398 }
49399 resultobj = result;
49400 return resultobj;
49401 fail:
49402 return NULL;
49403 }
49404
49405
49406 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49407 PyObject *obj;
49408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49409 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49410 return SWIG_Py_Void();
49411 }
49412
49413 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49414 return SWIG_Python_InitShadowInstance(args);
49415 }
49416
49417 SWIGINTERN int DefaultSpan_set(PyObject *) {
49418 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49419 return 1;
49420 }
49421
49422
49423 SWIGINTERN PyObject *DefaultSpan_get(void) {
49424 PyObject *pyobj = 0;
49425
49426 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49427 return pyobj;
49428 }
49429
49430
49431 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49432 PyObject *resultobj = 0;
49433 wxGBSizerItem *result = 0 ;
49434
49435 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49436 {
49437 PyThreadState* __tstate = wxPyBeginAllowThreads();
49438 result = (wxGBSizerItem *)new wxGBSizerItem();
49439 wxPyEndAllowThreads(__tstate);
49440 if (PyErr_Occurred()) SWIG_fail;
49441 }
49442 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49443 return resultobj;
49444 fail:
49445 return NULL;
49446 }
49447
49448
49449 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49450 PyObject *resultobj = 0;
49451 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49452 void *argp1 = 0 ;
49453 int res1 = 0 ;
49454 PyObject *swig_obj[1] ;
49455
49456 if (!args) SWIG_fail;
49457 swig_obj[0] = args;
49458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49459 if (!SWIG_IsOK(res1)) {
49460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49461 }
49462 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49463 {
49464 PyThreadState* __tstate = wxPyBeginAllowThreads();
49465 delete arg1;
49466
49467 wxPyEndAllowThreads(__tstate);
49468 if (PyErr_Occurred()) SWIG_fail;
49469 }
49470 resultobj = SWIG_Py_Void();
49471 return resultobj;
49472 fail:
49473 return NULL;
49474 }
49475
49476
49477 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49478 PyObject *resultobj = 0;
49479 wxWindow *arg1 = (wxWindow *) 0 ;
49480 wxGBPosition *arg2 = 0 ;
49481 wxGBSpan *arg3 = 0 ;
49482 int arg4 ;
49483 int arg5 ;
49484 PyObject *arg6 = (PyObject *) NULL ;
49485 wxGBSizerItem *result = 0 ;
49486 void *argp1 = 0 ;
49487 int res1 = 0 ;
49488 wxGBPosition temp2 ;
49489 wxGBSpan temp3 ;
49490 int val4 ;
49491 int ecode4 = 0 ;
49492 int val5 ;
49493 int ecode5 = 0 ;
49494 PyObject * obj0 = 0 ;
49495 PyObject * obj1 = 0 ;
49496 PyObject * obj2 = 0 ;
49497 PyObject * obj3 = 0 ;
49498 PyObject * obj4 = 0 ;
49499 PyObject * obj5 = 0 ;
49500 char * kwnames[] = {
49501 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49502 };
49503
49504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49506 if (!SWIG_IsOK(res1)) {
49507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49508 }
49509 arg1 = reinterpret_cast< wxWindow * >(argp1);
49510 {
49511 arg2 = &temp2;
49512 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49513 }
49514 {
49515 arg3 = &temp3;
49516 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49517 }
49518 ecode4 = SWIG_AsVal_int(obj3, &val4);
49519 if (!SWIG_IsOK(ecode4)) {
49520 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49521 }
49522 arg4 = static_cast< int >(val4);
49523 ecode5 = SWIG_AsVal_int(obj4, &val5);
49524 if (!SWIG_IsOK(ecode5)) {
49525 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49526 }
49527 arg5 = static_cast< int >(val5);
49528 if (obj5) {
49529 arg6 = obj5;
49530 }
49531 {
49532 PyThreadState* __tstate = wxPyBeginAllowThreads();
49533 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49534 wxPyEndAllowThreads(__tstate);
49535 if (PyErr_Occurred()) SWIG_fail;
49536 }
49537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49538 return resultobj;
49539 fail:
49540 return NULL;
49541 }
49542
49543
49544 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49545 PyObject *resultobj = 0;
49546 wxSizer *arg1 = (wxSizer *) 0 ;
49547 wxGBPosition *arg2 = 0 ;
49548 wxGBSpan *arg3 = 0 ;
49549 int arg4 ;
49550 int arg5 ;
49551 PyObject *arg6 = (PyObject *) NULL ;
49552 wxGBSizerItem *result = 0 ;
49553 int res1 = 0 ;
49554 wxGBPosition temp2 ;
49555 wxGBSpan temp3 ;
49556 int val4 ;
49557 int ecode4 = 0 ;
49558 int val5 ;
49559 int ecode5 = 0 ;
49560 PyObject * obj0 = 0 ;
49561 PyObject * obj1 = 0 ;
49562 PyObject * obj2 = 0 ;
49563 PyObject * obj3 = 0 ;
49564 PyObject * obj4 = 0 ;
49565 PyObject * obj5 = 0 ;
49566 char * kwnames[] = {
49567 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49568 };
49569
49570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49571 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49572 if (!SWIG_IsOK(res1)) {
49573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49574 }
49575 {
49576 arg2 = &temp2;
49577 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49578 }
49579 {
49580 arg3 = &temp3;
49581 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49582 }
49583 ecode4 = SWIG_AsVal_int(obj3, &val4);
49584 if (!SWIG_IsOK(ecode4)) {
49585 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49586 }
49587 arg4 = static_cast< int >(val4);
49588 ecode5 = SWIG_AsVal_int(obj4, &val5);
49589 if (!SWIG_IsOK(ecode5)) {
49590 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49591 }
49592 arg5 = static_cast< int >(val5);
49593 if (obj5) {
49594 arg6 = obj5;
49595 }
49596 {
49597 PyThreadState* __tstate = wxPyBeginAllowThreads();
49598 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49599 wxPyEndAllowThreads(__tstate);
49600 if (PyErr_Occurred()) SWIG_fail;
49601 }
49602 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49603 return resultobj;
49604 fail:
49605 return NULL;
49606 }
49607
49608
49609 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49610 PyObject *resultobj = 0;
49611 int arg1 ;
49612 int arg2 ;
49613 wxGBPosition *arg3 = 0 ;
49614 wxGBSpan *arg4 = 0 ;
49615 int arg5 ;
49616 int arg6 ;
49617 PyObject *arg7 = (PyObject *) NULL ;
49618 wxGBSizerItem *result = 0 ;
49619 int val1 ;
49620 int ecode1 = 0 ;
49621 int val2 ;
49622 int ecode2 = 0 ;
49623 wxGBPosition temp3 ;
49624 wxGBSpan temp4 ;
49625 int val5 ;
49626 int ecode5 = 0 ;
49627 int val6 ;
49628 int ecode6 = 0 ;
49629 PyObject * obj0 = 0 ;
49630 PyObject * obj1 = 0 ;
49631 PyObject * obj2 = 0 ;
49632 PyObject * obj3 = 0 ;
49633 PyObject * obj4 = 0 ;
49634 PyObject * obj5 = 0 ;
49635 PyObject * obj6 = 0 ;
49636 char * kwnames[] = {
49637 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49638 };
49639
49640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49641 ecode1 = SWIG_AsVal_int(obj0, &val1);
49642 if (!SWIG_IsOK(ecode1)) {
49643 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49644 }
49645 arg1 = static_cast< int >(val1);
49646 ecode2 = SWIG_AsVal_int(obj1, &val2);
49647 if (!SWIG_IsOK(ecode2)) {
49648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49649 }
49650 arg2 = static_cast< int >(val2);
49651 {
49652 arg3 = &temp3;
49653 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49654 }
49655 {
49656 arg4 = &temp4;
49657 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49658 }
49659 ecode5 = SWIG_AsVal_int(obj4, &val5);
49660 if (!SWIG_IsOK(ecode5)) {
49661 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49662 }
49663 arg5 = static_cast< int >(val5);
49664 ecode6 = SWIG_AsVal_int(obj5, &val6);
49665 if (!SWIG_IsOK(ecode6)) {
49666 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49667 }
49668 arg6 = static_cast< int >(val6);
49669 if (obj6) {
49670 arg7 = obj6;
49671 }
49672 {
49673 PyThreadState* __tstate = wxPyBeginAllowThreads();
49674 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49675 wxPyEndAllowThreads(__tstate);
49676 if (PyErr_Occurred()) SWIG_fail;
49677 }
49678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49679 return resultobj;
49680 fail:
49681 return NULL;
49682 }
49683
49684
49685 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49686 PyObject *resultobj = 0;
49687 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49688 wxGBPosition result;
49689 void *argp1 = 0 ;
49690 int res1 = 0 ;
49691 PyObject *swig_obj[1] ;
49692
49693 if (!args) SWIG_fail;
49694 swig_obj[0] = args;
49695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49696 if (!SWIG_IsOK(res1)) {
49697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49698 }
49699 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49700 {
49701 PyThreadState* __tstate = wxPyBeginAllowThreads();
49702 result = ((wxGBSizerItem const *)arg1)->GetPos();
49703 wxPyEndAllowThreads(__tstate);
49704 if (PyErr_Occurred()) SWIG_fail;
49705 }
49706 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49707 return resultobj;
49708 fail:
49709 return NULL;
49710 }
49711
49712
49713 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49714 PyObject *resultobj = 0;
49715 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49716 wxGBSpan result;
49717 void *argp1 = 0 ;
49718 int res1 = 0 ;
49719 PyObject *swig_obj[1] ;
49720
49721 if (!args) SWIG_fail;
49722 swig_obj[0] = args;
49723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49724 if (!SWIG_IsOK(res1)) {
49725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49726 }
49727 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49728 {
49729 PyThreadState* __tstate = wxPyBeginAllowThreads();
49730 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49731 wxPyEndAllowThreads(__tstate);
49732 if (PyErr_Occurred()) SWIG_fail;
49733 }
49734 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49735 return resultobj;
49736 fail:
49737 return NULL;
49738 }
49739
49740
49741 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49742 PyObject *resultobj = 0;
49743 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49744 wxGBPosition *arg2 = 0 ;
49745 bool result;
49746 void *argp1 = 0 ;
49747 int res1 = 0 ;
49748 wxGBPosition temp2 ;
49749 PyObject * obj0 = 0 ;
49750 PyObject * obj1 = 0 ;
49751 char * kwnames[] = {
49752 (char *) "self",(char *) "pos", NULL
49753 };
49754
49755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",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_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49759 }
49760 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49761 {
49762 arg2 = &temp2;
49763 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49764 }
49765 {
49766 PyThreadState* __tstate = wxPyBeginAllowThreads();
49767 result = (bool)(arg1)->SetPos((wxGBPosition 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_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49781 PyObject *resultobj = 0;
49782 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49783 wxGBSpan *arg2 = 0 ;
49784 bool result;
49785 void *argp1 = 0 ;
49786 int res1 = 0 ;
49787 wxGBSpan temp2 ;
49788 PyObject * obj0 = 0 ;
49789 PyObject * obj1 = 0 ;
49790 char * kwnames[] = {
49791 (char *) "self",(char *) "span", NULL
49792 };
49793
49794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49796 if (!SWIG_IsOK(res1)) {
49797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49798 }
49799 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49800 {
49801 arg2 = &temp2;
49802 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
49803 }
49804 {
49805 PyThreadState* __tstate = wxPyBeginAllowThreads();
49806 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
49807 wxPyEndAllowThreads(__tstate);
49808 if (PyErr_Occurred()) SWIG_fail;
49809 }
49810 {
49811 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49812 }
49813 return resultobj;
49814 fail:
49815 return NULL;
49816 }
49817
49818
49819 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49820 PyObject *resultobj = 0;
49821 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49822 wxGBSizerItem *arg2 = 0 ;
49823 bool result;
49824 void *argp1 = 0 ;
49825 int res1 = 0 ;
49826 void *argp2 = 0 ;
49827 int res2 = 0 ;
49828 PyObject * obj0 = 0 ;
49829 PyObject * obj1 = 0 ;
49830 char * kwnames[] = {
49831 (char *) "self",(char *) "other", NULL
49832 };
49833
49834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
49835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49836 if (!SWIG_IsOK(res1)) {
49837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49838 }
49839 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
49841 if (!SWIG_IsOK(res2)) {
49842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49843 }
49844 if (!argp2) {
49845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
49846 }
49847 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
49848 {
49849 PyThreadState* __tstate = wxPyBeginAllowThreads();
49850 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
49851 wxPyEndAllowThreads(__tstate);
49852 if (PyErr_Occurred()) SWIG_fail;
49853 }
49854 {
49855 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49856 }
49857 return resultobj;
49858 fail:
49859 return NULL;
49860 }
49861
49862
49863 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49864 PyObject *resultobj = 0;
49865 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49866 wxGBPosition *arg2 = 0 ;
49867 wxGBSpan *arg3 = 0 ;
49868 bool result;
49869 void *argp1 = 0 ;
49870 int res1 = 0 ;
49871 wxGBPosition temp2 ;
49872 wxGBSpan temp3 ;
49873 PyObject * obj0 = 0 ;
49874 PyObject * obj1 = 0 ;
49875 PyObject * obj2 = 0 ;
49876 char * kwnames[] = {
49877 (char *) "self",(char *) "pos",(char *) "span", NULL
49878 };
49879
49880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49882 if (!SWIG_IsOK(res1)) {
49883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49884 }
49885 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49886 {
49887 arg2 = &temp2;
49888 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49889 }
49890 {
49891 arg3 = &temp3;
49892 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49893 }
49894 {
49895 PyThreadState* __tstate = wxPyBeginAllowThreads();
49896 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
49897 wxPyEndAllowThreads(__tstate);
49898 if (PyErr_Occurred()) SWIG_fail;
49899 }
49900 {
49901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49902 }
49903 return resultobj;
49904 fail:
49905 return NULL;
49906 }
49907
49908
49909 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49910 PyObject *resultobj = 0;
49911 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49912 wxGBPosition result;
49913 void *argp1 = 0 ;
49914 int res1 = 0 ;
49915 PyObject *swig_obj[1] ;
49916
49917 if (!args) SWIG_fail;
49918 swig_obj[0] = args;
49919 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49920 if (!SWIG_IsOK(res1)) {
49921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49922 }
49923 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49924 {
49925 PyThreadState* __tstate = wxPyBeginAllowThreads();
49926 result = wxGBSizerItem_GetEndPos(arg1);
49927 wxPyEndAllowThreads(__tstate);
49928 if (PyErr_Occurred()) SWIG_fail;
49929 }
49930 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49931 return resultobj;
49932 fail:
49933 return NULL;
49934 }
49935
49936
49937 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49938 PyObject *resultobj = 0;
49939 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49940 wxGridBagSizer *result = 0 ;
49941 void *argp1 = 0 ;
49942 int res1 = 0 ;
49943 PyObject *swig_obj[1] ;
49944
49945 if (!args) SWIG_fail;
49946 swig_obj[0] = args;
49947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49948 if (!SWIG_IsOK(res1)) {
49949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49950 }
49951 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49952 {
49953 PyThreadState* __tstate = wxPyBeginAllowThreads();
49954 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
49955 wxPyEndAllowThreads(__tstate);
49956 if (PyErr_Occurred()) SWIG_fail;
49957 }
49958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49959 return resultobj;
49960 fail:
49961 return NULL;
49962 }
49963
49964
49965 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49966 PyObject *resultobj = 0;
49967 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49968 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
49969 void *argp1 = 0 ;
49970 int res1 = 0 ;
49971 void *argp2 = 0 ;
49972 int res2 = 0 ;
49973 PyObject * obj0 = 0 ;
49974 PyObject * obj1 = 0 ;
49975 char * kwnames[] = {
49976 (char *) "self",(char *) "sizer", NULL
49977 };
49978
49979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49981 if (!SWIG_IsOK(res1)) {
49982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49983 }
49984 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49985 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
49986 if (!SWIG_IsOK(res2)) {
49987 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
49988 }
49989 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
49990 {
49991 PyThreadState* __tstate = wxPyBeginAllowThreads();
49992 (arg1)->SetGBSizer(arg2);
49993 wxPyEndAllowThreads(__tstate);
49994 if (PyErr_Occurred()) SWIG_fail;
49995 }
49996 resultobj = SWIG_Py_Void();
49997 return resultobj;
49998 fail:
49999 return NULL;
50000 }
50001
50002
50003 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50004 PyObject *obj;
50005 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50006 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50007 return SWIG_Py_Void();
50008 }
50009
50010 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50011 return SWIG_Python_InitShadowInstance(args);
50012 }
50013
50014 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50015 PyObject *resultobj = 0;
50016 int arg1 = (int) 0 ;
50017 int arg2 = (int) 0 ;
50018 wxGridBagSizer *result = 0 ;
50019 int val1 ;
50020 int ecode1 = 0 ;
50021 int val2 ;
50022 int ecode2 = 0 ;
50023 PyObject * obj0 = 0 ;
50024 PyObject * obj1 = 0 ;
50025 char * kwnames[] = {
50026 (char *) "vgap",(char *) "hgap", NULL
50027 };
50028
50029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50030 if (obj0) {
50031 ecode1 = SWIG_AsVal_int(obj0, &val1);
50032 if (!SWIG_IsOK(ecode1)) {
50033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50034 }
50035 arg1 = static_cast< int >(val1);
50036 }
50037 if (obj1) {
50038 ecode2 = SWIG_AsVal_int(obj1, &val2);
50039 if (!SWIG_IsOK(ecode2)) {
50040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50041 }
50042 arg2 = static_cast< int >(val2);
50043 }
50044 {
50045 PyThreadState* __tstate = wxPyBeginAllowThreads();
50046 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50047 wxPyEndAllowThreads(__tstate);
50048 if (PyErr_Occurred()) SWIG_fail;
50049 }
50050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50051 return resultobj;
50052 fail:
50053 return NULL;
50054 }
50055
50056
50057 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50058 PyObject *resultobj = 0;
50059 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50060 PyObject *arg2 = (PyObject *) 0 ;
50061 wxGBPosition *arg3 = 0 ;
50062 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50063 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50064 int arg5 = (int) 0 ;
50065 int arg6 = (int) 0 ;
50066 PyObject *arg7 = (PyObject *) NULL ;
50067 wxGBSizerItem *result = 0 ;
50068 void *argp1 = 0 ;
50069 int res1 = 0 ;
50070 wxGBPosition temp3 ;
50071 wxGBSpan temp4 ;
50072 int val5 ;
50073 int ecode5 = 0 ;
50074 int val6 ;
50075 int ecode6 = 0 ;
50076 PyObject * obj0 = 0 ;
50077 PyObject * obj1 = 0 ;
50078 PyObject * obj2 = 0 ;
50079 PyObject * obj3 = 0 ;
50080 PyObject * obj4 = 0 ;
50081 PyObject * obj5 = 0 ;
50082 PyObject * obj6 = 0 ;
50083 char * kwnames[] = {
50084 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50085 };
50086
50087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50089 if (!SWIG_IsOK(res1)) {
50090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50091 }
50092 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50093 arg2 = obj1;
50094 {
50095 arg3 = &temp3;
50096 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50097 }
50098 if (obj3) {
50099 {
50100 arg4 = &temp4;
50101 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50102 }
50103 }
50104 if (obj4) {
50105 ecode5 = SWIG_AsVal_int(obj4, &val5);
50106 if (!SWIG_IsOK(ecode5)) {
50107 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50108 }
50109 arg5 = static_cast< int >(val5);
50110 }
50111 if (obj5) {
50112 ecode6 = SWIG_AsVal_int(obj5, &val6);
50113 if (!SWIG_IsOK(ecode6)) {
50114 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50115 }
50116 arg6 = static_cast< int >(val6);
50117 }
50118 if (obj6) {
50119 arg7 = obj6;
50120 }
50121 {
50122 PyThreadState* __tstate = wxPyBeginAllowThreads();
50123 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50124 wxPyEndAllowThreads(__tstate);
50125 if (PyErr_Occurred()) SWIG_fail;
50126 }
50127 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50128 return resultobj;
50129 fail:
50130 return NULL;
50131 }
50132
50133
50134 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50135 PyObject *resultobj = 0;
50136 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50137 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50138 wxGBSizerItem *result = 0 ;
50139 void *argp1 = 0 ;
50140 int res1 = 0 ;
50141 int res2 = 0 ;
50142 PyObject * obj0 = 0 ;
50143 PyObject * obj1 = 0 ;
50144 char * kwnames[] = {
50145 (char *) "self",(char *) "item", NULL
50146 };
50147
50148 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50149 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50150 if (!SWIG_IsOK(res1)) {
50151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50152 }
50153 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50154 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50155 if (!SWIG_IsOK(res2)) {
50156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50157 }
50158 {
50159 PyThreadState* __tstate = wxPyBeginAllowThreads();
50160 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50161 wxPyEndAllowThreads(__tstate);
50162 if (PyErr_Occurred()) SWIG_fail;
50163 }
50164 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50165 return resultobj;
50166 fail:
50167 return NULL;
50168 }
50169
50170
50171 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50172 PyObject *resultobj = 0;
50173 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50174 int arg2 ;
50175 int arg3 ;
50176 wxSize result;
50177 void *argp1 = 0 ;
50178 int res1 = 0 ;
50179 int val2 ;
50180 int ecode2 = 0 ;
50181 int val3 ;
50182 int ecode3 = 0 ;
50183 PyObject * obj0 = 0 ;
50184 PyObject * obj1 = 0 ;
50185 PyObject * obj2 = 0 ;
50186 char * kwnames[] = {
50187 (char *) "self",(char *) "row",(char *) "col", NULL
50188 };
50189
50190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50192 if (!SWIG_IsOK(res1)) {
50193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50194 }
50195 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50196 ecode2 = SWIG_AsVal_int(obj1, &val2);
50197 if (!SWIG_IsOK(ecode2)) {
50198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50199 }
50200 arg2 = static_cast< int >(val2);
50201 ecode3 = SWIG_AsVal_int(obj2, &val3);
50202 if (!SWIG_IsOK(ecode3)) {
50203 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50204 }
50205 arg3 = static_cast< int >(val3);
50206 {
50207 PyThreadState* __tstate = wxPyBeginAllowThreads();
50208 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50209 wxPyEndAllowThreads(__tstate);
50210 if (PyErr_Occurred()) SWIG_fail;
50211 }
50212 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50213 return resultobj;
50214 fail:
50215 return NULL;
50216 }
50217
50218
50219 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50220 PyObject *resultobj = 0;
50221 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50222 wxSize result;
50223 void *argp1 = 0 ;
50224 int res1 = 0 ;
50225 PyObject *swig_obj[1] ;
50226
50227 if (!args) SWIG_fail;
50228 swig_obj[0] = args;
50229 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50230 if (!SWIG_IsOK(res1)) {
50231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50232 }
50233 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50234 {
50235 PyThreadState* __tstate = wxPyBeginAllowThreads();
50236 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50237 wxPyEndAllowThreads(__tstate);
50238 if (PyErr_Occurred()) SWIG_fail;
50239 }
50240 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50241 return resultobj;
50242 fail:
50243 return NULL;
50244 }
50245
50246
50247 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50248 PyObject *resultobj = 0;
50249 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50250 wxSize *arg2 = 0 ;
50251 void *argp1 = 0 ;
50252 int res1 = 0 ;
50253 wxSize temp2 ;
50254 PyObject * obj0 = 0 ;
50255 PyObject * obj1 = 0 ;
50256 char * kwnames[] = {
50257 (char *) "self",(char *) "sz", NULL
50258 };
50259
50260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50262 if (!SWIG_IsOK(res1)) {
50263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50264 }
50265 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50266 {
50267 arg2 = &temp2;
50268 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50269 }
50270 {
50271 PyThreadState* __tstate = wxPyBeginAllowThreads();
50272 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50273 wxPyEndAllowThreads(__tstate);
50274 if (PyErr_Occurred()) SWIG_fail;
50275 }
50276 resultobj = SWIG_Py_Void();
50277 return resultobj;
50278 fail:
50279 return NULL;
50280 }
50281
50282
50283 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50284 PyObject *resultobj = 0;
50285 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50286 wxWindow *arg2 = (wxWindow *) 0 ;
50287 wxGBPosition result;
50288 void *argp1 = 0 ;
50289 int res1 = 0 ;
50290 void *argp2 = 0 ;
50291 int res2 = 0 ;
50292
50293 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50295 if (!SWIG_IsOK(res1)) {
50296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50297 }
50298 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50299 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50300 if (!SWIG_IsOK(res2)) {
50301 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50302 }
50303 arg2 = reinterpret_cast< wxWindow * >(argp2);
50304 {
50305 PyThreadState* __tstate = wxPyBeginAllowThreads();
50306 result = (arg1)->GetItemPosition(arg2);
50307 wxPyEndAllowThreads(__tstate);
50308 if (PyErr_Occurred()) SWIG_fail;
50309 }
50310 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50311 return resultobj;
50312 fail:
50313 return NULL;
50314 }
50315
50316
50317 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50318 PyObject *resultobj = 0;
50319 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50320 wxSizer *arg2 = (wxSizer *) 0 ;
50321 wxGBPosition result;
50322 void *argp1 = 0 ;
50323 int res1 = 0 ;
50324 void *argp2 = 0 ;
50325 int res2 = 0 ;
50326
50327 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50329 if (!SWIG_IsOK(res1)) {
50330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50331 }
50332 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50333 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50334 if (!SWIG_IsOK(res2)) {
50335 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50336 }
50337 arg2 = reinterpret_cast< wxSizer * >(argp2);
50338 {
50339 PyThreadState* __tstate = wxPyBeginAllowThreads();
50340 result = (arg1)->GetItemPosition(arg2);
50341 wxPyEndAllowThreads(__tstate);
50342 if (PyErr_Occurred()) SWIG_fail;
50343 }
50344 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50345 return resultobj;
50346 fail:
50347 return NULL;
50348 }
50349
50350
50351 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50352 PyObject *resultobj = 0;
50353 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50354 size_t arg2 ;
50355 wxGBPosition result;
50356 void *argp1 = 0 ;
50357 int res1 = 0 ;
50358 size_t val2 ;
50359 int ecode2 = 0 ;
50360
50361 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50363 if (!SWIG_IsOK(res1)) {
50364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50365 }
50366 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50367 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50368 if (!SWIG_IsOK(ecode2)) {
50369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50370 }
50371 arg2 = static_cast< size_t >(val2);
50372 {
50373 PyThreadState* __tstate = wxPyBeginAllowThreads();
50374 result = (arg1)->GetItemPosition(arg2);
50375 wxPyEndAllowThreads(__tstate);
50376 if (PyErr_Occurred()) SWIG_fail;
50377 }
50378 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50379 return resultobj;
50380 fail:
50381 return NULL;
50382 }
50383
50384
50385 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50386 int argc;
50387 PyObject *argv[3];
50388
50389 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50390 --argc;
50391 if (argc == 2) {
50392 int _v = 0;
50393 {
50394 void *vptr = 0;
50395 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50396 _v = SWIG_CheckState(res);
50397 }
50398 if (!_v) goto check_1;
50399 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50400 }
50401 check_1:
50402
50403 if (argc == 2) {
50404 int _v = 0;
50405 {
50406 void *vptr = 0;
50407 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50408 _v = SWIG_CheckState(res);
50409 }
50410 if (!_v) goto check_2;
50411 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50412 }
50413 check_2:
50414
50415 if (argc == 2) {
50416 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50417 }
50418
50419 fail:
50420 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50421 return NULL;
50422 }
50423
50424
50425 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50426 PyObject *resultobj = 0;
50427 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50428 wxWindow *arg2 = (wxWindow *) 0 ;
50429 wxGBPosition *arg3 = 0 ;
50430 bool result;
50431 void *argp1 = 0 ;
50432 int res1 = 0 ;
50433 void *argp2 = 0 ;
50434 int res2 = 0 ;
50435 wxGBPosition temp3 ;
50436
50437 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50439 if (!SWIG_IsOK(res1)) {
50440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50441 }
50442 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50443 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50444 if (!SWIG_IsOK(res2)) {
50445 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50446 }
50447 arg2 = reinterpret_cast< wxWindow * >(argp2);
50448 {
50449 arg3 = &temp3;
50450 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50451 }
50452 {
50453 PyThreadState* __tstate = wxPyBeginAllowThreads();
50454 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50455 wxPyEndAllowThreads(__tstate);
50456 if (PyErr_Occurred()) SWIG_fail;
50457 }
50458 {
50459 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50460 }
50461 return resultobj;
50462 fail:
50463 return NULL;
50464 }
50465
50466
50467 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50468 PyObject *resultobj = 0;
50469 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50470 wxSizer *arg2 = (wxSizer *) 0 ;
50471 wxGBPosition *arg3 = 0 ;
50472 bool result;
50473 void *argp1 = 0 ;
50474 int res1 = 0 ;
50475 void *argp2 = 0 ;
50476 int res2 = 0 ;
50477 wxGBPosition temp3 ;
50478
50479 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50481 if (!SWIG_IsOK(res1)) {
50482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50483 }
50484 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50485 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50486 if (!SWIG_IsOK(res2)) {
50487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50488 }
50489 arg2 = reinterpret_cast< wxSizer * >(argp2);
50490 {
50491 arg3 = &temp3;
50492 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50493 }
50494 {
50495 PyThreadState* __tstate = wxPyBeginAllowThreads();
50496 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50497 wxPyEndAllowThreads(__tstate);
50498 if (PyErr_Occurred()) SWIG_fail;
50499 }
50500 {
50501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50502 }
50503 return resultobj;
50504 fail:
50505 return NULL;
50506 }
50507
50508
50509 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50510 PyObject *resultobj = 0;
50511 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50512 size_t arg2 ;
50513 wxGBPosition *arg3 = 0 ;
50514 bool result;
50515 void *argp1 = 0 ;
50516 int res1 = 0 ;
50517 size_t val2 ;
50518 int ecode2 = 0 ;
50519 wxGBPosition temp3 ;
50520
50521 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50523 if (!SWIG_IsOK(res1)) {
50524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50525 }
50526 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50527 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50528 if (!SWIG_IsOK(ecode2)) {
50529 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50530 }
50531 arg2 = static_cast< size_t >(val2);
50532 {
50533 arg3 = &temp3;
50534 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50535 }
50536 {
50537 PyThreadState* __tstate = wxPyBeginAllowThreads();
50538 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50539 wxPyEndAllowThreads(__tstate);
50540 if (PyErr_Occurred()) SWIG_fail;
50541 }
50542 {
50543 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50544 }
50545 return resultobj;
50546 fail:
50547 return NULL;
50548 }
50549
50550
50551 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50552 int argc;
50553 PyObject *argv[4];
50554
50555 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50556 --argc;
50557 if (argc == 3) {
50558 int _v = 0;
50559 {
50560 void *vptr = 0;
50561 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50562 _v = SWIG_CheckState(res);
50563 }
50564 if (!_v) goto check_1;
50565 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50566 }
50567 check_1:
50568
50569 if (argc == 3) {
50570 int _v = 0;
50571 {
50572 void *vptr = 0;
50573 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50574 _v = SWIG_CheckState(res);
50575 }
50576 if (!_v) goto check_2;
50577 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50578 }
50579 check_2:
50580
50581 if (argc == 3) {
50582 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50583 }
50584
50585 fail:
50586 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50587 return NULL;
50588 }
50589
50590
50591 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50592 PyObject *resultobj = 0;
50593 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50594 wxWindow *arg2 = (wxWindow *) 0 ;
50595 wxGBSpan result;
50596 void *argp1 = 0 ;
50597 int res1 = 0 ;
50598 void *argp2 = 0 ;
50599 int res2 = 0 ;
50600
50601 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50603 if (!SWIG_IsOK(res1)) {
50604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50605 }
50606 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50607 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50608 if (!SWIG_IsOK(res2)) {
50609 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50610 }
50611 arg2 = reinterpret_cast< wxWindow * >(argp2);
50612 {
50613 PyThreadState* __tstate = wxPyBeginAllowThreads();
50614 result = (arg1)->GetItemSpan(arg2);
50615 wxPyEndAllowThreads(__tstate);
50616 if (PyErr_Occurred()) SWIG_fail;
50617 }
50618 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50619 return resultobj;
50620 fail:
50621 return NULL;
50622 }
50623
50624
50625 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50626 PyObject *resultobj = 0;
50627 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50628 wxSizer *arg2 = (wxSizer *) 0 ;
50629 wxGBSpan result;
50630 void *argp1 = 0 ;
50631 int res1 = 0 ;
50632 void *argp2 = 0 ;
50633 int res2 = 0 ;
50634
50635 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50637 if (!SWIG_IsOK(res1)) {
50638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50639 }
50640 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50641 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50642 if (!SWIG_IsOK(res2)) {
50643 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50644 }
50645 arg2 = reinterpret_cast< wxSizer * >(argp2);
50646 {
50647 PyThreadState* __tstate = wxPyBeginAllowThreads();
50648 result = (arg1)->GetItemSpan(arg2);
50649 wxPyEndAllowThreads(__tstate);
50650 if (PyErr_Occurred()) SWIG_fail;
50651 }
50652 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50653 return resultobj;
50654 fail:
50655 return NULL;
50656 }
50657
50658
50659 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50660 PyObject *resultobj = 0;
50661 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50662 size_t arg2 ;
50663 wxGBSpan result;
50664 void *argp1 = 0 ;
50665 int res1 = 0 ;
50666 size_t val2 ;
50667 int ecode2 = 0 ;
50668
50669 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50671 if (!SWIG_IsOK(res1)) {
50672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50673 }
50674 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50675 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50676 if (!SWIG_IsOK(ecode2)) {
50677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50678 }
50679 arg2 = static_cast< size_t >(val2);
50680 {
50681 PyThreadState* __tstate = wxPyBeginAllowThreads();
50682 result = (arg1)->GetItemSpan(arg2);
50683 wxPyEndAllowThreads(__tstate);
50684 if (PyErr_Occurred()) SWIG_fail;
50685 }
50686 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50687 return resultobj;
50688 fail:
50689 return NULL;
50690 }
50691
50692
50693 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50694 int argc;
50695 PyObject *argv[3];
50696
50697 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50698 --argc;
50699 if (argc == 2) {
50700 int _v = 0;
50701 {
50702 void *vptr = 0;
50703 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50704 _v = SWIG_CheckState(res);
50705 }
50706 if (!_v) goto check_1;
50707 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50708 }
50709 check_1:
50710
50711 if (argc == 2) {
50712 int _v = 0;
50713 {
50714 void *vptr = 0;
50715 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50716 _v = SWIG_CheckState(res);
50717 }
50718 if (!_v) goto check_2;
50719 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50720 }
50721 check_2:
50722
50723 if (argc == 2) {
50724 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50725 }
50726
50727 fail:
50728 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50729 return NULL;
50730 }
50731
50732
50733 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50734 PyObject *resultobj = 0;
50735 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50736 wxWindow *arg2 = (wxWindow *) 0 ;
50737 wxGBSpan *arg3 = 0 ;
50738 bool result;
50739 void *argp1 = 0 ;
50740 int res1 = 0 ;
50741 void *argp2 = 0 ;
50742 int res2 = 0 ;
50743 wxGBSpan temp3 ;
50744
50745 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50747 if (!SWIG_IsOK(res1)) {
50748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50749 }
50750 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50751 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50752 if (!SWIG_IsOK(res2)) {
50753 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50754 }
50755 arg2 = reinterpret_cast< wxWindow * >(argp2);
50756 {
50757 arg3 = &temp3;
50758 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50759 }
50760 {
50761 PyThreadState* __tstate = wxPyBeginAllowThreads();
50762 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50763 wxPyEndAllowThreads(__tstate);
50764 if (PyErr_Occurred()) SWIG_fail;
50765 }
50766 {
50767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50768 }
50769 return resultobj;
50770 fail:
50771 return NULL;
50772 }
50773
50774
50775 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50776 PyObject *resultobj = 0;
50777 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50778 wxSizer *arg2 = (wxSizer *) 0 ;
50779 wxGBSpan *arg3 = 0 ;
50780 bool result;
50781 void *argp1 = 0 ;
50782 int res1 = 0 ;
50783 void *argp2 = 0 ;
50784 int res2 = 0 ;
50785 wxGBSpan temp3 ;
50786
50787 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50789 if (!SWIG_IsOK(res1)) {
50790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50791 }
50792 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50793 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50794 if (!SWIG_IsOK(res2)) {
50795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50796 }
50797 arg2 = reinterpret_cast< wxSizer * >(argp2);
50798 {
50799 arg3 = &temp3;
50800 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50801 }
50802 {
50803 PyThreadState* __tstate = wxPyBeginAllowThreads();
50804 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50805 wxPyEndAllowThreads(__tstate);
50806 if (PyErr_Occurred()) SWIG_fail;
50807 }
50808 {
50809 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50810 }
50811 return resultobj;
50812 fail:
50813 return NULL;
50814 }
50815
50816
50817 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50818 PyObject *resultobj = 0;
50819 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50820 size_t arg2 ;
50821 wxGBSpan *arg3 = 0 ;
50822 bool result;
50823 void *argp1 = 0 ;
50824 int res1 = 0 ;
50825 size_t val2 ;
50826 int ecode2 = 0 ;
50827 wxGBSpan temp3 ;
50828
50829 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50831 if (!SWIG_IsOK(res1)) {
50832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50833 }
50834 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50835 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50836 if (!SWIG_IsOK(ecode2)) {
50837 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50838 }
50839 arg2 = static_cast< size_t >(val2);
50840 {
50841 arg3 = &temp3;
50842 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50843 }
50844 {
50845 PyThreadState* __tstate = wxPyBeginAllowThreads();
50846 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50847 wxPyEndAllowThreads(__tstate);
50848 if (PyErr_Occurred()) SWIG_fail;
50849 }
50850 {
50851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50852 }
50853 return resultobj;
50854 fail:
50855 return NULL;
50856 }
50857
50858
50859 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
50860 int argc;
50861 PyObject *argv[4];
50862
50863 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
50864 --argc;
50865 if (argc == 3) {
50866 int _v = 0;
50867 {
50868 void *vptr = 0;
50869 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50870 _v = SWIG_CheckState(res);
50871 }
50872 if (!_v) goto check_1;
50873 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
50874 }
50875 check_1:
50876
50877 if (argc == 3) {
50878 int _v = 0;
50879 {
50880 void *vptr = 0;
50881 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50882 _v = SWIG_CheckState(res);
50883 }
50884 if (!_v) goto check_2;
50885 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
50886 }
50887 check_2:
50888
50889 if (argc == 3) {
50890 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
50891 }
50892
50893 fail:
50894 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
50895 return NULL;
50896 }
50897
50898
50899 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50900 PyObject *resultobj = 0;
50901 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50902 wxWindow *arg2 = (wxWindow *) 0 ;
50903 wxGBSizerItem *result = 0 ;
50904 void *argp1 = 0 ;
50905 int res1 = 0 ;
50906 void *argp2 = 0 ;
50907 int res2 = 0 ;
50908
50909 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50911 if (!SWIG_IsOK(res1)) {
50912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50913 }
50914 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50915 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50916 if (!SWIG_IsOK(res2)) {
50917 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
50918 }
50919 arg2 = reinterpret_cast< wxWindow * >(argp2);
50920 {
50921 PyThreadState* __tstate = wxPyBeginAllowThreads();
50922 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50923 wxPyEndAllowThreads(__tstate);
50924 if (PyErr_Occurred()) SWIG_fail;
50925 }
50926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50927 return resultobj;
50928 fail:
50929 return NULL;
50930 }
50931
50932
50933 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50934 PyObject *resultobj = 0;
50935 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50936 wxSizer *arg2 = (wxSizer *) 0 ;
50937 wxGBSizerItem *result = 0 ;
50938 void *argp1 = 0 ;
50939 int res1 = 0 ;
50940 void *argp2 = 0 ;
50941 int res2 = 0 ;
50942
50943 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50944 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50945 if (!SWIG_IsOK(res1)) {
50946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50947 }
50948 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50949 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50950 if (!SWIG_IsOK(res2)) {
50951 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
50952 }
50953 arg2 = reinterpret_cast< wxSizer * >(argp2);
50954 {
50955 PyThreadState* __tstate = wxPyBeginAllowThreads();
50956 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
50957 wxPyEndAllowThreads(__tstate);
50958 if (PyErr_Occurred()) SWIG_fail;
50959 }
50960 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50961 return resultobj;
50962 fail:
50963 return NULL;
50964 }
50965
50966
50967 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
50968 int argc;
50969 PyObject *argv[3];
50970
50971 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
50972 --argc;
50973 if (argc == 2) {
50974 int _v = 0;
50975 {
50976 void *vptr = 0;
50977 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50978 _v = SWIG_CheckState(res);
50979 }
50980 if (!_v) goto check_1;
50981 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
50982 }
50983 check_1:
50984
50985 if (argc == 2) {
50986 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
50987 }
50988
50989 fail:
50990 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
50991 return NULL;
50992 }
50993
50994
50995 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50996 PyObject *resultobj = 0;
50997 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50998 wxGBPosition *arg2 = 0 ;
50999 wxGBSizerItem *result = 0 ;
51000 void *argp1 = 0 ;
51001 int res1 = 0 ;
51002 wxGBPosition temp2 ;
51003 PyObject * obj0 = 0 ;
51004 PyObject * obj1 = 0 ;
51005 char * kwnames[] = {
51006 (char *) "self",(char *) "pos", NULL
51007 };
51008
51009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51011 if (!SWIG_IsOK(res1)) {
51012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51013 }
51014 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51015 {
51016 arg2 = &temp2;
51017 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51018 }
51019 {
51020 PyThreadState* __tstate = wxPyBeginAllowThreads();
51021 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51022 wxPyEndAllowThreads(__tstate);
51023 if (PyErr_Occurred()) SWIG_fail;
51024 }
51025 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51026 return resultobj;
51027 fail:
51028 return NULL;
51029 }
51030
51031
51032 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51033 PyObject *resultobj = 0;
51034 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51035 wxPoint *arg2 = 0 ;
51036 wxGBSizerItem *result = 0 ;
51037 void *argp1 = 0 ;
51038 int res1 = 0 ;
51039 wxPoint temp2 ;
51040 PyObject * obj0 = 0 ;
51041 PyObject * obj1 = 0 ;
51042 char * kwnames[] = {
51043 (char *) "self",(char *) "pt", NULL
51044 };
51045
51046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51048 if (!SWIG_IsOK(res1)) {
51049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51050 }
51051 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51052 {
51053 arg2 = &temp2;
51054 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51055 }
51056 {
51057 PyThreadState* __tstate = wxPyBeginAllowThreads();
51058 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51059 wxPyEndAllowThreads(__tstate);
51060 if (PyErr_Occurred()) SWIG_fail;
51061 }
51062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51063 return resultobj;
51064 fail:
51065 return NULL;
51066 }
51067
51068
51069 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51070 PyObject *resultobj = 0;
51071 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51072 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51073 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51074 bool result;
51075 void *argp1 = 0 ;
51076 int res1 = 0 ;
51077 void *argp2 = 0 ;
51078 int res2 = 0 ;
51079 void *argp3 = 0 ;
51080 int res3 = 0 ;
51081 PyObject * obj0 = 0 ;
51082 PyObject * obj1 = 0 ;
51083 PyObject * obj2 = 0 ;
51084 char * kwnames[] = {
51085 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51086 };
51087
51088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51090 if (!SWIG_IsOK(res1)) {
51091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51092 }
51093 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51094 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51095 if (!SWIG_IsOK(res2)) {
51096 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51097 }
51098 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51099 if (obj2) {
51100 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51101 if (!SWIG_IsOK(res3)) {
51102 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51103 }
51104 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51105 }
51106 {
51107 PyThreadState* __tstate = wxPyBeginAllowThreads();
51108 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51109 wxPyEndAllowThreads(__tstate);
51110 if (PyErr_Occurred()) SWIG_fail;
51111 }
51112 {
51113 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51114 }
51115 return resultobj;
51116 fail:
51117 return NULL;
51118 }
51119
51120
51121 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51122 PyObject *resultobj = 0;
51123 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51124 wxGBPosition *arg2 = 0 ;
51125 wxGBSpan *arg3 = 0 ;
51126 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51127 bool result;
51128 void *argp1 = 0 ;
51129 int res1 = 0 ;
51130 wxGBPosition temp2 ;
51131 wxGBSpan temp3 ;
51132 void *argp4 = 0 ;
51133 int res4 = 0 ;
51134 PyObject * obj0 = 0 ;
51135 PyObject * obj1 = 0 ;
51136 PyObject * obj2 = 0 ;
51137 PyObject * obj3 = 0 ;
51138 char * kwnames[] = {
51139 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51140 };
51141
51142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51144 if (!SWIG_IsOK(res1)) {
51145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51146 }
51147 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51148 {
51149 arg2 = &temp2;
51150 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51151 }
51152 {
51153 arg3 = &temp3;
51154 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51155 }
51156 if (obj3) {
51157 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51158 if (!SWIG_IsOK(res4)) {
51159 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51160 }
51161 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51162 }
51163 {
51164 PyThreadState* __tstate = wxPyBeginAllowThreads();
51165 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51166 wxPyEndAllowThreads(__tstate);
51167 if (PyErr_Occurred()) SWIG_fail;
51168 }
51169 {
51170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51171 }
51172 return resultobj;
51173 fail:
51174 return NULL;
51175 }
51176
51177
51178 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51179 PyObject *obj;
51180 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51181 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51182 return SWIG_Py_Void();
51183 }
51184
51185 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51186 return SWIG_Python_InitShadowInstance(args);
51187 }
51188
51189 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51190 PyObject *resultobj = 0;
51191 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51192 wxRelationship arg2 ;
51193 wxWindow *arg3 = (wxWindow *) 0 ;
51194 wxEdge arg4 ;
51195 int arg5 = (int) 0 ;
51196 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51197 void *argp1 = 0 ;
51198 int res1 = 0 ;
51199 int val2 ;
51200 int ecode2 = 0 ;
51201 void *argp3 = 0 ;
51202 int res3 = 0 ;
51203 int val4 ;
51204 int ecode4 = 0 ;
51205 int val5 ;
51206 int ecode5 = 0 ;
51207 int val6 ;
51208 int ecode6 = 0 ;
51209 PyObject * obj0 = 0 ;
51210 PyObject * obj1 = 0 ;
51211 PyObject * obj2 = 0 ;
51212 PyObject * obj3 = 0 ;
51213 PyObject * obj4 = 0 ;
51214 PyObject * obj5 = 0 ;
51215 char * kwnames[] = {
51216 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51217 };
51218
51219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51221 if (!SWIG_IsOK(res1)) {
51222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51223 }
51224 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51225 ecode2 = SWIG_AsVal_int(obj1, &val2);
51226 if (!SWIG_IsOK(ecode2)) {
51227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51228 }
51229 arg2 = static_cast< wxRelationship >(val2);
51230 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51231 if (!SWIG_IsOK(res3)) {
51232 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51233 }
51234 arg3 = reinterpret_cast< wxWindow * >(argp3);
51235 ecode4 = SWIG_AsVal_int(obj3, &val4);
51236 if (!SWIG_IsOK(ecode4)) {
51237 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51238 }
51239 arg4 = static_cast< wxEdge >(val4);
51240 if (obj4) {
51241 ecode5 = SWIG_AsVal_int(obj4, &val5);
51242 if (!SWIG_IsOK(ecode5)) {
51243 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51244 }
51245 arg5 = static_cast< int >(val5);
51246 }
51247 if (obj5) {
51248 ecode6 = SWIG_AsVal_int(obj5, &val6);
51249 if (!SWIG_IsOK(ecode6)) {
51250 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51251 }
51252 arg6 = static_cast< int >(val6);
51253 }
51254 {
51255 PyThreadState* __tstate = wxPyBeginAllowThreads();
51256 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51257 wxPyEndAllowThreads(__tstate);
51258 if (PyErr_Occurred()) SWIG_fail;
51259 }
51260 resultobj = SWIG_Py_Void();
51261 return resultobj;
51262 fail:
51263 return NULL;
51264 }
51265
51266
51267 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51268 PyObject *resultobj = 0;
51269 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51270 wxWindow *arg2 = (wxWindow *) 0 ;
51271 int arg3 = (int) 0 ;
51272 void *argp1 = 0 ;
51273 int res1 = 0 ;
51274 void *argp2 = 0 ;
51275 int res2 = 0 ;
51276 int val3 ;
51277 int ecode3 = 0 ;
51278 PyObject * obj0 = 0 ;
51279 PyObject * obj1 = 0 ;
51280 PyObject * obj2 = 0 ;
51281 char * kwnames[] = {
51282 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51283 };
51284
51285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51287 if (!SWIG_IsOK(res1)) {
51288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51289 }
51290 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51291 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51292 if (!SWIG_IsOK(res2)) {
51293 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51294 }
51295 arg2 = reinterpret_cast< wxWindow * >(argp2);
51296 if (obj2) {
51297 ecode3 = SWIG_AsVal_int(obj2, &val3);
51298 if (!SWIG_IsOK(ecode3)) {
51299 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51300 }
51301 arg3 = static_cast< int >(val3);
51302 }
51303 {
51304 PyThreadState* __tstate = wxPyBeginAllowThreads();
51305 (arg1)->LeftOf(arg2,arg3);
51306 wxPyEndAllowThreads(__tstate);
51307 if (PyErr_Occurred()) SWIG_fail;
51308 }
51309 resultobj = SWIG_Py_Void();
51310 return resultobj;
51311 fail:
51312 return NULL;
51313 }
51314
51315
51316 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51317 PyObject *resultobj = 0;
51318 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51319 wxWindow *arg2 = (wxWindow *) 0 ;
51320 int arg3 = (int) 0 ;
51321 void *argp1 = 0 ;
51322 int res1 = 0 ;
51323 void *argp2 = 0 ;
51324 int res2 = 0 ;
51325 int val3 ;
51326 int ecode3 = 0 ;
51327 PyObject * obj0 = 0 ;
51328 PyObject * obj1 = 0 ;
51329 PyObject * obj2 = 0 ;
51330 char * kwnames[] = {
51331 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51332 };
51333
51334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51336 if (!SWIG_IsOK(res1)) {
51337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51338 }
51339 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51340 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51341 if (!SWIG_IsOK(res2)) {
51342 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51343 }
51344 arg2 = reinterpret_cast< wxWindow * >(argp2);
51345 if (obj2) {
51346 ecode3 = SWIG_AsVal_int(obj2, &val3);
51347 if (!SWIG_IsOK(ecode3)) {
51348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51349 }
51350 arg3 = static_cast< int >(val3);
51351 }
51352 {
51353 PyThreadState* __tstate = wxPyBeginAllowThreads();
51354 (arg1)->RightOf(arg2,arg3);
51355 wxPyEndAllowThreads(__tstate);
51356 if (PyErr_Occurred()) SWIG_fail;
51357 }
51358 resultobj = SWIG_Py_Void();
51359 return resultobj;
51360 fail:
51361 return NULL;
51362 }
51363
51364
51365 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51366 PyObject *resultobj = 0;
51367 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51368 wxWindow *arg2 = (wxWindow *) 0 ;
51369 int arg3 = (int) 0 ;
51370 void *argp1 = 0 ;
51371 int res1 = 0 ;
51372 void *argp2 = 0 ;
51373 int res2 = 0 ;
51374 int val3 ;
51375 int ecode3 = 0 ;
51376 PyObject * obj0 = 0 ;
51377 PyObject * obj1 = 0 ;
51378 PyObject * obj2 = 0 ;
51379 char * kwnames[] = {
51380 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51381 };
51382
51383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51385 if (!SWIG_IsOK(res1)) {
51386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51387 }
51388 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51390 if (!SWIG_IsOK(res2)) {
51391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51392 }
51393 arg2 = reinterpret_cast< wxWindow * >(argp2);
51394 if (obj2) {
51395 ecode3 = SWIG_AsVal_int(obj2, &val3);
51396 if (!SWIG_IsOK(ecode3)) {
51397 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51398 }
51399 arg3 = static_cast< int >(val3);
51400 }
51401 {
51402 PyThreadState* __tstate = wxPyBeginAllowThreads();
51403 (arg1)->Above(arg2,arg3);
51404 wxPyEndAllowThreads(__tstate);
51405 if (PyErr_Occurred()) SWIG_fail;
51406 }
51407 resultobj = SWIG_Py_Void();
51408 return resultobj;
51409 fail:
51410 return NULL;
51411 }
51412
51413
51414 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51415 PyObject *resultobj = 0;
51416 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51417 wxWindow *arg2 = (wxWindow *) 0 ;
51418 int arg3 = (int) 0 ;
51419 void *argp1 = 0 ;
51420 int res1 = 0 ;
51421 void *argp2 = 0 ;
51422 int res2 = 0 ;
51423 int val3 ;
51424 int ecode3 = 0 ;
51425 PyObject * obj0 = 0 ;
51426 PyObject * obj1 = 0 ;
51427 PyObject * obj2 = 0 ;
51428 char * kwnames[] = {
51429 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51430 };
51431
51432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51434 if (!SWIG_IsOK(res1)) {
51435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51436 }
51437 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51438 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51439 if (!SWIG_IsOK(res2)) {
51440 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51441 }
51442 arg2 = reinterpret_cast< wxWindow * >(argp2);
51443 if (obj2) {
51444 ecode3 = SWIG_AsVal_int(obj2, &val3);
51445 if (!SWIG_IsOK(ecode3)) {
51446 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51447 }
51448 arg3 = static_cast< int >(val3);
51449 }
51450 {
51451 PyThreadState* __tstate = wxPyBeginAllowThreads();
51452 (arg1)->Below(arg2,arg3);
51453 wxPyEndAllowThreads(__tstate);
51454 if (PyErr_Occurred()) SWIG_fail;
51455 }
51456 resultobj = SWIG_Py_Void();
51457 return resultobj;
51458 fail:
51459 return NULL;
51460 }
51461
51462
51463 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51464 PyObject *resultobj = 0;
51465 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51466 wxWindow *arg2 = (wxWindow *) 0 ;
51467 wxEdge arg3 ;
51468 int arg4 = (int) 0 ;
51469 void *argp1 = 0 ;
51470 int res1 = 0 ;
51471 void *argp2 = 0 ;
51472 int res2 = 0 ;
51473 int val3 ;
51474 int ecode3 = 0 ;
51475 int val4 ;
51476 int ecode4 = 0 ;
51477 PyObject * obj0 = 0 ;
51478 PyObject * obj1 = 0 ;
51479 PyObject * obj2 = 0 ;
51480 PyObject * obj3 = 0 ;
51481 char * kwnames[] = {
51482 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51483 };
51484
51485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51487 if (!SWIG_IsOK(res1)) {
51488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51489 }
51490 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51491 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51492 if (!SWIG_IsOK(res2)) {
51493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51494 }
51495 arg2 = reinterpret_cast< wxWindow * >(argp2);
51496 ecode3 = SWIG_AsVal_int(obj2, &val3);
51497 if (!SWIG_IsOK(ecode3)) {
51498 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51499 }
51500 arg3 = static_cast< wxEdge >(val3);
51501 if (obj3) {
51502 ecode4 = SWIG_AsVal_int(obj3, &val4);
51503 if (!SWIG_IsOK(ecode4)) {
51504 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51505 }
51506 arg4 = static_cast< int >(val4);
51507 }
51508 {
51509 PyThreadState* __tstate = wxPyBeginAllowThreads();
51510 (arg1)->SameAs(arg2,arg3,arg4);
51511 wxPyEndAllowThreads(__tstate);
51512 if (PyErr_Occurred()) SWIG_fail;
51513 }
51514 resultobj = SWIG_Py_Void();
51515 return resultobj;
51516 fail:
51517 return NULL;
51518 }
51519
51520
51521 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51522 PyObject *resultobj = 0;
51523 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51524 wxWindow *arg2 = (wxWindow *) 0 ;
51525 wxEdge arg3 ;
51526 int arg4 ;
51527 void *argp1 = 0 ;
51528 int res1 = 0 ;
51529 void *argp2 = 0 ;
51530 int res2 = 0 ;
51531 int val3 ;
51532 int ecode3 = 0 ;
51533 int val4 ;
51534 int ecode4 = 0 ;
51535 PyObject * obj0 = 0 ;
51536 PyObject * obj1 = 0 ;
51537 PyObject * obj2 = 0 ;
51538 PyObject * obj3 = 0 ;
51539 char * kwnames[] = {
51540 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51541 };
51542
51543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51545 if (!SWIG_IsOK(res1)) {
51546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51547 }
51548 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51550 if (!SWIG_IsOK(res2)) {
51551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51552 }
51553 arg2 = reinterpret_cast< wxWindow * >(argp2);
51554 ecode3 = SWIG_AsVal_int(obj2, &val3);
51555 if (!SWIG_IsOK(ecode3)) {
51556 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51557 }
51558 arg3 = static_cast< wxEdge >(val3);
51559 ecode4 = SWIG_AsVal_int(obj3, &val4);
51560 if (!SWIG_IsOK(ecode4)) {
51561 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51562 }
51563 arg4 = static_cast< int >(val4);
51564 {
51565 PyThreadState* __tstate = wxPyBeginAllowThreads();
51566 (arg1)->PercentOf(arg2,arg3,arg4);
51567 wxPyEndAllowThreads(__tstate);
51568 if (PyErr_Occurred()) SWIG_fail;
51569 }
51570 resultobj = SWIG_Py_Void();
51571 return resultobj;
51572 fail:
51573 return NULL;
51574 }
51575
51576
51577 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51578 PyObject *resultobj = 0;
51579 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51580 int arg2 ;
51581 void *argp1 = 0 ;
51582 int res1 = 0 ;
51583 int val2 ;
51584 int ecode2 = 0 ;
51585 PyObject * obj0 = 0 ;
51586 PyObject * obj1 = 0 ;
51587 char * kwnames[] = {
51588 (char *) "self",(char *) "val", NULL
51589 };
51590
51591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51593 if (!SWIG_IsOK(res1)) {
51594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51595 }
51596 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51597 ecode2 = SWIG_AsVal_int(obj1, &val2);
51598 if (!SWIG_IsOK(ecode2)) {
51599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51600 }
51601 arg2 = static_cast< int >(val2);
51602 {
51603 PyThreadState* __tstate = wxPyBeginAllowThreads();
51604 (arg1)->Absolute(arg2);
51605 wxPyEndAllowThreads(__tstate);
51606 if (PyErr_Occurred()) SWIG_fail;
51607 }
51608 resultobj = SWIG_Py_Void();
51609 return resultobj;
51610 fail:
51611 return NULL;
51612 }
51613
51614
51615 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51616 PyObject *resultobj = 0;
51617 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51618 void *argp1 = 0 ;
51619 int res1 = 0 ;
51620 PyObject *swig_obj[1] ;
51621
51622 if (!args) SWIG_fail;
51623 swig_obj[0] = args;
51624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51625 if (!SWIG_IsOK(res1)) {
51626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51627 }
51628 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51629 {
51630 PyThreadState* __tstate = wxPyBeginAllowThreads();
51631 (arg1)->Unconstrained();
51632 wxPyEndAllowThreads(__tstate);
51633 if (PyErr_Occurred()) SWIG_fail;
51634 }
51635 resultobj = SWIG_Py_Void();
51636 return resultobj;
51637 fail:
51638 return NULL;
51639 }
51640
51641
51642 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51643 PyObject *resultobj = 0;
51644 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51645 void *argp1 = 0 ;
51646 int res1 = 0 ;
51647 PyObject *swig_obj[1] ;
51648
51649 if (!args) SWIG_fail;
51650 swig_obj[0] = args;
51651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51652 if (!SWIG_IsOK(res1)) {
51653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51654 }
51655 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51656 {
51657 PyThreadState* __tstate = wxPyBeginAllowThreads();
51658 (arg1)->AsIs();
51659 wxPyEndAllowThreads(__tstate);
51660 if (PyErr_Occurred()) SWIG_fail;
51661 }
51662 resultobj = SWIG_Py_Void();
51663 return resultobj;
51664 fail:
51665 return NULL;
51666 }
51667
51668
51669 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51670 PyObject *resultobj = 0;
51671 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51672 wxWindow *result = 0 ;
51673 void *argp1 = 0 ;
51674 int res1 = 0 ;
51675 PyObject *swig_obj[1] ;
51676
51677 if (!args) SWIG_fail;
51678 swig_obj[0] = args;
51679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51680 if (!SWIG_IsOK(res1)) {
51681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51682 }
51683 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51684 {
51685 PyThreadState* __tstate = wxPyBeginAllowThreads();
51686 result = (wxWindow *)(arg1)->GetOtherWindow();
51687 wxPyEndAllowThreads(__tstate);
51688 if (PyErr_Occurred()) SWIG_fail;
51689 }
51690 {
51691 resultobj = wxPyMake_wxObject(result, 0);
51692 }
51693 return resultobj;
51694 fail:
51695 return NULL;
51696 }
51697
51698
51699 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51700 PyObject *resultobj = 0;
51701 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51702 wxEdge result;
51703 void *argp1 = 0 ;
51704 int res1 = 0 ;
51705 PyObject *swig_obj[1] ;
51706
51707 if (!args) SWIG_fail;
51708 swig_obj[0] = args;
51709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51710 if (!SWIG_IsOK(res1)) {
51711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51712 }
51713 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51714 {
51715 PyThreadState* __tstate = wxPyBeginAllowThreads();
51716 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51717 wxPyEndAllowThreads(__tstate);
51718 if (PyErr_Occurred()) SWIG_fail;
51719 }
51720 resultobj = SWIG_From_int(static_cast< int >(result));
51721 return resultobj;
51722 fail:
51723 return NULL;
51724 }
51725
51726
51727 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51728 PyObject *resultobj = 0;
51729 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51730 wxEdge arg2 ;
51731 void *argp1 = 0 ;
51732 int res1 = 0 ;
51733 int val2 ;
51734 int ecode2 = 0 ;
51735 PyObject * obj0 = 0 ;
51736 PyObject * obj1 = 0 ;
51737 char * kwnames[] = {
51738 (char *) "self",(char *) "which", NULL
51739 };
51740
51741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51743 if (!SWIG_IsOK(res1)) {
51744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51745 }
51746 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51747 ecode2 = SWIG_AsVal_int(obj1, &val2);
51748 if (!SWIG_IsOK(ecode2)) {
51749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51750 }
51751 arg2 = static_cast< wxEdge >(val2);
51752 {
51753 PyThreadState* __tstate = wxPyBeginAllowThreads();
51754 (arg1)->SetEdge(arg2);
51755 wxPyEndAllowThreads(__tstate);
51756 if (PyErr_Occurred()) SWIG_fail;
51757 }
51758 resultobj = SWIG_Py_Void();
51759 return resultobj;
51760 fail:
51761 return NULL;
51762 }
51763
51764
51765 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51766 PyObject *resultobj = 0;
51767 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51768 int arg2 ;
51769 void *argp1 = 0 ;
51770 int res1 = 0 ;
51771 int val2 ;
51772 int ecode2 = 0 ;
51773 PyObject * obj0 = 0 ;
51774 PyObject * obj1 = 0 ;
51775 char * kwnames[] = {
51776 (char *) "self",(char *) "v", NULL
51777 };
51778
51779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
51780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51781 if (!SWIG_IsOK(res1)) {
51782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51783 }
51784 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51785 ecode2 = SWIG_AsVal_int(obj1, &val2);
51786 if (!SWIG_IsOK(ecode2)) {
51787 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
51788 }
51789 arg2 = static_cast< int >(val2);
51790 {
51791 PyThreadState* __tstate = wxPyBeginAllowThreads();
51792 (arg1)->SetValue(arg2);
51793 wxPyEndAllowThreads(__tstate);
51794 if (PyErr_Occurred()) SWIG_fail;
51795 }
51796 resultobj = SWIG_Py_Void();
51797 return resultobj;
51798 fail:
51799 return NULL;
51800 }
51801
51802
51803 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51804 PyObject *resultobj = 0;
51805 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51806 int result;
51807 void *argp1 = 0 ;
51808 int res1 = 0 ;
51809 PyObject *swig_obj[1] ;
51810
51811 if (!args) SWIG_fail;
51812 swig_obj[0] = args;
51813 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51814 if (!SWIG_IsOK(res1)) {
51815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51816 }
51817 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51818 {
51819 PyThreadState* __tstate = wxPyBeginAllowThreads();
51820 result = (int)(arg1)->GetMargin();
51821 wxPyEndAllowThreads(__tstate);
51822 if (PyErr_Occurred()) SWIG_fail;
51823 }
51824 resultobj = SWIG_From_int(static_cast< int >(result));
51825 return resultobj;
51826 fail:
51827 return NULL;
51828 }
51829
51830
51831 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51832 PyObject *resultobj = 0;
51833 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51834 int arg2 ;
51835 void *argp1 = 0 ;
51836 int res1 = 0 ;
51837 int val2 ;
51838 int ecode2 = 0 ;
51839 PyObject * obj0 = 0 ;
51840 PyObject * obj1 = 0 ;
51841 char * kwnames[] = {
51842 (char *) "self",(char *) "m", NULL
51843 };
51844
51845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
51846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51847 if (!SWIG_IsOK(res1)) {
51848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51849 }
51850 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51851 ecode2 = SWIG_AsVal_int(obj1, &val2);
51852 if (!SWIG_IsOK(ecode2)) {
51853 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
51854 }
51855 arg2 = static_cast< int >(val2);
51856 {
51857 PyThreadState* __tstate = wxPyBeginAllowThreads();
51858 (arg1)->SetMargin(arg2);
51859 wxPyEndAllowThreads(__tstate);
51860 if (PyErr_Occurred()) SWIG_fail;
51861 }
51862 resultobj = SWIG_Py_Void();
51863 return resultobj;
51864 fail:
51865 return NULL;
51866 }
51867
51868
51869 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51870 PyObject *resultobj = 0;
51871 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51872 int result;
51873 void *argp1 = 0 ;
51874 int res1 = 0 ;
51875 PyObject *swig_obj[1] ;
51876
51877 if (!args) SWIG_fail;
51878 swig_obj[0] = args;
51879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51880 if (!SWIG_IsOK(res1)) {
51881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51882 }
51883 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51884 {
51885 PyThreadState* __tstate = wxPyBeginAllowThreads();
51886 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
51887 wxPyEndAllowThreads(__tstate);
51888 if (PyErr_Occurred()) SWIG_fail;
51889 }
51890 resultobj = SWIG_From_int(static_cast< int >(result));
51891 return resultobj;
51892 fail:
51893 return NULL;
51894 }
51895
51896
51897 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51898 PyObject *resultobj = 0;
51899 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51900 int result;
51901 void *argp1 = 0 ;
51902 int res1 = 0 ;
51903 PyObject *swig_obj[1] ;
51904
51905 if (!args) SWIG_fail;
51906 swig_obj[0] = args;
51907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51908 if (!SWIG_IsOK(res1)) {
51909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51910 }
51911 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51912 {
51913 PyThreadState* __tstate = wxPyBeginAllowThreads();
51914 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
51915 wxPyEndAllowThreads(__tstate);
51916 if (PyErr_Occurred()) SWIG_fail;
51917 }
51918 resultobj = SWIG_From_int(static_cast< int >(result));
51919 return resultobj;
51920 fail:
51921 return NULL;
51922 }
51923
51924
51925 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51926 PyObject *resultobj = 0;
51927 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51928 int result;
51929 void *argp1 = 0 ;
51930 int res1 = 0 ;
51931 PyObject *swig_obj[1] ;
51932
51933 if (!args) SWIG_fail;
51934 swig_obj[0] = args;
51935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51936 if (!SWIG_IsOK(res1)) {
51937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51938 }
51939 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51940 {
51941 PyThreadState* __tstate = wxPyBeginAllowThreads();
51942 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
51943 wxPyEndAllowThreads(__tstate);
51944 if (PyErr_Occurred()) SWIG_fail;
51945 }
51946 resultobj = SWIG_From_int(static_cast< int >(result));
51947 return resultobj;
51948 fail:
51949 return NULL;
51950 }
51951
51952
51953 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51954 PyObject *resultobj = 0;
51955 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51956 bool result;
51957 void *argp1 = 0 ;
51958 int res1 = 0 ;
51959 PyObject *swig_obj[1] ;
51960
51961 if (!args) SWIG_fail;
51962 swig_obj[0] = args;
51963 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51964 if (!SWIG_IsOK(res1)) {
51965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51966 }
51967 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51968 {
51969 PyThreadState* __tstate = wxPyBeginAllowThreads();
51970 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
51971 wxPyEndAllowThreads(__tstate);
51972 if (PyErr_Occurred()) SWIG_fail;
51973 }
51974 {
51975 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51976 }
51977 return resultobj;
51978 fail:
51979 return NULL;
51980 }
51981
51982
51983 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51984 PyObject *resultobj = 0;
51985 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51986 bool arg2 ;
51987 void *argp1 = 0 ;
51988 int res1 = 0 ;
51989 bool val2 ;
51990 int ecode2 = 0 ;
51991 PyObject * obj0 = 0 ;
51992 PyObject * obj1 = 0 ;
51993 char * kwnames[] = {
51994 (char *) "self",(char *) "d", NULL
51995 };
51996
51997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
51998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51999 if (!SWIG_IsOK(res1)) {
52000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52001 }
52002 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52003 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52004 if (!SWIG_IsOK(ecode2)) {
52005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52006 }
52007 arg2 = static_cast< bool >(val2);
52008 {
52009 PyThreadState* __tstate = wxPyBeginAllowThreads();
52010 (arg1)->SetDone(arg2);
52011 wxPyEndAllowThreads(__tstate);
52012 if (PyErr_Occurred()) SWIG_fail;
52013 }
52014 resultobj = SWIG_Py_Void();
52015 return resultobj;
52016 fail:
52017 return NULL;
52018 }
52019
52020
52021 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52022 PyObject *resultobj = 0;
52023 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52024 wxRelationship result;
52025 void *argp1 = 0 ;
52026 int res1 = 0 ;
52027 PyObject *swig_obj[1] ;
52028
52029 if (!args) SWIG_fail;
52030 swig_obj[0] = args;
52031 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52032 if (!SWIG_IsOK(res1)) {
52033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52034 }
52035 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52036 {
52037 PyThreadState* __tstate = wxPyBeginAllowThreads();
52038 result = (wxRelationship)(arg1)->GetRelationship();
52039 wxPyEndAllowThreads(__tstate);
52040 if (PyErr_Occurred()) SWIG_fail;
52041 }
52042 resultobj = SWIG_From_int(static_cast< int >(result));
52043 return resultobj;
52044 fail:
52045 return NULL;
52046 }
52047
52048
52049 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52050 PyObject *resultobj = 0;
52051 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52052 wxRelationship arg2 ;
52053 void *argp1 = 0 ;
52054 int res1 = 0 ;
52055 int val2 ;
52056 int ecode2 = 0 ;
52057 PyObject * obj0 = 0 ;
52058 PyObject * obj1 = 0 ;
52059 char * kwnames[] = {
52060 (char *) "self",(char *) "r", NULL
52061 };
52062
52063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",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_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52067 }
52068 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52069 ecode2 = SWIG_AsVal_int(obj1, &val2);
52070 if (!SWIG_IsOK(ecode2)) {
52071 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52072 }
52073 arg2 = static_cast< wxRelationship >(val2);
52074 {
52075 PyThreadState* __tstate = wxPyBeginAllowThreads();
52076 (arg1)->SetRelationship(arg2);
52077 wxPyEndAllowThreads(__tstate);
52078 if (PyErr_Occurred()) SWIG_fail;
52079 }
52080 resultobj = SWIG_Py_Void();
52081 return resultobj;
52082 fail:
52083 return NULL;
52084 }
52085
52086
52087 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52088 PyObject *resultobj = 0;
52089 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52090 wxWindow *arg2 = (wxWindow *) 0 ;
52091 bool result;
52092 void *argp1 = 0 ;
52093 int res1 = 0 ;
52094 void *argp2 = 0 ;
52095 int res2 = 0 ;
52096 PyObject * obj0 = 0 ;
52097 PyObject * obj1 = 0 ;
52098 char * kwnames[] = {
52099 (char *) "self",(char *) "otherW", NULL
52100 };
52101
52102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52104 if (!SWIG_IsOK(res1)) {
52105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52106 }
52107 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52109 if (!SWIG_IsOK(res2)) {
52110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52111 }
52112 arg2 = reinterpret_cast< wxWindow * >(argp2);
52113 {
52114 PyThreadState* __tstate = wxPyBeginAllowThreads();
52115 result = (bool)(arg1)->ResetIfWin(arg2);
52116 wxPyEndAllowThreads(__tstate);
52117 if (PyErr_Occurred()) SWIG_fail;
52118 }
52119 {
52120 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52121 }
52122 return resultobj;
52123 fail:
52124 return NULL;
52125 }
52126
52127
52128 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52129 PyObject *resultobj = 0;
52130 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52131 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52132 wxWindow *arg3 = (wxWindow *) 0 ;
52133 bool result;
52134 void *argp1 = 0 ;
52135 int res1 = 0 ;
52136 void *argp2 = 0 ;
52137 int res2 = 0 ;
52138 void *argp3 = 0 ;
52139 int res3 = 0 ;
52140 PyObject * obj0 = 0 ;
52141 PyObject * obj1 = 0 ;
52142 PyObject * obj2 = 0 ;
52143 char * kwnames[] = {
52144 (char *) "self",(char *) "constraints",(char *) "win", NULL
52145 };
52146
52147 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52148 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52149 if (!SWIG_IsOK(res1)) {
52150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52151 }
52152 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52153 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52154 if (!SWIG_IsOK(res2)) {
52155 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52156 }
52157 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52158 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52159 if (!SWIG_IsOK(res3)) {
52160 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52161 }
52162 arg3 = reinterpret_cast< wxWindow * >(argp3);
52163 {
52164 PyThreadState* __tstate = wxPyBeginAllowThreads();
52165 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52166 wxPyEndAllowThreads(__tstate);
52167 if (PyErr_Occurred()) SWIG_fail;
52168 }
52169 {
52170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52171 }
52172 return resultobj;
52173 fail:
52174 return NULL;
52175 }
52176
52177
52178 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52179 PyObject *resultobj = 0;
52180 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52181 wxEdge arg2 ;
52182 wxWindow *arg3 = (wxWindow *) 0 ;
52183 wxWindow *arg4 = (wxWindow *) 0 ;
52184 int result;
52185 void *argp1 = 0 ;
52186 int res1 = 0 ;
52187 int val2 ;
52188 int ecode2 = 0 ;
52189 void *argp3 = 0 ;
52190 int res3 = 0 ;
52191 void *argp4 = 0 ;
52192 int res4 = 0 ;
52193 PyObject * obj0 = 0 ;
52194 PyObject * obj1 = 0 ;
52195 PyObject * obj2 = 0 ;
52196 PyObject * obj3 = 0 ;
52197 char * kwnames[] = {
52198 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52199 };
52200
52201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52203 if (!SWIG_IsOK(res1)) {
52204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52205 }
52206 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52207 ecode2 = SWIG_AsVal_int(obj1, &val2);
52208 if (!SWIG_IsOK(ecode2)) {
52209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52210 }
52211 arg2 = static_cast< wxEdge >(val2);
52212 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52213 if (!SWIG_IsOK(res3)) {
52214 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52215 }
52216 arg3 = reinterpret_cast< wxWindow * >(argp3);
52217 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52218 if (!SWIG_IsOK(res4)) {
52219 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52220 }
52221 arg4 = reinterpret_cast< wxWindow * >(argp4);
52222 {
52223 PyThreadState* __tstate = wxPyBeginAllowThreads();
52224 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52225 wxPyEndAllowThreads(__tstate);
52226 if (PyErr_Occurred()) SWIG_fail;
52227 }
52228 resultobj = SWIG_From_int(static_cast< int >(result));
52229 return resultobj;
52230 fail:
52231 return NULL;
52232 }
52233
52234
52235 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52236 PyObject *obj;
52237 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52238 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52239 return SWIG_Py_Void();
52240 }
52241
52242 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52243 PyObject *resultobj = 0;
52244 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52245 wxIndividualLayoutConstraint *result = 0 ;
52246 void *argp1 = 0 ;
52247 int res1 = 0 ;
52248 PyObject *swig_obj[1] ;
52249
52250 if (!args) SWIG_fail;
52251 swig_obj[0] = args;
52252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52253 if (!SWIG_IsOK(res1)) {
52254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52255 }
52256 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52257 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52258 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52259 return resultobj;
52260 fail:
52261 return NULL;
52262 }
52263
52264
52265 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52266 PyObject *resultobj = 0;
52267 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52268 wxIndividualLayoutConstraint *result = 0 ;
52269 void *argp1 = 0 ;
52270 int res1 = 0 ;
52271 PyObject *swig_obj[1] ;
52272
52273 if (!args) SWIG_fail;
52274 swig_obj[0] = args;
52275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52276 if (!SWIG_IsOK(res1)) {
52277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52278 }
52279 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52280 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52282 return resultobj;
52283 fail:
52284 return NULL;
52285 }
52286
52287
52288 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52289 PyObject *resultobj = 0;
52290 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52291 wxIndividualLayoutConstraint *result = 0 ;
52292 void *argp1 = 0 ;
52293 int res1 = 0 ;
52294 PyObject *swig_obj[1] ;
52295
52296 if (!args) SWIG_fail;
52297 swig_obj[0] = args;
52298 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52299 if (!SWIG_IsOK(res1)) {
52300 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52301 }
52302 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52303 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52305 return resultobj;
52306 fail:
52307 return NULL;
52308 }
52309
52310
52311 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52312 PyObject *resultobj = 0;
52313 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52314 wxIndividualLayoutConstraint *result = 0 ;
52315 void *argp1 = 0 ;
52316 int res1 = 0 ;
52317 PyObject *swig_obj[1] ;
52318
52319 if (!args) SWIG_fail;
52320 swig_obj[0] = args;
52321 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52322 if (!SWIG_IsOK(res1)) {
52323 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52324 }
52325 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52326 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52327 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52328 return resultobj;
52329 fail:
52330 return NULL;
52331 }
52332
52333
52334 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52335 PyObject *resultobj = 0;
52336 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52337 wxIndividualLayoutConstraint *result = 0 ;
52338 void *argp1 = 0 ;
52339 int res1 = 0 ;
52340 PyObject *swig_obj[1] ;
52341
52342 if (!args) SWIG_fail;
52343 swig_obj[0] = args;
52344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52345 if (!SWIG_IsOK(res1)) {
52346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52347 }
52348 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52349 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52350 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52351 return resultobj;
52352 fail:
52353 return NULL;
52354 }
52355
52356
52357 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52358 PyObject *resultobj = 0;
52359 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52360 wxIndividualLayoutConstraint *result = 0 ;
52361 void *argp1 = 0 ;
52362 int res1 = 0 ;
52363 PyObject *swig_obj[1] ;
52364
52365 if (!args) SWIG_fail;
52366 swig_obj[0] = args;
52367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52368 if (!SWIG_IsOK(res1)) {
52369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52370 }
52371 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52372 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52373 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52374 return resultobj;
52375 fail:
52376 return NULL;
52377 }
52378
52379
52380 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52381 PyObject *resultobj = 0;
52382 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52383 wxIndividualLayoutConstraint *result = 0 ;
52384 void *argp1 = 0 ;
52385 int res1 = 0 ;
52386 PyObject *swig_obj[1] ;
52387
52388 if (!args) SWIG_fail;
52389 swig_obj[0] = args;
52390 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52391 if (!SWIG_IsOK(res1)) {
52392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52393 }
52394 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52395 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52397 return resultobj;
52398 fail:
52399 return NULL;
52400 }
52401
52402
52403 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52404 PyObject *resultobj = 0;
52405 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52406 wxIndividualLayoutConstraint *result = 0 ;
52407 void *argp1 = 0 ;
52408 int res1 = 0 ;
52409 PyObject *swig_obj[1] ;
52410
52411 if (!args) SWIG_fail;
52412 swig_obj[0] = args;
52413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52414 if (!SWIG_IsOK(res1)) {
52415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52416 }
52417 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52418 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52419 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52420 return resultobj;
52421 fail:
52422 return NULL;
52423 }
52424
52425
52426 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52427 PyObject *resultobj = 0;
52428 wxLayoutConstraints *result = 0 ;
52429
52430 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52431 {
52432 PyThreadState* __tstate = wxPyBeginAllowThreads();
52433 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52434 wxPyEndAllowThreads(__tstate);
52435 if (PyErr_Occurred()) SWIG_fail;
52436 }
52437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52438 return resultobj;
52439 fail:
52440 return NULL;
52441 }
52442
52443
52444 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52445 PyObject *resultobj = 0;
52446 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52447 void *argp1 = 0 ;
52448 int res1 = 0 ;
52449 PyObject *swig_obj[1] ;
52450
52451 if (!args) SWIG_fail;
52452 swig_obj[0] = args;
52453 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52454 if (!SWIG_IsOK(res1)) {
52455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52456 }
52457 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52458 {
52459 PyThreadState* __tstate = wxPyBeginAllowThreads();
52460 delete arg1;
52461
52462 wxPyEndAllowThreads(__tstate);
52463 if (PyErr_Occurred()) SWIG_fail;
52464 }
52465 resultobj = SWIG_Py_Void();
52466 return resultobj;
52467 fail:
52468 return NULL;
52469 }
52470
52471
52472 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52473 PyObject *resultobj = 0;
52474 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52475 wxWindow *arg2 = (wxWindow *) 0 ;
52476 int *arg3 = (int *) 0 ;
52477 bool result;
52478 void *argp1 = 0 ;
52479 int res1 = 0 ;
52480 void *argp2 = 0 ;
52481 int res2 = 0 ;
52482 int temp3 ;
52483 int res3 = SWIG_TMPOBJ ;
52484 PyObject * obj0 = 0 ;
52485 PyObject * obj1 = 0 ;
52486 char * kwnames[] = {
52487 (char *) "self",(char *) "win", NULL
52488 };
52489
52490 arg3 = &temp3;
52491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52493 if (!SWIG_IsOK(res1)) {
52494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52495 }
52496 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52498 if (!SWIG_IsOK(res2)) {
52499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52500 }
52501 arg2 = reinterpret_cast< wxWindow * >(argp2);
52502 {
52503 PyThreadState* __tstate = wxPyBeginAllowThreads();
52504 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52505 wxPyEndAllowThreads(__tstate);
52506 if (PyErr_Occurred()) SWIG_fail;
52507 }
52508 {
52509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52510 }
52511 if (SWIG_IsTmpObj(res3)) {
52512 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52513 } else {
52514 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52516 }
52517 return resultobj;
52518 fail:
52519 return NULL;
52520 }
52521
52522
52523 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52524 PyObject *resultobj = 0;
52525 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52526 bool result;
52527 void *argp1 = 0 ;
52528 int res1 = 0 ;
52529 PyObject *swig_obj[1] ;
52530
52531 if (!args) SWIG_fail;
52532 swig_obj[0] = args;
52533 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52534 if (!SWIG_IsOK(res1)) {
52535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52536 }
52537 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52538 {
52539 PyThreadState* __tstate = wxPyBeginAllowThreads();
52540 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52541 wxPyEndAllowThreads(__tstate);
52542 if (PyErr_Occurred()) SWIG_fail;
52543 }
52544 {
52545 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52546 }
52547 return resultobj;
52548 fail:
52549 return NULL;
52550 }
52551
52552
52553 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52554 PyObject *obj;
52555 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52556 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52557 return SWIG_Py_Void();
52558 }
52559
52560 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52561 return SWIG_Python_InitShadowInstance(args);
52562 }
52563
52564 static PyMethodDef SwigMethods[] = {
52565 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52566 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52567 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52568 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52569 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52570 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52571 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52572 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52573 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52574 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52575 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52576 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52577 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52578 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52579 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52580 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52581 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52582 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52583 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52584 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52585 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52586 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52587 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52588 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52589 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52590 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52591 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52592 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52593 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52594 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52595 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52596 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52597 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52598 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52599 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52600 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52601 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52602 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52603 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52604 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52605 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52606 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52607 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52608 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52609 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52610 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52611 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52612 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52613 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52614 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52615 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52616 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52617 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52618 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52619 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52620 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52621 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52622 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52623 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52624 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52625 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52626 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52627 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52628 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52629 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52630 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52631 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52632 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52633 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52634 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52635 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52636 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52637 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52638 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52639 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52640 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52641 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52642 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52643 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52644 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52645 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52646 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52647 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52648 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52649 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52650 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52651 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52652 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52653 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52654 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52655 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52656 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52657 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52658 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52659 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52660 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52661 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52662 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52663 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52664 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52665 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52666 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52667 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52668 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52669 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52670 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52671 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52672 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52673 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52674 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52675 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52676 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52677 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52678 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52679 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52680 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52681 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52682 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52683 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52684 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52685 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52686 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52687 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52688 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52689 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52690 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52691 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52692 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52693 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52694 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52695 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52696 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52697 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52698 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52699 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52700 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52701 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52702 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52703 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52704 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52705 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52706 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52707 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52708 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52709 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52710 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52711 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52712 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52713 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52714 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52715 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52716 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52717 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52718 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52719 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52720 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52721 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52722 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52723 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52724 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52725 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52726 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52727 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52728 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52729 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52730 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52731 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52732 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52733 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52734 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52735 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52736 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52737 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52738 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52739 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52740 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52741 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52742 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52743 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52744 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52745 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52746 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52747 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52748 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52749 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52750 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52751 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52752 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52753 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52754 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52755 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52756 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52757 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52758 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52759 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52760 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52761 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52762 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
52763 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
52764 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
52765 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
52766 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
52767 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52768 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52769 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
52770 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
52771 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
52772 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52773 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52774 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52775 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
52776 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
52777 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
52778 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
52779 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52780 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
52781 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
52782 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52783 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52784 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52785 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52786 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
52787 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
52788 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
52789 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
52790 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
52791 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
52792 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
52793 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52794 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
52795 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
52796 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
52797 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
52798 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
52799 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
52800 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
52801 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
52802 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
52803 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
52804 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
52805 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52806 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
52807 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52808 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
52809 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
52810 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
52811 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
52813 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
52814 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
52815 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
52816 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
52817 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
52818 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
52819 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
52820 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
52822 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
52823 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
52824 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
52825 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
52826 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
52827 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
52828 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
52829 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
52830 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
52831 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
52832 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
52834 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
52840 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52841 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
52842 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
52843 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
52844 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52845 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
52846 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
52848 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
52852 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
52853 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
52856 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
52857 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
52858 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
52863 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
52864 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
52866 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
52868 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
52869 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
52870 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
52871 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
52872 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
52874 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
52876 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
52877 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
52878 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52879 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
52880 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
52881 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
52882 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
52883 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
52884 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
52885 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
52886 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
52887 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
52888 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
52890 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
52903 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52904 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52905 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52906 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
52907 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
52908 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52909 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
52910 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
52912 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
52913 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
52914 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
52915 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
52916 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
52917 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
52918 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
52919 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
52920 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
52921 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
52922 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
52923 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
52924 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
52925 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
52926 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
52927 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
52928 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
52929 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
52930 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
52931 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
52932 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
52933 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
52934 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
52935 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
52936 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
52937 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
52938 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
52939 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
52940 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
52941 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
52942 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
52943 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
52944 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
52945 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
52946 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
52947 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
52948 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
52950 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
52951 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
52952 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
52953 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52954 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52955 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
52956 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
52957 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52958 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
52960 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
52961 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
52962 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52963 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
52964 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
52965 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
52966 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
52967 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
52968 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
52969 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
52970 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
52971 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
52972 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
52973 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
52974 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
52975 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
52976 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
52977 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
52978 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
52979 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
52980 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
52982 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
52983 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
52985 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
52986 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
52987 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
52989 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
52990 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
52991 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
52992 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
52993 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
52994 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
52995 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
52996 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
52997 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
52999 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53001 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53002 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53003 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53004 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53005 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53006 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53007 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53008 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53009 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53010 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53011 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53012 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53013 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53014 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53015 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53018 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53019 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53021 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53022 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53024 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53025 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53026 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53027 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53028 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53029 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53030 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53034 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53035 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53036 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53037 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53038 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53039 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53040 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53041 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53042 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53043 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53044 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53045 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53046 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53047 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53048 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53049 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53050 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53051 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53052 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53053 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53054 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53055 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53056 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53057 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53058 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53059 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53060 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53061 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53062 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53063 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53064 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53065 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53066 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53067 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53068 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53069 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53070 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53071 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53072 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53073 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53074 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53075 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53076 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53077 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53078 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53079 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53080 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53081 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53082 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53083 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53084 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53085 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53086 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53087 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53088 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53089 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53090 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53091 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53092 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53093 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53095 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53096 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53097 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53098 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53100 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53101 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53102 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53103 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53104 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53105 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53106 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53107 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53108 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53109 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53110 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53111 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53112 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53113 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53114 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53115 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53116 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53117 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53118 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53119 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53120 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53121 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53122 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53123 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53124 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53125 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53126 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53127 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53128 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53129 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53130 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53131 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53132 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53133 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53134 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53135 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53136 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53138 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53139 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53142 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53143 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53144 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53145 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53146 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53147 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53149 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53150 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53152 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53153 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53154 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53155 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53156 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53157 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53158 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53159 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53160 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53161 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53162 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53163 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53164 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53165 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53166 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53167 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53168 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53169 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53170 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53171 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53172 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53173 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53174 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53175 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53176 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53177 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53178 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53179 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53180 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53181 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53182 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53183 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53184 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53185 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53186 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53188 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53189 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53190 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53191 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53193 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53194 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53195 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53198 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53199 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53200 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53202 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53203 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53204 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53205 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53206 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53207 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53208 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53209 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53210 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53211 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53212 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53213 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53214 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53215 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53216 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53217 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53218 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53219 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53220 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53221 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53223 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53224 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53225 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53226 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53227 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53228 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53229 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53230 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53231 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53232 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53233 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53234 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53235 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53237 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53238 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53239 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53240 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53241 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53242 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53243 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53244 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53245 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53246 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53247 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53248 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53249 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53250 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53251 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53252 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53253 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53254 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53256 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53257 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53258 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53259 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53260 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53261 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53263 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53264 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53266 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53267 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53268 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53270 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53271 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53272 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53273 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53274 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53275 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53276 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53277 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53278 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53279 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53280 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53281 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53282 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53283 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53284 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53285 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53286 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53287 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53288 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53289 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53290 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53291 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53292 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53293 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53294 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53295 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53296 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53297 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53298 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53299 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53300 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53301 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53302 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53303 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53304 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53305 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53306 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53307 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53308 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53309 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53310 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53311 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53312 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53313 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53314 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53315 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53316 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53317 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53318 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53319 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53320 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53321 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53322 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53323 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53324 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53325 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53326 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53327 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53328 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53329 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53330 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53331 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53333 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53334 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53335 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53336 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53337 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53338 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53339 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53340 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53341 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53342 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53343 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53344 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53345 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53346 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53348 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53349 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53350 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53351 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53352 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53353 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53354 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53355 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53356 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53357 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53358 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53359 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53360 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53361 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53362 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53363 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53364 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53365 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53366 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53367 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53368 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53369 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53370 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53371 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53372 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53373 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53374 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53375 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53376 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53377 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53378 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53380 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53381 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53382 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53383 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53384 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53385 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53386 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53387 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53388 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53389 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53391 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53392 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53393 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53394 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53395 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53396 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53397 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53398 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53399 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53400 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53401 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53402 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53403 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53405 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53406 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53407 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53408 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53409 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53410 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53411 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53412 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53413 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53414 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53415 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53416 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53418 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53419 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53421 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53422 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53423 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53424 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53425 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53426 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53427 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53428 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53430 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53431 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53432 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53433 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53434 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53435 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53436 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53437 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53438 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53439 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53440 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53441 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53442 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53443 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53444 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53445 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53446 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53447 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53448 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53449 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53450 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53451 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53452 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53453 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53454 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53455 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53456 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53457 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53458 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53459 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53461 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53462 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53463 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53464 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53465 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53467 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53468 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53469 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53470 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53471 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53472 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53473 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53474 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53475 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53476 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53477 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53478 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53479 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53480 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53481 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53482 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53483 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53484 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53485 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53486 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53487 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53488 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53489 { (char *)"Window_GetDefaultItem", (PyCFunction)_wrap_Window_GetDefaultItem, METH_O, NULL},
53490 { (char *)"Window_SetDefaultItem", (PyCFunction) _wrap_Window_SetDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"Window_SetTmpDefaultItem", (PyCFunction) _wrap_Window_SetTmpDefaultItem, METH_VARARGS | METH_KEYWORDS, NULL},
53492 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53493 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53494 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53495 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53496 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53497 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53498 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53499 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53500 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53503 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53505 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53506 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53508 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53509 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53510 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53512 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53513 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53514 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53515 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53516 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53518 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53519 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53520 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53522 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53524 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53526 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53527 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53528 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53529 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53530 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53531 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53532 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53534 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53535 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53536 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53537 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53538 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53539 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53540 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53541 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53542 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53544 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53546 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53547 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53548 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53549 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53550 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53551 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53552 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53553 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53555 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53556 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53557 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53558 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53560 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53561 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53562 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53563 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53564 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53565 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53566 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53567 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53569 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53571 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53573 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53574 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53575 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53577 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53578 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53579 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53580 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53581 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53582 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53583 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53584 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53590 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53591 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53592 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53593 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53594 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53595 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53596 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53598 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53599 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53600 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53601 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53603 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53604 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53605 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53606 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53607 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53608 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53609 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53610 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53611 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53612 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53613 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53614 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53615 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53616 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53617 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53618 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53620 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53621 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53622 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53623 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53624 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53625 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53626 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53627 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53628 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53629 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53630 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53631 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53632 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53633 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53634 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53635 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53636 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53637 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53638 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53639 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53640 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53641 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53642 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53644 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53647 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53648 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53649 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53651 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53653 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53654 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53655 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53657 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53658 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53662 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53665 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53666 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53668 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53669 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53673 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53674 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53675 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53676 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53677 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53678 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53679 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53680 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53681 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53682 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53683 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53684 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53685 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53686 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53687 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53688 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53689 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53690 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53691 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53692 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53693 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53694 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53697 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53699 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53700 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53703 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53704 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53705 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53706 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53709 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53710 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53711 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53713 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53715 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53716 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53717 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53719 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53721 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53722 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53723 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53725 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53726 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53727 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53728 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53729 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53730 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53731 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53732 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53733 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53735 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53736 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53737 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53738 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53739 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53741 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53743 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53745 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53746 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53748 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53749 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53751 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53752 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53753 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53754 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53755 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53756 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53757 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53758 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
53761 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
53763 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
53764 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
53765 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
53767 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
53768 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
53769 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
53770 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
53771 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
53773 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
53774 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53775 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
53776 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
53777 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53778 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
53779 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
53781 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53783 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
53785 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
53786 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
53788 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53789 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
53790 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53791 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
53792 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
53794 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
53795 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
53796 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
53797 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
53798 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
53799 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53800 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53802 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
53803 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
53804 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
53805 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
53806 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
53808 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
53809 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
53813 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
53814 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
53815 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
53816 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
53817 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
53818 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
53820 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
53822 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
53824 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
53825 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
53827 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
53829 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53830 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53831 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
53832 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
53833 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
53834 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
53836 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
53837 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
53838 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53840 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53842 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
53845 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53847 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53848 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53851 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
53852 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
53853 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
53854 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
53855 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
53856 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
53857 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
53862 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
53863 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
53864 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
53866 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
53867 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
53868 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
53869 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53870 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
53871 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
53872 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53873 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
53874 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
53876 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
53877 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
53879 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
53880 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
53881 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
53887 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
53888 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
53889 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
53890 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
53891 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
53892 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
53895 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
53899 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
53901 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
53902 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
53903 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
53904 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
53905 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
53906 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
53907 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
53908 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
53912 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
53913 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
53914 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
53915 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
53916 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
53917 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
53918 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
53920 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
53921 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
53922 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
53924 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53925 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53927 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
53928 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
53929 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
53930 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
53932 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
53933 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
53934 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
53938 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
53940 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
53941 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
53942 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
53943 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
53944 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
53948 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
53949 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
53954 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
53955 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
53957 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
53958 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
53960 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53962 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
53963 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
53964 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
53965 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
53966 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
53967 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
53968 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
53969 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53970 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53971 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
53973 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
53974 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
53975 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53976 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
53979 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
53980 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
53982 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
53984 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
53985 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
53986 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
53987 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
53989 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
53990 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
53992 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
53993 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
53994 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
53995 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
53997 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
53999 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54002 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54003 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54004 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54005 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54006 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54007 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54008 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54009 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54010 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54011 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54012 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54014 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54015 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54016 { NULL, NULL, 0, NULL }
54017 };
54018
54019
54020 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54021
54022 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54023 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54024 }
54025 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54026 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54027 }
54028 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54029 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54030 }
54031 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54032 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54033 }
54034 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54035 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54036 }
54037 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54038 return (void *)((wxSizer *) ((wxGridSizer *) x));
54039 }
54040 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54041 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54042 }
54043 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54044 return (void *)((wxSizer *) ((wxPySizer *) x));
54045 }
54046 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54047 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54048 }
54049 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54050 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54051 }
54052 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54053 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54054 }
54055 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54056 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54057 }
54058 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54059 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54060 }
54061 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54062 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54063 }
54064 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54065 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54066 }
54067 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54068 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54069 }
54070 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54071 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54072 }
54073 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54074 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54075 }
54076 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54077 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54078 }
54079 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54080 return (void *)((wxEvent *) ((wxPyEvent *) x));
54081 }
54082 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54083 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54084 }
54085 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54086 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54087 }
54088 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54089 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54090 }
54091 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54092 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54093 }
54094 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54095 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54096 }
54097 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54098 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54099 }
54100 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54101 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54102 }
54103 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54104 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54105 }
54106 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54107 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54108 }
54109 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54110 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54111 }
54112 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54113 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54114 }
54115 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54116 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54117 }
54118 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54119 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54120 }
54121 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54122 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54123 }
54124 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54125 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54126 }
54127 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54128 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54129 }
54130 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54131 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54132 }
54133 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54134 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54135 }
54136 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54137 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54138 }
54139 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54140 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54141 }
54142 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54143 return (void *)((wxEvent *) ((wxShowEvent *) x));
54144 }
54145 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54146 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54147 }
54148 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54149 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54150 }
54151 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54152 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54153 }
54154 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54155 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54156 }
54157 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54158 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54159 }
54160 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54161 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54162 }
54163 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54164 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54165 }
54166 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54167 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54168 }
54169 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54170 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54171 }
54172 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54173 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54174 }
54175 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54176 return (void *)((wxControl *) ((wxControlWithItems *) x));
54177 }
54178 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54179 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54180 }
54181 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54182 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54183 }
54184 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54185 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54186 }
54187 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54188 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54189 }
54190 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54191 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54192 }
54193 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54194 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54195 }
54196 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54197 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54198 }
54199 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54200 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54201 }
54202 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54203 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54204 }
54205 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54206 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54207 }
54208 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54209 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54210 }
54211 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54212 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54213 }
54214 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54215 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54216 }
54217 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54218 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54219 }
54220 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54221 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54222 }
54223 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54224 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54225 }
54226 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54227 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54228 }
54229 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54230 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54231 }
54232 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54233 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54234 }
54235 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54236 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54237 }
54238 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54239 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54240 }
54241 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54242 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54243 }
54244 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54245 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54246 }
54247 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54248 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54249 }
54250 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54251 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54252 }
54253 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54254 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54255 }
54256 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54257 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54258 }
54259 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54260 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54261 }
54262 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54263 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54264 }
54265 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54266 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54267 }
54268 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54269 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54270 }
54271 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54272 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54273 }
54274 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54275 return (void *)((wxObject *) ((wxSizerItem *) x));
54276 }
54277 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54278 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54279 }
54280 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54281 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54282 }
54283 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54284 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54285 }
54286 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54287 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54288 }
54289 static void *_p_wxSizerTo_p_wxObject(void *x) {
54290 return (void *)((wxObject *) ((wxSizer *) x));
54291 }
54292 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54293 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54294 }
54295 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54296 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54297 }
54298 static void *_p_wxEventTo_p_wxObject(void *x) {
54299 return (void *)((wxObject *) ((wxEvent *) x));
54300 }
54301 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54302 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54303 }
54304 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54305 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54306 }
54307 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54308 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54309 }
54310 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54311 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54312 }
54313 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54314 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54315 }
54316 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54317 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54318 }
54319 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54320 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54321 }
54322 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54323 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54324 }
54325 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54326 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54327 }
54328 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54329 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54330 }
54331 static void *_p_wxControlTo_p_wxObject(void *x) {
54332 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54333 }
54334 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54335 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54336 }
54337 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54338 return (void *)((wxObject *) ((wxFSFile *) x));
54339 }
54340 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54341 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54342 }
54343 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54344 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54345 }
54346 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54347 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54348 }
54349 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54350 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54351 }
54352 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54353 return (void *)((wxObject *) ((wxMenuItem *) x));
54354 }
54355 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54356 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54357 }
54358 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54359 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54360 }
54361 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54362 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54363 }
54364 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54365 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54366 }
54367 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54368 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54369 }
54370 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54371 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54372 }
54373 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54374 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54375 }
54376 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54377 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54378 }
54379 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54380 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54381 }
54382 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54383 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54384 }
54385 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54386 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54387 }
54388 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54389 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54390 }
54391 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54392 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54393 }
54394 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54395 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54396 }
54397 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54398 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54399 }
54400 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54401 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54402 }
54403 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54404 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54405 }
54406 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54407 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54408 }
54409 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54410 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54411 }
54412 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54413 return (void *)((wxObject *) ((wxImageHandler *) x));
54414 }
54415 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54416 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54417 }
54418 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54419 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54420 }
54421 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54422 return (void *)((wxObject *) ((wxEvtHandler *) x));
54423 }
54424 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54425 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54426 }
54427 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54428 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54429 }
54430 static void *_p_wxImageTo_p_wxObject(void *x) {
54431 return (void *)((wxObject *) ((wxImage *) x));
54432 }
54433 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54434 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54435 }
54436 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54437 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54438 }
54439 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54440 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54441 }
54442 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54443 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54444 }
54445 static void *_p_wxWindowTo_p_wxObject(void *x) {
54446 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54447 }
54448 static void *_p_wxMenuTo_p_wxObject(void *x) {
54449 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54450 }
54451 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54452 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54453 }
54454 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54455 return (void *)((wxObject *) ((wxFileSystem *) x));
54456 }
54457 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54458 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54459 }
54460 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54461 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54462 }
54463 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54464 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54465 }
54466 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54467 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54468 }
54469 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54470 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54471 }
54472 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54473 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54474 }
54475 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54476 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54477 }
54478 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54479 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54480 }
54481 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54482 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54483 }
54484 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54485 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54486 }
54487 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54488 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54489 }
54490 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54491 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54492 }
54493 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54494 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54495 }
54496 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54497 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54498 }
54499 static void *_p_wxControlTo_p_wxWindow(void *x) {
54500 return (void *)((wxWindow *) ((wxControl *) x));
54501 }
54502 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54503 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54504 }
54505 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54506 return (void *)((wxWindow *) ((wxMenuBar *) x));
54507 }
54508 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54509 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54510 }
54511 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54512 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54513 }
54514 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54515 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54516 }
54517 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54518 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54519 }
54520 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54521 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54522 }
54523 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54524 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54525 }
54526 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54527 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54528 }
54529 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54530 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54531 }
54532 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54533 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54534 }
54535 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54536 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54537 }
54538 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54539 return (void *)((wxValidator *) ((wxPyValidator *) x));
54540 }
54541 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54542 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54543 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};
54544 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54545 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54546 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54547 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54548 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54549 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54550 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54551 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54552 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54553 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54554 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54555 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54556 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54557 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54558 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54559 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54560 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54561 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54562 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54563 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54564 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54565 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54566 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54567 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54568 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54569 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54570 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54571 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54572 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54573 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54574 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54575 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54576 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54577 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54578 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54579 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54580 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54581 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54582 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54583 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54584 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54585 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54586 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54587 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54588 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54589 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54590 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54591 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54592 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54593 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54594 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54595 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54596 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54597 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54598 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54599 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54600 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54601 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54602 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54603 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54604 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54605 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54606 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54607 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54608 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54609 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54610 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54611 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54612 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54613 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54614 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54615 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54616 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54617 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54618 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54619 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54620 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54621 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54622 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54623 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54624 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54625 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54626 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54627 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54628 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54629 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54630 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54631 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54632 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54633 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54634 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54635 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54636 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54637 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54638 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54639 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54640 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54641 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54642 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54643 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54644 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54645 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54646 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54647 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54648 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54649 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54650 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54651 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54652 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54653 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54654 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54655 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54656 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54657 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54658 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54659 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54660 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54661 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54662 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54663 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54664 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54665 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54666 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54667 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54668 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54669 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54670 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54671
54672 static swig_type_info *swig_type_initial[] = {
54673 &_swigt__p_buffer,
54674 &_swigt__p_char,
54675 &_swigt__p_form_ops_t,
54676 &_swigt__p_int,
54677 &_swigt__p_long,
54678 &_swigt__p_unsigned_char,
54679 &_swigt__p_unsigned_int,
54680 &_swigt__p_unsigned_long,
54681 &_swigt__p_wxANIHandler,
54682 &_swigt__p_wxAcceleratorEntry,
54683 &_swigt__p_wxAcceleratorTable,
54684 &_swigt__p_wxActivateEvent,
54685 &_swigt__p_wxAppTraits,
54686 &_swigt__p_wxArrayString,
54687 &_swigt__p_wxBMPHandler,
54688 &_swigt__p_wxBitmap,
54689 &_swigt__p_wxBoxSizer,
54690 &_swigt__p_wxButton,
54691 &_swigt__p_wxCURHandler,
54692 &_swigt__p_wxCaret,
54693 &_swigt__p_wxChildFocusEvent,
54694 &_swigt__p_wxClipboardTextEvent,
54695 &_swigt__p_wxCloseEvent,
54696 &_swigt__p_wxColour,
54697 &_swigt__p_wxCommandEvent,
54698 &_swigt__p_wxContextMenuEvent,
54699 &_swigt__p_wxControl,
54700 &_swigt__p_wxControlWithItems,
54701 &_swigt__p_wxCursor,
54702 &_swigt__p_wxDC,
54703 &_swigt__p_wxDateEvent,
54704 &_swigt__p_wxDateTime,
54705 &_swigt__p_wxDisplayChangedEvent,
54706 &_swigt__p_wxDropFilesEvent,
54707 &_swigt__p_wxDuplexMode,
54708 &_swigt__p_wxEraseEvent,
54709 &_swigt__p_wxEvent,
54710 &_swigt__p_wxEventLoop,
54711 &_swigt__p_wxEventLoopActivator,
54712 &_swigt__p_wxEvtHandler,
54713 &_swigt__p_wxFSFile,
54714 &_swigt__p_wxFileSystem,
54715 &_swigt__p_wxFileSystemHandler,
54716 &_swigt__p_wxFlexGridSizer,
54717 &_swigt__p_wxFocusEvent,
54718 &_swigt__p_wxFont,
54719 &_swigt__p_wxFrame,
54720 &_swigt__p_wxGBPosition,
54721 &_swigt__p_wxGBSizerItem,
54722 &_swigt__p_wxGBSpan,
54723 &_swigt__p_wxGIFHandler,
54724 &_swigt__p_wxGridBagSizer,
54725 &_swigt__p_wxGridSizer,
54726 &_swigt__p_wxICOHandler,
54727 &_swigt__p_wxIconizeEvent,
54728 &_swigt__p_wxIdleEvent,
54729 &_swigt__p_wxImage,
54730 &_swigt__p_wxImageHandler,
54731 &_swigt__p_wxImageHistogram,
54732 &_swigt__p_wxImage_HSVValue,
54733 &_swigt__p_wxImage_RGBValue,
54734 &_swigt__p_wxIndividualLayoutConstraint,
54735 &_swigt__p_wxInitDialogEvent,
54736 &_swigt__p_wxInputStream,
54737 &_swigt__p_wxInternetFSHandler,
54738 &_swigt__p_wxItemContainer,
54739 &_swigt__p_wxJPEGHandler,
54740 &_swigt__p_wxKeyEvent,
54741 &_swigt__p_wxLayoutConstraints,
54742 &_swigt__p_wxMaximizeEvent,
54743 &_swigt__p_wxMemoryFSHandler,
54744 &_swigt__p_wxMenu,
54745 &_swigt__p_wxMenuBar,
54746 &_swigt__p_wxMenuBarBase,
54747 &_swigt__p_wxMenuEvent,
54748 &_swigt__p_wxMenuItem,
54749 &_swigt__p_wxMouseCaptureChangedEvent,
54750 &_swigt__p_wxMouseEvent,
54751 &_swigt__p_wxMoveEvent,
54752 &_swigt__p_wxNavigationKeyEvent,
54753 &_swigt__p_wxNcPaintEvent,
54754 &_swigt__p_wxNotifyEvent,
54755 &_swigt__p_wxObject,
54756 &_swigt__p_wxOutputStream,
54757 &_swigt__p_wxPCXHandler,
54758 &_swigt__p_wxPNGHandler,
54759 &_swigt__p_wxPNMHandler,
54760 &_swigt__p_wxPaintEvent,
54761 &_swigt__p_wxPaletteChangedEvent,
54762 &_swigt__p_wxPaperSize,
54763 &_swigt__p_wxPoint,
54764 &_swigt__p_wxPoint2D,
54765 &_swigt__p_wxPropagateOnce,
54766 &_swigt__p_wxPropagationDisabler,
54767 &_swigt__p_wxPyApp,
54768 &_swigt__p_wxPyCommandEvent,
54769 &_swigt__p_wxPyDropTarget,
54770 &_swigt__p_wxPyEvent,
54771 &_swigt__p_wxPyFileSystemHandler,
54772 &_swigt__p_wxPyImageHandler,
54773 &_swigt__p_wxPyInputStream,
54774 &_swigt__p_wxPySizer,
54775 &_swigt__p_wxPyValidator,
54776 &_swigt__p_wxQuantize,
54777 &_swigt__p_wxQueryNewPaletteEvent,
54778 &_swigt__p_wxRealPoint,
54779 &_swigt__p_wxRect,
54780 &_swigt__p_wxRegion,
54781 &_swigt__p_wxScrollEvent,
54782 &_swigt__p_wxScrollWinEvent,
54783 &_swigt__p_wxSetCursorEvent,
54784 &_swigt__p_wxShowEvent,
54785 &_swigt__p_wxSize,
54786 &_swigt__p_wxSizeEvent,
54787 &_swigt__p_wxSizer,
54788 &_swigt__p_wxSizerItem,
54789 &_swigt__p_wxStaticBox,
54790 &_swigt__p_wxStaticBoxSizer,
54791 &_swigt__p_wxStdDialogButtonSizer,
54792 &_swigt__p_wxSysColourChangedEvent,
54793 &_swigt__p_wxTIFFHandler,
54794 &_swigt__p_wxToolTip,
54795 &_swigt__p_wxUpdateUIEvent,
54796 &_swigt__p_wxValidator,
54797 &_swigt__p_wxVisualAttributes,
54798 &_swigt__p_wxWindow,
54799 &_swigt__p_wxWindowCreateEvent,
54800 &_swigt__p_wxWindowDestroyEvent,
54801 &_swigt__p_wxXPMHandler,
54802 &_swigt__p_wxZipFSHandler,
54803 };
54804
54805 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
54806 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
54807 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
54808 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
54809 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
54810 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
54811 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
54812 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
54813 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
54814 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
54815 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
54816 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
54817 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
54818 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
54819 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}};
54820 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
54821 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}};
54822 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
54823 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}};
54824 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
54825 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54826 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
54827 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
54828 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
54829 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}};
54830 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54831 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}};
54832 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
54833 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
54834 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
54835 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
54836 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
54837 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54838 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
54839 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
54840 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
54841 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}};
54842 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
54843 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
54844 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}};
54845 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
54846 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
54847 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}};
54848 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}};
54849 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
54850 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
54851 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
54852 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
54853 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
54854 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
54855 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
54856 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
54857 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}};
54858 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}};
54859 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54860 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
54861 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
54862 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}};
54863 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
54864 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
54865 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
54866 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
54867 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
54868 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
54869 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54870 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}};
54871 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
54872 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54873 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
54874 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54875 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54876 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
54877 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
54878 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
54879 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
54880 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
54881 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54882 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
54883 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
54884 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
54885 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54886 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
54887 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}};
54888 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
54889 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
54890 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
54891 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
54892 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
54893 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54894 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
54895 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
54896 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
54897 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
54898 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
54899 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
54900 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
54901 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
54902 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
54903 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
54904 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
54905 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
54906 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
54907 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
54908 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
54909 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
54910 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
54911 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
54912 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
54913 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
54914 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
54915 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
54916 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
54917 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
54918 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
54919 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}};
54920 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}};
54921 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
54922 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
54923 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
54924 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
54925 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
54926 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
54927 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
54928 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}};
54929 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
54930 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}};
54931 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
54932 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
54933 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
54934 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
54935
54936 static swig_cast_info *swig_cast_initial[] = {
54937 _swigc__p_buffer,
54938 _swigc__p_char,
54939 _swigc__p_form_ops_t,
54940 _swigc__p_int,
54941 _swigc__p_long,
54942 _swigc__p_unsigned_char,
54943 _swigc__p_unsigned_int,
54944 _swigc__p_unsigned_long,
54945 _swigc__p_wxANIHandler,
54946 _swigc__p_wxAcceleratorEntry,
54947 _swigc__p_wxAcceleratorTable,
54948 _swigc__p_wxActivateEvent,
54949 _swigc__p_wxAppTraits,
54950 _swigc__p_wxArrayString,
54951 _swigc__p_wxBMPHandler,
54952 _swigc__p_wxBitmap,
54953 _swigc__p_wxBoxSizer,
54954 _swigc__p_wxButton,
54955 _swigc__p_wxCURHandler,
54956 _swigc__p_wxCaret,
54957 _swigc__p_wxChildFocusEvent,
54958 _swigc__p_wxClipboardTextEvent,
54959 _swigc__p_wxCloseEvent,
54960 _swigc__p_wxColour,
54961 _swigc__p_wxCommandEvent,
54962 _swigc__p_wxContextMenuEvent,
54963 _swigc__p_wxControl,
54964 _swigc__p_wxControlWithItems,
54965 _swigc__p_wxCursor,
54966 _swigc__p_wxDC,
54967 _swigc__p_wxDateEvent,
54968 _swigc__p_wxDateTime,
54969 _swigc__p_wxDisplayChangedEvent,
54970 _swigc__p_wxDropFilesEvent,
54971 _swigc__p_wxDuplexMode,
54972 _swigc__p_wxEraseEvent,
54973 _swigc__p_wxEvent,
54974 _swigc__p_wxEventLoop,
54975 _swigc__p_wxEventLoopActivator,
54976 _swigc__p_wxEvtHandler,
54977 _swigc__p_wxFSFile,
54978 _swigc__p_wxFileSystem,
54979 _swigc__p_wxFileSystemHandler,
54980 _swigc__p_wxFlexGridSizer,
54981 _swigc__p_wxFocusEvent,
54982 _swigc__p_wxFont,
54983 _swigc__p_wxFrame,
54984 _swigc__p_wxGBPosition,
54985 _swigc__p_wxGBSizerItem,
54986 _swigc__p_wxGBSpan,
54987 _swigc__p_wxGIFHandler,
54988 _swigc__p_wxGridBagSizer,
54989 _swigc__p_wxGridSizer,
54990 _swigc__p_wxICOHandler,
54991 _swigc__p_wxIconizeEvent,
54992 _swigc__p_wxIdleEvent,
54993 _swigc__p_wxImage,
54994 _swigc__p_wxImageHandler,
54995 _swigc__p_wxImageHistogram,
54996 _swigc__p_wxImage_HSVValue,
54997 _swigc__p_wxImage_RGBValue,
54998 _swigc__p_wxIndividualLayoutConstraint,
54999 _swigc__p_wxInitDialogEvent,
55000 _swigc__p_wxInputStream,
55001 _swigc__p_wxInternetFSHandler,
55002 _swigc__p_wxItemContainer,
55003 _swigc__p_wxJPEGHandler,
55004 _swigc__p_wxKeyEvent,
55005 _swigc__p_wxLayoutConstraints,
55006 _swigc__p_wxMaximizeEvent,
55007 _swigc__p_wxMemoryFSHandler,
55008 _swigc__p_wxMenu,
55009 _swigc__p_wxMenuBar,
55010 _swigc__p_wxMenuBarBase,
55011 _swigc__p_wxMenuEvent,
55012 _swigc__p_wxMenuItem,
55013 _swigc__p_wxMouseCaptureChangedEvent,
55014 _swigc__p_wxMouseEvent,
55015 _swigc__p_wxMoveEvent,
55016 _swigc__p_wxNavigationKeyEvent,
55017 _swigc__p_wxNcPaintEvent,
55018 _swigc__p_wxNotifyEvent,
55019 _swigc__p_wxObject,
55020 _swigc__p_wxOutputStream,
55021 _swigc__p_wxPCXHandler,
55022 _swigc__p_wxPNGHandler,
55023 _swigc__p_wxPNMHandler,
55024 _swigc__p_wxPaintEvent,
55025 _swigc__p_wxPaletteChangedEvent,
55026 _swigc__p_wxPaperSize,
55027 _swigc__p_wxPoint,
55028 _swigc__p_wxPoint2D,
55029 _swigc__p_wxPropagateOnce,
55030 _swigc__p_wxPropagationDisabler,
55031 _swigc__p_wxPyApp,
55032 _swigc__p_wxPyCommandEvent,
55033 _swigc__p_wxPyDropTarget,
55034 _swigc__p_wxPyEvent,
55035 _swigc__p_wxPyFileSystemHandler,
55036 _swigc__p_wxPyImageHandler,
55037 _swigc__p_wxPyInputStream,
55038 _swigc__p_wxPySizer,
55039 _swigc__p_wxPyValidator,
55040 _swigc__p_wxQuantize,
55041 _swigc__p_wxQueryNewPaletteEvent,
55042 _swigc__p_wxRealPoint,
55043 _swigc__p_wxRect,
55044 _swigc__p_wxRegion,
55045 _swigc__p_wxScrollEvent,
55046 _swigc__p_wxScrollWinEvent,
55047 _swigc__p_wxSetCursorEvent,
55048 _swigc__p_wxShowEvent,
55049 _swigc__p_wxSize,
55050 _swigc__p_wxSizeEvent,
55051 _swigc__p_wxSizer,
55052 _swigc__p_wxSizerItem,
55053 _swigc__p_wxStaticBox,
55054 _swigc__p_wxStaticBoxSizer,
55055 _swigc__p_wxStdDialogButtonSizer,
55056 _swigc__p_wxSysColourChangedEvent,
55057 _swigc__p_wxTIFFHandler,
55058 _swigc__p_wxToolTip,
55059 _swigc__p_wxUpdateUIEvent,
55060 _swigc__p_wxValidator,
55061 _swigc__p_wxVisualAttributes,
55062 _swigc__p_wxWindow,
55063 _swigc__p_wxWindowCreateEvent,
55064 _swigc__p_wxWindowDestroyEvent,
55065 _swigc__p_wxXPMHandler,
55066 _swigc__p_wxZipFSHandler,
55067 };
55068
55069
55070 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55071
55072 static swig_const_info swig_const_table[] = {
55073 {0, 0, 0, 0.0, 0, 0}};
55074
55075 #ifdef __cplusplus
55076 }
55077 #endif
55078 /* -----------------------------------------------------------------------------
55079 * Type initialization:
55080 * This problem is tough by the requirement that no dynamic
55081 * memory is used. Also, since swig_type_info structures store pointers to
55082 * swig_cast_info structures and swig_cast_info structures store pointers back
55083 * to swig_type_info structures, we need some lookup code at initialization.
55084 * The idea is that swig generates all the structures that are needed.
55085 * The runtime then collects these partially filled structures.
55086 * The SWIG_InitializeModule function takes these initial arrays out of
55087 * swig_module, and does all the lookup, filling in the swig_module.types
55088 * array with the correct data and linking the correct swig_cast_info
55089 * structures together.
55090 *
55091 * The generated swig_type_info structures are assigned staticly to an initial
55092 * array. We just loop though that array, and handle each type individually.
55093 * First we lookup if this type has been already loaded, and if so, use the
55094 * loaded structure instead of the generated one. Then we have to fill in the
55095 * cast linked list. The cast data is initially stored in something like a
55096 * two-dimensional array. Each row corresponds to a type (there are the same
55097 * number of rows as there are in the swig_type_initial array). Each entry in
55098 * a column is one of the swig_cast_info structures for that type.
55099 * The cast_initial array is actually an array of arrays, because each row has
55100 * a variable number of columns. So to actually build the cast linked list,
55101 * we find the array of casts associated with the type, and loop through it
55102 * adding the casts to the list. The one last trick we need to do is making
55103 * sure the type pointer in the swig_cast_info struct is correct.
55104 *
55105 * First off, we lookup the cast->type name to see if it is already loaded.
55106 * There are three cases to handle:
55107 * 1) If the cast->type has already been loaded AND the type we are adding
55108 * casting info to has not been loaded (it is in this module), THEN we
55109 * replace the cast->type pointer with the type pointer that has already
55110 * been loaded.
55111 * 2) If BOTH types (the one we are adding casting info to, and the
55112 * cast->type) are loaded, THEN the cast info has already been loaded by
55113 * the previous module so we just ignore it.
55114 * 3) Finally, if cast->type has not already been loaded, then we add that
55115 * swig_cast_info to the linked list (because the cast->type) pointer will
55116 * be correct.
55117 * ----------------------------------------------------------------------------- */
55118
55119 #ifdef __cplusplus
55120 extern "C" {
55121 #if 0
55122 } /* c-mode */
55123 #endif
55124 #endif
55125
55126 #if 0
55127 #define SWIGRUNTIME_DEBUG
55128 #endif
55129
55130 SWIGRUNTIME void
55131 SWIG_InitializeModule(void *clientdata) {
55132 size_t i;
55133 swig_module_info *module_head;
55134 static int init_run = 0;
55135
55136 clientdata = clientdata;
55137
55138 if (init_run) return;
55139 init_run = 1;
55140
55141 /* Initialize the swig_module */
55142 swig_module.type_initial = swig_type_initial;
55143 swig_module.cast_initial = swig_cast_initial;
55144
55145 /* Try and load any already created modules */
55146 module_head = SWIG_GetModule(clientdata);
55147 if (module_head) {
55148 swig_module.next = module_head->next;
55149 module_head->next = &swig_module;
55150 } else {
55151 /* This is the first module loaded */
55152 swig_module.next = &swig_module;
55153 SWIG_SetModule(clientdata, &swig_module);
55154 }
55155
55156 /* Now work on filling in swig_module.types */
55157 #ifdef SWIGRUNTIME_DEBUG
55158 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55159 #endif
55160 for (i = 0; i < swig_module.size; ++i) {
55161 swig_type_info *type = 0;
55162 swig_type_info *ret;
55163 swig_cast_info *cast;
55164
55165 #ifdef SWIGRUNTIME_DEBUG
55166 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55167 #endif
55168
55169 /* if there is another module already loaded */
55170 if (swig_module.next != &swig_module) {
55171 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55172 }
55173 if (type) {
55174 /* Overwrite clientdata field */
55175 #ifdef SWIGRUNTIME_DEBUG
55176 printf("SWIG_InitializeModule: found type %s\n", type->name);
55177 #endif
55178 if (swig_module.type_initial[i]->clientdata) {
55179 type->clientdata = swig_module.type_initial[i]->clientdata;
55180 #ifdef SWIGRUNTIME_DEBUG
55181 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55182 #endif
55183 }
55184 } else {
55185 type = swig_module.type_initial[i];
55186 }
55187
55188 /* Insert casting types */
55189 cast = swig_module.cast_initial[i];
55190 while (cast->type) {
55191 /* Don't need to add information already in the list */
55192 ret = 0;
55193 #ifdef SWIGRUNTIME_DEBUG
55194 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55195 #endif
55196 if (swig_module.next != &swig_module) {
55197 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55198 #ifdef SWIGRUNTIME_DEBUG
55199 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55200 #endif
55201 }
55202 if (ret) {
55203 if (type == swig_module.type_initial[i]) {
55204 #ifdef SWIGRUNTIME_DEBUG
55205 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55206 #endif
55207 cast->type = ret;
55208 ret = 0;
55209 } else {
55210 /* Check for casting already in the list */
55211 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55212 #ifdef SWIGRUNTIME_DEBUG
55213 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55214 #endif
55215 if (!ocast) ret = 0;
55216 }
55217 }
55218
55219 if (!ret) {
55220 #ifdef SWIGRUNTIME_DEBUG
55221 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55222 #endif
55223 if (type->cast) {
55224 type->cast->prev = cast;
55225 cast->next = type->cast;
55226 }
55227 type->cast = cast;
55228 }
55229 cast++;
55230 }
55231 /* Set entry in modules->types array equal to the type */
55232 swig_module.types[i] = type;
55233 }
55234 swig_module.types[i] = 0;
55235
55236 #ifdef SWIGRUNTIME_DEBUG
55237 printf("**** SWIG_InitializeModule: Cast List ******\n");
55238 for (i = 0; i < swig_module.size; ++i) {
55239 int j = 0;
55240 swig_cast_info *cast = swig_module.cast_initial[i];
55241 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55242 while (cast->type) {
55243 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55244 cast++;
55245 ++j;
55246 }
55247 printf("---- Total casts: %d\n",j);
55248 }
55249 printf("**** SWIG_InitializeModule: Cast List ******\n");
55250 #endif
55251 }
55252
55253 /* This function will propagate the clientdata field of type to
55254 * any new swig_type_info structures that have been added into the list
55255 * of equivalent types. It is like calling
55256 * SWIG_TypeClientData(type, clientdata) a second time.
55257 */
55258 SWIGRUNTIME void
55259 SWIG_PropagateClientData(void) {
55260 size_t i;
55261 swig_cast_info *equiv;
55262 static int init_run = 0;
55263
55264 if (init_run) return;
55265 init_run = 1;
55266
55267 for (i = 0; i < swig_module.size; i++) {
55268 if (swig_module.types[i]->clientdata) {
55269 equiv = swig_module.types[i]->cast;
55270 while (equiv) {
55271 if (!equiv->converter) {
55272 if (equiv->type && !equiv->type->clientdata)
55273 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55274 }
55275 equiv = equiv->next;
55276 }
55277 }
55278 }
55279 }
55280
55281 #ifdef __cplusplus
55282 #if 0
55283 {
55284 /* c-mode */
55285 #endif
55286 }
55287 #endif
55288
55289
55290
55291 #ifdef __cplusplus
55292 extern "C" {
55293 #endif
55294
55295 /* Python-specific SWIG API */
55296 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55297 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55298 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55299
55300 /* -----------------------------------------------------------------------------
55301 * global variable support code.
55302 * ----------------------------------------------------------------------------- */
55303
55304 typedef struct swig_globalvar {
55305 char *name; /* Name of global variable */
55306 PyObject *(*get_attr)(void); /* Return the current value */
55307 int (*set_attr)(PyObject *); /* Set the value */
55308 struct swig_globalvar *next;
55309 } swig_globalvar;
55310
55311 typedef struct swig_varlinkobject {
55312 PyObject_HEAD
55313 swig_globalvar *vars;
55314 } swig_varlinkobject;
55315
55316 SWIGINTERN PyObject *
55317 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55318 return PyString_FromString("<Swig global variables>");
55319 }
55320
55321 SWIGINTERN PyObject *
55322 swig_varlink_str(swig_varlinkobject *v) {
55323 PyObject *str = PyString_FromString("(");
55324 swig_globalvar *var;
55325 for (var = v->vars; var; var=var->next) {
55326 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55327 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55328 }
55329 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55330 return str;
55331 }
55332
55333 SWIGINTERN int
55334 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55335 PyObject *str = swig_varlink_str(v);
55336 fprintf(fp,"Swig global variables ");
55337 fprintf(fp,"%s\n", PyString_AsString(str));
55338 Py_DECREF(str);
55339 return 0;
55340 }
55341
55342 SWIGINTERN void
55343 swig_varlink_dealloc(swig_varlinkobject *v) {
55344 swig_globalvar *var = v->vars;
55345 while (var) {
55346 swig_globalvar *n = var->next;
55347 free(var->name);
55348 free(var);
55349 var = n;
55350 }
55351 }
55352
55353 SWIGINTERN PyObject *
55354 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55355 PyObject *res = NULL;
55356 swig_globalvar *var = v->vars;
55357 while (var) {
55358 if (strcmp(var->name,n) == 0) {
55359 res = (*var->get_attr)();
55360 break;
55361 }
55362 var = var->next;
55363 }
55364 if (res == NULL && !PyErr_Occurred()) {
55365 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55366 }
55367 return res;
55368 }
55369
55370 SWIGINTERN int
55371 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55372 int res = 1;
55373 swig_globalvar *var = v->vars;
55374 while (var) {
55375 if (strcmp(var->name,n) == 0) {
55376 res = (*var->set_attr)(p);
55377 break;
55378 }
55379 var = var->next;
55380 }
55381 if (res == 1 && !PyErr_Occurred()) {
55382 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55383 }
55384 return res;
55385 }
55386
55387 SWIGINTERN PyTypeObject*
55388 swig_varlink_type(void) {
55389 static char varlink__doc__[] = "Swig var link object";
55390 static PyTypeObject varlink_type;
55391 static int type_init = 0;
55392 if (!type_init) {
55393 const PyTypeObject tmp
55394 = {
55395 PyObject_HEAD_INIT(NULL)
55396 0, /* Number of items in variable part (ob_size) */
55397 (char *)"swigvarlink", /* Type name (tp_name) */
55398 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55399 0, /* Itemsize (tp_itemsize) */
55400 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55401 (printfunc) swig_varlink_print, /* Print (tp_print) */
55402 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55403 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55404 0, /* tp_compare */
55405 (reprfunc) swig_varlink_repr, /* tp_repr */
55406 0, /* tp_as_number */
55407 0, /* tp_as_sequence */
55408 0, /* tp_as_mapping */
55409 0, /* tp_hash */
55410 0, /* tp_call */
55411 (reprfunc)swig_varlink_str, /* tp_str */
55412 0, /* tp_getattro */
55413 0, /* tp_setattro */
55414 0, /* tp_as_buffer */
55415 0, /* tp_flags */
55416 varlink__doc__, /* tp_doc */
55417 0, /* tp_traverse */
55418 0, /* tp_clear */
55419 0, /* tp_richcompare */
55420 0, /* tp_weaklistoffset */
55421 #if PY_VERSION_HEX >= 0x02020000
55422 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55423 #endif
55424 #if PY_VERSION_HEX >= 0x02030000
55425 0, /* tp_del */
55426 #endif
55427 #ifdef COUNT_ALLOCS
55428 0,0,0,0 /* tp_alloc -> tp_next */
55429 #endif
55430 };
55431 varlink_type = tmp;
55432 varlink_type.ob_type = &PyType_Type;
55433 type_init = 1;
55434 }
55435 return &varlink_type;
55436 }
55437
55438 /* Create a variable linking object for use later */
55439 SWIGINTERN PyObject *
55440 SWIG_Python_newvarlink(void) {
55441 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55442 if (result) {
55443 result->vars = 0;
55444 }
55445 return ((PyObject*) result);
55446 }
55447
55448 SWIGINTERN void
55449 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55450 swig_varlinkobject *v = (swig_varlinkobject *) p;
55451 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55452 if (gv) {
55453 size_t size = strlen(name)+1;
55454 gv->name = (char *)malloc(size);
55455 if (gv->name) {
55456 strncpy(gv->name,name,size);
55457 gv->get_attr = get_attr;
55458 gv->set_attr = set_attr;
55459 gv->next = v->vars;
55460 }
55461 }
55462 v->vars = gv;
55463 }
55464
55465 SWIGINTERN PyObject *
55466 SWIG_globals() {
55467 static PyObject *_SWIG_globals = 0;
55468 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55469 return _SWIG_globals;
55470 }
55471
55472 /* -----------------------------------------------------------------------------
55473 * constants/methods manipulation
55474 * ----------------------------------------------------------------------------- */
55475
55476 /* Install Constants */
55477 SWIGINTERN void
55478 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55479 PyObject *obj = 0;
55480 size_t i;
55481 for (i = 0; constants[i].type; ++i) {
55482 switch(constants[i].type) {
55483 case SWIG_PY_POINTER:
55484 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55485 break;
55486 case SWIG_PY_BINARY:
55487 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55488 break;
55489 default:
55490 obj = 0;
55491 break;
55492 }
55493 if (obj) {
55494 PyDict_SetItemString(d, constants[i].name, obj);
55495 Py_DECREF(obj);
55496 }
55497 }
55498 }
55499
55500 /* -----------------------------------------------------------------------------*/
55501 /* Fix SwigMethods to carry the callback ptrs when needed */
55502 /* -----------------------------------------------------------------------------*/
55503
55504 SWIGINTERN void
55505 SWIG_Python_FixMethods(PyMethodDef *methods,
55506 swig_const_info *const_table,
55507 swig_type_info **types,
55508 swig_type_info **types_initial) {
55509 size_t i;
55510 for (i = 0; methods[i].ml_name; ++i) {
55511 char *c = methods[i].ml_doc;
55512 if (c && (c = strstr(c, "swig_ptr: "))) {
55513 int j;
55514 swig_const_info *ci = 0;
55515 char *name = c + 10;
55516 for (j = 0; const_table[j].type; ++j) {
55517 if (strncmp(const_table[j].name, name,
55518 strlen(const_table[j].name)) == 0) {
55519 ci = &(const_table[j]);
55520 break;
55521 }
55522 }
55523 if (ci) {
55524 size_t shift = (ci->ptype) - types;
55525 swig_type_info *ty = types_initial[shift];
55526 size_t ldoc = (c - methods[i].ml_doc);
55527 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55528 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55529 if (ndoc) {
55530 char *buff = ndoc;
55531 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55532 if (ptr) {
55533 strncpy(buff, methods[i].ml_doc, ldoc);
55534 buff += ldoc;
55535 strncpy(buff, "swig_ptr: ", 10);
55536 buff += 10;
55537 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55538 methods[i].ml_doc = ndoc;
55539 }
55540 }
55541 }
55542 }
55543 }
55544 }
55545
55546 #ifdef __cplusplus
55547 }
55548 #endif
55549
55550 /* -----------------------------------------------------------------------------*
55551 * Partial Init method
55552 * -----------------------------------------------------------------------------*/
55553
55554 #ifdef __cplusplus
55555 extern "C"
55556 #endif
55557 SWIGEXPORT void SWIG_init(void) {
55558 PyObject *m, *d;
55559
55560 /* Fix SwigMethods to carry the callback ptrs when needed */
55561 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55562
55563 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55564 d = PyModule_GetDict(m);
55565
55566 SWIG_InitializeModule(0);
55567 SWIG_InstallConstants(d,swig_const_table);
55568
55569
55570
55571 #ifndef wxPyUSE_EXPORT
55572 // Make our API structure a CObject so other modules can import it
55573 // from this module.
55574 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55575 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55576 Py_XDECREF(cobj);
55577 #endif
55578
55579 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55580 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55581 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55582 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55583 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55584 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55585 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55586 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55587 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55588 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55589 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55590 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55591 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55592 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55593 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55594 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55595 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55596 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55597 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55598 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55599 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55600 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55601 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55602 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55603 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55604 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55605 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55606 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55607 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55608 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55609 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55610 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55611 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55612 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55613 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55614 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55615 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55616 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55617 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55618 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55619 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55620 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55621 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55622 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55623 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55624 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55625 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55626 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55627 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55628 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55629 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55630 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55631 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55632 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55633 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55634 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55635 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55636 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55637 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55638 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55639 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55640 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55641 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55642 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55643 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55644 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55645 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55646 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55647 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55648 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55649 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55650 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55651 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55652 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55653 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55654 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55655 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55656 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55657 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55658 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55659 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55660 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55661 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55662 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55663 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55664 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55665 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55666 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55667 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55668 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55669 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55670 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55671 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55672 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55673 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55674 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55675 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55676 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55677 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55678 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55679 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55680 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55681 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55682 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55683 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55684 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55685 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55686 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55687 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55688 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55689 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55690 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55691 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55692 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55693 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55694 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55695 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55696 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55697 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55698 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55699 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55700 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55701 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55702 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55703 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55704 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55705 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55706 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55707 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55708 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55709 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55710 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55711 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55712 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55713 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55714 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55715 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55716 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55717 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55718 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55719 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55720 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55721 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55722 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55723 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55724 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55725 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55726 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55727 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55728 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55729 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55730 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55731 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55732 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55733 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55734 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55735 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55736 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55737 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55738 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
55739 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
55740 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
55741 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
55742 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
55743 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
55744 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
55745 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
55746 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
55747 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
55748 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
55749 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
55750 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
55751 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
55752 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
55753 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
55754 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
55755 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
55756 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
55757 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
55758 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
55759 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
55760 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
55761 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
55762 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
55763 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
55764 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
55765 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
55766 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
55767 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
55768 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
55769 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
55770 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
55771 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
55772 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
55773 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
55774 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
55775 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
55776 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
55777 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
55778 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
55779 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
55780 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
55781 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
55782 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
55783 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
55784 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
55785 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
55786 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
55787 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
55788 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
55789 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
55790 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
55791 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
55792 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
55793 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
55794 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
55795 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
55796 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
55797 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
55798 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
55799 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
55800 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
55801 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
55802 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
55803 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
55804 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
55805 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
55806 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
55807 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
55808 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
55809 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
55810 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
55811 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
55812 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
55813 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
55814 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
55815 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
55816 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
55817 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
55818 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
55819 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
55820 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
55821 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
55822 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
55823 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
55824 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
55825 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
55826 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
55827 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
55828 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
55829 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
55830 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
55831 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
55832 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
55833 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
55834 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
55835 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
55836 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
55837 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
55838 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
55839 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
55840 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
55841 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
55842 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
55843 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
55844 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
55845 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
55846 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
55847 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
55848 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
55849 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
55850 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
55851 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
55852 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
55853 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
55854 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
55855 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
55856 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
55857 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
55858 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
55859 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
55860 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
55861 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
55862 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
55863 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
55864 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
55865 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
55866 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
55867 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
55868 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
55869 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
55870 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
55871 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
55872 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
55873 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
55874 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
55875 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
55876 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
55877 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
55878 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
55879 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
55880 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
55881 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
55882 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
55883 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
55884 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
55885 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
55886 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
55887 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
55888 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
55889 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
55890 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
55891 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
55892 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
55893 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
55894 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
55895 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
55896 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
55897 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
55898 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
55899 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
55900 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
55901 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
55902 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
55903 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
55904 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
55905 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
55906 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
55907 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
55908 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
55909 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
55910 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
55911 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
55912 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
55913 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
55914 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
55915 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
55916 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
55917 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
55918 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
55919 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
55920 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
55921 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
55922 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
55923 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
55924 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
55925 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
55926 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
55927 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
55928 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
55929 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
55930 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
55931 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
55932 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
55933 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
55934 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
55935 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
55936 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
55937 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
55938 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
55939 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
55940 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
55941 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
55942 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
55943 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
55944 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
55945 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
55946 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
55947 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
55948 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
55949 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
55950 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
55951 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
55952 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
55953 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
55954 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
55955 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
55956 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
55957 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
55958 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
55959 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
55960 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
55961 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
55962 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
55963 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
55964 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
55965 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
55966 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
55967 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
55968 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
55969 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
55970 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
55971 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
55972 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
55973 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
55974 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
55975 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
55976 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
55977 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
55978 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
55979 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
55980 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
55981 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
55982 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
55983 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
55984 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
55985 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
55986 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
55987 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
55988 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
55989 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
55990 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
55991 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
55992 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
55993 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
55994 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
55995 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
55996 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
55997 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
55998 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
55999 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56000 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56001 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56002 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56003 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56004 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56005 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56006 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56007 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56008 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56009 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56010 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56011 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56012 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56013 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56014 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56015 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56016 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56017 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56018 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56019 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56020 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56021 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56022 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56023 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56024 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56025 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56026 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56027 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56028 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56029 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56030 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56031 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56032 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56033 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56034 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56035 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56036 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56037 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56038 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56039 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56040 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56041 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56042 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56043 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56044 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56045 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56046 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56047 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56048 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56049 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56050 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56051 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56052 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56053 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56054 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56055 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56056 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56057 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56058 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56059 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56060 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56061 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56062 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56063 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56064 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56065 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56066 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56067 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56068 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56069 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56070 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56071 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56072 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56073 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56074 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56075 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56076 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56077 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56078 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56079 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56080 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56081 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56082 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56083 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56084 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56085 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56086 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56087 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56088 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56089 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56090 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56091 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56092 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56093 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56094 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56095 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56096 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56097 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56098 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56099 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56100 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56101 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56102 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56103 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56104 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56105 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56106 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56107 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56108 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56109 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56110 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56111 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56112 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56113 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56114 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56115 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56116 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56117 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56118 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56119 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56120 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56121 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56122 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56123 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56124 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56125 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56126 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56127 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56128 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56129 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56130 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56131 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56132 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56133 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56134 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56135 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56136 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56137 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56138 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56139 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56140 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56141 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56142 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56143 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56144 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56145 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56146 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56147 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56148 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56149 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56150 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56151 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56152 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56153 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56154 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56155 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56156 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56157 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56158 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56159 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56160 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56161 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56162 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56163 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56164 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56165 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56166 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56167 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56168 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56169 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56170 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56171 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56172 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56173 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56174 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56175 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56176 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56177 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56178 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56179 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56180 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56181 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56182 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56183 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56184 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56185 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56186 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56187 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56188 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56189 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56190 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56191 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56192 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56193 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56194 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56195 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56196 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56197 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56198 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56199 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56200 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56201 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56202 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56203 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56204 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56205 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56206 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56207 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56208 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56209 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56210 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56211 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56212 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56213 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56214 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56215 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56216 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56217 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56218 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56219 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56220 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56221 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56222 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56223 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56224 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56225 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56226 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56227 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56228 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56229 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56230 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56231 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56232 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56233 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56234 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56235 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56236 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56237 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56238 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56239 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56240 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56241
56242 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56243
56244
56245 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56246
56247 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56248 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56249 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56250 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56251 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56252 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56253 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56254 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56255 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56256 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56257 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56258 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56259 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56260 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56261 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56262 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56263 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56264 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56265 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56266 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56267 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56268 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56269 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56270 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56271 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56272 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56273 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56274 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56275 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56276 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56277 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56278 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56279 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56280 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56281 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56282 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56283 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56284 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56285 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56286 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56287 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56288 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56289 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56290 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56291 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56292 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56293 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56294 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56295 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56296 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56297 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56298 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56299 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56300 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56301 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56302 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56303 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56304 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56305 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56306 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56307 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56308 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56309 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56310 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56311 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56312 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56313 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56314 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56315 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56316 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56317 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56318 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56319 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56320 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56321 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56322 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56323 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56324 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56325 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56326 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56327 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56328 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56329 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56330 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56331 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56332 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56333 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56334 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56335 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56336 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56337 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56338 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56339 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56340 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56341 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56342 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56343 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56344 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56345 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56346 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56347 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56348 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56349 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56350 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56351 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56352 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56353 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56354 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56355 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56356 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56357 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56358 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56359 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56360 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56361 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56362 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56363 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56364 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56365 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56366 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56367 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56368 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56369 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56370 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56371 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56372 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56373 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56374 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56375 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56376 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56377 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56378 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56379 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56380 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56381 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56382 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56383 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56384 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56385 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56386 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56387 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56388 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56389 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56390 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56391 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56392 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56393 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56394 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56395 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56396 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56397 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56398 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56399 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56400 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56401 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56402 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56403 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56404 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56405 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56406 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56407 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56408 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56409 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56410 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56411 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56412 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56413 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56414 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56415 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56416 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56417 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56418 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56419 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56420 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56421 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56422 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56423 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56424 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56425 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56426 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56427 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56428 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56429 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56430 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56431 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56432 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56433 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56434 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56435 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56436 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56437 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56438 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56439 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56440 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56441 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56442 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56443 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56444 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56445 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56446 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56447 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56448 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56449 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56450 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56451 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56452 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56453
56454 // Initialize threading, some globals and such
56455 __wxPyPreStart(d);
56456
56457
56458 // Although these are defined in __version__ they need to be here too so
56459 // that an assert can be done to ensure that the wxPython and the wxWindows
56460 // versions match.
56461 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56462 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56463 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56464
56465 }
56466
wxWidgets (Impactor)