]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/msw/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
use NavigateIn() method instead of sending wxNavigationKeyEvent directly
[wxWidgets.git] / wxPython / src / msw / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #if PY_VERSION_HEX < 0x02050000
989 typedef int Py_ssize_t;
990 #endif
991
992 /* for raw pointers */
993 #define SWIG_Python_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, 0)
994 #define SWIG_ConvertPtr(obj, pptr, type, flags) SWIG_Python_ConvertPtr(obj, pptr, type, flags)
995 #define SWIG_ConvertPtrAndOwn(obj,pptr,type,flags,own) SWIG_Python_ConvertPtrAndOwn(obj, pptr, type, flags, own)
996 #define SWIG_NewPointerObj(ptr, type, flags) SWIG_Python_NewPointerObj(ptr, type, flags)
997 #define SWIG_CheckImplicit(ty) SWIG_Python_CheckImplicit(ty)
998 #define SWIG_AcquirePtr(ptr, src) SWIG_Python_AcquirePtr(ptr, src)
999 #define swig_owntype int
1000
1001 /* for raw packed data */
1002 #define SWIG_ConvertPacked(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1003 #define SWIG_NewPackedObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1004
1005 /* for class or struct pointers */
1006 #define SWIG_ConvertInstance(obj, pptr, type, flags) SWIG_ConvertPtr(obj, pptr, type, flags)
1007 #define SWIG_NewInstanceObj(ptr, type, flags) SWIG_NewPointerObj(ptr, type, flags)
1008
1009 /* for C or C++ function pointers */
1010 #define SWIG_ConvertFunctionPtr(obj, pptr, type) SWIG_Python_ConvertFunctionPtr(obj, pptr, type)
1011 #define SWIG_NewFunctionPtrObj(ptr, type) SWIG_Python_NewPointerObj(ptr, type, 0)
1012
1013 /* for C++ member pointers, ie, member methods */
1014 #define SWIG_ConvertMember(obj, ptr, sz, ty) SWIG_Python_ConvertPacked(obj, ptr, sz, ty)
1015 #define SWIG_NewMemberObj(ptr, sz, type) SWIG_Python_NewPackedObj(ptr, sz, type)
1016
1017
1018 /* Runtime API */
1019
1020 #define SWIG_GetModule(clientdata) SWIG_Python_GetModule()
1021 #define SWIG_SetModule(clientdata, pointer) SWIG_Python_SetModule(pointer)
1022 #define SWIG_NewClientData(obj) PySwigClientData_New(obj)
1023
1024 #define SWIG_SetErrorObj SWIG_Python_SetErrorObj
1025 #define SWIG_SetErrorMsg SWIG_Python_SetErrorMsg
1026 #define SWIG_ErrorType(code) SWIG_Python_ErrorType(code)
1027 #define SWIG_Error(code, msg) SWIG_Python_SetErrorMsg(SWIG_ErrorType(code), msg)
1028 #define SWIG_fail goto fail
1029
1030
1031 /* Runtime API implementation */
1032
1033 /* Error manipulation */
1034
1035 SWIGINTERN void
1036 SWIG_Python_SetErrorObj(PyObject *errtype, PyObject *obj) {
1037 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1038 PyErr_SetObject(errtype, obj);
1039 Py_DECREF(obj);
1040 SWIG_PYTHON_THREAD_END_BLOCK;
1041 }
1042
1043 SWIGINTERN void
1044 SWIG_Python_SetErrorMsg(PyObject *errtype, const char *msg) {
1045 SWIG_PYTHON_THREAD_BEGIN_BLOCK;
1046 PyErr_SetString(errtype, (char *) msg);
1047 SWIG_PYTHON_THREAD_END_BLOCK;
1048 }
1049
1050 #define SWIG_Python_Raise(obj, type, desc) SWIG_Python_SetErrorObj(SWIG_Python_ExceptionType(desc), obj)
1051
1052 /* Set a constant value */
1053
1054 SWIGINTERN void
1055 SWIG_Python_SetConstant(PyObject *d, const char *name, PyObject *obj) {
1056 PyDict_SetItemString(d, (char*) name, obj);
1057 Py_DECREF(obj);
1058 }
1059
1060 /* Append a value to the result obj */
1061
1062 SWIGINTERN PyObject*
1063 SWIG_Python_AppendOutput(PyObject* result, PyObject* obj) {
1064 #if !defined(SWIG_PYTHON_OUTPUT_TUPLE)
1065 if (!result) {
1066 result = obj;
1067 } else if (result == Py_None) {
1068 Py_DECREF(result);
1069 result = obj;
1070 } else {
1071 if (!PyList_Check(result)) {
1072 PyObject *o2 = result;
1073 result = PyList_New(1);
1074 PyList_SetItem(result, 0, o2);
1075 }
1076 PyList_Append(result,obj);
1077 Py_DECREF(obj);
1078 }
1079 return result;
1080 #else
1081 PyObject* o2;
1082 PyObject* o3;
1083 if (!result) {
1084 result = obj;
1085 } else if (result == Py_None) {
1086 Py_DECREF(result);
1087 result = obj;
1088 } else {
1089 if (!PyTuple_Check(result)) {
1090 o2 = result;
1091 result = PyTuple_New(1);
1092 PyTuple_SET_ITEM(result, 0, o2);
1093 }
1094 o3 = PyTuple_New(1);
1095 PyTuple_SET_ITEM(o3, 0, obj);
1096 o2 = result;
1097 result = PySequence_Concat(o2, o3);
1098 Py_DECREF(o2);
1099 Py_DECREF(o3);
1100 }
1101 return result;
1102 #endif
1103 }
1104
1105 /* Unpack the argument tuple */
1106
1107 SWIGINTERN int
1108 SWIG_Python_UnpackTuple(PyObject *args, const char *name, int min, int max, PyObject **objs)
1109 {
1110 if (!args) {
1111 if (!min && !max) {
1112 return 1;
1113 } else {
1114 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got none",
1115 name, (min == max ? "" : "at least "), min);
1116 return 0;
1117 }
1118 }
1119 if (!PyTuple_Check(args)) {
1120 PyErr_SetString(PyExc_SystemError, "UnpackTuple() argument list is not a tuple");
1121 return 0;
1122 } else {
1123 register int l = PyTuple_GET_SIZE(args);
1124 if (l < min) {
1125 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1126 name, (min == max ? "" : "at least "), min, l);
1127 return 0;
1128 } else if (l > max) {
1129 PyErr_Format(PyExc_TypeError, "%s expected %s%d arguments, got %d",
1130 name, (min == max ? "" : "at most "), max, l);
1131 return 0;
1132 } else {
1133 register int i;
1134 for (i = 0; i < l; ++i) {
1135 objs[i] = PyTuple_GET_ITEM(args, i);
1136 }
1137 for (; l < max; ++l) {
1138 objs[l] = 0;
1139 }
1140 return i + 1;
1141 }
1142 }
1143 }
1144
1145 /* A functor is a function object with one single object argument */
1146 #if PY_VERSION_HEX >= 0x02020000
1147 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunctionObjArgs(functor, obj, NULL);
1148 #else
1149 #define SWIG_Python_CallFunctor(functor, obj) PyObject_CallFunction(functor, "O", obj);
1150 #endif
1151
1152 /*
1153 Helper for static pointer initialization for both C and C++ code, for example
1154 static PyObject *SWIG_STATIC_POINTER(MyVar) = NewSomething(...);
1155 */
1156 #ifdef __cplusplus
1157 #define SWIG_STATIC_POINTER(var) var
1158 #else
1159 #define SWIG_STATIC_POINTER(var) var = 0; if (!var) var
1160 #endif
1161
1162 /* -----------------------------------------------------------------------------
1163 * Pointer declarations
1164 * ----------------------------------------------------------------------------- */
1165
1166 /* Flags for new pointer objects */
1167 #define SWIG_POINTER_NOSHADOW (SWIG_POINTER_OWN << 1)
1168 #define SWIG_POINTER_NEW (SWIG_POINTER_NOSHADOW | SWIG_POINTER_OWN)
1169
1170 #define SWIG_POINTER_IMPLICIT_CONV (SWIG_POINTER_DISOWN << 1)
1171
1172 #ifdef __cplusplus
1173 extern "C" {
1174 #if 0
1175 } /* cc-mode */
1176 #endif
1177 #endif
1178
1179 /* How to access Py_None */
1180 #if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
1181 # ifndef SWIG_PYTHON_NO_BUILD_NONE
1182 # ifndef SWIG_PYTHON_BUILD_NONE
1183 # define SWIG_PYTHON_BUILD_NONE
1184 # endif
1185 # endif
1186 #endif
1187
1188 #ifdef SWIG_PYTHON_BUILD_NONE
1189 # ifdef Py_None
1190 # undef Py_None
1191 # define Py_None SWIG_Py_None()
1192 # endif
1193 SWIGRUNTIMEINLINE PyObject *
1194 _SWIG_Py_None(void)
1195 {
1196 PyObject *none = Py_BuildValue("");
1197 Py_DECREF(none);
1198 return none;
1199 }
1200 SWIGRUNTIME PyObject *
1201 SWIG_Py_None(void)
1202 {
1203 static PyObject *SWIG_STATIC_POINTER(none) = _SWIG_Py_None();
1204 return none;
1205 }
1206 #endif
1207
1208 /* The python void return value */
1209
1210 SWIGRUNTIMEINLINE PyObject *
1211 SWIG_Py_Void(void)
1212 {
1213 PyObject *none = Py_None;
1214 Py_INCREF(none);
1215 return none;
1216 }
1217
1218 /* PySwigClientData */
1219
1220 typedef struct {
1221 PyObject *klass;
1222 PyObject *newraw;
1223 PyObject *newargs;
1224 PyObject *destroy;
1225 int delargs;
1226 int implicitconv;
1227 } PySwigClientData;
1228
1229 SWIGRUNTIMEINLINE int
1230 SWIG_Python_CheckImplicit(swig_type_info *ty)
1231 {
1232 PySwigClientData *data = (PySwigClientData *)ty->clientdata;
1233 return data ? data->implicitconv : 0;
1234 }
1235
1236 SWIGRUNTIMEINLINE PyObject *
1237 SWIG_Python_ExceptionType(swig_type_info *desc) {
1238 PySwigClientData *data = desc ? (PySwigClientData *) desc->clientdata : 0;
1239 PyObject *klass = data ? data->klass : 0;
1240 return (klass ? klass : PyExc_RuntimeError);
1241 }
1242
1243
1244 SWIGRUNTIME PySwigClientData *
1245 PySwigClientData_New(PyObject* obj)
1246 {
1247 if (!obj) {
1248 return 0;
1249 } else {
1250 PySwigClientData *data = (PySwigClientData *)malloc(sizeof(PySwigClientData));
1251 /* the klass element */
1252 data->klass = obj;
1253 Py_INCREF(data->klass);
1254 /* the newraw method and newargs arguments used to create a new raw instance */
1255 if (PyClass_Check(obj)) {
1256 data->newraw = 0;
1257 data->newargs = obj;
1258 Py_INCREF(obj);
1259 } else {
1260 #if (PY_VERSION_HEX < 0x02020000)
1261 data->newraw = 0;
1262 #else
1263 data->newraw = PyObject_GetAttrString(data->klass, (char *)"__new__");
1264 #endif
1265 if (data->newraw) {
1266 Py_INCREF(data->newraw);
1267 data->newargs = PyTuple_New(1);
1268 PyTuple_SetItem(data->newargs, 0, obj);
1269 } else {
1270 data->newargs = obj;
1271 }
1272 Py_INCREF(data->newargs);
1273 }
1274 /* the destroy method, aka as the C++ delete method */
1275 data->destroy = PyObject_GetAttrString(data->klass, (char *)"__swig_destroy__");
1276 if (PyErr_Occurred()) {
1277 PyErr_Clear();
1278 data->destroy = 0;
1279 }
1280 if (data->destroy) {
1281 int flags;
1282 Py_INCREF(data->destroy);
1283 flags = PyCFunction_GET_FLAGS(data->destroy);
1284 #ifdef METH_O
1285 data->delargs = !(flags & (METH_O));
1286 #else
1287 data->delargs = 0;
1288 #endif
1289 } else {
1290 data->delargs = 0;
1291 }
1292 data->implicitconv = 0;
1293 return data;
1294 }
1295 }
1296
1297 SWIGRUNTIME void
1298 PySwigClientData_Del(PySwigClientData* data)
1299 {
1300 Py_XDECREF(data->newraw);
1301 Py_XDECREF(data->newargs);
1302 Py_XDECREF(data->destroy);
1303 }
1304
1305 /* =============== PySwigObject =====================*/
1306
1307 typedef struct {
1308 PyObject_HEAD
1309 void *ptr;
1310 swig_type_info *ty;
1311 int own;
1312 PyObject *next;
1313 } PySwigObject;
1314
1315 SWIGRUNTIME PyObject *
1316 PySwigObject_long(PySwigObject *v)
1317 {
1318 return PyLong_FromVoidPtr(v->ptr);
1319 }
1320
1321 SWIGRUNTIME PyObject *
1322 PySwigObject_format(const char* fmt, PySwigObject *v)
1323 {
1324 PyObject *res = NULL;
1325 PyObject *args = PyTuple_New(1);
1326 if (args) {
1327 if (PyTuple_SetItem(args, 0, PySwigObject_long(v)) == 0) {
1328 PyObject *ofmt = PyString_FromString(fmt);
1329 if (ofmt) {
1330 res = PyString_Format(ofmt,args);
1331 Py_DECREF(ofmt);
1332 }
1333 Py_DECREF(args);
1334 }
1335 }
1336 return res;
1337 }
1338
1339 SWIGRUNTIME PyObject *
1340 PySwigObject_oct(PySwigObject *v)
1341 {
1342 return PySwigObject_format("%o",v);
1343 }
1344
1345 SWIGRUNTIME PyObject *
1346 PySwigObject_hex(PySwigObject *v)
1347 {
1348 return PySwigObject_format("%x",v);
1349 }
1350
1351 SWIGRUNTIME PyObject *
1352 #ifdef METH_NOARGS
1353 PySwigObject_repr(PySwigObject *v)
1354 #else
1355 PySwigObject_repr(PySwigObject *v, PyObject *args)
1356 #endif
1357 {
1358 const char *name = SWIG_TypePrettyName(v->ty);
1359 PyObject *hex = PySwigObject_hex(v);
1360 PyObject *repr = PyString_FromFormat("<Swig Object of type '%s' at 0x%s>", name, PyString_AsString(hex));
1361 Py_DECREF(hex);
1362 if (v->next) {
1363 #ifdef METH_NOARGS
1364 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next);
1365 #else
1366 PyObject *nrep = PySwigObject_repr((PySwigObject *)v->next, args);
1367 #endif
1368 PyString_ConcatAndDel(&repr,nrep);
1369 }
1370 return repr;
1371 }
1372
1373 SWIGRUNTIME int
1374 PySwigObject_print(PySwigObject *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1375 {
1376 #ifdef METH_NOARGS
1377 PyObject *repr = PySwigObject_repr(v);
1378 #else
1379 PyObject *repr = PySwigObject_repr(v, NULL);
1380 #endif
1381 if (repr) {
1382 fputs(PyString_AsString(repr), fp);
1383 Py_DECREF(repr);
1384 return 0;
1385 } else {
1386 return 1;
1387 }
1388 }
1389
1390 SWIGRUNTIME PyObject *
1391 PySwigObject_str(PySwigObject *v)
1392 {
1393 char result[SWIG_BUFFER_SIZE];
1394 return SWIG_PackVoidPtr(result, v->ptr, v->ty->name, sizeof(result)) ?
1395 PyString_FromString(result) : 0;
1396 }
1397
1398 SWIGRUNTIME int
1399 PySwigObject_compare(PySwigObject *v, PySwigObject *w)
1400 {
1401 void *i = v->ptr;
1402 void *j = w->ptr;
1403 return (i < j) ? -1 : ((i > j) ? 1 : 0);
1404 }
1405
1406 SWIGRUNTIME PyTypeObject* _PySwigObject_type(void);
1407
1408 SWIGRUNTIME PyTypeObject*
1409 PySwigObject_type(void) {
1410 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigObject_type();
1411 return type;
1412 }
1413
1414 SWIGRUNTIMEINLINE int
1415 PySwigObject_Check(PyObject *op) {
1416 return ((op)->ob_type == PySwigObject_type())
1417 || (strcmp((op)->ob_type->tp_name,"PySwigObject") == 0);
1418 }
1419
1420 SWIGRUNTIME PyObject *
1421 PySwigObject_New(void *ptr, swig_type_info *ty, int own);
1422
1423 SWIGRUNTIME void
1424 PySwigObject_dealloc(PyObject *v)
1425 {
1426 PySwigObject *sobj = (PySwigObject *) v;
1427 PyObject *next = sobj->next;
1428 if (sobj->own) {
1429 swig_type_info *ty = sobj->ty;
1430 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
1431 PyObject *destroy = data ? data->destroy : 0;
1432 if (destroy) {
1433 /* destroy is always a VARARGS method */
1434 PyObject *res;
1435 if (data->delargs) {
1436 /* we need to create a temporal object to carry the destroy operation */
1437 PyObject *tmp = PySwigObject_New(sobj->ptr, ty, 0);
1438 res = SWIG_Python_CallFunctor(destroy, tmp);
1439 Py_DECREF(tmp);
1440 } else {
1441 PyCFunction meth = PyCFunction_GET_FUNCTION(destroy);
1442 PyObject *mself = PyCFunction_GET_SELF(destroy);
1443 res = ((*meth)(mself, v));
1444 }
1445 Py_XDECREF(res);
1446 } else {
1447 const char *name = SWIG_TypePrettyName(ty);
1448 #if !defined(SWIG_PYTHON_SILENT_MEMLEAK)
1449 printf("swig/python detected a memory leak of type '%s', no destructor found.\n", name);
1450 #endif
1451 }
1452 }
1453 Py_XDECREF(next);
1454 PyObject_DEL(v);
1455 }
1456
1457 SWIGRUNTIME PyObject*
1458 PySwigObject_append(PyObject* v, PyObject* next)
1459 {
1460 PySwigObject *sobj = (PySwigObject *) v;
1461 #ifndef METH_O
1462 PyObject *tmp = 0;
1463 if (!PyArg_ParseTuple(next,(char *)"O:append", &tmp)) return NULL;
1464 next = tmp;
1465 #endif
1466 if (!PySwigObject_Check(next)) {
1467 return NULL;
1468 }
1469 sobj->next = next;
1470 Py_INCREF(next);
1471 return SWIG_Py_Void();
1472 }
1473
1474 SWIGRUNTIME PyObject*
1475 #ifdef METH_NOARGS
1476 PySwigObject_next(PyObject* v)
1477 #else
1478 PySwigObject_next(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1479 #endif
1480 {
1481 PySwigObject *sobj = (PySwigObject *) v;
1482 if (sobj->next) {
1483 Py_INCREF(sobj->next);
1484 return sobj->next;
1485 } else {
1486 return SWIG_Py_Void();
1487 }
1488 }
1489
1490 SWIGINTERN PyObject*
1491 #ifdef METH_NOARGS
1492 PySwigObject_disown(PyObject *v)
1493 #else
1494 PySwigObject_disown(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1495 #endif
1496 {
1497 PySwigObject *sobj = (PySwigObject *)v;
1498 sobj->own = 0;
1499 return SWIG_Py_Void();
1500 }
1501
1502 SWIGINTERN PyObject*
1503 #ifdef METH_NOARGS
1504 PySwigObject_acquire(PyObject *v)
1505 #else
1506 PySwigObject_acquire(PyObject* v, PyObject *SWIGUNUSEDPARM(args))
1507 #endif
1508 {
1509 PySwigObject *sobj = (PySwigObject *)v;
1510 sobj->own = SWIG_POINTER_OWN;
1511 return SWIG_Py_Void();
1512 }
1513
1514 SWIGINTERN PyObject*
1515 PySwigObject_own(PyObject *v, PyObject *args)
1516 {
1517 PyObject *val = 0;
1518 #if (PY_VERSION_HEX < 0x02020000)
1519 if (!PyArg_ParseTuple(args,(char *)"|O:own",&val))
1520 #else
1521 if (!PyArg_UnpackTuple(args, (char *)"own", 0, 1, &val))
1522 #endif
1523 {
1524 return NULL;
1525 }
1526 else
1527 {
1528 PySwigObject *sobj = (PySwigObject *)v;
1529 PyObject *obj = PyBool_FromLong(sobj->own);
1530 if (val) {
1531 #ifdef METH_NOARGS
1532 if (PyObject_IsTrue(val)) {
1533 PySwigObject_acquire(v);
1534 } else {
1535 PySwigObject_disown(v);
1536 }
1537 #else
1538 if (PyObject_IsTrue(val)) {
1539 PySwigObject_acquire(v,args);
1540 } else {
1541 PySwigObject_disown(v,args);
1542 }
1543 #endif
1544 }
1545 return obj;
1546 }
1547 }
1548
1549 #ifdef METH_O
1550 static PyMethodDef
1551 swigobject_methods[] = {
1552 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_NOARGS, (char *)"releases ownership of the pointer"},
1553 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_NOARGS, (char *)"aquires ownership of the pointer"},
1554 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1555 {(char *)"append", (PyCFunction)PySwigObject_append, METH_O, (char *)"appends another 'this' object"},
1556 {(char *)"next", (PyCFunction)PySwigObject_next, METH_NOARGS, (char *)"returns the next 'this' object"},
1557 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_NOARGS, (char *)"returns object representation"},
1558 {0, 0, 0, 0}
1559 };
1560 #else
1561 static PyMethodDef
1562 swigobject_methods[] = {
1563 {(char *)"disown", (PyCFunction)PySwigObject_disown, METH_VARARGS, (char *)"releases ownership of the pointer"},
1564 {(char *)"acquire", (PyCFunction)PySwigObject_acquire, METH_VARARGS, (char *)"aquires ownership of the pointer"},
1565 {(char *)"own", (PyCFunction)PySwigObject_own, METH_VARARGS, (char *)"returns/sets ownership of the pointer"},
1566 {(char *)"append", (PyCFunction)PySwigObject_append, METH_VARARGS, (char *)"appends another 'this' object"},
1567 {(char *)"next", (PyCFunction)PySwigObject_next, METH_VARARGS, (char *)"returns the next 'this' object"},
1568 {(char *)"__repr__",(PyCFunction)PySwigObject_repr, METH_VARARGS, (char *)"returns object representation"},
1569 {0, 0, 0, 0}
1570 };
1571 #endif
1572
1573 #if PY_VERSION_HEX < 0x02020000
1574 SWIGINTERN PyObject *
1575 PySwigObject_getattr(PySwigObject *sobj,char *name)
1576 {
1577 return Py_FindMethod(swigobject_methods, (PyObject *)sobj, name);
1578 }
1579 #endif
1580
1581 SWIGRUNTIME PyTypeObject*
1582 _PySwigObject_type(void) {
1583 static char swigobject_doc[] = "Swig object carries a C/C++ instance pointer";
1584
1585 static PyNumberMethods PySwigObject_as_number = {
1586 (binaryfunc)0, /*nb_add*/
1587 (binaryfunc)0, /*nb_subtract*/
1588 (binaryfunc)0, /*nb_multiply*/
1589 (binaryfunc)0, /*nb_divide*/
1590 (binaryfunc)0, /*nb_remainder*/
1591 (binaryfunc)0, /*nb_divmod*/
1592 (ternaryfunc)0,/*nb_power*/
1593 (unaryfunc)0, /*nb_negative*/
1594 (unaryfunc)0, /*nb_positive*/
1595 (unaryfunc)0, /*nb_absolute*/
1596 (inquiry)0, /*nb_nonzero*/
1597 0, /*nb_invert*/
1598 0, /*nb_lshift*/
1599 0, /*nb_rshift*/
1600 0, /*nb_and*/
1601 0, /*nb_xor*/
1602 0, /*nb_or*/
1603 (coercion)0, /*nb_coerce*/
1604 (unaryfunc)PySwigObject_long, /*nb_int*/
1605 (unaryfunc)PySwigObject_long, /*nb_long*/
1606 (unaryfunc)0, /*nb_float*/
1607 (unaryfunc)PySwigObject_oct, /*nb_oct*/
1608 (unaryfunc)PySwigObject_hex, /*nb_hex*/
1609 #if PY_VERSION_HEX >= 0x02020000
1610 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_true_divide */
1611 #elif PY_VERSION_HEX >= 0x02000000
1612 0,0,0,0,0,0,0,0,0,0,0 /* nb_inplace_add -> nb_inplace_or */
1613 #endif
1614 };
1615
1616 static PyTypeObject pyswigobject_type;
1617 static int type_init = 0;
1618 if (!type_init) {
1619 const PyTypeObject tmp
1620 = {
1621 PyObject_HEAD_INIT(NULL)
1622 0, /* ob_size */
1623 (char *)"PySwigObject", /* tp_name */
1624 sizeof(PySwigObject), /* tp_basicsize */
1625 0, /* tp_itemsize */
1626 (destructor)PySwigObject_dealloc, /* tp_dealloc */
1627 (printfunc)PySwigObject_print, /* tp_print */
1628 #if PY_VERSION_HEX < 0x02020000
1629 (getattrfunc)PySwigObject_getattr, /* tp_getattr */
1630 #else
1631 (getattrfunc)0, /* tp_getattr */
1632 #endif
1633 (setattrfunc)0, /* tp_setattr */
1634 (cmpfunc)PySwigObject_compare, /* tp_compare */
1635 (reprfunc)PySwigObject_repr, /* tp_repr */
1636 &PySwigObject_as_number, /* tp_as_number */
1637 0, /* tp_as_sequence */
1638 0, /* tp_as_mapping */
1639 (hashfunc)0, /* tp_hash */
1640 (ternaryfunc)0, /* tp_call */
1641 (reprfunc)PySwigObject_str, /* tp_str */
1642 PyObject_GenericGetAttr, /* tp_getattro */
1643 0, /* tp_setattro */
1644 0, /* tp_as_buffer */
1645 Py_TPFLAGS_DEFAULT, /* tp_flags */
1646 swigobject_doc, /* tp_doc */
1647 0, /* tp_traverse */
1648 0, /* tp_clear */
1649 0, /* tp_richcompare */
1650 0, /* tp_weaklistoffset */
1651 #if PY_VERSION_HEX >= 0x02020000
1652 0, /* tp_iter */
1653 0, /* tp_iternext */
1654 swigobject_methods, /* tp_methods */
1655 0, /* tp_members */
1656 0, /* tp_getset */
1657 0, /* tp_base */
1658 0, /* tp_dict */
1659 0, /* tp_descr_get */
1660 0, /* tp_descr_set */
1661 0, /* tp_dictoffset */
1662 0, /* tp_init */
1663 0, /* tp_alloc */
1664 0, /* tp_new */
1665 0, /* tp_free */
1666 0, /* tp_is_gc */
1667 0, /* tp_bases */
1668 0, /* tp_mro */
1669 0, /* tp_cache */
1670 0, /* tp_subclasses */
1671 0, /* tp_weaklist */
1672 #endif
1673 #if PY_VERSION_HEX >= 0x02030000
1674 0, /* tp_del */
1675 #endif
1676 #ifdef COUNT_ALLOCS
1677 0,0,0,0 /* tp_alloc -> tp_next */
1678 #endif
1679 };
1680 pyswigobject_type = tmp;
1681 pyswigobject_type.ob_type = &PyType_Type;
1682 type_init = 1;
1683 }
1684 return &pyswigobject_type;
1685 }
1686
1687 SWIGRUNTIME PyObject *
1688 PySwigObject_New(void *ptr, swig_type_info *ty, int own)
1689 {
1690 PySwigObject *sobj = PyObject_NEW(PySwigObject, PySwigObject_type());
1691 if (sobj) {
1692 sobj->ptr = ptr;
1693 sobj->ty = ty;
1694 sobj->own = own;
1695 sobj->next = 0;
1696 }
1697 return (PyObject *)sobj;
1698 }
1699
1700 /* -----------------------------------------------------------------------------
1701 * Implements a simple Swig Packed type, and use it instead of string
1702 * ----------------------------------------------------------------------------- */
1703
1704 typedef struct {
1705 PyObject_HEAD
1706 void *pack;
1707 swig_type_info *ty;
1708 size_t size;
1709 } PySwigPacked;
1710
1711 SWIGRUNTIME int
1712 PySwigPacked_print(PySwigPacked *v, FILE *fp, int SWIGUNUSEDPARM(flags))
1713 {
1714 char result[SWIG_BUFFER_SIZE];
1715 fputs("<Swig Packed ", fp);
1716 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1717 fputs("at ", fp);
1718 fputs(result, fp);
1719 }
1720 fputs(v->ty->name,fp);
1721 fputs(">", fp);
1722 return 0;
1723 }
1724
1725 SWIGRUNTIME PyObject *
1726 PySwigPacked_repr(PySwigPacked *v)
1727 {
1728 char result[SWIG_BUFFER_SIZE];
1729 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))) {
1730 return PyString_FromFormat("<Swig Packed at %s%s>", result, v->ty->name);
1731 } else {
1732 return PyString_FromFormat("<Swig Packed %s>", v->ty->name);
1733 }
1734 }
1735
1736 SWIGRUNTIME PyObject *
1737 PySwigPacked_str(PySwigPacked *v)
1738 {
1739 char result[SWIG_BUFFER_SIZE];
1740 if (SWIG_PackDataName(result, v->pack, v->size, 0, sizeof(result))){
1741 return PyString_FromFormat("%s%s", result, v->ty->name);
1742 } else {
1743 return PyString_FromString(v->ty->name);
1744 }
1745 }
1746
1747 SWIGRUNTIME int
1748 PySwigPacked_compare(PySwigPacked *v, PySwigPacked *w)
1749 {
1750 size_t i = v->size;
1751 size_t j = w->size;
1752 int s = (i < j) ? -1 : ((i > j) ? 1 : 0);
1753 return s ? s : strncmp((char *)v->pack, (char *)w->pack, 2*v->size);
1754 }
1755
1756 SWIGRUNTIME PyTypeObject* _PySwigPacked_type(void);
1757
1758 SWIGRUNTIME PyTypeObject*
1759 PySwigPacked_type(void) {
1760 static PyTypeObject *SWIG_STATIC_POINTER(type) = _PySwigPacked_type();
1761 return type;
1762 }
1763
1764 SWIGRUNTIMEINLINE int
1765 PySwigPacked_Check(PyObject *op) {
1766 return ((op)->ob_type == _PySwigPacked_type())
1767 || (strcmp((op)->ob_type->tp_name,"PySwigPacked") == 0);
1768 }
1769
1770 SWIGRUNTIME void
1771 PySwigPacked_dealloc(PyObject *v)
1772 {
1773 if (PySwigPacked_Check(v)) {
1774 PySwigPacked *sobj = (PySwigPacked *) v;
1775 free(sobj->pack);
1776 }
1777 PyObject_DEL(v);
1778 }
1779
1780 SWIGRUNTIME PyTypeObject*
1781 _PySwigPacked_type(void) {
1782 static char swigpacked_doc[] = "Swig object carries a C/C++ instance pointer";
1783 static PyTypeObject pyswigpacked_type;
1784 static int type_init = 0;
1785 if (!type_init) {
1786 const PyTypeObject tmp
1787 = {
1788 PyObject_HEAD_INIT(NULL)
1789 0, /* ob_size */
1790 (char *)"PySwigPacked", /* tp_name */
1791 sizeof(PySwigPacked), /* tp_basicsize */
1792 0, /* tp_itemsize */
1793 (destructor)PySwigPacked_dealloc, /* tp_dealloc */
1794 (printfunc)PySwigPacked_print, /* tp_print */
1795 (getattrfunc)0, /* tp_getattr */
1796 (setattrfunc)0, /* tp_setattr */
1797 (cmpfunc)PySwigPacked_compare, /* tp_compare */
1798 (reprfunc)PySwigPacked_repr, /* tp_repr */
1799 0, /* tp_as_number */
1800 0, /* tp_as_sequence */
1801 0, /* tp_as_mapping */
1802 (hashfunc)0, /* tp_hash */
1803 (ternaryfunc)0, /* tp_call */
1804 (reprfunc)PySwigPacked_str, /* tp_str */
1805 PyObject_GenericGetAttr, /* tp_getattro */
1806 0, /* tp_setattro */
1807 0, /* tp_as_buffer */
1808 Py_TPFLAGS_DEFAULT, /* tp_flags */
1809 swigpacked_doc, /* tp_doc */
1810 0, /* tp_traverse */
1811 0, /* tp_clear */
1812 0, /* tp_richcompare */
1813 0, /* tp_weaklistoffset */
1814 #if PY_VERSION_HEX >= 0x02020000
1815 0, /* tp_iter */
1816 0, /* tp_iternext */
1817 0, /* tp_methods */
1818 0, /* tp_members */
1819 0, /* tp_getset */
1820 0, /* tp_base */
1821 0, /* tp_dict */
1822 0, /* tp_descr_get */
1823 0, /* tp_descr_set */
1824 0, /* tp_dictoffset */
1825 0, /* tp_init */
1826 0, /* tp_alloc */
1827 0, /* tp_new */
1828 0, /* tp_free */
1829 0, /* tp_is_gc */
1830 0, /* tp_bases */
1831 0, /* tp_mro */
1832 0, /* tp_cache */
1833 0, /* tp_subclasses */
1834 0, /* tp_weaklist */
1835 #endif
1836 #if PY_VERSION_HEX >= 0x02030000
1837 0, /* tp_del */
1838 #endif
1839 #ifdef COUNT_ALLOCS
1840 0,0,0,0 /* tp_alloc -> tp_next */
1841 #endif
1842 };
1843 pyswigpacked_type = tmp;
1844 pyswigpacked_type.ob_type = &PyType_Type;
1845 type_init = 1;
1846 }
1847 return &pyswigpacked_type;
1848 }
1849
1850 SWIGRUNTIME PyObject *
1851 PySwigPacked_New(void *ptr, size_t size, swig_type_info *ty)
1852 {
1853 PySwigPacked *sobj = PyObject_NEW(PySwigPacked, PySwigPacked_type());
1854 if (sobj) {
1855 void *pack = malloc(size);
1856 if (pack) {
1857 memcpy(pack, ptr, size);
1858 sobj->pack = pack;
1859 sobj->ty = ty;
1860 sobj->size = size;
1861 } else {
1862 PyObject_DEL((PyObject *) sobj);
1863 sobj = 0;
1864 }
1865 }
1866 return (PyObject *) sobj;
1867 }
1868
1869 SWIGRUNTIME swig_type_info *
1870 PySwigPacked_UnpackData(PyObject *obj, void *ptr, size_t size)
1871 {
1872 if (PySwigPacked_Check(obj)) {
1873 PySwigPacked *sobj = (PySwigPacked *)obj;
1874 if (sobj->size != size) return 0;
1875 memcpy(ptr, sobj->pack, size);
1876 return sobj->ty;
1877 } else {
1878 return 0;
1879 }
1880 }
1881
1882 /* -----------------------------------------------------------------------------
1883 * pointers/data manipulation
1884 * ----------------------------------------------------------------------------- */
1885
1886 SWIGRUNTIMEINLINE PyObject *
1887 _SWIG_This(void)
1888 {
1889 return PyString_FromString("this");
1890 }
1891
1892 SWIGRUNTIME PyObject *
1893 SWIG_This(void)
1894 {
1895 static PyObject *SWIG_STATIC_POINTER(swig_this) = _SWIG_This();
1896 return swig_this;
1897 }
1898
1899 /* #define SWIG_PYTHON_SLOW_GETSET_THIS */
1900
1901 SWIGRUNTIME PySwigObject *
1902 SWIG_Python_GetSwigThis(PyObject *pyobj)
1903 {
1904 if (PySwigObject_Check(pyobj)) {
1905 return (PySwigObject *) pyobj;
1906 } else {
1907 PyObject *obj = 0;
1908 #if (!defined(SWIG_PYTHON_SLOW_GETSET_THIS) && (PY_VERSION_HEX >= 0x02030000))
1909 if (PyInstance_Check(pyobj)) {
1910 obj = _PyInstance_Lookup(pyobj, SWIG_This());
1911 } else {
1912 PyObject **dictptr = _PyObject_GetDictPtr(pyobj);
1913 if (dictptr != NULL) {
1914 PyObject *dict = *dictptr;
1915 obj = dict ? PyDict_GetItem(dict, SWIG_This()) : 0;
1916 } else {
1917 #ifdef PyWeakref_CheckProxy
1918 if (PyWeakref_CheckProxy(pyobj)) {
1919 PyObject *wobj = PyWeakref_GET_OBJECT(pyobj);
1920 return wobj ? SWIG_Python_GetSwigThis(wobj) : 0;
1921 }
1922 #endif
1923 obj = PyObject_GetAttr(pyobj,SWIG_This());
1924 if (obj) {
1925 Py_DECREF(obj);
1926 } else {
1927 if (PyErr_Occurred()) PyErr_Clear();
1928 return 0;
1929 }
1930 }
1931 }
1932 #else
1933 obj = PyObject_GetAttr(pyobj,SWIG_This());
1934 if (obj) {
1935 Py_DECREF(obj);
1936 } else {
1937 if (PyErr_Occurred()) PyErr_Clear();
1938 return 0;
1939 }
1940 #endif
1941 if (obj && !PySwigObject_Check(obj)) {
1942 /* a PyObject is called 'this', try to get the 'real this'
1943 PySwigObject from it */
1944 return SWIG_Python_GetSwigThis(obj);
1945 }
1946 return (PySwigObject *)obj;
1947 }
1948 }
1949
1950 /* Acquire a pointer value */
1951
1952 SWIGRUNTIME int
1953 SWIG_Python_AcquirePtr(PyObject *obj, int own) {
1954 if (own) {
1955 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1956 if (sobj) {
1957 int oldown = sobj->own;
1958 sobj->own = own;
1959 return oldown;
1960 }
1961 }
1962 return 0;
1963 }
1964
1965 /* Convert a pointer value */
1966
1967 SWIGRUNTIME int
1968 SWIG_Python_ConvertPtrAndOwn(PyObject *obj, void **ptr, swig_type_info *ty, int flags, int *own) {
1969 if (!obj) return SWIG_ERROR;
1970 if (obj == Py_None) {
1971 if (ptr) *ptr = 0;
1972 return SWIG_OK;
1973 } else {
1974 PySwigObject *sobj = SWIG_Python_GetSwigThis(obj);
1975 while (sobj) {
1976 void *vptr = sobj->ptr;
1977 if (ty) {
1978 swig_type_info *to = sobj->ty;
1979 if (to == ty) {
1980 /* no type cast needed */
1981 if (ptr) *ptr = vptr;
1982 break;
1983 } else {
1984 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
1985 if (!tc) {
1986 sobj = (PySwigObject *)sobj->next;
1987 } else {
1988 if (ptr) *ptr = SWIG_TypeCast(tc,vptr);
1989 break;
1990 }
1991 }
1992 } else {
1993 if (ptr) *ptr = vptr;
1994 break;
1995 }
1996 }
1997 if (sobj) {
1998 if (own) *own = sobj->own;
1999 if (flags & SWIG_POINTER_DISOWN) {
2000 sobj->own = 0;
2001 }
2002 return SWIG_OK;
2003 } else {
2004 int res = SWIG_ERROR;
2005 if (flags & SWIG_POINTER_IMPLICIT_CONV) {
2006 PySwigClientData *data = ty ? (PySwigClientData *) ty->clientdata : 0;
2007 if (data && !data->implicitconv) {
2008 PyObject *klass = data->klass;
2009 if (klass) {
2010 PyObject *impconv;
2011 data->implicitconv = 1; /* avoid recursion and call 'explicit' constructors*/
2012 impconv = SWIG_Python_CallFunctor(klass, obj);
2013 data->implicitconv = 0;
2014 if (PyErr_Occurred()) {
2015 PyErr_Clear();
2016 impconv = 0;
2017 }
2018 if (impconv) {
2019 PySwigObject *iobj = SWIG_Python_GetSwigThis(impconv);
2020 if (iobj) {
2021 void *vptr;
2022 res = SWIG_Python_ConvertPtrAndOwn((PyObject*)iobj, &vptr, ty, 0, 0);
2023 if (SWIG_IsOK(res)) {
2024 if (ptr) {
2025 *ptr = vptr;
2026 /* transfer the ownership to 'ptr' */
2027 iobj->own = 0;
2028 res = SWIG_AddCast(res);
2029 res = SWIG_AddNewMask(res);
2030 } else {
2031 res = SWIG_AddCast(res);
2032 }
2033 }
2034 }
2035 Py_DECREF(impconv);
2036 }
2037 }
2038 }
2039 }
2040 return res;
2041 }
2042 }
2043 }
2044
2045 /* Convert a function ptr value */
2046
2047 SWIGRUNTIME int
2048 SWIG_Python_ConvertFunctionPtr(PyObject *obj, void **ptr, swig_type_info *ty) {
2049 if (!PyCFunction_Check(obj)) {
2050 return SWIG_ConvertPtr(obj, ptr, ty, 0);
2051 } else {
2052 void *vptr = 0;
2053
2054 /* here we get the method pointer for callbacks */
2055 const char *doc = (((PyCFunctionObject *)obj) -> m_ml -> ml_doc);
2056 const char *desc = doc ? strstr(doc, "swig_ptr: ") : 0;
2057 if (desc) {
2058 desc = ty ? SWIG_UnpackVoidPtr(desc + 10, &vptr, ty->name) : 0;
2059 if (!desc) return SWIG_ERROR;
2060 }
2061 if (ty) {
2062 swig_cast_info *tc = SWIG_TypeCheck(desc,ty);
2063 if (!tc) return SWIG_ERROR;
2064 *ptr = SWIG_TypeCast(tc,vptr);
2065 } else {
2066 *ptr = vptr;
2067 }
2068 return SWIG_OK;
2069 }
2070 }
2071
2072 /* Convert a packed value value */
2073
2074 SWIGRUNTIME int
2075 SWIG_Python_ConvertPacked(PyObject *obj, void *ptr, size_t sz, swig_type_info *ty) {
2076 swig_type_info *to = PySwigPacked_UnpackData(obj, ptr, sz);
2077 if (!to) return SWIG_ERROR;
2078 if (ty) {
2079 if (to != ty) {
2080 /* check type cast? */
2081 swig_cast_info *tc = SWIG_TypeCheck(to->name,ty);
2082 if (!tc) return SWIG_ERROR;
2083 }
2084 }
2085 return SWIG_OK;
2086 }
2087
2088 /* -----------------------------------------------------------------------------
2089 * Create a new pointer object
2090 * ----------------------------------------------------------------------------- */
2091
2092 /*
2093 Create a new instance object, whitout calling __init__, and set the
2094 'this' attribute.
2095 */
2096
2097 SWIGRUNTIME PyObject*
2098 SWIG_Python_NewShadowInstance(PySwigClientData *data, PyObject *swig_this)
2099 {
2100 #if (PY_VERSION_HEX >= 0x02020000)
2101 PyObject *inst = 0;
2102 PyObject *newraw = data->newraw;
2103 if (newraw) {
2104 inst = PyObject_Call(newraw, data->newargs, NULL);
2105 if (inst) {
2106 #if !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2107 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2108 if (dictptr != NULL) {
2109 PyObject *dict = *dictptr;
2110 if (dict == NULL) {
2111 dict = PyDict_New();
2112 *dictptr = dict;
2113 PyDict_SetItem(dict, SWIG_This(), swig_this);
2114 }
2115 }
2116 #else
2117 PyObject *key = SWIG_This();
2118 PyObject_SetAttr(inst, key, swig_this);
2119 #endif
2120 }
2121 } else {
2122 PyObject *dict = PyDict_New();
2123 PyDict_SetItem(dict, SWIG_This(), swig_this);
2124 inst = PyInstance_NewRaw(data->newargs, dict);
2125 Py_DECREF(dict);
2126 }
2127 return inst;
2128 #else
2129 #if (PY_VERSION_HEX >= 0x02010000)
2130 PyObject *inst;
2131 PyObject *dict = PyDict_New();
2132 PyDict_SetItem(dict, SWIG_This(), swig_this);
2133 inst = PyInstance_NewRaw(data->newargs, dict);
2134 Py_DECREF(dict);
2135 return (PyObject *) inst;
2136 #else
2137 PyInstanceObject *inst = PyObject_NEW(PyInstanceObject, &PyInstance_Type);
2138 if (inst == NULL) {
2139 return NULL;
2140 }
2141 inst->in_class = (PyClassObject *)data->newargs;
2142 Py_INCREF(inst->in_class);
2143 inst->in_dict = PyDict_New();
2144 if (inst->in_dict == NULL) {
2145 Py_DECREF(inst);
2146 return NULL;
2147 }
2148 #ifdef Py_TPFLAGS_HAVE_WEAKREFS
2149 inst->in_weakreflist = NULL;
2150 #endif
2151 #ifdef Py_TPFLAGS_GC
2152 PyObject_GC_Init(inst);
2153 #endif
2154 PyDict_SetItem(inst->in_dict, SWIG_This(), swig_this);
2155 return (PyObject *) inst;
2156 #endif
2157 #endif
2158 }
2159
2160 SWIGRUNTIME void
2161 SWIG_Python_SetSwigThis(PyObject *inst, PyObject *swig_this)
2162 {
2163 PyObject *dict;
2164 #if (PY_VERSION_HEX >= 0x02020000) && !defined(SWIG_PYTHON_SLOW_GETSET_THIS)
2165 PyObject **dictptr = _PyObject_GetDictPtr(inst);
2166 if (dictptr != NULL) {
2167 dict = *dictptr;
2168 if (dict == NULL) {
2169 dict = PyDict_New();
2170 *dictptr = dict;
2171 }
2172 PyDict_SetItem(dict, SWIG_This(), swig_this);
2173 return;
2174 }
2175 #endif
2176 dict = PyObject_GetAttrString(inst, "__dict__");
2177 PyDict_SetItem(dict, SWIG_This(), swig_this);
2178 Py_DECREF(dict);
2179 }
2180
2181
2182 SWIGINTERN PyObject *
2183 SWIG_Python_InitShadowInstance(PyObject *args) {
2184 PyObject *obj[2];
2185 if (!SWIG_Python_UnpackTuple(args,(char*)"swiginit", 2, 2, obj)) {
2186 return NULL;
2187 } else {
2188 PySwigObject *sthis = SWIG_Python_GetSwigThis(obj[0]);
2189 if (sthis) {
2190 PySwigObject_append((PyObject*) sthis, obj[1]);
2191 } else {
2192 SWIG_Python_SetSwigThis(obj[0], obj[1]);
2193 }
2194 return SWIG_Py_Void();
2195 }
2196 }
2197
2198 /* Create a new pointer object */
2199
2200 SWIGRUNTIME PyObject *
2201 SWIG_Python_NewPointerObj(void *ptr, swig_type_info *type, int flags) {
2202 if (!ptr) {
2203 return SWIG_Py_Void();
2204 } else {
2205 int own = (flags & SWIG_POINTER_OWN) ? SWIG_POINTER_OWN : 0;
2206 PyObject *robj = PySwigObject_New(ptr, type, own);
2207 PySwigClientData *clientdata = type ? (PySwigClientData *)(type->clientdata) : 0;
2208 if (clientdata && !(flags & SWIG_POINTER_NOSHADOW)) {
2209 PyObject *inst = SWIG_Python_NewShadowInstance(clientdata, robj);
2210 if (inst) {
2211 Py_DECREF(robj);
2212 robj = inst;
2213 }
2214 }
2215 return robj;
2216 }
2217 }
2218
2219 /* Create a new packed object */
2220
2221 SWIGRUNTIMEINLINE PyObject *
2222 SWIG_Python_NewPackedObj(void *ptr, size_t sz, swig_type_info *type) {
2223 return ptr ? PySwigPacked_New((void *) ptr, sz, type) : SWIG_Py_Void();
2224 }
2225
2226 /* -----------------------------------------------------------------------------*
2227 * Get type list
2228 * -----------------------------------------------------------------------------*/
2229
2230 #ifdef SWIG_LINK_RUNTIME
2231 void *SWIG_ReturnGlobalTypeList(void *);
2232 #endif
2233
2234 SWIGRUNTIME swig_module_info *
2235 SWIG_Python_GetModule(void) {
2236 static void *type_pointer = (void *)0;
2237 /* first check if module already created */
2238 if (!type_pointer) {
2239 #ifdef SWIG_LINK_RUNTIME
2240 type_pointer = SWIG_ReturnGlobalTypeList((void *)0);
2241 #else
2242 type_pointer = PyCObject_Import((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2243 (char*)"type_pointer" SWIG_TYPE_TABLE_NAME);
2244 if (PyErr_Occurred()) {
2245 PyErr_Clear();
2246 type_pointer = (void *)0;
2247 }
2248 #endif
2249 }
2250 return (swig_module_info *) type_pointer;
2251 }
2252
2253 #if PY_MAJOR_VERSION < 2
2254 /* PyModule_AddObject function was introduced in Python 2.0. The following function
2255 is copied out of Python/modsupport.c in python version 2.3.4 */
2256 SWIGINTERN int
2257 PyModule_AddObject(PyObject *m, char *name, PyObject *o)
2258 {
2259 PyObject *dict;
2260 if (!PyModule_Check(m)) {
2261 PyErr_SetString(PyExc_TypeError,
2262 "PyModule_AddObject() needs module as first arg");
2263 return SWIG_ERROR;
2264 }
2265 if (!o) {
2266 PyErr_SetString(PyExc_TypeError,
2267 "PyModule_AddObject() needs non-NULL value");
2268 return SWIG_ERROR;
2269 }
2270
2271 dict = PyModule_GetDict(m);
2272 if (dict == NULL) {
2273 /* Internal error -- modules must have a dict! */
2274 PyErr_Format(PyExc_SystemError, "module '%s' has no __dict__",
2275 PyModule_GetName(m));
2276 return SWIG_ERROR;
2277 }
2278 if (PyDict_SetItemString(dict, name, o))
2279 return SWIG_ERROR;
2280 Py_DECREF(o);
2281 return SWIG_OK;
2282 }
2283 #endif
2284
2285 SWIGRUNTIME void
2286 SWIG_Python_DestroyModule(void *vptr)
2287 {
2288 swig_module_info *swig_module = (swig_module_info *) vptr;
2289 swig_type_info **types = swig_module->types;
2290 size_t i;
2291 for (i =0; i < swig_module->size; ++i) {
2292 swig_type_info *ty = types[i];
2293 if (ty->owndata) {
2294 PySwigClientData *data = (PySwigClientData *) ty->clientdata;
2295 if (data) PySwigClientData_Del(data);
2296 }
2297 }
2298 Py_DECREF(SWIG_This());
2299 }
2300
2301 SWIGRUNTIME void
2302 SWIG_Python_SetModule(swig_module_info *swig_module) {
2303 static PyMethodDef swig_empty_runtime_method_table[] = { {NULL, NULL, 0, NULL} };/* Sentinel */
2304
2305 PyObject *module = Py_InitModule((char*)"swig_runtime_data" SWIG_RUNTIME_VERSION,
2306 swig_empty_runtime_method_table);
2307 PyObject *pointer = PyCObject_FromVoidPtr((void *) swig_module, SWIG_Python_DestroyModule);
2308 if (pointer && module) {
2309 PyModule_AddObject(module, (char*)"type_pointer" SWIG_TYPE_TABLE_NAME, pointer);
2310 } else {
2311 Py_XDECREF(pointer);
2312 }
2313 }
2314
2315 /* The python cached type query */
2316 SWIGRUNTIME PyObject *
2317 SWIG_Python_TypeCache() {
2318 static PyObject *SWIG_STATIC_POINTER(cache) = PyDict_New();
2319 return cache;
2320 }
2321
2322 SWIGRUNTIME swig_type_info *
2323 SWIG_Python_TypeQuery(const char *type)
2324 {
2325 PyObject *cache = SWIG_Python_TypeCache();
2326 PyObject *key = PyString_FromString(type);
2327 PyObject *obj = PyDict_GetItem(cache, key);
2328 swig_type_info *descriptor;
2329 if (obj) {
2330 descriptor = (swig_type_info *) PyCObject_AsVoidPtr(obj);
2331 } else {
2332 swig_module_info *swig_module = SWIG_Python_GetModule();
2333 descriptor = SWIG_TypeQueryModule(swig_module, swig_module, type);
2334 if (descriptor) {
2335 obj = PyCObject_FromVoidPtr(descriptor, NULL);
2336 PyDict_SetItem(cache, key, obj);
2337 Py_DECREF(obj);
2338 }
2339 }
2340 Py_DECREF(key);
2341 return descriptor;
2342 }
2343
2344 /*
2345 For backward compatibility only
2346 */
2347 #define SWIG_POINTER_EXCEPTION 0
2348 #define SWIG_arg_fail(arg) SWIG_Python_ArgFail(arg)
2349 #define SWIG_MustGetPtr(p, type, argnum, flags) SWIG_Python_MustGetPtr(p, type, argnum, flags)
2350
2351 SWIGRUNTIME int
2352 SWIG_Python_AddErrMesg(const char* mesg, int infront)
2353 {
2354 if (PyErr_Occurred()) {
2355 PyObject *type = 0;
2356 PyObject *value = 0;
2357 PyObject *traceback = 0;
2358 PyErr_Fetch(&type, &value, &traceback);
2359 if (value) {
2360 PyObject *old_str = PyObject_Str(value);
2361 Py_XINCREF(type);
2362 PyErr_Clear();
2363 if (infront) {
2364 PyErr_Format(type, "%s %s", mesg, PyString_AsString(old_str));
2365 } else {
2366 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
2367 }
2368 Py_DECREF(old_str);
2369 }
2370 return 1;
2371 } else {
2372 return 0;
2373 }
2374 }
2375
2376 SWIGRUNTIME int
2377 SWIG_Python_ArgFail(int argnum)
2378 {
2379 if (PyErr_Occurred()) {
2380 /* add information about failing argument */
2381 char mesg[256];
2382 PyOS_snprintf(mesg, sizeof(mesg), "argument number %d:", argnum);
2383 return SWIG_Python_AddErrMesg(mesg, 1);
2384 } else {
2385 return 0;
2386 }
2387 }
2388
2389 SWIGRUNTIMEINLINE const char *
2390 PySwigObject_GetDesc(PyObject *self)
2391 {
2392 PySwigObject *v = (PySwigObject *)self;
2393 swig_type_info *ty = v ? v->ty : 0;
2394 return ty ? ty->str : (char*)"";
2395 }
2396
2397 SWIGRUNTIME void
2398 SWIG_Python_TypeError(const char *type, PyObject *obj)
2399 {
2400 if (type) {
2401 #if defined(SWIG_COBJECT_TYPES)
2402 if (obj && PySwigObject_Check(obj)) {
2403 const char *otype = (const char *) PySwigObject_GetDesc(obj);
2404 if (otype) {
2405 PyErr_Format(PyExc_TypeError, "a '%s' is expected, 'PySwigObject(%s)' is received",
2406 type, otype);
2407 return;
2408 }
2409 } else
2410 #endif
2411 {
2412 const char *otype = (obj ? obj->ob_type->tp_name : 0);
2413 if (otype) {
2414 PyObject *str = PyObject_Str(obj);
2415 const char *cstr = str ? PyString_AsString(str) : 0;
2416 if (cstr) {
2417 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s(%s)' is received",
2418 type, otype, cstr);
2419 } else {
2420 PyErr_Format(PyExc_TypeError, "a '%s' is expected, '%s' is received",
2421 type, otype);
2422 }
2423 Py_XDECREF(str);
2424 return;
2425 }
2426 }
2427 PyErr_Format(PyExc_TypeError, "a '%s' is expected", type);
2428 } else {
2429 PyErr_Format(PyExc_TypeError, "unexpected type is received");
2430 }
2431 }
2432
2433
2434 /* Convert a pointer value, signal an exception on a type mismatch */
2435 SWIGRUNTIME void *
2436 SWIG_Python_MustGetPtr(PyObject *obj, swig_type_info *ty, int argnum, int flags) {
2437 void *result;
2438 if (SWIG_Python_ConvertPtr(obj, &result, ty, flags) == -1) {
2439 PyErr_Clear();
2440 if (flags & SWIG_POINTER_EXCEPTION) {
2441 SWIG_Python_TypeError(SWIG_TypePrettyName(ty), obj);
2442 SWIG_Python_ArgFail(argnum);
2443 }
2444 }
2445 return result;
2446 }
2447
2448
2449 #ifdef __cplusplus
2450 #if 0
2451 { /* cc-mode */
2452 #endif
2453 }
2454 #endif
2455
2456
2457
2458 #define SWIG_exception_fail(code, msg) do { SWIG_Error(code, msg); SWIG_fail; } while(0)
2459
2460 #define SWIG_contract_assert(expr, msg) if (!(expr)) { SWIG_Error(SWIG_RuntimeError, msg); SWIG_fail; } else
2461
2462
2463
2464 /* -------- TYPES TABLE (BEGIN) -------- */
2465
2466 #define SWIGTYPE_p_buffer swig_types[0]
2467 #define SWIGTYPE_p_char swig_types[1]
2468 #define SWIGTYPE_p_form_ops_t swig_types[2]
2469 #define SWIGTYPE_p_int swig_types[3]
2470 #define SWIGTYPE_p_long swig_types[4]
2471 #define SWIGTYPE_p_unsigned_char swig_types[5]
2472 #define SWIGTYPE_p_unsigned_int swig_types[6]
2473 #define SWIGTYPE_p_unsigned_long swig_types[7]
2474 #define SWIGTYPE_p_wxANIHandler swig_types[8]
2475 #define SWIGTYPE_p_wxAcceleratorEntry swig_types[9]
2476 #define SWIGTYPE_p_wxAcceleratorTable swig_types[10]
2477 #define SWIGTYPE_p_wxActivateEvent swig_types[11]
2478 #define SWIGTYPE_p_wxAppTraits swig_types[12]
2479 #define SWIGTYPE_p_wxArrayString swig_types[13]
2480 #define SWIGTYPE_p_wxBMPHandler swig_types[14]
2481 #define SWIGTYPE_p_wxBitmap swig_types[15]
2482 #define SWIGTYPE_p_wxBoxSizer swig_types[16]
2483 #define SWIGTYPE_p_wxButton swig_types[17]
2484 #define SWIGTYPE_p_wxCURHandler swig_types[18]
2485 #define SWIGTYPE_p_wxCaret swig_types[19]
2486 #define SWIGTYPE_p_wxChildFocusEvent swig_types[20]
2487 #define SWIGTYPE_p_wxClipboardTextEvent swig_types[21]
2488 #define SWIGTYPE_p_wxCloseEvent swig_types[22]
2489 #define SWIGTYPE_p_wxColour swig_types[23]
2490 #define SWIGTYPE_p_wxCommandEvent swig_types[24]
2491 #define SWIGTYPE_p_wxContextMenuEvent swig_types[25]
2492 #define SWIGTYPE_p_wxControl swig_types[26]
2493 #define SWIGTYPE_p_wxControlWithItems swig_types[27]
2494 #define SWIGTYPE_p_wxCursor swig_types[28]
2495 #define SWIGTYPE_p_wxDC swig_types[29]
2496 #define SWIGTYPE_p_wxDateEvent swig_types[30]
2497 #define SWIGTYPE_p_wxDateTime swig_types[31]
2498 #define SWIGTYPE_p_wxDisplayChangedEvent swig_types[32]
2499 #define SWIGTYPE_p_wxDouble swig_types[33]
2500 #define SWIGTYPE_p_wxDropFilesEvent swig_types[34]
2501 #define SWIGTYPE_p_wxDuplexMode swig_types[35]
2502 #define SWIGTYPE_p_wxEraseEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEvent swig_types[37]
2504 #define SWIGTYPE_p_wxEventBlocker swig_types[38]
2505 #define SWIGTYPE_p_wxEventLoop swig_types[39]
2506 #define SWIGTYPE_p_wxEventLoopActivator swig_types[40]
2507 #define SWIGTYPE_p_wxEvtHandler swig_types[41]
2508 #define SWIGTYPE_p_wxFSFile swig_types[42]
2509 #define SWIGTYPE_p_wxFileSystem swig_types[43]
2510 #define SWIGTYPE_p_wxFileSystemHandler swig_types[44]
2511 #define SWIGTYPE_p_wxFlexGridSizer swig_types[45]
2512 #define SWIGTYPE_p_wxFocusEvent swig_types[46]
2513 #define SWIGTYPE_p_wxFont swig_types[47]
2514 #define SWIGTYPE_p_wxFrame swig_types[48]
2515 #define SWIGTYPE_p_wxGBPosition swig_types[49]
2516 #define SWIGTYPE_p_wxGBSizerItem swig_types[50]
2517 #define SWIGTYPE_p_wxGBSpan swig_types[51]
2518 #define SWIGTYPE_p_wxGIFHandler swig_types[52]
2519 #define SWIGTYPE_p_wxGridBagSizer swig_types[53]
2520 #define SWIGTYPE_p_wxGridSizer swig_types[54]
2521 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[55]
2522 #define SWIGTYPE_p_wxICOHandler swig_types[56]
2523 #define SWIGTYPE_p_wxIconizeEvent swig_types[57]
2524 #define SWIGTYPE_p_wxIdleEvent swig_types[58]
2525 #define SWIGTYPE_p_wxImage swig_types[59]
2526 #define SWIGTYPE_p_wxImageHandler swig_types[60]
2527 #define SWIGTYPE_p_wxImageHistogram swig_types[61]
2528 #define SWIGTYPE_p_wxImage_HSVValue swig_types[62]
2529 #define SWIGTYPE_p_wxImage_RGBValue swig_types[63]
2530 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[64]
2531 #define SWIGTYPE_p_wxInitDialogEvent swig_types[65]
2532 #define SWIGTYPE_p_wxInputStream swig_types[66]
2533 #define SWIGTYPE_p_wxInternetFSHandler swig_types[67]
2534 #define SWIGTYPE_p_wxItemContainer swig_types[68]
2535 #define SWIGTYPE_p_wxJPEGHandler swig_types[69]
2536 #define SWIGTYPE_p_wxKeyEvent swig_types[70]
2537 #define SWIGTYPE_p_wxLayoutConstraints swig_types[71]
2538 #define SWIGTYPE_p_wxMaximizeEvent swig_types[72]
2539 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[73]
2540 #define SWIGTYPE_p_wxMenu swig_types[74]
2541 #define SWIGTYPE_p_wxMenuBar swig_types[75]
2542 #define SWIGTYPE_p_wxMenuBarBase swig_types[76]
2543 #define SWIGTYPE_p_wxMenuEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMenuItem swig_types[78]
2545 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[80]
2547 #define SWIGTYPE_p_wxMouseEvent swig_types[81]
2548 #define SWIGTYPE_p_wxMoveEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxNcPaintEvent swig_types[84]
2551 #define SWIGTYPE_p_wxNotifyEvent swig_types[85]
2552 #define SWIGTYPE_p_wxObject swig_types[86]
2553 #define SWIGTYPE_p_wxOutputStream swig_types[87]
2554 #define SWIGTYPE_p_wxPCXHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPNGHandler swig_types[89]
2556 #define SWIGTYPE_p_wxPNMHandler swig_types[90]
2557 #define SWIGTYPE_p_wxPaintEvent swig_types[91]
2558 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[92]
2559 #define SWIGTYPE_p_wxPaperSize swig_types[93]
2560 #define SWIGTYPE_p_wxPoint swig_types[94]
2561 #define SWIGTYPE_p_wxPoint2D swig_types[95]
2562 #define SWIGTYPE_p_wxPropagateOnce swig_types[96]
2563 #define SWIGTYPE_p_wxPropagationDisabler swig_types[97]
2564 #define SWIGTYPE_p_wxPyApp swig_types[98]
2565 #define SWIGTYPE_p_wxPyCommandEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyDropTarget swig_types[100]
2567 #define SWIGTYPE_p_wxPyEvent swig_types[101]
2568 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[102]
2569 #define SWIGTYPE_p_wxPyImageHandler swig_types[103]
2570 #define SWIGTYPE_p_wxPyInputStream swig_types[104]
2571 #define SWIGTYPE_p_wxPySizer swig_types[105]
2572 #define SWIGTYPE_p_wxPyValidator swig_types[106]
2573 #define SWIGTYPE_p_wxQuantize swig_types[107]
2574 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[108]
2575 #define SWIGTYPE_p_wxRealPoint swig_types[109]
2576 #define SWIGTYPE_p_wxRect swig_types[110]
2577 #define SWIGTYPE_p_wxRect2D swig_types[111]
2578 #define SWIGTYPE_p_wxRegion swig_types[112]
2579 #define SWIGTYPE_p_wxScrollEvent swig_types[113]
2580 #define SWIGTYPE_p_wxScrollWinEvent swig_types[114]
2581 #define SWIGTYPE_p_wxSetCursorEvent swig_types[115]
2582 #define SWIGTYPE_p_wxShowEvent swig_types[116]
2583 #define SWIGTYPE_p_wxSize swig_types[117]
2584 #define SWIGTYPE_p_wxSizeEvent swig_types[118]
2585 #define SWIGTYPE_p_wxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxSizerItem swig_types[120]
2587 #define SWIGTYPE_p_wxStaticBox swig_types[121]
2588 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[122]
2589 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[123]
2590 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[124]
2591 #define SWIGTYPE_p_wxTGAHandler swig_types[125]
2592 #define SWIGTYPE_p_wxTIFFHandler swig_types[126]
2593 #define SWIGTYPE_p_wxToolTip swig_types[127]
2594 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[128]
2595 #define SWIGTYPE_p_wxValidator swig_types[129]
2596 #define SWIGTYPE_p_wxVisualAttributes swig_types[130]
2597 #define SWIGTYPE_p_wxWindow swig_types[131]
2598 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[132]
2599 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[133]
2600 #define SWIGTYPE_p_wxXPMHandler swig_types[134]
2601 #define SWIGTYPE_p_wxZipFSHandler swig_types[135]
2602 static swig_type_info *swig_types[137];
2603 static swig_module_info swig_module = {swig_types, 136, 0, 0, 0, 0};
2604 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2605 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2606
2607 /* -------- TYPES TABLE (END) -------- */
2608
2609 #if (PY_VERSION_HEX <= 0x02000000)
2610 # if !defined(SWIG_PYTHON_CLASSIC)
2611 # error "This python version requires to use swig with the '-classic' option"
2612 # endif
2613 #endif
2614 #if (PY_VERSION_HEX <= 0x02020000)
2615 # error "This python version requires to use swig with the '-nomodern' option"
2616 #endif
2617 #if (PY_VERSION_HEX <= 0x02020000)
2618 # error "This python version requires to use swig with the '-nomodernargs' option"
2619 #endif
2620 #ifndef METH_O
2621 # error "This python version requires to use swig with the '-nofastunpack' option"
2622 #endif
2623
2624 /*-----------------------------------------------
2625 @(target):= _core_.so
2626 ------------------------------------------------*/
2627 #define SWIG_init init_core_
2628
2629 #define SWIG_name "_core_"
2630
2631 #define SWIGVERSION 0x010329
2632
2633
2634 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2635 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2636
2637
2638 #include <stdexcept>
2639
2640
2641 namespace swig {
2642 class PyObject_ptr {
2643 protected:
2644 PyObject *_obj;
2645
2646 public:
2647 PyObject_ptr() :_obj(0)
2648 {
2649 }
2650
2651 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2652 {
2653 Py_XINCREF(_obj);
2654 }
2655
2656 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2657 {
2658 if (initial_ref) Py_XINCREF(_obj);
2659 }
2660
2661 PyObject_ptr & operator=(const PyObject_ptr& item)
2662 {
2663 Py_XINCREF(item._obj);
2664 Py_XDECREF(_obj);
2665 _obj = item._obj;
2666 return *this;
2667 }
2668
2669 ~PyObject_ptr()
2670 {
2671 Py_XDECREF(_obj);
2672 }
2673
2674 operator PyObject *() const
2675 {
2676 return _obj;
2677 }
2678
2679 PyObject *operator->() const
2680 {
2681 return _obj;
2682 }
2683 };
2684 }
2685
2686
2687 namespace swig {
2688 struct PyObject_var : PyObject_ptr {
2689 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2690
2691 PyObject_var & operator = (PyObject* obj)
2692 {
2693 Py_XDECREF(_obj);
2694 _obj = obj;
2695 return *this;
2696 }
2697 };
2698 }
2699
2700
2701 #include "wx/wxPython/wxPython_int.h"
2702 #include "wx/wxPython/pyclasses.h"
2703 #include "wx/wxPython/twoitem.h"
2704
2705
2706 #ifndef wxPyUSE_EXPORT
2707 // Helper functions for dealing with SWIG objects and such. These are
2708 // located here so they know about the SWIG types and functions declared
2709 // in the wrapper code.
2710
2711 #include <wx/hashmap.h>
2712 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2713
2714
2715 // Maintains a hashmap of className to swig_type_info pointers. Given the
2716 // name of a class either looks up the type info in the cache, or scans the
2717 // SWIG tables for it.
2718 extern PyObject* wxPyPtrTypeMap;
2719 static
2720 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2721
2722 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2723
2724 if (typeInfoCache == NULL)
2725 typeInfoCache = new wxPyTypeInfoHashMap;
2726
2727 wxString name(className);
2728 swig_type_info* swigType = (*typeInfoCache)[name];
2729
2730 if (! swigType) {
2731 // it wasn't in the cache, so look it up from SWIG
2732 name.Append(wxT(" *"));
2733 swigType = SWIG_TypeQuery(name.mb_str());
2734
2735 // if it still wasn't found, try looking for a mapped name
2736 if (!swigType) {
2737 PyObject* item;
2738 name = className;
2739
2740 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2741 (char*)(const char*)name.mbc_str())) != NULL) {
2742 name = wxString(PyString_AsString(item), *wxConvCurrent);
2743 name.Append(wxT(" *"));
2744 swigType = SWIG_TypeQuery(name.mb_str());
2745 }
2746 }
2747 if (swigType) {
2748 // and add it to the map if found
2749 (*typeInfoCache)[className] = swigType;
2750 }
2751 }
2752 return swigType;
2753 }
2754
2755
2756 // Check if a class name is a type known to SWIG
2757 bool wxPyCheckSwigType(const wxChar* className) {
2758
2759 swig_type_info* swigType = wxPyFindSwigType(className);
2760 return swigType != NULL;
2761 }
2762
2763
2764 // Given a pointer to a C++ object and a class name, construct a Python proxy
2765 // object for it.
2766 PyObject* wxPyConstructObject(void* ptr,
2767 const wxChar* className,
2768 int setThisOwn) {
2769
2770 swig_type_info* swigType = wxPyFindSwigType(className);
2771 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2772
2773 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2774 }
2775
2776
2777 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2778 // Ensures that the proxy object is of the specified (or derived) type. If
2779 // not able to perform the conversion then a Python exception is set and the
2780 // error should be handled properly in the caller. Returns True on success.
2781 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2782 const wxChar* className) {
2783
2784 swig_type_info* swigType = wxPyFindSwigType(className);
2785 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2786
2787 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2788 }
2789
2790
2791
2792 // Make a SWIGified pointer object suitable for a .this attribute
2793 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2794
2795 PyObject* robj = NULL;
2796
2797 swig_type_info* swigType = wxPyFindSwigType(className);
2798 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2799
2800 robj = PySwigObject_New(ptr, swigType, 0);
2801 return robj;
2802 }
2803
2804
2805 // Python's PyInstance_Check does not return True for instances of new-style
2806 // classes. This should get close enough for both new and old classes but I
2807 // should re-evaluate the need for doing instance checks...
2808 bool wxPyInstance_Check(PyObject* obj) {
2809 return PyObject_HasAttrString(obj, "__class__") != 0;
2810 }
2811
2812
2813 // This one checks if the object is an instance of a SWIG proxy class (it has
2814 // a .this attribute, and the .this attribute is a PySwigObject.)
2815 bool wxPySwigInstance_Check(PyObject* obj) {
2816 static PyObject* this_str = NULL;
2817 if (this_str == NULL)
2818 this_str = PyString_FromString("this");
2819
2820 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2821 if (this_attr) {
2822 bool retval = (PySwigObject_Check(this_attr) != 0);
2823 Py_DECREF(this_attr);
2824 return retval;
2825 }
2826
2827 PyErr_Clear();
2828 return false;
2829 }
2830
2831
2832 // Export a C API in a struct. Other modules will be able to load this from
2833 // the wx._core_ module and will then have safe access to these functions,
2834 // even if they are located in another shared library.
2835 static wxPyCoreAPI API = {
2836
2837 wxPyCheckSwigType,
2838 wxPyConstructObject,
2839 wxPyConvertSwigPtr,
2840 wxPyMakeSwigPtr,
2841
2842 wxPyBeginAllowThreads,
2843 wxPyEndAllowThreads,
2844 wxPyBeginBlockThreads,
2845 wxPyEndBlockThreads,
2846
2847 wxPy_ConvertList,
2848
2849 wxString_in_helper,
2850 Py2wxString,
2851 wx2PyString,
2852
2853 byte_LIST_helper,
2854 int_LIST_helper,
2855 long_LIST_helper,
2856 string_LIST_helper,
2857 wxPoint_LIST_helper,
2858 wxBitmap_LIST_helper,
2859 wxString_LIST_helper,
2860 wxAcceleratorEntry_LIST_helper,
2861
2862 wxSize_helper,
2863 wxPoint_helper,
2864 wxRealPoint_helper,
2865 wxRect_helper,
2866 wxColour_helper,
2867 wxPoint2D_helper,
2868
2869 wxPySimple_typecheck,
2870 wxColour_typecheck,
2871
2872 wxPyCBH_setCallbackInfo,
2873 wxPyCBH_findCallback,
2874 wxPyCBH_callCallback,
2875 wxPyCBH_callCallbackObj,
2876 wxPyCBH_delete,
2877
2878 wxPyMake_wxObject,
2879 wxPyMake_wxSizer,
2880 wxPyPtrTypeMap_Add,
2881 wxPy2int_seq_helper,
2882 wxPy4int_seq_helper,
2883 wxArrayString2PyList_helper,
2884 wxArrayInt2PyList_helper,
2885
2886 wxPyClientData_dtor,
2887 wxPyUserData_dtor,
2888 wxPyOORClientData_dtor,
2889
2890 wxPyCBInputStream_create,
2891 wxPyCBInputStream_copy,
2892
2893 wxPyInstance_Check,
2894 wxPySwigInstance_Check,
2895
2896 wxPyCheckForApp,
2897
2898 wxArrayDouble2PyList_helper,
2899 wxPoint2D_LIST_helper,
2900 wxRect2D_helper,
2901
2902 };
2903
2904 #endif
2905
2906
2907 #if !WXWIN_COMPATIBILITY_2_4
2908 #define wxHIDE_READONLY 0
2909 #endif
2910
2911
2912 #define SWIG_From_long PyInt_FromLong
2913
2914
2915 SWIGINTERNINLINE PyObject *
2916 SWIG_From_int (int value)
2917 {
2918 return SWIG_From_long (value);
2919 }
2920
2921 static const wxString wxPyEmptyString(wxEmptyString);
2922 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2923 return self->GetClassInfo()->GetClassName();
2924 }
2925 SWIGINTERN void wxObject_Destroy(wxObject *self){
2926 delete self;
2927 }
2928
2929 #ifndef __WXMAC__
2930 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2931 #endif
2932
2933
2934 #include <limits.h>
2935 #ifndef LLONG_MIN
2936 # define LLONG_MIN LONG_LONG_MIN
2937 #endif
2938 #ifndef LLONG_MAX
2939 # define LLONG_MAX LONG_LONG_MAX
2940 #endif
2941 #ifndef ULLONG_MAX
2942 # define ULLONG_MAX ULONG_LONG_MAX
2943 #endif
2944
2945
2946 SWIGINTERN int
2947 SWIG_AsVal_long (PyObject* obj, long* val)
2948 {
2949 if (PyNumber_Check(obj)) {
2950 if (val) *val = PyInt_AsLong(obj);
2951 return SWIG_OK;
2952 }
2953 return SWIG_TypeError;
2954 }
2955
2956
2957 SWIGINTERN int
2958 SWIG_AsVal_int (PyObject * obj, int *val)
2959 {
2960 long v;
2961 int res = SWIG_AsVal_long (obj, &v);
2962 if (SWIG_IsOK(res)) {
2963 if ((v < INT_MIN || v > INT_MAX)) {
2964 return SWIG_OverflowError;
2965 } else {
2966 if (val) *val = static_cast< int >(v);
2967 }
2968 }
2969 return res;
2970 }
2971
2972 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2973 wxSize temp, *obj = &temp;
2974 if ( other == Py_None ) return false;
2975 if ( ! wxSize_helper(other, &obj) ) {
2976 PyErr_Clear();
2977 return false;
2978 }
2979 return self->operator==(*obj);
2980 }
2981 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2982 wxSize temp, *obj = &temp;
2983 if ( other == Py_None ) return true;
2984 if ( ! wxSize_helper(other, &obj)) {
2985 PyErr_Clear();
2986 return true;
2987 }
2988 return self->operator!=(*obj);
2989 }
2990
2991 #include <float.h>
2992
2993
2994 SWIGINTERN int
2995 SWIG_AsVal_double (PyObject *obj, double* val)
2996 {
2997 if (PyNumber_Check(obj)) {
2998 if (val) *val = PyFloat_AsDouble(obj);
2999 return SWIG_OK;
3000 }
3001 return SWIG_TypeError;
3002 }
3003
3004
3005 SWIGINTERN int
3006 SWIG_AsVal_float (PyObject * obj, float *val)
3007 {
3008 double v;
3009 int res = SWIG_AsVal_double (obj, &v);
3010 if (SWIG_IsOK(res)) {
3011 if ((v < -FLT_MAX || v > FLT_MAX)) {
3012 return SWIG_OverflowError;
3013 } else {
3014 if (val) *val = static_cast< float >(v);
3015 }
3016 }
3017 return res;
3018 }
3019
3020 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3021 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3022 PyObject* tup = PyTuple_New(2);
3023 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3024 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3025 //wxPyEndBlockThreads(blocked);
3026 return tup;
3027 }
3028
3029 #define SWIG_From_double PyFloat_FromDouble
3030
3031 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3032 wxRealPoint temp, *obj = &temp;
3033 if ( other == Py_None ) return false;
3034 if ( ! wxRealPoint_helper(other, &obj) ) {
3035 PyErr_Clear();
3036 return false;
3037 }
3038 return self->operator==(*obj);
3039 }
3040 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3041 wxRealPoint temp, *obj = &temp;
3042 if ( other == Py_None ) return true;
3043 if ( ! wxRealPoint_helper(other, &obj)) {
3044 PyErr_Clear();
3045 return true;
3046 }
3047 return self->operator!=(*obj);
3048 }
3049 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3050 self->x = x;
3051 self->y = y;
3052 }
3053 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3054 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3055 PyObject* tup = PyTuple_New(2);
3056 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3057 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3058 //PyEndBlockThreads(blocked);
3059 return tup;
3060 }
3061 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3062 wxPoint temp, *obj = &temp;
3063 if ( other == Py_None ) return false;
3064 if ( ! wxPoint_helper(other, &obj) ) {
3065 PyErr_Clear();
3066 return false;
3067 }
3068 return self->operator==(*obj);
3069 }
3070 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3071 wxPoint temp, *obj = &temp;
3072 if ( other == Py_None ) return true;
3073 if ( ! wxPoint_helper(other, &obj)) {
3074 PyErr_Clear();
3075 return true;
3076 }
3077 return self->operator!=(*obj);
3078 }
3079 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3080 self->x = x;
3081 self->y = y;
3082 }
3083 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3084 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3085 PyObject* tup = PyTuple_New(2);
3086 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3087 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3088 //wxPyEndBlockThreads(blocked);
3089 return tup;
3090 }
3091 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3092 wxRect temp, *obj = &temp;
3093 if ( other == Py_None ) return false;
3094 if ( ! wxRect_helper(other, &obj) ) {
3095 PyErr_Clear();
3096 return false;
3097 }
3098 return self->operator==(*obj);
3099 }
3100 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3101 wxRect temp, *obj = &temp;
3102 if ( other == Py_None ) return true;
3103 if ( ! wxRect_helper(other, &obj)) {
3104 PyErr_Clear();
3105 return true;
3106 }
3107 return self->operator!=(*obj);
3108 }
3109 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3110 self->x = x;
3111 self->y = y;
3112 self->width = width;
3113 self->height = height;
3114 }
3115 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3116 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3117 PyObject* tup = PyTuple_New(4);
3118 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3119 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3120 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3121 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3122 //wxPyEndBlockThreads(blocked);
3123 return tup;
3124 }
3125
3126 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3127 wxRegion reg1(*r1);
3128 wxRegion reg2(*r2);
3129 wxRect dest(0,0,0,0);
3130 PyObject* obj;
3131
3132 reg1.Intersect(reg2);
3133 dest = reg1.GetBox();
3134
3135 if (dest != wxRect(0,0,0,0)) {
3136 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3137 wxRect* newRect = new wxRect(dest);
3138 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3139 //wxPyEndBlockThreads(blocked);
3140 return obj;
3141 }
3142 Py_INCREF(Py_None);
3143 return Py_None;
3144 }
3145
3146 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3147 wxPoint2D temp, *obj = &temp;
3148 if ( other == Py_None ) return false;
3149 if ( ! wxPoint2D_helper(other, &obj) ) {
3150 PyErr_Clear();
3151 return false;
3152 }
3153 return self->operator==(*obj);
3154 }
3155 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3156 wxPoint2D temp, *obj = &temp;
3157 if ( other == Py_None ) return true;
3158 if ( ! wxPoint2D_helper(other, &obj)) {
3159 PyErr_Clear();
3160 return true;
3161 }
3162 return self->operator!=(*obj);
3163 }
3164 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3165 self->m_x = x;
3166 self->m_y = y;
3167 }
3168 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3169 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3170 PyObject* tup = PyTuple_New(2);
3171 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3172 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3173 //wxPyEndBlockThreads(blocked);
3174 return tup;
3175 }
3176 SWIGINTERN bool wxRect2D___eq__(wxRect2D *self,PyObject *other){
3177 wxRect2D temp, *obj = &temp;
3178 if ( other == Py_None ) return false;
3179 if ( ! wxRect2D_helper(other, &obj) ) {
3180 PyErr_Clear();
3181 return false;
3182 }
3183 return self->operator==(*obj);
3184 }
3185 SWIGINTERN bool wxRect2D___ne__(wxRect2D *self,PyObject *other){
3186 wxRect2D temp, *obj = &temp;
3187 if ( other == Py_None ) return true;
3188 if ( ! wxRect2D_helper(other, &obj)) {
3189 PyErr_Clear();
3190 return true;
3191 }
3192 return self->operator!=(*obj);
3193 }
3194 SWIGINTERN void wxRect2D_Set(wxRect2D *self,wxDouble x=0,wxDouble y=0,wxDouble width=0,wxDouble height=0){
3195 self->m_x = x;
3196 self->m_y = y;
3197 self->m_width = width;
3198 self->m_height = height;
3199 }
3200 SWIGINTERN PyObject *wxRect2D_Get(wxRect2D *self){
3201 //wxPyBlock_t blocked = wxPyBeginBlockThreads();
3202 PyObject* tup = PyTuple_New(4);
3203 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3204 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3205 PyTuple_SET_ITEM(tup, 2, PyFloat_FromDouble(self->m_width));
3206 PyTuple_SET_ITEM(tup, 3, PyFloat_FromDouble(self->m_height));
3207 //wxPyEndBlockThreads(blocked);
3208 return tup;
3209 }
3210
3211 #include "wx/wxPython/pyistream.h"
3212
3213 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3214 wxInputStream* wxis = wxPyCBInputStream::create(p);
3215 if (wxis)
3216 return new wxPyInputStream(wxis);
3217 else
3218 return NULL;
3219 }
3220
3221 SWIGINTERN swig_type_info*
3222 SWIG_pchar_descriptor()
3223 {
3224 static int init = 0;
3225 static swig_type_info* info = 0;
3226 if (!init) {
3227 info = SWIG_TypeQuery("_p_char");
3228 init = 1;
3229 }
3230 return info;
3231 }
3232
3233
3234 SWIGINTERNINLINE PyObject *
3235 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3236 {
3237 if (carray) {
3238 if (size > INT_MAX) {
3239 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3240 return pchar_descriptor ?
3241 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3242 } else {
3243 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3244 }
3245 } else {
3246 return SWIG_Py_Void();
3247 }
3248 }
3249
3250
3251 SWIGINTERNINLINE PyObject *
3252 SWIG_From_char (char c)
3253 {
3254 return SWIG_FromCharPtrAndSize(&c,1);
3255 }
3256
3257
3258 SWIGINTERNINLINE PyObject*
3259 SWIG_From_unsigned_SS_long (unsigned long value)
3260 {
3261 return (value > LONG_MAX) ?
3262 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3263 }
3264
3265
3266 SWIGINTERNINLINE PyObject *
3267 SWIG_From_size_t (size_t value)
3268 {
3269 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3270 }
3271
3272
3273 SWIGINTERN int
3274 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3275 {
3276 if (PyString_Check(obj)) {
3277 char *cstr; Py_ssize_t len;
3278 PyString_AsStringAndSize(obj, &cstr, &len);
3279 if (cptr) {
3280 if (alloc) {
3281 /*
3282 In python the user should not be able to modify the inner
3283 string representation. To warranty that, if you define
3284 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3285 buffer is always returned.
3286
3287 The default behavior is just to return the pointer value,
3288 so, be careful.
3289 */
3290 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3291 if (*alloc != SWIG_OLDOBJ)
3292 #else
3293 if (*alloc == SWIG_NEWOBJ)
3294 #endif
3295 {
3296 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3297 *alloc = SWIG_NEWOBJ;
3298 }
3299 else {
3300 *cptr = cstr;
3301 *alloc = SWIG_OLDOBJ;
3302 }
3303 } else {
3304 *cptr = PyString_AsString(obj);
3305 }
3306 }
3307 if (psize) *psize = len + 1;
3308 return SWIG_OK;
3309 } else {
3310 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3311 if (pchar_descriptor) {
3312 void* vptr = 0;
3313 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3314 if (cptr) *cptr = (char *) vptr;
3315 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3316 if (alloc) *alloc = SWIG_OLDOBJ;
3317 return SWIG_OK;
3318 }
3319 }
3320 }
3321 return SWIG_TypeError;
3322 }
3323
3324
3325 SWIGINTERN int
3326 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3327 {
3328 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3329 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3330 if (SWIG_IsOK(res)) {
3331 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3332 if (csize <= size) {
3333 if (val) {
3334 if (csize) memcpy(val, cptr, csize*sizeof(char));
3335 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3336 }
3337 if (alloc == SWIG_NEWOBJ) {
3338 delete[] cptr;
3339 res = SWIG_DelNewMask(res);
3340 }
3341 return res;
3342 }
3343 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3344 }
3345 return SWIG_TypeError;
3346 }
3347
3348
3349 SWIGINTERN int
3350 SWIG_AsVal_char (PyObject * obj, char *val)
3351 {
3352 int res = SWIG_AsCharArray(obj, val, 1);
3353 if (!SWIG_IsOK(res)) {
3354 long v;
3355 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3356 if (SWIG_IsOK(res)) {
3357 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3358 if (val) *val = static_cast< char >(v);
3359 } else {
3360 res = SWIG_OverflowError;
3361 }
3362 }
3363 }
3364 return res;
3365 }
3366
3367 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3368 // We use only strings for the streams, not unicode
3369 PyObject* str = PyObject_Str(obj);
3370 if (! str) {
3371 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3372 return;
3373 }
3374 self->Write(PyString_AS_STRING(str),
3375 PyString_GET_SIZE(str));
3376 Py_DECREF(str);
3377 }
3378
3379 #include "wx/wxPython/pyistream.h"
3380
3381
3382 class wxPyFileSystemHandler : public wxFileSystemHandler
3383 {
3384 public:
3385 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3386
3387 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3388 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3389 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3390 DEC_PYCALLBACK_STRING__pure(FindNext);
3391
3392 wxString GetProtocol(const wxString& location) {
3393 return wxFileSystemHandler::GetProtocol(location);
3394 }
3395
3396 wxString GetLeftLocation(const wxString& location) {
3397 return wxFileSystemHandler::GetLeftLocation(location);
3398 }
3399
3400 wxString GetAnchor(const wxString& location) {
3401 return wxFileSystemHandler::GetAnchor(location);
3402 }
3403
3404 wxString GetRightLocation(const wxString& location) {
3405 return wxFileSystemHandler::GetRightLocation(location);
3406 }
3407
3408 wxString GetMimeTypeFromExt(const wxString& location) {
3409 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3410 }
3411
3412 PYPRIVATE;
3413 };
3414
3415
3416 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3417 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3418 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3419 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3420
3421
3422 SWIGINTERN int
3423 SWIG_AsVal_bool (PyObject *obj, bool *val)
3424 {
3425 if (obj == Py_True) {
3426 if (val) *val = true;
3427 return SWIG_OK;
3428 } else if (obj == Py_False) {
3429 if (val) *val = false;
3430 return SWIG_OK;
3431 } else {
3432 long v = 0;
3433 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3434 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3435 return res;
3436 }
3437 }
3438
3439 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3440 wxFileName fname = wxFileSystem::URLToFileName(url);
3441 return fname.GetFullPath();
3442 }
3443
3444 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3445 wxImage& image,
3446 long type) {
3447 wxMemoryFSHandler::AddFile(filename, image, type);
3448 }
3449
3450 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3451 const wxBitmap& bitmap,
3452 long type) {
3453 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3454 }
3455
3456 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3457 PyObject* data) {
3458 if (! PyString_Check(data)) {
3459 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3460 "Expected string object"));
3461 return;
3462 }
3463
3464 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3465 void* ptr = (void*)PyString_AsString(data);
3466 size_t size = PyString_Size(data);
3467 wxPyEndBlockThreads(blocked);
3468
3469 wxMemoryFSHandler::AddFile(filename, ptr, size);
3470 }
3471
3472
3473 #include "wx/wxPython/pyistream.h"
3474
3475
3476 SWIGINTERN int
3477 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3478 {
3479 long v = 0;
3480 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3481 return SWIG_TypeError;
3482 }
3483 else if (val)
3484 *val = (unsigned long)v;
3485 return SWIG_OK;
3486 }
3487
3488
3489 SWIGINTERN int
3490 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3491 {
3492 unsigned long v;
3493 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3494 if (SWIG_IsOK(res)) {
3495 if ((v > UCHAR_MAX)) {
3496 return SWIG_OverflowError;
3497 } else {
3498 if (val) *val = static_cast< unsigned char >(v);
3499 }
3500 }
3501 return res;
3502 }
3503
3504
3505 SWIGINTERNINLINE PyObject *
3506 SWIG_From_unsigned_SS_char (unsigned char value)
3507 {
3508 return SWIG_From_unsigned_SS_long (value);
3509 }
3510
3511 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3512 wxImageHistogramEntry e = (*self)[key];
3513 return e.value;
3514 }
3515 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3516 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3517 wxImageHistogramEntry e = (*self)[key];
3518 return e.value;
3519 }
3520 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3521 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3522 colour.Green(),
3523 colour.Blue());
3524 wxImageHistogramEntry e = (*self)[key];
3525 return e.value;
3526 }
3527
3528 // Pull the nested class out to the top level for SWIG's sake
3529 #define wxImage_RGBValue wxImage::RGBValue
3530 #define wxImage_HSVValue wxImage::HSVValue
3531
3532 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3533 if (width > 0 && height > 0)
3534 return new wxImage(width, height, clear);
3535 else
3536 return new wxImage;
3537 }
3538 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3539 return new wxImage(bitmap.ConvertToImage());
3540 }
3541 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3542 if (DATASIZE != width*height*3) {
3543 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3544 return NULL;
3545 }
3546
3547 // Copy the source data so the wxImage can clean it up later
3548 buffer copy = (buffer)malloc(DATASIZE);
3549 if (copy == NULL) {
3550 wxPyBLOCK_THREADS(PyErr_NoMemory());
3551 return NULL;
3552 }
3553 memcpy(copy, data, DATASIZE);
3554 return new wxImage(width, height, copy, false);
3555 }
3556 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3557 if (DATASIZE != width*height*3) {
3558 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3559 return NULL;
3560 }
3561 if (ALPHASIZE != width*height) {
3562 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3563 return NULL;
3564 }
3565
3566 // Copy the source data so the wxImage can clean it up later
3567 buffer dcopy = (buffer)malloc(DATASIZE);
3568 if (dcopy == NULL) {
3569 wxPyBLOCK_THREADS(PyErr_NoMemory());
3570 return NULL;
3571 }
3572 memcpy(dcopy, data, DATASIZE);
3573
3574 buffer acopy = (buffer)malloc(ALPHASIZE);
3575 if (acopy == NULL) {
3576 wxPyBLOCK_THREADS(PyErr_NoMemory());
3577 return NULL;
3578 }
3579 memcpy(acopy, alpha, ALPHASIZE);
3580
3581 return new wxImage(width, height, dcopy, acopy, false);
3582 }
3583 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3584 wxSize size(self->GetWidth(), self->GetHeight());
3585 return size;
3586 }
3587 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3588 buffer data = self->GetData();
3589 int len = self->GetWidth() * self->GetHeight() * 3;
3590 PyObject* rv;
3591 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3592 return rv;
3593 }
3594 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3595 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3596 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3597 return;
3598 }
3599 buffer copy = (buffer)malloc(DATASIZE);
3600 if (copy == NULL) {
3601 wxPyBLOCK_THREADS(PyErr_NoMemory());
3602 return;
3603 }
3604 memcpy(copy, data, DATASIZE);
3605 self->SetData(copy, false);
3606 // wxImage takes ownership of copy...
3607 }
3608 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3609 buffer data = self->GetData();
3610 int len = self->GetWidth() * self->GetHeight() * 3;
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3616 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3618 return;
3619 }
3620 self->SetData(data, true);
3621 }
3622 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3623 buffer data = self->GetAlpha();
3624 if (! data) {
3625 RETURN_NONE();
3626 } else {
3627 int len = self->GetWidth() * self->GetHeight();
3628 PyObject* rv;
3629 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3630 return rv;
3631 }
3632 }
3633 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3634 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3635 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3636 return;
3637 }
3638 buffer acopy = (buffer)malloc(ALPHASIZE);
3639 if (acopy == NULL) {
3640 wxPyBLOCK_THREADS(PyErr_NoMemory());
3641 return;
3642 }
3643 memcpy(acopy, alpha, ALPHASIZE);
3644 self->SetAlpha(acopy, false);
3645 // wxImage takes ownership of acopy...
3646 }
3647 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3648 buffer data = self->GetAlpha();
3649 int len = self->GetWidth() * self->GetHeight();
3650 PyObject* rv;
3651 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3652 return rv;
3653 }
3654 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3655 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3656 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3657 return;
3658 }
3659 self->SetAlpha(alpha, true);
3660 }
3661 SWIGINTERN PyObject *wxImage_GetHandlers(){
3662 wxList& list = wxImage::GetHandlers();
3663 return wxPy_ConvertList(&list);
3664 }
3665 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3666 wxBitmap bitmap(*self, depth);
3667 return bitmap;
3668 }
3669 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3670 wxImage mono = self->ConvertToMono( red, green, blue );
3671 wxBitmap bitmap( mono, 1 );
3672 return bitmap;
3673 }
3674
3675 wxImage* _ImageFromBuffer(int width, int height,
3676 buffer data, int DATASIZE,
3677 buffer alpha=NULL, int ALPHASIZE=0)
3678 {
3679 if (DATASIZE != width*height*3) {
3680 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3681 return NULL;
3682 }
3683 if (alpha != NULL) {
3684 if (ALPHASIZE != width*height) {
3685 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3686 return NULL;
3687 }
3688 return new wxImage(width, height, data, alpha, true);
3689 }
3690 return new wxImage(width, height, data, true);
3691 }
3692
3693 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3694 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3695 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3696 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3697 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3698 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3699 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3700 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3701 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3702 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3703 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3704 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3705 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3706 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3707 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3708
3709 #include <wx/imagtga.h>
3710
3711
3712 #include <wx/quantize.h>
3713
3714 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3715 return wxQuantize::Quantize(src, dest,
3716 //NULL, // palette
3717 desiredNoColours,
3718 NULL, // eightBitData
3719 flags);
3720 }
3721 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3722 if (PyCallable_Check(func)) {
3723 self->Connect(id, lastId, eventType,
3724 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3725 new wxPyCallback(func));
3726 }
3727 else if (func == Py_None) {
3728 self->Disconnect(id, lastId, eventType,
3729 (wxObjectEventFunction)
3730 &wxPyCallback::EventThunker);
3731 }
3732 else {
3733 wxPyBLOCK_THREADS(
3734 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3735 }
3736 }
3737 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3738 return self->Disconnect(id, lastId, eventType,
3739 (wxObjectEventFunction)
3740 &wxPyCallback::EventThunker);
3741 }
3742 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3743 if (_self && _self != Py_None) {
3744 self->SetClientObject(new wxPyOORClientData(_self, incref));
3745 }
3746 else {
3747 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3748 if (data) {
3749 self->SetClientObject(NULL); // This will delete it too
3750 }
3751 }
3752 }
3753
3754 #if ! wxUSE_HOTKEY
3755 #define wxEVT_HOTKEY -9999
3756 #endif
3757
3758 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3759 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3760 if (data) {
3761 Py_INCREF(data->m_obj);
3762 return data->m_obj;
3763 } else {
3764 Py_INCREF(Py_None);
3765 return Py_None;
3766 }
3767 }
3768 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3769 wxPyClientData* data = new wxPyClientData(clientData);
3770 self->SetClientObject(data);
3771 }
3772 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3773 #if wxUSE_UNICODE
3774 return self->GetUnicodeKey();
3775 #else
3776 return 0;
3777 #endif
3778 }
3779 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3780 #if wxUSE_UNICODE
3781 self->m_uniChar = uniChar;
3782 #endif
3783 }
3784
3785 SWIGINTERNINLINE PyObject *
3786 SWIG_From_unsigned_SS_int (unsigned int value)
3787 {
3788 return SWIG_From_unsigned_SS_long (value);
3789 }
3790
3791
3792 SWIGINTERN int
3793 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3794 {
3795 unsigned long v;
3796 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3797 if (SWIG_IsOK(res)) {
3798 if ((v > UINT_MAX)) {
3799 return SWIG_OverflowError;
3800 } else {
3801 if (val) *val = static_cast< unsigned int >(v);
3802 }
3803 }
3804 return res;
3805 }
3806
3807 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3808 self->m_size = size;
3809 }
3810 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3811 int count = self->GetNumberOfFiles();
3812 wxString* files = self->GetFiles();
3813 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3814 PyObject* list = PyList_New(count);
3815
3816 if (!list) {
3817 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3818 wxPyEndBlockThreads(blocked);
3819 return NULL;
3820 }
3821
3822 for (int i=0; i<count; i++) {
3823 PyList_SetItem(list, i, wx2PyString(files[i]));
3824 }
3825 wxPyEndBlockThreads(blocked);
3826 return list;
3827 }
3828
3829
3830 SWIGINTERN wxPyApp *new_wxPyApp(){
3831 wxPythonApp = new wxPyApp();
3832 return wxPythonApp;
3833 }
3834 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3835 return wxPyTestDisplayAvailable();
3836 }
3837
3838 void wxApp_CleanUp() {
3839 __wxPyCleanup();
3840 }
3841
3842
3843 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3844
3845
3846
3847
3848
3849 SWIGINTERNINLINE PyObject *
3850 SWIG_FromCharPtr(const char *cptr)
3851 {
3852 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3853 }
3854
3855
3856 #if 0 // #ifdef __WXMAC__
3857
3858 // A dummy class that raises an exception if used...
3859 class wxEventLoop
3860 {
3861 public:
3862 wxEventLoop() { wxPyRaiseNotImplemented(); }
3863 int Run() { return 0; }
3864 void Exit(int rc = 0) {}
3865 bool Pending() const { return false; }
3866 bool Dispatch() { return false; }
3867 bool IsRunning() const { return false; }
3868 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3869 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3870 };
3871
3872 #else
3873
3874 #include <wx/evtloop.h>
3875
3876 #endif
3877
3878
3879
3880 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3881 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3882 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3883 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3884 wxWindowList& list = self->GetChildren();
3885 return wxPy_ConvertList(&list);
3886 }
3887 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3888 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3889 #if wxUSE_HOTKEY
3890 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3891 #else
3892 return false;
3893 #endif
3894 }
3895 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3896
3897
3898
3899 return false;
3900
3901 }
3902 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3903 return wxPyGetWinHandle(self);
3904 }
3905 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3906 self->AssociateHandle((WXWidget)handle);
3907 }
3908
3909 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3910 return wxWindow::FindWindowById(id, parent);
3911 }
3912
3913 wxWindow* wxFindWindowByName( const wxString& name,
3914 const wxWindow *parent = NULL ) {
3915 return wxWindow::FindWindowByName(name, parent);
3916 }
3917
3918 wxWindow* wxFindWindowByLabel( const wxString& label,
3919 const wxWindow *parent = NULL ) {
3920 return wxWindow::FindWindowByLabel(label, parent);
3921 }
3922
3923
3924 #ifdef __WXMSW__
3925 #include <wx/msw/private.h> // to get wxGetWindowId
3926 #endif
3927
3928
3929 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3930 #ifdef __WXMSW__
3931 WXHWND hWnd = (WXHWND)_hWnd;
3932 long id = wxGetWindowId(hWnd);
3933 wxWindow* win = new wxWindow;
3934 if (parent)
3935 parent->AddChild(win);
3936 win->SetEventHandler(win);
3937 win->SetHWND(hWnd);
3938 win->SetId(id);
3939 win->SubclassWin(hWnd);
3940 win->AdoptAttributesFromHWND();
3941 win->SetupColours();
3942 return win;
3943 #else
3944 wxPyRaiseNotImplemented();
3945 return NULL;
3946 #endif
3947 }
3948
3949
3950 PyObject* GetTopLevelWindows() {
3951 return wxPy_ConvertList(&wxTopLevelWindows);
3952 }
3953
3954
3955 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3956 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3957 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3958
3959 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3960
3961
3962 SWIGINTERNINLINE int
3963 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3964 {
3965 unsigned long v;
3966 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3967 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3968 return res;
3969 }
3970
3971 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3972 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3973 wxMenuItemList& list = self->GetMenuItems();
3974 return wxPy_ConvertList(&list);
3975 }
3976 SWIGINTERN void wxMenuBar_SetAutoWindowMenu(bool enable){}
3977 SWIGINTERN bool wxMenuBar_GetAutoWindowMenu(){ return false; }
3978 static const wxString wxPyControlNameStr(wxControlNameStr);
3979 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3980 if (clientData) {
3981 wxPyClientData* data = new wxPyClientData(clientData);
3982 return self->Append(item, data);
3983 } else
3984 return self->Append(item);
3985 }
3986 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
3987 if (clientData) {
3988 wxPyClientData* data = new wxPyClientData(clientData);
3989 return self->Insert(item, pos, data);
3990 } else
3991 return self->Insert(item, pos);
3992 }
3993 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
3994 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3995 if (data) {
3996 Py_INCREF(data->m_obj);
3997 return data->m_obj;
3998 } else {
3999 Py_INCREF(Py_None);
4000 return Py_None;
4001 }
4002 }
4003 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4004 wxPyClientData* data = new wxPyClientData(clientData);
4005 self->SetClientObject(n, data);
4006 }
4007
4008
4009 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4010 wxPyUserData* data = NULL;
4011 if ( userData ) {
4012 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4013 data = new wxPyUserData(userData);
4014 wxPyEndBlockThreads(blocked);
4015 }
4016 return new wxSizerItem(window, proportion, flag, border, data);
4017 }
4018 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4019 wxPyUserData* data = NULL;
4020 if ( userData ) {
4021 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4022 data = new wxPyUserData(userData);
4023 wxPyEndBlockThreads(blocked);
4024 }
4025 return new wxSizerItem(width, height, proportion, flag, border, data);
4026 }
4027 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4028 wxPyUserData* data = NULL;
4029 if ( userData ) {
4030 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4031 data = new wxPyUserData(userData);
4032 wxPyEndBlockThreads(blocked);
4033 }
4034 return new wxSizerItem(sizer, proportion, flag, border, data);
4035 }
4036
4037 SWIGINTERNINLINE PyObject *
4038 SWIG_From_float (float value)
4039 {
4040 return SWIG_From_double (value);
4041 }
4042
4043 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4044 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4045 if (data) {
4046 Py_INCREF(data->m_obj);
4047 return data->m_obj;
4048 } else {
4049 Py_INCREF(Py_None);
4050 return Py_None;
4051 }
4052 }
4053 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4054 wxPyUserData* data = NULL;
4055 if ( userData ) {
4056 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4057 data = new wxPyUserData(userData);
4058 wxPyEndBlockThreads(blocked);
4059 }
4060 self->SetUserData(data);
4061 }
4062
4063 // Figure out the type of the sizer item
4064
4065 struct wxPySizerItemInfo {
4066 wxPySizerItemInfo()
4067 : window(NULL), sizer(NULL), gotSize(false),
4068 size(wxDefaultSize), gotPos(false), pos(-1)
4069 {}
4070
4071 wxWindow* window;
4072 wxSizer* sizer;
4073 bool gotSize;
4074 wxSize size;
4075 bool gotPos;
4076 int pos;
4077 };
4078
4079 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4080
4081 wxPySizerItemInfo info;
4082 wxSize size;
4083 wxSize* sizePtr = &size;
4084
4085 // Find out what the type of the item is
4086 // try wxWindow
4087 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4088 PyErr_Clear();
4089 info.window = NULL;
4090
4091 // try wxSizer
4092 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4093 PyErr_Clear();
4094 info.sizer = NULL;
4095
4096 // try wxSize or (w,h)
4097 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4098 info.size = *sizePtr;
4099 info.gotSize = true;
4100 }
4101
4102 // or a single int
4103 if (checkIdx && PyInt_Check(item)) {
4104 info.pos = PyInt_AsLong(item);
4105 info.gotPos = true;
4106 }
4107 }
4108 }
4109
4110 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4111 // no expected type, figure out what kind of error message to generate
4112 if ( !checkSize && !checkIdx )
4113 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4114 else if ( checkSize && !checkIdx )
4115 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4116 else if ( !checkSize && checkIdx)
4117 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4118 else
4119 // can this one happen?
4120 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4121 }
4122
4123 return info;
4124 }
4125
4126 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4127 if (!self->GetClientObject())
4128 self->SetClientObject(new wxPyOORClientData(_self));
4129 }
4130 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4131
4132 wxPyUserData* data = NULL;
4133 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4134 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4135 if ( userData && (info.window || info.sizer || info.gotSize) )
4136 data = new wxPyUserData(userData);
4137 if ( info.sizer )
4138 PyObject_SetAttrString(item,"thisown",Py_False);
4139 wxPyEndBlockThreads(blocked);
4140
4141 // Now call the real Add method if a valid item type was found
4142 if ( info.window )
4143 return self->Add(info.window, proportion, flag, border, data);
4144 else if ( info.sizer )
4145 return self->Add(info.sizer, proportion, flag, border, data);
4146 else if (info.gotSize)
4147 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4148 proportion, flag, border, data);
4149 else
4150 return NULL;
4151 }
4152 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4153
4154 wxPyUserData* data = NULL;
4155 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4156 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4157 if ( userData && (info.window || info.sizer || info.gotSize) )
4158 data = new wxPyUserData(userData);
4159 if ( info.sizer )
4160 PyObject_SetAttrString(item,"thisown",Py_False);
4161 wxPyEndBlockThreads(blocked);
4162
4163 // Now call the real Insert method if a valid item type was found
4164 if ( info.window )
4165 return self->Insert(before, info.window, proportion, flag, border, data);
4166 else if ( info.sizer )
4167 return self->Insert(before, info.sizer, proportion, flag, border, data);
4168 else if (info.gotSize)
4169 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4170 proportion, flag, border, data);
4171 else
4172 return NULL;
4173 }
4174 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4175
4176 wxPyUserData* data = NULL;
4177 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4178 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4179 if ( userData && (info.window || info.sizer || info.gotSize) )
4180 data = new wxPyUserData(userData);
4181 if ( info.sizer )
4182 PyObject_SetAttrString(item,"thisown",Py_False);
4183 wxPyEndBlockThreads(blocked);
4184
4185 // Now call the real Prepend method if a valid item type was found
4186 if ( info.window )
4187 return self->Prepend(info.window, proportion, flag, border, data);
4188 else if ( info.sizer )
4189 return self->Prepend(info.sizer, proportion, flag, border, data);
4190 else if (info.gotSize)
4191 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4192 proportion, flag, border, data);
4193 else
4194 return NULL;
4195 }
4196 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4197 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4198 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4199 wxPyEndBlockThreads(blocked);
4200 if ( info.window )
4201 return self->Remove(info.window);
4202 else if ( info.sizer )
4203 return self->Remove(info.sizer);
4204 else if ( info.gotPos )
4205 return self->Remove(info.pos);
4206 else
4207 return false;
4208 }
4209 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4210 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4211 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4212 wxPyEndBlockThreads(blocked);
4213 if ( info.window )
4214 return self->Detach(info.window);
4215 else if ( info.sizer )
4216 return self->Detach(info.sizer);
4217 else if ( info.gotPos )
4218 return self->Detach(info.pos);
4219 else
4220 return false;
4221 }
4222 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4223 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4224 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4225 wxPyEndBlockThreads(blocked);
4226 if ( info.window )
4227 return self->GetItem(info.window);
4228 else if ( info.sizer )
4229 return self->GetItem(info.sizer);
4230 else if ( info.gotPos )
4231 return self->GetItem(info.pos);
4232 else
4233 return NULL;
4234 }
4235 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4236 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4237 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4238 wxPyEndBlockThreads(blocked);
4239 if ( info.window )
4240 self->SetItemMinSize(info.window, size);
4241 else if ( info.sizer )
4242 self->SetItemMinSize(info.sizer, size);
4243 else if ( info.gotPos )
4244 self->SetItemMinSize(info.pos, size);
4245 }
4246 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4247 wxSizerItemList& list = self->GetChildren();
4248 return wxPy_ConvertList(&list);
4249 }
4250 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4251 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4252 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4253 wxPyEndBlockThreads(blocked);
4254 if ( info.window )
4255 return self->Show(info.window, show, recursive);
4256 else if ( info.sizer )
4257 return self->Show(info.sizer, show, recursive);
4258 else if ( info.gotPos )
4259 return self->Show(info.pos, show);
4260 else
4261 return false;
4262 }
4263 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4264 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4265 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4266 wxPyEndBlockThreads(blocked);
4267 if ( info.window )
4268 return self->IsShown(info.window);
4269 else if ( info.sizer )
4270 return self->IsShown(info.sizer);
4271 else if ( info.gotPos )
4272 return self->IsShown(info.pos);
4273 else
4274 return false;
4275 }
4276
4277 // See pyclasses.h
4278 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4279 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4280 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4281
4282
4283
4284
4285 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4286 {
4287 if (source == Py_None) {
4288 **obj = wxGBPosition(-1,-1);
4289 return true;
4290 }
4291 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4292 }
4293
4294 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4295 {
4296 if (source == Py_None) {
4297 **obj = wxGBSpan(-1,-1);
4298 return true;
4299 }
4300 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4301 }
4302
4303
4304 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4305 wxGBPosition temp, *obj = &temp;
4306 if ( other == Py_None ) return false;
4307 if ( ! wxGBPosition_helper(other, &obj) ) {
4308 PyErr_Clear();
4309 return false;
4310 }
4311 return self->operator==(*obj);
4312 }
4313 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4314 wxGBPosition temp, *obj = &temp;
4315 if ( other == Py_None ) return true;
4316 if ( ! wxGBPosition_helper(other, &obj)) {
4317 PyErr_Clear();
4318 return true;
4319 }
4320 return self->operator!=(*obj);
4321 }
4322 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4323 self->SetRow(row);
4324 self->SetCol(col);
4325 }
4326 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 PyObject* tup = PyTuple_New(2);
4329 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4330 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4331 wxPyEndBlockThreads(blocked);
4332 return tup;
4333 }
4334 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4335 wxGBSpan temp, *obj = &temp;
4336 if ( other == Py_None ) return false;
4337 if ( ! wxGBSpan_helper(other, &obj) ) {
4338 PyErr_Clear();
4339 return false;
4340 }
4341 return self->operator==(*obj);
4342 }
4343 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4344 wxGBSpan temp, *obj = &temp;
4345 if ( other == Py_None ) return true;
4346 if ( ! wxGBSpan_helper(other, &obj)) {
4347 PyErr_Clear();
4348 return true;
4349 }
4350 return self->operator!=(*obj);
4351 }
4352 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4353 self->SetRowspan(rowspan);
4354 self->SetColspan(colspan);
4355 }
4356 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4357 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4358 PyObject* tup = PyTuple_New(2);
4359 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4360 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4361 wxPyEndBlockThreads(blocked);
4362 return tup;
4363 }
4364 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4365 wxPyUserData* data = NULL;
4366 if ( userData ) {
4367 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4368 data = new wxPyUserData(userData);
4369 wxPyEndBlockThreads(blocked);
4370 }
4371 return new wxGBSizerItem(window, pos, span, flag, border, data);
4372 }
4373 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4374 wxPyUserData* data = NULL;
4375 if ( userData ) {
4376 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4377 data = new wxPyUserData(userData);
4378 wxPyEndBlockThreads(blocked);
4379 }
4380 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4381 }
4382 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4383 wxPyUserData* data = NULL;
4384 if ( userData ) {
4385 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4386 data = new wxPyUserData(userData);
4387 wxPyEndBlockThreads(blocked);
4388 }
4389 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4390 }
4391 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4392 int row, col;
4393 self->GetEndPos(row, col);
4394 return wxGBPosition(row, col);
4395 }
4396 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4397
4398 wxPyUserData* data = NULL;
4399 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4400 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4401 if ( userData && (info.window || info.sizer || info.gotSize) )
4402 data = new wxPyUserData(userData);
4403 if ( info.sizer )
4404 PyObject_SetAttrString(item,"thisown",Py_False);
4405 wxPyEndBlockThreads(blocked);
4406
4407 // Now call the real Add method if a valid item type was found
4408 if ( info.window )
4409 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4410 else if ( info.sizer )
4411 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4412 else if (info.gotSize)
4413 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4414 pos, span, flag, border, data);
4415 return NULL;
4416 }
4417
4418
4419 #ifdef __cplusplus
4420 extern "C" {
4421 #endif
4422 SWIGINTERN int EmptyString_set(PyObject *) {
4423 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4424 return 1;
4425 }
4426
4427
4428 SWIGINTERN PyObject *EmptyString_get(void) {
4429 PyObject *pyobj = 0;
4430
4431 {
4432 #if wxUSE_UNICODE
4433 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4434 #else
4435 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4436 #endif
4437 }
4438 return pyobj;
4439 }
4440
4441
4442 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4443 PyObject *resultobj = 0;
4444 wxObject *arg1 = (wxObject *) 0 ;
4445 wxString result;
4446 void *argp1 = 0 ;
4447 int res1 = 0 ;
4448 PyObject *swig_obj[1] ;
4449
4450 if (!args) SWIG_fail;
4451 swig_obj[0] = args;
4452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4453 if (!SWIG_IsOK(res1)) {
4454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4455 }
4456 arg1 = reinterpret_cast< wxObject * >(argp1);
4457 {
4458 PyThreadState* __tstate = wxPyBeginAllowThreads();
4459 result = wxObject_GetClassName(arg1);
4460 wxPyEndAllowThreads(__tstate);
4461 if (PyErr_Occurred()) SWIG_fail;
4462 }
4463 {
4464 #if wxUSE_UNICODE
4465 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4466 #else
4467 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4468 #endif
4469 }
4470 return resultobj;
4471 fail:
4472 return NULL;
4473 }
4474
4475
4476 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4477 PyObject *resultobj = 0;
4478 wxObject *arg1 = (wxObject *) 0 ;
4479 void *argp1 = 0 ;
4480 int res1 = 0 ;
4481 PyObject *swig_obj[1] ;
4482
4483 if (!args) SWIG_fail;
4484 swig_obj[0] = args;
4485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4486 if (!SWIG_IsOK(res1)) {
4487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4488 }
4489 arg1 = reinterpret_cast< wxObject * >(argp1);
4490 {
4491 PyThreadState* __tstate = wxPyBeginAllowThreads();
4492 wxObject_Destroy(arg1);
4493 wxPyEndAllowThreads(__tstate);
4494 if (PyErr_Occurred()) SWIG_fail;
4495 }
4496 resultobj = SWIG_Py_Void();
4497 return resultobj;
4498 fail:
4499 return NULL;
4500 }
4501
4502
4503 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4504 PyObject *resultobj = 0;
4505 wxObject *arg1 = (wxObject *) 0 ;
4506 wxObject *arg2 = 0 ;
4507 bool result;
4508 void *argp1 = 0 ;
4509 int res1 = 0 ;
4510 void *argp2 = 0 ;
4511 int res2 = 0 ;
4512 PyObject * obj0 = 0 ;
4513 PyObject * obj1 = 0 ;
4514 char * kwnames[] = {
4515 (char *) "self",(char *) "p", NULL
4516 };
4517
4518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4520 if (!SWIG_IsOK(res1)) {
4521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4522 }
4523 arg1 = reinterpret_cast< wxObject * >(argp1);
4524 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4525 if (!SWIG_IsOK(res2)) {
4526 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4527 }
4528 if (!argp2) {
4529 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4530 }
4531 arg2 = reinterpret_cast< wxObject * >(argp2);
4532 {
4533 PyThreadState* __tstate = wxPyBeginAllowThreads();
4534 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4535 wxPyEndAllowThreads(__tstate);
4536 if (PyErr_Occurred()) SWIG_fail;
4537 }
4538 {
4539 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4540 }
4541 return resultobj;
4542 fail:
4543 return NULL;
4544 }
4545
4546
4547 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4548 PyObject *obj;
4549 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4550 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4551 return SWIG_Py_Void();
4552 }
4553
4554 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4555 PyObject *resultobj = 0;
4556 wxSize *arg1 = (wxSize *) 0 ;
4557 int arg2 ;
4558 void *argp1 = 0 ;
4559 int res1 = 0 ;
4560 int val2 ;
4561 int ecode2 = 0 ;
4562 PyObject *swig_obj[2] ;
4563
4564 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4566 if (!SWIG_IsOK(res1)) {
4567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4568 }
4569 arg1 = reinterpret_cast< wxSize * >(argp1);
4570 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4571 if (!SWIG_IsOK(ecode2)) {
4572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4573 }
4574 arg2 = static_cast< int >(val2);
4575 if (arg1) (arg1)->x = arg2;
4576
4577 resultobj = SWIG_Py_Void();
4578 return resultobj;
4579 fail:
4580 return NULL;
4581 }
4582
4583
4584 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4585 PyObject *resultobj = 0;
4586 wxSize *arg1 = (wxSize *) 0 ;
4587 int result;
4588 void *argp1 = 0 ;
4589 int res1 = 0 ;
4590 PyObject *swig_obj[1] ;
4591
4592 if (!args) SWIG_fail;
4593 swig_obj[0] = args;
4594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4595 if (!SWIG_IsOK(res1)) {
4596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4597 }
4598 arg1 = reinterpret_cast< wxSize * >(argp1);
4599 result = (int) ((arg1)->x);
4600 resultobj = SWIG_From_int(static_cast< int >(result));
4601 return resultobj;
4602 fail:
4603 return NULL;
4604 }
4605
4606
4607 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4608 PyObject *resultobj = 0;
4609 wxSize *arg1 = (wxSize *) 0 ;
4610 int arg2 ;
4611 void *argp1 = 0 ;
4612 int res1 = 0 ;
4613 int val2 ;
4614 int ecode2 = 0 ;
4615 PyObject *swig_obj[2] ;
4616
4617 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4619 if (!SWIG_IsOK(res1)) {
4620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4621 }
4622 arg1 = reinterpret_cast< wxSize * >(argp1);
4623 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4624 if (!SWIG_IsOK(ecode2)) {
4625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4626 }
4627 arg2 = static_cast< int >(val2);
4628 if (arg1) (arg1)->y = arg2;
4629
4630 resultobj = SWIG_Py_Void();
4631 return resultobj;
4632 fail:
4633 return NULL;
4634 }
4635
4636
4637 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4638 PyObject *resultobj = 0;
4639 wxSize *arg1 = (wxSize *) 0 ;
4640 int result;
4641 void *argp1 = 0 ;
4642 int res1 = 0 ;
4643 PyObject *swig_obj[1] ;
4644
4645 if (!args) SWIG_fail;
4646 swig_obj[0] = args;
4647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4648 if (!SWIG_IsOK(res1)) {
4649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4650 }
4651 arg1 = reinterpret_cast< wxSize * >(argp1);
4652 result = (int) ((arg1)->y);
4653 resultobj = SWIG_From_int(static_cast< int >(result));
4654 return resultobj;
4655 fail:
4656 return NULL;
4657 }
4658
4659
4660 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4661 PyObject *resultobj = 0;
4662 int arg1 = (int) 0 ;
4663 int arg2 = (int) 0 ;
4664 wxSize *result = 0 ;
4665 int val1 ;
4666 int ecode1 = 0 ;
4667 int val2 ;
4668 int ecode2 = 0 ;
4669 PyObject * obj0 = 0 ;
4670 PyObject * obj1 = 0 ;
4671 char * kwnames[] = {
4672 (char *) "w",(char *) "h", NULL
4673 };
4674
4675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4676 if (obj0) {
4677 ecode1 = SWIG_AsVal_int(obj0, &val1);
4678 if (!SWIG_IsOK(ecode1)) {
4679 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4680 }
4681 arg1 = static_cast< int >(val1);
4682 }
4683 if (obj1) {
4684 ecode2 = SWIG_AsVal_int(obj1, &val2);
4685 if (!SWIG_IsOK(ecode2)) {
4686 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4687 }
4688 arg2 = static_cast< int >(val2);
4689 }
4690 {
4691 result = (wxSize *)new wxSize(arg1,arg2);
4692 if (PyErr_Occurred()) SWIG_fail;
4693 }
4694 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4695 return resultobj;
4696 fail:
4697 return NULL;
4698 }
4699
4700
4701 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4702 PyObject *resultobj = 0;
4703 wxSize *arg1 = (wxSize *) 0 ;
4704 void *argp1 = 0 ;
4705 int res1 = 0 ;
4706 PyObject *swig_obj[1] ;
4707
4708 if (!args) SWIG_fail;
4709 swig_obj[0] = args;
4710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4711 if (!SWIG_IsOK(res1)) {
4712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4713 }
4714 arg1 = reinterpret_cast< wxSize * >(argp1);
4715 {
4716 delete arg1;
4717
4718 if (PyErr_Occurred()) SWIG_fail;
4719 }
4720 resultobj = SWIG_Py_Void();
4721 return resultobj;
4722 fail:
4723 return NULL;
4724 }
4725
4726
4727 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4728 PyObject *resultobj = 0;
4729 wxSize *arg1 = (wxSize *) 0 ;
4730 PyObject *arg2 = (PyObject *) 0 ;
4731 bool result;
4732 void *argp1 = 0 ;
4733 int res1 = 0 ;
4734 PyObject * obj0 = 0 ;
4735 PyObject * obj1 = 0 ;
4736 char * kwnames[] = {
4737 (char *) "self",(char *) "other", NULL
4738 };
4739
4740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4742 if (!SWIG_IsOK(res1)) {
4743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4744 }
4745 arg1 = reinterpret_cast< wxSize * >(argp1);
4746 arg2 = obj1;
4747 {
4748 result = (bool)wxSize___eq__(arg1,arg2);
4749 if (PyErr_Occurred()) SWIG_fail;
4750 }
4751 {
4752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4753 }
4754 return resultobj;
4755 fail:
4756 return NULL;
4757 }
4758
4759
4760 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4761 PyObject *resultobj = 0;
4762 wxSize *arg1 = (wxSize *) 0 ;
4763 PyObject *arg2 = (PyObject *) 0 ;
4764 bool result;
4765 void *argp1 = 0 ;
4766 int res1 = 0 ;
4767 PyObject * obj0 = 0 ;
4768 PyObject * obj1 = 0 ;
4769 char * kwnames[] = {
4770 (char *) "self",(char *) "other", NULL
4771 };
4772
4773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4775 if (!SWIG_IsOK(res1)) {
4776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4777 }
4778 arg1 = reinterpret_cast< wxSize * >(argp1);
4779 arg2 = obj1;
4780 {
4781 result = (bool)wxSize___ne__(arg1,arg2);
4782 if (PyErr_Occurred()) SWIG_fail;
4783 }
4784 {
4785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4786 }
4787 return resultobj;
4788 fail:
4789 return NULL;
4790 }
4791
4792
4793 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4794 PyObject *resultobj = 0;
4795 wxSize *arg1 = (wxSize *) 0 ;
4796 wxSize *arg2 = 0 ;
4797 wxSize result;
4798 void *argp1 = 0 ;
4799 int res1 = 0 ;
4800 wxSize temp2 ;
4801 PyObject * obj0 = 0 ;
4802 PyObject * obj1 = 0 ;
4803 char * kwnames[] = {
4804 (char *) "self",(char *) "sz", NULL
4805 };
4806
4807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4809 if (!SWIG_IsOK(res1)) {
4810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4811 }
4812 arg1 = reinterpret_cast< wxSize * >(argp1);
4813 {
4814 arg2 = &temp2;
4815 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4816 }
4817 {
4818 result = (arg1)->operator +((wxSize const &)*arg2);
4819 if (PyErr_Occurred()) SWIG_fail;
4820 }
4821 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4822 return resultobj;
4823 fail:
4824 return NULL;
4825 }
4826
4827
4828 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4829 PyObject *resultobj = 0;
4830 wxSize *arg1 = (wxSize *) 0 ;
4831 wxSize *arg2 = 0 ;
4832 wxSize result;
4833 void *argp1 = 0 ;
4834 int res1 = 0 ;
4835 wxSize temp2 ;
4836 PyObject * obj0 = 0 ;
4837 PyObject * obj1 = 0 ;
4838 char * kwnames[] = {
4839 (char *) "self",(char *) "sz", NULL
4840 };
4841
4842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4844 if (!SWIG_IsOK(res1)) {
4845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4846 }
4847 arg1 = reinterpret_cast< wxSize * >(argp1);
4848 {
4849 arg2 = &temp2;
4850 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4851 }
4852 {
4853 result = (arg1)->operator -((wxSize const &)*arg2);
4854 if (PyErr_Occurred()) SWIG_fail;
4855 }
4856 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4857 return resultobj;
4858 fail:
4859 return NULL;
4860 }
4861
4862
4863 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4864 PyObject *resultobj = 0;
4865 wxSize *arg1 = (wxSize *) 0 ;
4866 wxSize *arg2 = 0 ;
4867 void *argp1 = 0 ;
4868 int res1 = 0 ;
4869 wxSize temp2 ;
4870 PyObject * obj0 = 0 ;
4871 PyObject * obj1 = 0 ;
4872 char * kwnames[] = {
4873 (char *) "self",(char *) "sz", NULL
4874 };
4875
4876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4878 if (!SWIG_IsOK(res1)) {
4879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4880 }
4881 arg1 = reinterpret_cast< wxSize * >(argp1);
4882 {
4883 arg2 = &temp2;
4884 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4885 }
4886 {
4887 (arg1)->IncTo((wxSize const &)*arg2);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_Py_Void();
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj = 0;
4899 wxSize *arg1 = (wxSize *) 0 ;
4900 wxSize *arg2 = 0 ;
4901 void *argp1 = 0 ;
4902 int res1 = 0 ;
4903 wxSize temp2 ;
4904 PyObject * obj0 = 0 ;
4905 PyObject * obj1 = 0 ;
4906 char * kwnames[] = {
4907 (char *) "self",(char *) "sz", NULL
4908 };
4909
4910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4912 if (!SWIG_IsOK(res1)) {
4913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4914 }
4915 arg1 = reinterpret_cast< wxSize * >(argp1);
4916 {
4917 arg2 = &temp2;
4918 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4919 }
4920 {
4921 (arg1)->DecTo((wxSize const &)*arg2);
4922 if (PyErr_Occurred()) SWIG_fail;
4923 }
4924 resultobj = SWIG_Py_Void();
4925 return resultobj;
4926 fail:
4927 return NULL;
4928 }
4929
4930
4931 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4932 PyObject *resultobj = 0;
4933 wxSize *arg1 = (wxSize *) 0 ;
4934 int arg2 ;
4935 int arg3 ;
4936 void *argp1 = 0 ;
4937 int res1 = 0 ;
4938 int val2 ;
4939 int ecode2 = 0 ;
4940 int val3 ;
4941 int ecode3 = 0 ;
4942 PyObject * obj0 = 0 ;
4943 PyObject * obj1 = 0 ;
4944 PyObject * obj2 = 0 ;
4945 char * kwnames[] = {
4946 (char *) "self",(char *) "dx",(char *) "dy", NULL
4947 };
4948
4949 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4950 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4951 if (!SWIG_IsOK(res1)) {
4952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4953 }
4954 arg1 = reinterpret_cast< wxSize * >(argp1);
4955 ecode2 = SWIG_AsVal_int(obj1, &val2);
4956 if (!SWIG_IsOK(ecode2)) {
4957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4958 }
4959 arg2 = static_cast< int >(val2);
4960 ecode3 = SWIG_AsVal_int(obj2, &val3);
4961 if (!SWIG_IsOK(ecode3)) {
4962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4963 }
4964 arg3 = static_cast< int >(val3);
4965 {
4966 (arg1)->IncBy(arg2,arg3);
4967 if (PyErr_Occurred()) SWIG_fail;
4968 }
4969 resultobj = SWIG_Py_Void();
4970 return resultobj;
4971 fail:
4972 return NULL;
4973 }
4974
4975
4976 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4977 PyObject *resultobj = 0;
4978 wxSize *arg1 = (wxSize *) 0 ;
4979 int arg2 ;
4980 int arg3 ;
4981 void *argp1 = 0 ;
4982 int res1 = 0 ;
4983 int val2 ;
4984 int ecode2 = 0 ;
4985 int val3 ;
4986 int ecode3 = 0 ;
4987 PyObject * obj0 = 0 ;
4988 PyObject * obj1 = 0 ;
4989 PyObject * obj2 = 0 ;
4990 char * kwnames[] = {
4991 (char *) "self",(char *) "dx",(char *) "dy", NULL
4992 };
4993
4994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4996 if (!SWIG_IsOK(res1)) {
4997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
4998 }
4999 arg1 = reinterpret_cast< wxSize * >(argp1);
5000 ecode2 = SWIG_AsVal_int(obj1, &val2);
5001 if (!SWIG_IsOK(ecode2)) {
5002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5003 }
5004 arg2 = static_cast< int >(val2);
5005 ecode3 = SWIG_AsVal_int(obj2, &val3);
5006 if (!SWIG_IsOK(ecode3)) {
5007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5008 }
5009 arg3 = static_cast< int >(val3);
5010 {
5011 (arg1)->DecBy(arg2,arg3);
5012 if (PyErr_Occurred()) SWIG_fail;
5013 }
5014 resultobj = SWIG_Py_Void();
5015 return resultobj;
5016 fail:
5017 return NULL;
5018 }
5019
5020
5021 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5022 PyObject *resultobj = 0;
5023 wxSize *arg1 = (wxSize *) 0 ;
5024 float arg2 ;
5025 float arg3 ;
5026 void *argp1 = 0 ;
5027 int res1 = 0 ;
5028 float val2 ;
5029 int ecode2 = 0 ;
5030 float val3 ;
5031 int ecode3 = 0 ;
5032 PyObject * obj0 = 0 ;
5033 PyObject * obj1 = 0 ;
5034 PyObject * obj2 = 0 ;
5035 char * kwnames[] = {
5036 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5037 };
5038
5039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5041 if (!SWIG_IsOK(res1)) {
5042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5043 }
5044 arg1 = reinterpret_cast< wxSize * >(argp1);
5045 ecode2 = SWIG_AsVal_float(obj1, &val2);
5046 if (!SWIG_IsOK(ecode2)) {
5047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5048 }
5049 arg2 = static_cast< float >(val2);
5050 ecode3 = SWIG_AsVal_float(obj2, &val3);
5051 if (!SWIG_IsOK(ecode3)) {
5052 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5053 }
5054 arg3 = static_cast< float >(val3);
5055 {
5056 (arg1)->Scale(arg2,arg3);
5057 if (PyErr_Occurred()) SWIG_fail;
5058 }
5059 resultobj = SWIG_Py_Void();
5060 return resultobj;
5061 fail:
5062 return NULL;
5063 }
5064
5065
5066 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5067 PyObject *resultobj = 0;
5068 wxSize *arg1 = (wxSize *) 0 ;
5069 int arg2 ;
5070 int arg3 ;
5071 void *argp1 = 0 ;
5072 int res1 = 0 ;
5073 int val2 ;
5074 int ecode2 = 0 ;
5075 int val3 ;
5076 int ecode3 = 0 ;
5077 PyObject * obj0 = 0 ;
5078 PyObject * obj1 = 0 ;
5079 PyObject * obj2 = 0 ;
5080 char * kwnames[] = {
5081 (char *) "self",(char *) "w",(char *) "h", NULL
5082 };
5083
5084 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5085 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5086 if (!SWIG_IsOK(res1)) {
5087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5088 }
5089 arg1 = reinterpret_cast< wxSize * >(argp1);
5090 ecode2 = SWIG_AsVal_int(obj1, &val2);
5091 if (!SWIG_IsOK(ecode2)) {
5092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5093 }
5094 arg2 = static_cast< int >(val2);
5095 ecode3 = SWIG_AsVal_int(obj2, &val3);
5096 if (!SWIG_IsOK(ecode3)) {
5097 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5098 }
5099 arg3 = static_cast< int >(val3);
5100 {
5101 (arg1)->Set(arg2,arg3);
5102 if (PyErr_Occurred()) SWIG_fail;
5103 }
5104 resultobj = SWIG_Py_Void();
5105 return resultobj;
5106 fail:
5107 return NULL;
5108 }
5109
5110
5111 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5112 PyObject *resultobj = 0;
5113 wxSize *arg1 = (wxSize *) 0 ;
5114 int arg2 ;
5115 void *argp1 = 0 ;
5116 int res1 = 0 ;
5117 int val2 ;
5118 int ecode2 = 0 ;
5119 PyObject * obj0 = 0 ;
5120 PyObject * obj1 = 0 ;
5121 char * kwnames[] = {
5122 (char *) "self",(char *) "w", NULL
5123 };
5124
5125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5127 if (!SWIG_IsOK(res1)) {
5128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5129 }
5130 arg1 = reinterpret_cast< wxSize * >(argp1);
5131 ecode2 = SWIG_AsVal_int(obj1, &val2);
5132 if (!SWIG_IsOK(ecode2)) {
5133 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5134 }
5135 arg2 = static_cast< int >(val2);
5136 {
5137 (arg1)->SetWidth(arg2);
5138 if (PyErr_Occurred()) SWIG_fail;
5139 }
5140 resultobj = SWIG_Py_Void();
5141 return resultobj;
5142 fail:
5143 return NULL;
5144 }
5145
5146
5147 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5148 PyObject *resultobj = 0;
5149 wxSize *arg1 = (wxSize *) 0 ;
5150 int arg2 ;
5151 void *argp1 = 0 ;
5152 int res1 = 0 ;
5153 int val2 ;
5154 int ecode2 = 0 ;
5155 PyObject * obj0 = 0 ;
5156 PyObject * obj1 = 0 ;
5157 char * kwnames[] = {
5158 (char *) "self",(char *) "h", NULL
5159 };
5160
5161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5163 if (!SWIG_IsOK(res1)) {
5164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5165 }
5166 arg1 = reinterpret_cast< wxSize * >(argp1);
5167 ecode2 = SWIG_AsVal_int(obj1, &val2);
5168 if (!SWIG_IsOK(ecode2)) {
5169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5170 }
5171 arg2 = static_cast< int >(val2);
5172 {
5173 (arg1)->SetHeight(arg2);
5174 if (PyErr_Occurred()) SWIG_fail;
5175 }
5176 resultobj = SWIG_Py_Void();
5177 return resultobj;
5178 fail:
5179 return NULL;
5180 }
5181
5182
5183 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5184 PyObject *resultobj = 0;
5185 wxSize *arg1 = (wxSize *) 0 ;
5186 int result;
5187 void *argp1 = 0 ;
5188 int res1 = 0 ;
5189 PyObject *swig_obj[1] ;
5190
5191 if (!args) SWIG_fail;
5192 swig_obj[0] = args;
5193 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5194 if (!SWIG_IsOK(res1)) {
5195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5196 }
5197 arg1 = reinterpret_cast< wxSize * >(argp1);
5198 {
5199 result = (int)((wxSize const *)arg1)->GetWidth();
5200 if (PyErr_Occurred()) SWIG_fail;
5201 }
5202 resultobj = SWIG_From_int(static_cast< int >(result));
5203 return resultobj;
5204 fail:
5205 return NULL;
5206 }
5207
5208
5209 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5210 PyObject *resultobj = 0;
5211 wxSize *arg1 = (wxSize *) 0 ;
5212 int result;
5213 void *argp1 = 0 ;
5214 int res1 = 0 ;
5215 PyObject *swig_obj[1] ;
5216
5217 if (!args) SWIG_fail;
5218 swig_obj[0] = args;
5219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5220 if (!SWIG_IsOK(res1)) {
5221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5222 }
5223 arg1 = reinterpret_cast< wxSize * >(argp1);
5224 {
5225 result = (int)((wxSize const *)arg1)->GetHeight();
5226 if (PyErr_Occurred()) SWIG_fail;
5227 }
5228 resultobj = SWIG_From_int(static_cast< int >(result));
5229 return resultobj;
5230 fail:
5231 return NULL;
5232 }
5233
5234
5235 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5236 PyObject *resultobj = 0;
5237 wxSize *arg1 = (wxSize *) 0 ;
5238 bool result;
5239 void *argp1 = 0 ;
5240 int res1 = 0 ;
5241 PyObject *swig_obj[1] ;
5242
5243 if (!args) SWIG_fail;
5244 swig_obj[0] = args;
5245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5246 if (!SWIG_IsOK(res1)) {
5247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5248 }
5249 arg1 = reinterpret_cast< wxSize * >(argp1);
5250 {
5251 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5252 if (PyErr_Occurred()) SWIG_fail;
5253 }
5254 {
5255 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5256 }
5257 return resultobj;
5258 fail:
5259 return NULL;
5260 }
5261
5262
5263 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5264 PyObject *resultobj = 0;
5265 wxSize *arg1 = (wxSize *) 0 ;
5266 wxSize *arg2 = 0 ;
5267 void *argp1 = 0 ;
5268 int res1 = 0 ;
5269 wxSize temp2 ;
5270 PyObject * obj0 = 0 ;
5271 PyObject * obj1 = 0 ;
5272 char * kwnames[] = {
5273 (char *) "self",(char *) "size", NULL
5274 };
5275
5276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5278 if (!SWIG_IsOK(res1)) {
5279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5280 }
5281 arg1 = reinterpret_cast< wxSize * >(argp1);
5282 {
5283 arg2 = &temp2;
5284 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5285 }
5286 {
5287 (arg1)->SetDefaults((wxSize const &)*arg2);
5288 if (PyErr_Occurred()) SWIG_fail;
5289 }
5290 resultobj = SWIG_Py_Void();
5291 return resultobj;
5292 fail:
5293 return NULL;
5294 }
5295
5296
5297 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5298 PyObject *resultobj = 0;
5299 wxSize *arg1 = (wxSize *) 0 ;
5300 PyObject *result = 0 ;
5301 void *argp1 = 0 ;
5302 int res1 = 0 ;
5303 PyObject *swig_obj[1] ;
5304
5305 if (!args) SWIG_fail;
5306 swig_obj[0] = args;
5307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5308 if (!SWIG_IsOK(res1)) {
5309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5310 }
5311 arg1 = reinterpret_cast< wxSize * >(argp1);
5312 {
5313 result = (PyObject *)wxSize_Get(arg1);
5314 if (PyErr_Occurred()) SWIG_fail;
5315 }
5316 resultobj = result;
5317 return resultobj;
5318 fail:
5319 return NULL;
5320 }
5321
5322
5323 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5324 PyObject *obj;
5325 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5326 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5327 return SWIG_Py_Void();
5328 }
5329
5330 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5331 return SWIG_Python_InitShadowInstance(args);
5332 }
5333
5334 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5335 PyObject *resultobj = 0;
5336 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5337 double arg2 ;
5338 void *argp1 = 0 ;
5339 int res1 = 0 ;
5340 double val2 ;
5341 int ecode2 = 0 ;
5342 PyObject *swig_obj[2] ;
5343
5344 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5346 if (!SWIG_IsOK(res1)) {
5347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5348 }
5349 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5350 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5351 if (!SWIG_IsOK(ecode2)) {
5352 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5353 }
5354 arg2 = static_cast< double >(val2);
5355 if (arg1) (arg1)->x = arg2;
5356
5357 resultobj = SWIG_Py_Void();
5358 return resultobj;
5359 fail:
5360 return NULL;
5361 }
5362
5363
5364 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5365 PyObject *resultobj = 0;
5366 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5367 double result;
5368 void *argp1 = 0 ;
5369 int res1 = 0 ;
5370 PyObject *swig_obj[1] ;
5371
5372 if (!args) SWIG_fail;
5373 swig_obj[0] = args;
5374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5375 if (!SWIG_IsOK(res1)) {
5376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5377 }
5378 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5379 result = (double) ((arg1)->x);
5380 resultobj = SWIG_From_double(static_cast< double >(result));
5381 return resultobj;
5382 fail:
5383 return NULL;
5384 }
5385
5386
5387 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5388 PyObject *resultobj = 0;
5389 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5390 double arg2 ;
5391 void *argp1 = 0 ;
5392 int res1 = 0 ;
5393 double val2 ;
5394 int ecode2 = 0 ;
5395 PyObject *swig_obj[2] ;
5396
5397 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5399 if (!SWIG_IsOK(res1)) {
5400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5401 }
5402 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5403 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5404 if (!SWIG_IsOK(ecode2)) {
5405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5406 }
5407 arg2 = static_cast< double >(val2);
5408 if (arg1) (arg1)->y = arg2;
5409
5410 resultobj = SWIG_Py_Void();
5411 return resultobj;
5412 fail:
5413 return NULL;
5414 }
5415
5416
5417 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5418 PyObject *resultobj = 0;
5419 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5420 double result;
5421 void *argp1 = 0 ;
5422 int res1 = 0 ;
5423 PyObject *swig_obj[1] ;
5424
5425 if (!args) SWIG_fail;
5426 swig_obj[0] = args;
5427 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5428 if (!SWIG_IsOK(res1)) {
5429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5430 }
5431 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5432 result = (double) ((arg1)->y);
5433 resultobj = SWIG_From_double(static_cast< double >(result));
5434 return resultobj;
5435 fail:
5436 return NULL;
5437 }
5438
5439
5440 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5441 PyObject *resultobj = 0;
5442 double arg1 = (double) 0.0 ;
5443 double arg2 = (double) 0.0 ;
5444 wxRealPoint *result = 0 ;
5445 double val1 ;
5446 int ecode1 = 0 ;
5447 double val2 ;
5448 int ecode2 = 0 ;
5449 PyObject * obj0 = 0 ;
5450 PyObject * obj1 = 0 ;
5451 char * kwnames[] = {
5452 (char *) "x",(char *) "y", NULL
5453 };
5454
5455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5456 if (obj0) {
5457 ecode1 = SWIG_AsVal_double(obj0, &val1);
5458 if (!SWIG_IsOK(ecode1)) {
5459 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5460 }
5461 arg1 = static_cast< double >(val1);
5462 }
5463 if (obj1) {
5464 ecode2 = SWIG_AsVal_double(obj1, &val2);
5465 if (!SWIG_IsOK(ecode2)) {
5466 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5467 }
5468 arg2 = static_cast< double >(val2);
5469 }
5470 {
5471 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5472 if (PyErr_Occurred()) SWIG_fail;
5473 }
5474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5475 return resultobj;
5476 fail:
5477 return NULL;
5478 }
5479
5480
5481 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5482 PyObject *resultobj = 0;
5483 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5484 void *argp1 = 0 ;
5485 int res1 = 0 ;
5486 PyObject *swig_obj[1] ;
5487
5488 if (!args) SWIG_fail;
5489 swig_obj[0] = args;
5490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5491 if (!SWIG_IsOK(res1)) {
5492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5493 }
5494 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5495 {
5496 delete arg1;
5497
5498 if (PyErr_Occurred()) SWIG_fail;
5499 }
5500 resultobj = SWIG_Py_Void();
5501 return resultobj;
5502 fail:
5503 return NULL;
5504 }
5505
5506
5507 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5508 PyObject *resultobj = 0;
5509 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5510 PyObject *arg2 = (PyObject *) 0 ;
5511 bool result;
5512 void *argp1 = 0 ;
5513 int res1 = 0 ;
5514 PyObject * obj0 = 0 ;
5515 PyObject * obj1 = 0 ;
5516 char * kwnames[] = {
5517 (char *) "self",(char *) "other", NULL
5518 };
5519
5520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5522 if (!SWIG_IsOK(res1)) {
5523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5524 }
5525 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5526 arg2 = obj1;
5527 {
5528 result = (bool)wxRealPoint___eq__(arg1,arg2);
5529 if (PyErr_Occurred()) SWIG_fail;
5530 }
5531 {
5532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5533 }
5534 return resultobj;
5535 fail:
5536 return NULL;
5537 }
5538
5539
5540 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5541 PyObject *resultobj = 0;
5542 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5543 PyObject *arg2 = (PyObject *) 0 ;
5544 bool result;
5545 void *argp1 = 0 ;
5546 int res1 = 0 ;
5547 PyObject * obj0 = 0 ;
5548 PyObject * obj1 = 0 ;
5549 char * kwnames[] = {
5550 (char *) "self",(char *) "other", NULL
5551 };
5552
5553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5555 if (!SWIG_IsOK(res1)) {
5556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5557 }
5558 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5559 arg2 = obj1;
5560 {
5561 result = (bool)wxRealPoint___ne__(arg1,arg2);
5562 if (PyErr_Occurred()) SWIG_fail;
5563 }
5564 {
5565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5566 }
5567 return resultobj;
5568 fail:
5569 return NULL;
5570 }
5571
5572
5573 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5574 PyObject *resultobj = 0;
5575 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5576 wxRealPoint *arg2 = 0 ;
5577 wxRealPoint result;
5578 void *argp1 = 0 ;
5579 int res1 = 0 ;
5580 wxRealPoint temp2 ;
5581 PyObject * obj0 = 0 ;
5582 PyObject * obj1 = 0 ;
5583 char * kwnames[] = {
5584 (char *) "self",(char *) "pt", NULL
5585 };
5586
5587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5589 if (!SWIG_IsOK(res1)) {
5590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5591 }
5592 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5593 {
5594 arg2 = &temp2;
5595 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5596 }
5597 {
5598 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5599 if (PyErr_Occurred()) SWIG_fail;
5600 }
5601 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5602 return resultobj;
5603 fail:
5604 return NULL;
5605 }
5606
5607
5608 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5609 PyObject *resultobj = 0;
5610 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5611 wxRealPoint *arg2 = 0 ;
5612 wxRealPoint result;
5613 void *argp1 = 0 ;
5614 int res1 = 0 ;
5615 wxRealPoint temp2 ;
5616 PyObject * obj0 = 0 ;
5617 PyObject * obj1 = 0 ;
5618 char * kwnames[] = {
5619 (char *) "self",(char *) "pt", NULL
5620 };
5621
5622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5624 if (!SWIG_IsOK(res1)) {
5625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5626 }
5627 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5628 {
5629 arg2 = &temp2;
5630 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5631 }
5632 {
5633 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5634 if (PyErr_Occurred()) SWIG_fail;
5635 }
5636 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5637 return resultobj;
5638 fail:
5639 return NULL;
5640 }
5641
5642
5643 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5644 PyObject *resultobj = 0;
5645 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5646 double arg2 ;
5647 double arg3 ;
5648 void *argp1 = 0 ;
5649 int res1 = 0 ;
5650 double val2 ;
5651 int ecode2 = 0 ;
5652 double val3 ;
5653 int ecode3 = 0 ;
5654 PyObject * obj0 = 0 ;
5655 PyObject * obj1 = 0 ;
5656 PyObject * obj2 = 0 ;
5657 char * kwnames[] = {
5658 (char *) "self",(char *) "x",(char *) "y", NULL
5659 };
5660
5661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5663 if (!SWIG_IsOK(res1)) {
5664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5665 }
5666 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5667 ecode2 = SWIG_AsVal_double(obj1, &val2);
5668 if (!SWIG_IsOK(ecode2)) {
5669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5670 }
5671 arg2 = static_cast< double >(val2);
5672 ecode3 = SWIG_AsVal_double(obj2, &val3);
5673 if (!SWIG_IsOK(ecode3)) {
5674 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5675 }
5676 arg3 = static_cast< double >(val3);
5677 {
5678 wxRealPoint_Set(arg1,arg2,arg3);
5679 if (PyErr_Occurred()) SWIG_fail;
5680 }
5681 resultobj = SWIG_Py_Void();
5682 return resultobj;
5683 fail:
5684 return NULL;
5685 }
5686
5687
5688 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5689 PyObject *resultobj = 0;
5690 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5691 PyObject *result = 0 ;
5692 void *argp1 = 0 ;
5693 int res1 = 0 ;
5694 PyObject *swig_obj[1] ;
5695
5696 if (!args) SWIG_fail;
5697 swig_obj[0] = args;
5698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5699 if (!SWIG_IsOK(res1)) {
5700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5701 }
5702 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5703 {
5704 result = (PyObject *)wxRealPoint_Get(arg1);
5705 if (PyErr_Occurred()) SWIG_fail;
5706 }
5707 resultobj = result;
5708 return resultobj;
5709 fail:
5710 return NULL;
5711 }
5712
5713
5714 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5715 PyObject *obj;
5716 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5717 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5718 return SWIG_Py_Void();
5719 }
5720
5721 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5722 return SWIG_Python_InitShadowInstance(args);
5723 }
5724
5725 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5726 PyObject *resultobj = 0;
5727 wxPoint *arg1 = (wxPoint *) 0 ;
5728 int arg2 ;
5729 void *argp1 = 0 ;
5730 int res1 = 0 ;
5731 int val2 ;
5732 int ecode2 = 0 ;
5733 PyObject *swig_obj[2] ;
5734
5735 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5736 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5737 if (!SWIG_IsOK(res1)) {
5738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5739 }
5740 arg1 = reinterpret_cast< wxPoint * >(argp1);
5741 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5742 if (!SWIG_IsOK(ecode2)) {
5743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5744 }
5745 arg2 = static_cast< int >(val2);
5746 if (arg1) (arg1)->x = arg2;
5747
5748 resultobj = SWIG_Py_Void();
5749 return resultobj;
5750 fail:
5751 return NULL;
5752 }
5753
5754
5755 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5756 PyObject *resultobj = 0;
5757 wxPoint *arg1 = (wxPoint *) 0 ;
5758 int result;
5759 void *argp1 = 0 ;
5760 int res1 = 0 ;
5761 PyObject *swig_obj[1] ;
5762
5763 if (!args) SWIG_fail;
5764 swig_obj[0] = args;
5765 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5766 if (!SWIG_IsOK(res1)) {
5767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5768 }
5769 arg1 = reinterpret_cast< wxPoint * >(argp1);
5770 result = (int) ((arg1)->x);
5771 resultobj = SWIG_From_int(static_cast< int >(result));
5772 return resultobj;
5773 fail:
5774 return NULL;
5775 }
5776
5777
5778 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5779 PyObject *resultobj = 0;
5780 wxPoint *arg1 = (wxPoint *) 0 ;
5781 int arg2 ;
5782 void *argp1 = 0 ;
5783 int res1 = 0 ;
5784 int val2 ;
5785 int ecode2 = 0 ;
5786 PyObject *swig_obj[2] ;
5787
5788 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5789 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5790 if (!SWIG_IsOK(res1)) {
5791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5792 }
5793 arg1 = reinterpret_cast< wxPoint * >(argp1);
5794 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5795 if (!SWIG_IsOK(ecode2)) {
5796 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5797 }
5798 arg2 = static_cast< int >(val2);
5799 if (arg1) (arg1)->y = arg2;
5800
5801 resultobj = SWIG_Py_Void();
5802 return resultobj;
5803 fail:
5804 return NULL;
5805 }
5806
5807
5808 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5809 PyObject *resultobj = 0;
5810 wxPoint *arg1 = (wxPoint *) 0 ;
5811 int result;
5812 void *argp1 = 0 ;
5813 int res1 = 0 ;
5814 PyObject *swig_obj[1] ;
5815
5816 if (!args) SWIG_fail;
5817 swig_obj[0] = args;
5818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5819 if (!SWIG_IsOK(res1)) {
5820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5821 }
5822 arg1 = reinterpret_cast< wxPoint * >(argp1);
5823 result = (int) ((arg1)->y);
5824 resultobj = SWIG_From_int(static_cast< int >(result));
5825 return resultobj;
5826 fail:
5827 return NULL;
5828 }
5829
5830
5831 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5832 PyObject *resultobj = 0;
5833 int arg1 = (int) 0 ;
5834 int arg2 = (int) 0 ;
5835 wxPoint *result = 0 ;
5836 int val1 ;
5837 int ecode1 = 0 ;
5838 int val2 ;
5839 int ecode2 = 0 ;
5840 PyObject * obj0 = 0 ;
5841 PyObject * obj1 = 0 ;
5842 char * kwnames[] = {
5843 (char *) "x",(char *) "y", NULL
5844 };
5845
5846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5847 if (obj0) {
5848 ecode1 = SWIG_AsVal_int(obj0, &val1);
5849 if (!SWIG_IsOK(ecode1)) {
5850 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5851 }
5852 arg1 = static_cast< int >(val1);
5853 }
5854 if (obj1) {
5855 ecode2 = SWIG_AsVal_int(obj1, &val2);
5856 if (!SWIG_IsOK(ecode2)) {
5857 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5858 }
5859 arg2 = static_cast< int >(val2);
5860 }
5861 {
5862 result = (wxPoint *)new wxPoint(arg1,arg2);
5863 if (PyErr_Occurred()) SWIG_fail;
5864 }
5865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5866 return resultobj;
5867 fail:
5868 return NULL;
5869 }
5870
5871
5872 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5873 PyObject *resultobj = 0;
5874 wxPoint *arg1 = (wxPoint *) 0 ;
5875 void *argp1 = 0 ;
5876 int res1 = 0 ;
5877 PyObject *swig_obj[1] ;
5878
5879 if (!args) SWIG_fail;
5880 swig_obj[0] = args;
5881 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5882 if (!SWIG_IsOK(res1)) {
5883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5884 }
5885 arg1 = reinterpret_cast< wxPoint * >(argp1);
5886 {
5887 delete arg1;
5888
5889 if (PyErr_Occurred()) SWIG_fail;
5890 }
5891 resultobj = SWIG_Py_Void();
5892 return resultobj;
5893 fail:
5894 return NULL;
5895 }
5896
5897
5898 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5899 PyObject *resultobj = 0;
5900 wxPoint *arg1 = (wxPoint *) 0 ;
5901 PyObject *arg2 = (PyObject *) 0 ;
5902 bool result;
5903 void *argp1 = 0 ;
5904 int res1 = 0 ;
5905 PyObject * obj0 = 0 ;
5906 PyObject * obj1 = 0 ;
5907 char * kwnames[] = {
5908 (char *) "self",(char *) "other", NULL
5909 };
5910
5911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5913 if (!SWIG_IsOK(res1)) {
5914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5915 }
5916 arg1 = reinterpret_cast< wxPoint * >(argp1);
5917 arg2 = obj1;
5918 {
5919 result = (bool)wxPoint___eq__(arg1,arg2);
5920 if (PyErr_Occurred()) SWIG_fail;
5921 }
5922 {
5923 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5924 }
5925 return resultobj;
5926 fail:
5927 return NULL;
5928 }
5929
5930
5931 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5932 PyObject *resultobj = 0;
5933 wxPoint *arg1 = (wxPoint *) 0 ;
5934 PyObject *arg2 = (PyObject *) 0 ;
5935 bool result;
5936 void *argp1 = 0 ;
5937 int res1 = 0 ;
5938 PyObject * obj0 = 0 ;
5939 PyObject * obj1 = 0 ;
5940 char * kwnames[] = {
5941 (char *) "self",(char *) "other", NULL
5942 };
5943
5944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5946 if (!SWIG_IsOK(res1)) {
5947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5948 }
5949 arg1 = reinterpret_cast< wxPoint * >(argp1);
5950 arg2 = obj1;
5951 {
5952 result = (bool)wxPoint___ne__(arg1,arg2);
5953 if (PyErr_Occurred()) SWIG_fail;
5954 }
5955 {
5956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5957 }
5958 return resultobj;
5959 fail:
5960 return NULL;
5961 }
5962
5963
5964 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5965 PyObject *resultobj = 0;
5966 wxPoint *arg1 = (wxPoint *) 0 ;
5967 wxPoint *arg2 = 0 ;
5968 wxPoint result;
5969 void *argp1 = 0 ;
5970 int res1 = 0 ;
5971 wxPoint temp2 ;
5972 PyObject * obj0 = 0 ;
5973 PyObject * obj1 = 0 ;
5974 char * kwnames[] = {
5975 (char *) "self",(char *) "pt", NULL
5976 };
5977
5978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5980 if (!SWIG_IsOK(res1)) {
5981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5982 }
5983 arg1 = reinterpret_cast< wxPoint * >(argp1);
5984 {
5985 arg2 = &temp2;
5986 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5987 }
5988 {
5989 result = (arg1)->operator +((wxPoint const &)*arg2);
5990 if (PyErr_Occurred()) SWIG_fail;
5991 }
5992 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5993 return resultobj;
5994 fail:
5995 return NULL;
5996 }
5997
5998
5999 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6000 PyObject *resultobj = 0;
6001 wxPoint *arg1 = (wxPoint *) 0 ;
6002 wxPoint *arg2 = 0 ;
6003 wxPoint result;
6004 void *argp1 = 0 ;
6005 int res1 = 0 ;
6006 wxPoint temp2 ;
6007 PyObject * obj0 = 0 ;
6008 PyObject * obj1 = 0 ;
6009 char * kwnames[] = {
6010 (char *) "self",(char *) "pt", NULL
6011 };
6012
6013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6015 if (!SWIG_IsOK(res1)) {
6016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6017 }
6018 arg1 = reinterpret_cast< wxPoint * >(argp1);
6019 {
6020 arg2 = &temp2;
6021 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6022 }
6023 {
6024 result = (arg1)->operator -((wxPoint const &)*arg2);
6025 if (PyErr_Occurred()) SWIG_fail;
6026 }
6027 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6028 return resultobj;
6029 fail:
6030 return NULL;
6031 }
6032
6033
6034 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6035 PyObject *resultobj = 0;
6036 wxPoint *arg1 = (wxPoint *) 0 ;
6037 wxPoint *arg2 = 0 ;
6038 wxPoint *result = 0 ;
6039 void *argp1 = 0 ;
6040 int res1 = 0 ;
6041 wxPoint temp2 ;
6042 PyObject * obj0 = 0 ;
6043 PyObject * obj1 = 0 ;
6044 char * kwnames[] = {
6045 (char *) "self",(char *) "pt", NULL
6046 };
6047
6048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6050 if (!SWIG_IsOK(res1)) {
6051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6052 }
6053 arg1 = reinterpret_cast< wxPoint * >(argp1);
6054 {
6055 arg2 = &temp2;
6056 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6057 }
6058 {
6059 {
6060 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6061 result = (wxPoint *) &_result_ref;
6062 }
6063 if (PyErr_Occurred()) SWIG_fail;
6064 }
6065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6066 return resultobj;
6067 fail:
6068 return NULL;
6069 }
6070
6071
6072 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6073 PyObject *resultobj = 0;
6074 wxPoint *arg1 = (wxPoint *) 0 ;
6075 wxPoint *arg2 = 0 ;
6076 wxPoint *result = 0 ;
6077 void *argp1 = 0 ;
6078 int res1 = 0 ;
6079 wxPoint temp2 ;
6080 PyObject * obj0 = 0 ;
6081 PyObject * obj1 = 0 ;
6082 char * kwnames[] = {
6083 (char *) "self",(char *) "pt", NULL
6084 };
6085
6086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6087 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6088 if (!SWIG_IsOK(res1)) {
6089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6090 }
6091 arg1 = reinterpret_cast< wxPoint * >(argp1);
6092 {
6093 arg2 = &temp2;
6094 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6095 }
6096 {
6097 {
6098 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6099 result = (wxPoint *) &_result_ref;
6100 }
6101 if (PyErr_Occurred()) SWIG_fail;
6102 }
6103 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6104 return resultobj;
6105 fail:
6106 return NULL;
6107 }
6108
6109
6110 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6111 PyObject *resultobj = 0;
6112 wxPoint *arg1 = (wxPoint *) 0 ;
6113 long arg2 ;
6114 long arg3 ;
6115 void *argp1 = 0 ;
6116 int res1 = 0 ;
6117 long val2 ;
6118 int ecode2 = 0 ;
6119 long val3 ;
6120 int ecode3 = 0 ;
6121 PyObject * obj0 = 0 ;
6122 PyObject * obj1 = 0 ;
6123 PyObject * obj2 = 0 ;
6124 char * kwnames[] = {
6125 (char *) "self",(char *) "x",(char *) "y", NULL
6126 };
6127
6128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6130 if (!SWIG_IsOK(res1)) {
6131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6132 }
6133 arg1 = reinterpret_cast< wxPoint * >(argp1);
6134 ecode2 = SWIG_AsVal_long(obj1, &val2);
6135 if (!SWIG_IsOK(ecode2)) {
6136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6137 }
6138 arg2 = static_cast< long >(val2);
6139 ecode3 = SWIG_AsVal_long(obj2, &val3);
6140 if (!SWIG_IsOK(ecode3)) {
6141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6142 }
6143 arg3 = static_cast< long >(val3);
6144 {
6145 wxPoint_Set(arg1,arg2,arg3);
6146 if (PyErr_Occurred()) SWIG_fail;
6147 }
6148 resultobj = SWIG_Py_Void();
6149 return resultobj;
6150 fail:
6151 return NULL;
6152 }
6153
6154
6155 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6156 PyObject *resultobj = 0;
6157 wxPoint *arg1 = (wxPoint *) 0 ;
6158 PyObject *result = 0 ;
6159 void *argp1 = 0 ;
6160 int res1 = 0 ;
6161 PyObject *swig_obj[1] ;
6162
6163 if (!args) SWIG_fail;
6164 swig_obj[0] = args;
6165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6166 if (!SWIG_IsOK(res1)) {
6167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6168 }
6169 arg1 = reinterpret_cast< wxPoint * >(argp1);
6170 {
6171 result = (PyObject *)wxPoint_Get(arg1);
6172 if (PyErr_Occurred()) SWIG_fail;
6173 }
6174 resultobj = result;
6175 return resultobj;
6176 fail:
6177 return NULL;
6178 }
6179
6180
6181 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6182 PyObject *obj;
6183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6184 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6185 return SWIG_Py_Void();
6186 }
6187
6188 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6189 return SWIG_Python_InitShadowInstance(args);
6190 }
6191
6192 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6193 PyObject *resultobj = 0;
6194 int arg1 = (int) 0 ;
6195 int arg2 = (int) 0 ;
6196 int arg3 = (int) 0 ;
6197 int arg4 = (int) 0 ;
6198 wxRect *result = 0 ;
6199 int val1 ;
6200 int ecode1 = 0 ;
6201 int val2 ;
6202 int ecode2 = 0 ;
6203 int val3 ;
6204 int ecode3 = 0 ;
6205 int val4 ;
6206 int ecode4 = 0 ;
6207 PyObject * obj0 = 0 ;
6208 PyObject * obj1 = 0 ;
6209 PyObject * obj2 = 0 ;
6210 PyObject * obj3 = 0 ;
6211 char * kwnames[] = {
6212 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6213 };
6214
6215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6216 if (obj0) {
6217 ecode1 = SWIG_AsVal_int(obj0, &val1);
6218 if (!SWIG_IsOK(ecode1)) {
6219 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6220 }
6221 arg1 = static_cast< int >(val1);
6222 }
6223 if (obj1) {
6224 ecode2 = SWIG_AsVal_int(obj1, &val2);
6225 if (!SWIG_IsOK(ecode2)) {
6226 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6227 }
6228 arg2 = static_cast< int >(val2);
6229 }
6230 if (obj2) {
6231 ecode3 = SWIG_AsVal_int(obj2, &val3);
6232 if (!SWIG_IsOK(ecode3)) {
6233 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6234 }
6235 arg3 = static_cast< int >(val3);
6236 }
6237 if (obj3) {
6238 ecode4 = SWIG_AsVal_int(obj3, &val4);
6239 if (!SWIG_IsOK(ecode4)) {
6240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6241 }
6242 arg4 = static_cast< int >(val4);
6243 }
6244 {
6245 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6246 if (PyErr_Occurred()) SWIG_fail;
6247 }
6248 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6249 return resultobj;
6250 fail:
6251 return NULL;
6252 }
6253
6254
6255 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6256 PyObject *resultobj = 0;
6257 wxPoint *arg1 = 0 ;
6258 wxPoint *arg2 = 0 ;
6259 wxRect *result = 0 ;
6260 wxPoint temp1 ;
6261 wxPoint temp2 ;
6262 PyObject * obj0 = 0 ;
6263 PyObject * obj1 = 0 ;
6264 char * kwnames[] = {
6265 (char *) "topLeft",(char *) "bottomRight", NULL
6266 };
6267
6268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6269 {
6270 arg1 = &temp1;
6271 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6272 }
6273 {
6274 arg2 = &temp2;
6275 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6276 }
6277 {
6278 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6279 if (PyErr_Occurred()) SWIG_fail;
6280 }
6281 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6282 return resultobj;
6283 fail:
6284 return NULL;
6285 }
6286
6287
6288 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6289 PyObject *resultobj = 0;
6290 wxPoint *arg1 = 0 ;
6291 wxSize *arg2 = 0 ;
6292 wxRect *result = 0 ;
6293 wxPoint temp1 ;
6294 wxSize temp2 ;
6295 PyObject * obj0 = 0 ;
6296 PyObject * obj1 = 0 ;
6297 char * kwnames[] = {
6298 (char *) "pos",(char *) "size", NULL
6299 };
6300
6301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6302 {
6303 arg1 = &temp1;
6304 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6305 }
6306 {
6307 arg2 = &temp2;
6308 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6309 }
6310 {
6311 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6312 if (PyErr_Occurred()) SWIG_fail;
6313 }
6314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6315 return resultobj;
6316 fail:
6317 return NULL;
6318 }
6319
6320
6321 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6322 PyObject *resultobj = 0;
6323 wxSize *arg1 = 0 ;
6324 wxRect *result = 0 ;
6325 wxSize temp1 ;
6326 PyObject * obj0 = 0 ;
6327 char * kwnames[] = {
6328 (char *) "size", NULL
6329 };
6330
6331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6332 {
6333 arg1 = &temp1;
6334 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6335 }
6336 {
6337 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6338 if (PyErr_Occurred()) SWIG_fail;
6339 }
6340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6341 return resultobj;
6342 fail:
6343 return NULL;
6344 }
6345
6346
6347 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6348 PyObject *resultobj = 0;
6349 wxRect *arg1 = (wxRect *) 0 ;
6350 void *argp1 = 0 ;
6351 int res1 = 0 ;
6352 PyObject *swig_obj[1] ;
6353
6354 if (!args) SWIG_fail;
6355 swig_obj[0] = args;
6356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6357 if (!SWIG_IsOK(res1)) {
6358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6359 }
6360 arg1 = reinterpret_cast< wxRect * >(argp1);
6361 {
6362 delete arg1;
6363
6364 if (PyErr_Occurred()) SWIG_fail;
6365 }
6366 resultobj = SWIG_Py_Void();
6367 return resultobj;
6368 fail:
6369 return NULL;
6370 }
6371
6372
6373 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6374 PyObject *resultobj = 0;
6375 wxRect *arg1 = (wxRect *) 0 ;
6376 int result;
6377 void *argp1 = 0 ;
6378 int res1 = 0 ;
6379 PyObject *swig_obj[1] ;
6380
6381 if (!args) SWIG_fail;
6382 swig_obj[0] = args;
6383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6384 if (!SWIG_IsOK(res1)) {
6385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6386 }
6387 arg1 = reinterpret_cast< wxRect * >(argp1);
6388 {
6389 result = (int)((wxRect const *)arg1)->GetX();
6390 if (PyErr_Occurred()) SWIG_fail;
6391 }
6392 resultobj = SWIG_From_int(static_cast< int >(result));
6393 return resultobj;
6394 fail:
6395 return NULL;
6396 }
6397
6398
6399 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6400 PyObject *resultobj = 0;
6401 wxRect *arg1 = (wxRect *) 0 ;
6402 int arg2 ;
6403 void *argp1 = 0 ;
6404 int res1 = 0 ;
6405 int val2 ;
6406 int ecode2 = 0 ;
6407 PyObject * obj0 = 0 ;
6408 PyObject * obj1 = 0 ;
6409 char * kwnames[] = {
6410 (char *) "self",(char *) "x", NULL
6411 };
6412
6413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6415 if (!SWIG_IsOK(res1)) {
6416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6417 }
6418 arg1 = reinterpret_cast< wxRect * >(argp1);
6419 ecode2 = SWIG_AsVal_int(obj1, &val2);
6420 if (!SWIG_IsOK(ecode2)) {
6421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6422 }
6423 arg2 = static_cast< int >(val2);
6424 {
6425 (arg1)->SetX(arg2);
6426 if (PyErr_Occurred()) SWIG_fail;
6427 }
6428 resultobj = SWIG_Py_Void();
6429 return resultobj;
6430 fail:
6431 return NULL;
6432 }
6433
6434
6435 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6436 PyObject *resultobj = 0;
6437 wxRect *arg1 = (wxRect *) 0 ;
6438 int result;
6439 void *argp1 = 0 ;
6440 int res1 = 0 ;
6441 PyObject *swig_obj[1] ;
6442
6443 if (!args) SWIG_fail;
6444 swig_obj[0] = args;
6445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6446 if (!SWIG_IsOK(res1)) {
6447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6448 }
6449 arg1 = reinterpret_cast< wxRect * >(argp1);
6450 {
6451 result = (int)(arg1)->GetY();
6452 if (PyErr_Occurred()) SWIG_fail;
6453 }
6454 resultobj = SWIG_From_int(static_cast< int >(result));
6455 return resultobj;
6456 fail:
6457 return NULL;
6458 }
6459
6460
6461 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6462 PyObject *resultobj = 0;
6463 wxRect *arg1 = (wxRect *) 0 ;
6464 int arg2 ;
6465 void *argp1 = 0 ;
6466 int res1 = 0 ;
6467 int val2 ;
6468 int ecode2 = 0 ;
6469 PyObject * obj0 = 0 ;
6470 PyObject * obj1 = 0 ;
6471 char * kwnames[] = {
6472 (char *) "self",(char *) "y", NULL
6473 };
6474
6475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6477 if (!SWIG_IsOK(res1)) {
6478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6479 }
6480 arg1 = reinterpret_cast< wxRect * >(argp1);
6481 ecode2 = SWIG_AsVal_int(obj1, &val2);
6482 if (!SWIG_IsOK(ecode2)) {
6483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6484 }
6485 arg2 = static_cast< int >(val2);
6486 {
6487 (arg1)->SetY(arg2);
6488 if (PyErr_Occurred()) SWIG_fail;
6489 }
6490 resultobj = SWIG_Py_Void();
6491 return resultobj;
6492 fail:
6493 return NULL;
6494 }
6495
6496
6497 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6498 PyObject *resultobj = 0;
6499 wxRect *arg1 = (wxRect *) 0 ;
6500 int result;
6501 void *argp1 = 0 ;
6502 int res1 = 0 ;
6503 PyObject *swig_obj[1] ;
6504
6505 if (!args) SWIG_fail;
6506 swig_obj[0] = args;
6507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6508 if (!SWIG_IsOK(res1)) {
6509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6510 }
6511 arg1 = reinterpret_cast< wxRect * >(argp1);
6512 {
6513 result = (int)((wxRect const *)arg1)->GetWidth();
6514 if (PyErr_Occurred()) SWIG_fail;
6515 }
6516 resultobj = SWIG_From_int(static_cast< int >(result));
6517 return resultobj;
6518 fail:
6519 return NULL;
6520 }
6521
6522
6523 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6524 PyObject *resultobj = 0;
6525 wxRect *arg1 = (wxRect *) 0 ;
6526 int arg2 ;
6527 void *argp1 = 0 ;
6528 int res1 = 0 ;
6529 int val2 ;
6530 int ecode2 = 0 ;
6531 PyObject * obj0 = 0 ;
6532 PyObject * obj1 = 0 ;
6533 char * kwnames[] = {
6534 (char *) "self",(char *) "w", NULL
6535 };
6536
6537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6538 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6539 if (!SWIG_IsOK(res1)) {
6540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6541 }
6542 arg1 = reinterpret_cast< wxRect * >(argp1);
6543 ecode2 = SWIG_AsVal_int(obj1, &val2);
6544 if (!SWIG_IsOK(ecode2)) {
6545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6546 }
6547 arg2 = static_cast< int >(val2);
6548 {
6549 (arg1)->SetWidth(arg2);
6550 if (PyErr_Occurred()) SWIG_fail;
6551 }
6552 resultobj = SWIG_Py_Void();
6553 return resultobj;
6554 fail:
6555 return NULL;
6556 }
6557
6558
6559 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6560 PyObject *resultobj = 0;
6561 wxRect *arg1 = (wxRect *) 0 ;
6562 int result;
6563 void *argp1 = 0 ;
6564 int res1 = 0 ;
6565 PyObject *swig_obj[1] ;
6566
6567 if (!args) SWIG_fail;
6568 swig_obj[0] = args;
6569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6570 if (!SWIG_IsOK(res1)) {
6571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6572 }
6573 arg1 = reinterpret_cast< wxRect * >(argp1);
6574 {
6575 result = (int)((wxRect const *)arg1)->GetHeight();
6576 if (PyErr_Occurred()) SWIG_fail;
6577 }
6578 resultobj = SWIG_From_int(static_cast< int >(result));
6579 return resultobj;
6580 fail:
6581 return NULL;
6582 }
6583
6584
6585 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6586 PyObject *resultobj = 0;
6587 wxRect *arg1 = (wxRect *) 0 ;
6588 int arg2 ;
6589 void *argp1 = 0 ;
6590 int res1 = 0 ;
6591 int val2 ;
6592 int ecode2 = 0 ;
6593 PyObject * obj0 = 0 ;
6594 PyObject * obj1 = 0 ;
6595 char * kwnames[] = {
6596 (char *) "self",(char *) "h", NULL
6597 };
6598
6599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6601 if (!SWIG_IsOK(res1)) {
6602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6603 }
6604 arg1 = reinterpret_cast< wxRect * >(argp1);
6605 ecode2 = SWIG_AsVal_int(obj1, &val2);
6606 if (!SWIG_IsOK(ecode2)) {
6607 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6608 }
6609 arg2 = static_cast< int >(val2);
6610 {
6611 (arg1)->SetHeight(arg2);
6612 if (PyErr_Occurred()) SWIG_fail;
6613 }
6614 resultobj = SWIG_Py_Void();
6615 return resultobj;
6616 fail:
6617 return NULL;
6618 }
6619
6620
6621 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6622 PyObject *resultobj = 0;
6623 wxRect *arg1 = (wxRect *) 0 ;
6624 wxPoint result;
6625 void *argp1 = 0 ;
6626 int res1 = 0 ;
6627 PyObject *swig_obj[1] ;
6628
6629 if (!args) SWIG_fail;
6630 swig_obj[0] = args;
6631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6632 if (!SWIG_IsOK(res1)) {
6633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6634 }
6635 arg1 = reinterpret_cast< wxRect * >(argp1);
6636 {
6637 result = ((wxRect const *)arg1)->GetPosition();
6638 if (PyErr_Occurred()) SWIG_fail;
6639 }
6640 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6641 return resultobj;
6642 fail:
6643 return NULL;
6644 }
6645
6646
6647 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6648 PyObject *resultobj = 0;
6649 wxRect *arg1 = (wxRect *) 0 ;
6650 wxPoint *arg2 = 0 ;
6651 void *argp1 = 0 ;
6652 int res1 = 0 ;
6653 wxPoint temp2 ;
6654 PyObject * obj0 = 0 ;
6655 PyObject * obj1 = 0 ;
6656 char * kwnames[] = {
6657 (char *) "self",(char *) "p", NULL
6658 };
6659
6660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6662 if (!SWIG_IsOK(res1)) {
6663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6664 }
6665 arg1 = reinterpret_cast< wxRect * >(argp1);
6666 {
6667 arg2 = &temp2;
6668 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6669 }
6670 {
6671 (arg1)->SetPosition((wxPoint const &)*arg2);
6672 if (PyErr_Occurred()) SWIG_fail;
6673 }
6674 resultobj = SWIG_Py_Void();
6675 return resultobj;
6676 fail:
6677 return NULL;
6678 }
6679
6680
6681 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6682 PyObject *resultobj = 0;
6683 wxRect *arg1 = (wxRect *) 0 ;
6684 wxSize result;
6685 void *argp1 = 0 ;
6686 int res1 = 0 ;
6687 PyObject *swig_obj[1] ;
6688
6689 if (!args) SWIG_fail;
6690 swig_obj[0] = args;
6691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6692 if (!SWIG_IsOK(res1)) {
6693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6694 }
6695 arg1 = reinterpret_cast< wxRect * >(argp1);
6696 {
6697 result = ((wxRect const *)arg1)->GetSize();
6698 if (PyErr_Occurred()) SWIG_fail;
6699 }
6700 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6701 return resultobj;
6702 fail:
6703 return NULL;
6704 }
6705
6706
6707 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6708 PyObject *resultobj = 0;
6709 wxRect *arg1 = (wxRect *) 0 ;
6710 wxSize *arg2 = 0 ;
6711 void *argp1 = 0 ;
6712 int res1 = 0 ;
6713 wxSize temp2 ;
6714 PyObject * obj0 = 0 ;
6715 PyObject * obj1 = 0 ;
6716 char * kwnames[] = {
6717 (char *) "self",(char *) "s", NULL
6718 };
6719
6720 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6721 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6722 if (!SWIG_IsOK(res1)) {
6723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6724 }
6725 arg1 = reinterpret_cast< wxRect * >(argp1);
6726 {
6727 arg2 = &temp2;
6728 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6729 }
6730 {
6731 (arg1)->SetSize((wxSize const &)*arg2);
6732 if (PyErr_Occurred()) SWIG_fail;
6733 }
6734 resultobj = SWIG_Py_Void();
6735 return resultobj;
6736 fail:
6737 return NULL;
6738 }
6739
6740
6741 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6742 PyObject *resultobj = 0;
6743 wxRect *arg1 = (wxRect *) 0 ;
6744 bool result;
6745 void *argp1 = 0 ;
6746 int res1 = 0 ;
6747 PyObject *swig_obj[1] ;
6748
6749 if (!args) SWIG_fail;
6750 swig_obj[0] = args;
6751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6752 if (!SWIG_IsOK(res1)) {
6753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6754 }
6755 arg1 = reinterpret_cast< wxRect * >(argp1);
6756 {
6757 result = (bool)((wxRect const *)arg1)->IsEmpty();
6758 if (PyErr_Occurred()) SWIG_fail;
6759 }
6760 {
6761 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6762 }
6763 return resultobj;
6764 fail:
6765 return NULL;
6766 }
6767
6768
6769 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6770 PyObject *resultobj = 0;
6771 wxRect *arg1 = (wxRect *) 0 ;
6772 wxPoint result;
6773 void *argp1 = 0 ;
6774 int res1 = 0 ;
6775 PyObject *swig_obj[1] ;
6776
6777 if (!args) SWIG_fail;
6778 swig_obj[0] = args;
6779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6780 if (!SWIG_IsOK(res1)) {
6781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6782 }
6783 arg1 = reinterpret_cast< wxRect * >(argp1);
6784 {
6785 result = ((wxRect const *)arg1)->GetTopLeft();
6786 if (PyErr_Occurred()) SWIG_fail;
6787 }
6788 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6789 return resultobj;
6790 fail:
6791 return NULL;
6792 }
6793
6794
6795 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6796 PyObject *resultobj = 0;
6797 wxRect *arg1 = (wxRect *) 0 ;
6798 wxPoint *arg2 = 0 ;
6799 void *argp1 = 0 ;
6800 int res1 = 0 ;
6801 wxPoint temp2 ;
6802 PyObject * obj0 = 0 ;
6803 PyObject * obj1 = 0 ;
6804 char * kwnames[] = {
6805 (char *) "self",(char *) "p", NULL
6806 };
6807
6808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6810 if (!SWIG_IsOK(res1)) {
6811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6812 }
6813 arg1 = reinterpret_cast< wxRect * >(argp1);
6814 {
6815 arg2 = &temp2;
6816 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6817 }
6818 {
6819 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6820 if (PyErr_Occurred()) SWIG_fail;
6821 }
6822 resultobj = SWIG_Py_Void();
6823 return resultobj;
6824 fail:
6825 return NULL;
6826 }
6827
6828
6829 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6830 PyObject *resultobj = 0;
6831 wxRect *arg1 = (wxRect *) 0 ;
6832 wxPoint result;
6833 void *argp1 = 0 ;
6834 int res1 = 0 ;
6835 PyObject *swig_obj[1] ;
6836
6837 if (!args) SWIG_fail;
6838 swig_obj[0] = args;
6839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6840 if (!SWIG_IsOK(res1)) {
6841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6842 }
6843 arg1 = reinterpret_cast< wxRect * >(argp1);
6844 {
6845 result = ((wxRect const *)arg1)->GetBottomRight();
6846 if (PyErr_Occurred()) SWIG_fail;
6847 }
6848 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6849 return resultobj;
6850 fail:
6851 return NULL;
6852 }
6853
6854
6855 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6856 PyObject *resultobj = 0;
6857 wxRect *arg1 = (wxRect *) 0 ;
6858 wxPoint *arg2 = 0 ;
6859 void *argp1 = 0 ;
6860 int res1 = 0 ;
6861 wxPoint temp2 ;
6862 PyObject * obj0 = 0 ;
6863 PyObject * obj1 = 0 ;
6864 char * kwnames[] = {
6865 (char *) "self",(char *) "p", NULL
6866 };
6867
6868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6870 if (!SWIG_IsOK(res1)) {
6871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6872 }
6873 arg1 = reinterpret_cast< wxRect * >(argp1);
6874 {
6875 arg2 = &temp2;
6876 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6877 }
6878 {
6879 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6880 if (PyErr_Occurred()) SWIG_fail;
6881 }
6882 resultobj = SWIG_Py_Void();
6883 return resultobj;
6884 fail:
6885 return NULL;
6886 }
6887
6888
6889 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6890 PyObject *resultobj = 0;
6891 wxRect *arg1 = (wxRect *) 0 ;
6892 wxPoint result;
6893 void *argp1 = 0 ;
6894 int res1 = 0 ;
6895 PyObject *swig_obj[1] ;
6896
6897 if (!args) SWIG_fail;
6898 swig_obj[0] = args;
6899 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6900 if (!SWIG_IsOK(res1)) {
6901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6902 }
6903 arg1 = reinterpret_cast< wxRect * >(argp1);
6904 {
6905 result = ((wxRect const *)arg1)->GetTopRight();
6906 if (PyErr_Occurred()) SWIG_fail;
6907 }
6908 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6909 return resultobj;
6910 fail:
6911 return NULL;
6912 }
6913
6914
6915 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6916 PyObject *resultobj = 0;
6917 wxRect *arg1 = (wxRect *) 0 ;
6918 wxPoint *arg2 = 0 ;
6919 void *argp1 = 0 ;
6920 int res1 = 0 ;
6921 wxPoint temp2 ;
6922 PyObject * obj0 = 0 ;
6923 PyObject * obj1 = 0 ;
6924 char * kwnames[] = {
6925 (char *) "self",(char *) "p", NULL
6926 };
6927
6928 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6929 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6930 if (!SWIG_IsOK(res1)) {
6931 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6932 }
6933 arg1 = reinterpret_cast< wxRect * >(argp1);
6934 {
6935 arg2 = &temp2;
6936 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6937 }
6938 {
6939 (arg1)->SetTopRight((wxPoint const &)*arg2);
6940 if (PyErr_Occurred()) SWIG_fail;
6941 }
6942 resultobj = SWIG_Py_Void();
6943 return resultobj;
6944 fail:
6945 return NULL;
6946 }
6947
6948
6949 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6950 PyObject *resultobj = 0;
6951 wxRect *arg1 = (wxRect *) 0 ;
6952 wxPoint result;
6953 void *argp1 = 0 ;
6954 int res1 = 0 ;
6955 PyObject *swig_obj[1] ;
6956
6957 if (!args) SWIG_fail;
6958 swig_obj[0] = args;
6959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6960 if (!SWIG_IsOK(res1)) {
6961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6962 }
6963 arg1 = reinterpret_cast< wxRect * >(argp1);
6964 {
6965 result = ((wxRect const *)arg1)->GetBottomLeft();
6966 if (PyErr_Occurred()) SWIG_fail;
6967 }
6968 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6969 return resultobj;
6970 fail:
6971 return NULL;
6972 }
6973
6974
6975 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6976 PyObject *resultobj = 0;
6977 wxRect *arg1 = (wxRect *) 0 ;
6978 wxPoint *arg2 = 0 ;
6979 void *argp1 = 0 ;
6980 int res1 = 0 ;
6981 wxPoint temp2 ;
6982 PyObject * obj0 = 0 ;
6983 PyObject * obj1 = 0 ;
6984 char * kwnames[] = {
6985 (char *) "self",(char *) "p", NULL
6986 };
6987
6988 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6989 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6990 if (!SWIG_IsOK(res1)) {
6991 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6992 }
6993 arg1 = reinterpret_cast< wxRect * >(argp1);
6994 {
6995 arg2 = &temp2;
6996 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6997 }
6998 {
6999 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7000 if (PyErr_Occurred()) SWIG_fail;
7001 }
7002 resultobj = SWIG_Py_Void();
7003 return resultobj;
7004 fail:
7005 return NULL;
7006 }
7007
7008
7009 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7010 PyObject *resultobj = 0;
7011 wxRect *arg1 = (wxRect *) 0 ;
7012 int result;
7013 void *argp1 = 0 ;
7014 int res1 = 0 ;
7015 PyObject *swig_obj[1] ;
7016
7017 if (!args) SWIG_fail;
7018 swig_obj[0] = args;
7019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7020 if (!SWIG_IsOK(res1)) {
7021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7022 }
7023 arg1 = reinterpret_cast< wxRect * >(argp1);
7024 {
7025 result = (int)((wxRect const *)arg1)->GetLeft();
7026 if (PyErr_Occurred()) SWIG_fail;
7027 }
7028 resultobj = SWIG_From_int(static_cast< int >(result));
7029 return resultobj;
7030 fail:
7031 return NULL;
7032 }
7033
7034
7035 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7036 PyObject *resultobj = 0;
7037 wxRect *arg1 = (wxRect *) 0 ;
7038 int result;
7039 void *argp1 = 0 ;
7040 int res1 = 0 ;
7041 PyObject *swig_obj[1] ;
7042
7043 if (!args) SWIG_fail;
7044 swig_obj[0] = args;
7045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7046 if (!SWIG_IsOK(res1)) {
7047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7048 }
7049 arg1 = reinterpret_cast< wxRect * >(argp1);
7050 {
7051 result = (int)((wxRect const *)arg1)->GetTop();
7052 if (PyErr_Occurred()) SWIG_fail;
7053 }
7054 resultobj = SWIG_From_int(static_cast< int >(result));
7055 return resultobj;
7056 fail:
7057 return NULL;
7058 }
7059
7060
7061 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7062 PyObject *resultobj = 0;
7063 wxRect *arg1 = (wxRect *) 0 ;
7064 int result;
7065 void *argp1 = 0 ;
7066 int res1 = 0 ;
7067 PyObject *swig_obj[1] ;
7068
7069 if (!args) SWIG_fail;
7070 swig_obj[0] = args;
7071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7072 if (!SWIG_IsOK(res1)) {
7073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7074 }
7075 arg1 = reinterpret_cast< wxRect * >(argp1);
7076 {
7077 result = (int)((wxRect const *)arg1)->GetBottom();
7078 if (PyErr_Occurred()) SWIG_fail;
7079 }
7080 resultobj = SWIG_From_int(static_cast< int >(result));
7081 return resultobj;
7082 fail:
7083 return NULL;
7084 }
7085
7086
7087 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7088 PyObject *resultobj = 0;
7089 wxRect *arg1 = (wxRect *) 0 ;
7090 int result;
7091 void *argp1 = 0 ;
7092 int res1 = 0 ;
7093 PyObject *swig_obj[1] ;
7094
7095 if (!args) SWIG_fail;
7096 swig_obj[0] = args;
7097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7098 if (!SWIG_IsOK(res1)) {
7099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7100 }
7101 arg1 = reinterpret_cast< wxRect * >(argp1);
7102 {
7103 result = (int)((wxRect const *)arg1)->GetRight();
7104 if (PyErr_Occurred()) SWIG_fail;
7105 }
7106 resultobj = SWIG_From_int(static_cast< int >(result));
7107 return resultobj;
7108 fail:
7109 return NULL;
7110 }
7111
7112
7113 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7114 PyObject *resultobj = 0;
7115 wxRect *arg1 = (wxRect *) 0 ;
7116 int arg2 ;
7117 void *argp1 = 0 ;
7118 int res1 = 0 ;
7119 int val2 ;
7120 int ecode2 = 0 ;
7121 PyObject * obj0 = 0 ;
7122 PyObject * obj1 = 0 ;
7123 char * kwnames[] = {
7124 (char *) "self",(char *) "left", NULL
7125 };
7126
7127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7129 if (!SWIG_IsOK(res1)) {
7130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7131 }
7132 arg1 = reinterpret_cast< wxRect * >(argp1);
7133 ecode2 = SWIG_AsVal_int(obj1, &val2);
7134 if (!SWIG_IsOK(ecode2)) {
7135 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7136 }
7137 arg2 = static_cast< int >(val2);
7138 {
7139 (arg1)->SetLeft(arg2);
7140 if (PyErr_Occurred()) SWIG_fail;
7141 }
7142 resultobj = SWIG_Py_Void();
7143 return resultobj;
7144 fail:
7145 return NULL;
7146 }
7147
7148
7149 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7150 PyObject *resultobj = 0;
7151 wxRect *arg1 = (wxRect *) 0 ;
7152 int arg2 ;
7153 void *argp1 = 0 ;
7154 int res1 = 0 ;
7155 int val2 ;
7156 int ecode2 = 0 ;
7157 PyObject * obj0 = 0 ;
7158 PyObject * obj1 = 0 ;
7159 char * kwnames[] = {
7160 (char *) "self",(char *) "right", NULL
7161 };
7162
7163 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7164 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7165 if (!SWIG_IsOK(res1)) {
7166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7167 }
7168 arg1 = reinterpret_cast< wxRect * >(argp1);
7169 ecode2 = SWIG_AsVal_int(obj1, &val2);
7170 if (!SWIG_IsOK(ecode2)) {
7171 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7172 }
7173 arg2 = static_cast< int >(val2);
7174 {
7175 (arg1)->SetRight(arg2);
7176 if (PyErr_Occurred()) SWIG_fail;
7177 }
7178 resultobj = SWIG_Py_Void();
7179 return resultobj;
7180 fail:
7181 return NULL;
7182 }
7183
7184
7185 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7186 PyObject *resultobj = 0;
7187 wxRect *arg1 = (wxRect *) 0 ;
7188 int arg2 ;
7189 void *argp1 = 0 ;
7190 int res1 = 0 ;
7191 int val2 ;
7192 int ecode2 = 0 ;
7193 PyObject * obj0 = 0 ;
7194 PyObject * obj1 = 0 ;
7195 char * kwnames[] = {
7196 (char *) "self",(char *) "top", NULL
7197 };
7198
7199 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7200 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7201 if (!SWIG_IsOK(res1)) {
7202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7203 }
7204 arg1 = reinterpret_cast< wxRect * >(argp1);
7205 ecode2 = SWIG_AsVal_int(obj1, &val2);
7206 if (!SWIG_IsOK(ecode2)) {
7207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7208 }
7209 arg2 = static_cast< int >(val2);
7210 {
7211 (arg1)->SetTop(arg2);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 resultobj = SWIG_Py_Void();
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = 0;
7223 wxRect *arg1 = (wxRect *) 0 ;
7224 int arg2 ;
7225 void *argp1 = 0 ;
7226 int res1 = 0 ;
7227 int val2 ;
7228 int ecode2 = 0 ;
7229 PyObject * obj0 = 0 ;
7230 PyObject * obj1 = 0 ;
7231 char * kwnames[] = {
7232 (char *) "self",(char *) "bottom", NULL
7233 };
7234
7235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7237 if (!SWIG_IsOK(res1)) {
7238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7239 }
7240 arg1 = reinterpret_cast< wxRect * >(argp1);
7241 ecode2 = SWIG_AsVal_int(obj1, &val2);
7242 if (!SWIG_IsOK(ecode2)) {
7243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7244 }
7245 arg2 = static_cast< int >(val2);
7246 {
7247 (arg1)->SetBottom(arg2);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_Py_Void();
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 int arg2 ;
7261 int arg3 ;
7262 wxRect result;
7263 void *argp1 = 0 ;
7264 int res1 = 0 ;
7265 int val2 ;
7266 int ecode2 = 0 ;
7267 int val3 ;
7268 int ecode3 = 0 ;
7269 PyObject * obj0 = 0 ;
7270 PyObject * obj1 = 0 ;
7271 PyObject * obj2 = 0 ;
7272 char * kwnames[] = {
7273 (char *) "self",(char *) "dx",(char *) "dy", NULL
7274 };
7275
7276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7278 if (!SWIG_IsOK(res1)) {
7279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7280 }
7281 arg1 = reinterpret_cast< wxRect * >(argp1);
7282 ecode2 = SWIG_AsVal_int(obj1, &val2);
7283 if (!SWIG_IsOK(ecode2)) {
7284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7285 }
7286 arg2 = static_cast< int >(val2);
7287 ecode3 = SWIG_AsVal_int(obj2, &val3);
7288 if (!SWIG_IsOK(ecode3)) {
7289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7290 }
7291 arg3 = static_cast< int >(val3);
7292 {
7293 result = (arg1)->Inflate(arg2,arg3);
7294 if (PyErr_Occurred()) SWIG_fail;
7295 }
7296 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7297 return resultobj;
7298 fail:
7299 return NULL;
7300 }
7301
7302
7303 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7304 PyObject *resultobj = 0;
7305 wxRect *arg1 = (wxRect *) 0 ;
7306 int arg2 ;
7307 int arg3 ;
7308 wxRect *result = 0 ;
7309 void *argp1 = 0 ;
7310 int res1 = 0 ;
7311 int val2 ;
7312 int ecode2 = 0 ;
7313 int val3 ;
7314 int ecode3 = 0 ;
7315 PyObject * obj0 = 0 ;
7316 PyObject * obj1 = 0 ;
7317 PyObject * obj2 = 0 ;
7318 char * kwnames[] = {
7319 (char *) "self",(char *) "dx",(char *) "dy", NULL
7320 };
7321
7322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7324 if (!SWIG_IsOK(res1)) {
7325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7326 }
7327 arg1 = reinterpret_cast< wxRect * >(argp1);
7328 ecode2 = SWIG_AsVal_int(obj1, &val2);
7329 if (!SWIG_IsOK(ecode2)) {
7330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7331 }
7332 arg2 = static_cast< int >(val2);
7333 ecode3 = SWIG_AsVal_int(obj2, &val3);
7334 if (!SWIG_IsOK(ecode3)) {
7335 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7336 }
7337 arg3 = static_cast< int >(val3);
7338 {
7339 {
7340 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7341 result = (wxRect *) &_result_ref;
7342 }
7343 if (PyErr_Occurred()) SWIG_fail;
7344 }
7345 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7346 return resultobj;
7347 fail:
7348 return NULL;
7349 }
7350
7351
7352 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7353 PyObject *resultobj = 0;
7354 wxRect *arg1 = (wxRect *) 0 ;
7355 int arg2 ;
7356 int arg3 ;
7357 void *argp1 = 0 ;
7358 int res1 = 0 ;
7359 int val2 ;
7360 int ecode2 = 0 ;
7361 int val3 ;
7362 int ecode3 = 0 ;
7363 PyObject * obj0 = 0 ;
7364 PyObject * obj1 = 0 ;
7365 PyObject * obj2 = 0 ;
7366 char * kwnames[] = {
7367 (char *) "self",(char *) "dx",(char *) "dy", NULL
7368 };
7369
7370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7372 if (!SWIG_IsOK(res1)) {
7373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7374 }
7375 arg1 = reinterpret_cast< wxRect * >(argp1);
7376 ecode2 = SWIG_AsVal_int(obj1, &val2);
7377 if (!SWIG_IsOK(ecode2)) {
7378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7379 }
7380 arg2 = static_cast< int >(val2);
7381 ecode3 = SWIG_AsVal_int(obj2, &val3);
7382 if (!SWIG_IsOK(ecode3)) {
7383 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7384 }
7385 arg3 = static_cast< int >(val3);
7386 {
7387 (arg1)->Offset(arg2,arg3);
7388 if (PyErr_Occurred()) SWIG_fail;
7389 }
7390 resultobj = SWIG_Py_Void();
7391 return resultobj;
7392 fail:
7393 return NULL;
7394 }
7395
7396
7397 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7398 PyObject *resultobj = 0;
7399 wxRect *arg1 = (wxRect *) 0 ;
7400 wxPoint *arg2 = 0 ;
7401 void *argp1 = 0 ;
7402 int res1 = 0 ;
7403 wxPoint temp2 ;
7404 PyObject * obj0 = 0 ;
7405 PyObject * obj1 = 0 ;
7406 char * kwnames[] = {
7407 (char *) "self",(char *) "pt", NULL
7408 };
7409
7410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7411 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7412 if (!SWIG_IsOK(res1)) {
7413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7414 }
7415 arg1 = reinterpret_cast< wxRect * >(argp1);
7416 {
7417 arg2 = &temp2;
7418 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7419 }
7420 {
7421 (arg1)->Offset((wxPoint const &)*arg2);
7422 if (PyErr_Occurred()) SWIG_fail;
7423 }
7424 resultobj = SWIG_Py_Void();
7425 return resultobj;
7426 fail:
7427 return NULL;
7428 }
7429
7430
7431 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7432 PyObject *resultobj = 0;
7433 wxRect *arg1 = (wxRect *) 0 ;
7434 wxRect *arg2 = 0 ;
7435 wxRect result;
7436 void *argp1 = 0 ;
7437 int res1 = 0 ;
7438 wxRect temp2 ;
7439 PyObject * obj0 = 0 ;
7440 PyObject * obj1 = 0 ;
7441 char * kwnames[] = {
7442 (char *) "self",(char *) "rect", NULL
7443 };
7444
7445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7447 if (!SWIG_IsOK(res1)) {
7448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7449 }
7450 arg1 = reinterpret_cast< wxRect * >(argp1);
7451 {
7452 arg2 = &temp2;
7453 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7454 }
7455 {
7456 result = (arg1)->Intersect((wxRect const &)*arg2);
7457 if (PyErr_Occurred()) SWIG_fail;
7458 }
7459 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7460 return resultobj;
7461 fail:
7462 return NULL;
7463 }
7464
7465
7466 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7467 PyObject *resultobj = 0;
7468 wxRect *arg1 = (wxRect *) 0 ;
7469 wxRect *arg2 = 0 ;
7470 wxRect result;
7471 void *argp1 = 0 ;
7472 int res1 = 0 ;
7473 wxRect temp2 ;
7474 PyObject * obj0 = 0 ;
7475 PyObject * obj1 = 0 ;
7476 char * kwnames[] = {
7477 (char *) "self",(char *) "rect", NULL
7478 };
7479
7480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",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_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7484 }
7485 arg1 = reinterpret_cast< wxRect * >(argp1);
7486 {
7487 arg2 = &temp2;
7488 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7489 }
7490 {
7491 result = (arg1)->Union((wxRect const &)*arg2);
7492 if (PyErr_Occurred()) SWIG_fail;
7493 }
7494 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7495 return resultobj;
7496 fail:
7497 return NULL;
7498 }
7499
7500
7501 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7502 PyObject *resultobj = 0;
7503 wxRect *arg1 = (wxRect *) 0 ;
7504 wxRect *arg2 = 0 ;
7505 wxRect result;
7506 void *argp1 = 0 ;
7507 int res1 = 0 ;
7508 wxRect temp2 ;
7509 PyObject * obj0 = 0 ;
7510 PyObject * obj1 = 0 ;
7511 char * kwnames[] = {
7512 (char *) "self",(char *) "rect", NULL
7513 };
7514
7515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7517 if (!SWIG_IsOK(res1)) {
7518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7519 }
7520 arg1 = reinterpret_cast< wxRect * >(argp1);
7521 {
7522 arg2 = &temp2;
7523 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7524 }
7525 {
7526 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7527 if (PyErr_Occurred()) SWIG_fail;
7528 }
7529 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7530 return resultobj;
7531 fail:
7532 return NULL;
7533 }
7534
7535
7536 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7537 PyObject *resultobj = 0;
7538 wxRect *arg1 = (wxRect *) 0 ;
7539 wxRect *arg2 = 0 ;
7540 wxRect *result = 0 ;
7541 void *argp1 = 0 ;
7542 int res1 = 0 ;
7543 wxRect temp2 ;
7544 PyObject * obj0 = 0 ;
7545 PyObject * obj1 = 0 ;
7546 char * kwnames[] = {
7547 (char *) "self",(char *) "rect", NULL
7548 };
7549
7550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7552 if (!SWIG_IsOK(res1)) {
7553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7554 }
7555 arg1 = reinterpret_cast< wxRect * >(argp1);
7556 {
7557 arg2 = &temp2;
7558 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7559 }
7560 {
7561 {
7562 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7563 result = (wxRect *) &_result_ref;
7564 }
7565 if (PyErr_Occurred()) SWIG_fail;
7566 }
7567 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7568 return resultobj;
7569 fail:
7570 return NULL;
7571 }
7572
7573
7574 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7575 PyObject *resultobj = 0;
7576 wxRect *arg1 = (wxRect *) 0 ;
7577 PyObject *arg2 = (PyObject *) 0 ;
7578 bool result;
7579 void *argp1 = 0 ;
7580 int res1 = 0 ;
7581 PyObject * obj0 = 0 ;
7582 PyObject * obj1 = 0 ;
7583 char * kwnames[] = {
7584 (char *) "self",(char *) "other", NULL
7585 };
7586
7587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7589 if (!SWIG_IsOK(res1)) {
7590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7591 }
7592 arg1 = reinterpret_cast< wxRect * >(argp1);
7593 arg2 = obj1;
7594 {
7595 result = (bool)wxRect___eq__(arg1,arg2);
7596 if (PyErr_Occurred()) SWIG_fail;
7597 }
7598 {
7599 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7600 }
7601 return resultobj;
7602 fail:
7603 return NULL;
7604 }
7605
7606
7607 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7608 PyObject *resultobj = 0;
7609 wxRect *arg1 = (wxRect *) 0 ;
7610 PyObject *arg2 = (PyObject *) 0 ;
7611 bool result;
7612 void *argp1 = 0 ;
7613 int res1 = 0 ;
7614 PyObject * obj0 = 0 ;
7615 PyObject * obj1 = 0 ;
7616 char * kwnames[] = {
7617 (char *) "self",(char *) "other", NULL
7618 };
7619
7620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7622 if (!SWIG_IsOK(res1)) {
7623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7624 }
7625 arg1 = reinterpret_cast< wxRect * >(argp1);
7626 arg2 = obj1;
7627 {
7628 result = (bool)wxRect___ne__(arg1,arg2);
7629 if (PyErr_Occurred()) SWIG_fail;
7630 }
7631 {
7632 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7633 }
7634 return resultobj;
7635 fail:
7636 return NULL;
7637 }
7638
7639
7640 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7641 PyObject *resultobj = 0;
7642 wxRect *arg1 = (wxRect *) 0 ;
7643 int arg2 ;
7644 int arg3 ;
7645 bool result;
7646 void *argp1 = 0 ;
7647 int res1 = 0 ;
7648 int val2 ;
7649 int ecode2 = 0 ;
7650 int val3 ;
7651 int ecode3 = 0 ;
7652 PyObject * obj0 = 0 ;
7653 PyObject * obj1 = 0 ;
7654 PyObject * obj2 = 0 ;
7655 char * kwnames[] = {
7656 (char *) "self",(char *) "x",(char *) "y", NULL
7657 };
7658
7659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7661 if (!SWIG_IsOK(res1)) {
7662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7663 }
7664 arg1 = reinterpret_cast< wxRect * >(argp1);
7665 ecode2 = SWIG_AsVal_int(obj1, &val2);
7666 if (!SWIG_IsOK(ecode2)) {
7667 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7668 }
7669 arg2 = static_cast< int >(val2);
7670 ecode3 = SWIG_AsVal_int(obj2, &val3);
7671 if (!SWIG_IsOK(ecode3)) {
7672 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7673 }
7674 arg3 = static_cast< int >(val3);
7675 {
7676 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7677 if (PyErr_Occurred()) SWIG_fail;
7678 }
7679 {
7680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7681 }
7682 return resultobj;
7683 fail:
7684 return NULL;
7685 }
7686
7687
7688 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7689 PyObject *resultobj = 0;
7690 wxRect *arg1 = (wxRect *) 0 ;
7691 wxPoint *arg2 = 0 ;
7692 bool result;
7693 void *argp1 = 0 ;
7694 int res1 = 0 ;
7695 wxPoint temp2 ;
7696 PyObject * obj0 = 0 ;
7697 PyObject * obj1 = 0 ;
7698 char * kwnames[] = {
7699 (char *) "self",(char *) "pt", NULL
7700 };
7701
7702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7704 if (!SWIG_IsOK(res1)) {
7705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7706 }
7707 arg1 = reinterpret_cast< wxRect * >(argp1);
7708 {
7709 arg2 = &temp2;
7710 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7711 }
7712 {
7713 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7714 if (PyErr_Occurred()) SWIG_fail;
7715 }
7716 {
7717 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7718 }
7719 return resultobj;
7720 fail:
7721 return NULL;
7722 }
7723
7724
7725 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7726 PyObject *resultobj = 0;
7727 wxRect *arg1 = (wxRect *) 0 ;
7728 wxRect *arg2 = 0 ;
7729 bool result;
7730 void *argp1 = 0 ;
7731 int res1 = 0 ;
7732 wxRect temp2 ;
7733 PyObject * obj0 = 0 ;
7734 PyObject * obj1 = 0 ;
7735 char * kwnames[] = {
7736 (char *) "self",(char *) "rect", NULL
7737 };
7738
7739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7741 if (!SWIG_IsOK(res1)) {
7742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7743 }
7744 arg1 = reinterpret_cast< wxRect * >(argp1);
7745 {
7746 arg2 = &temp2;
7747 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7748 }
7749 {
7750 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7751 if (PyErr_Occurred()) SWIG_fail;
7752 }
7753 {
7754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7755 }
7756 return resultobj;
7757 fail:
7758 return NULL;
7759 }
7760
7761
7762 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7763 PyObject *resultobj = 0;
7764 wxRect *arg1 = (wxRect *) 0 ;
7765 wxRect *arg2 = 0 ;
7766 bool result;
7767 void *argp1 = 0 ;
7768 int res1 = 0 ;
7769 wxRect temp2 ;
7770 PyObject * obj0 = 0 ;
7771 PyObject * obj1 = 0 ;
7772 char * kwnames[] = {
7773 (char *) "self",(char *) "rect", NULL
7774 };
7775
7776 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7777 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7778 if (!SWIG_IsOK(res1)) {
7779 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7780 }
7781 arg1 = reinterpret_cast< wxRect * >(argp1);
7782 {
7783 arg2 = &temp2;
7784 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7785 }
7786 {
7787 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7788 if (PyErr_Occurred()) SWIG_fail;
7789 }
7790 {
7791 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7792 }
7793 return resultobj;
7794 fail:
7795 return NULL;
7796 }
7797
7798
7799 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7800 PyObject *resultobj = 0;
7801 wxRect *arg1 = (wxRect *) 0 ;
7802 wxRect *arg2 = 0 ;
7803 int arg3 = (int) wxBOTH ;
7804 wxRect result;
7805 void *argp1 = 0 ;
7806 int res1 = 0 ;
7807 wxRect temp2 ;
7808 int val3 ;
7809 int ecode3 = 0 ;
7810 PyObject * obj0 = 0 ;
7811 PyObject * obj1 = 0 ;
7812 PyObject * obj2 = 0 ;
7813 char * kwnames[] = {
7814 (char *) "self",(char *) "r",(char *) "dir", NULL
7815 };
7816
7817 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7818 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7819 if (!SWIG_IsOK(res1)) {
7820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7821 }
7822 arg1 = reinterpret_cast< wxRect * >(argp1);
7823 {
7824 arg2 = &temp2;
7825 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7826 }
7827 if (obj2) {
7828 ecode3 = SWIG_AsVal_int(obj2, &val3);
7829 if (!SWIG_IsOK(ecode3)) {
7830 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7831 }
7832 arg3 = static_cast< int >(val3);
7833 }
7834 {
7835 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7836 if (PyErr_Occurred()) SWIG_fail;
7837 }
7838 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7839 return resultobj;
7840 fail:
7841 return NULL;
7842 }
7843
7844
7845 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7846 PyObject *resultobj = 0;
7847 wxRect *arg1 = (wxRect *) 0 ;
7848 int arg2 ;
7849 void *argp1 = 0 ;
7850 int res1 = 0 ;
7851 int val2 ;
7852 int ecode2 = 0 ;
7853 PyObject *swig_obj[2] ;
7854
7855 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7857 if (!SWIG_IsOK(res1)) {
7858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7859 }
7860 arg1 = reinterpret_cast< wxRect * >(argp1);
7861 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7862 if (!SWIG_IsOK(ecode2)) {
7863 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7864 }
7865 arg2 = static_cast< int >(val2);
7866 if (arg1) (arg1)->x = arg2;
7867
7868 resultobj = SWIG_Py_Void();
7869 return resultobj;
7870 fail:
7871 return NULL;
7872 }
7873
7874
7875 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7876 PyObject *resultobj = 0;
7877 wxRect *arg1 = (wxRect *) 0 ;
7878 int result;
7879 void *argp1 = 0 ;
7880 int res1 = 0 ;
7881 PyObject *swig_obj[1] ;
7882
7883 if (!args) SWIG_fail;
7884 swig_obj[0] = args;
7885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7886 if (!SWIG_IsOK(res1)) {
7887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7888 }
7889 arg1 = reinterpret_cast< wxRect * >(argp1);
7890 result = (int) ((arg1)->x);
7891 resultobj = SWIG_From_int(static_cast< int >(result));
7892 return resultobj;
7893 fail:
7894 return NULL;
7895 }
7896
7897
7898 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7899 PyObject *resultobj = 0;
7900 wxRect *arg1 = (wxRect *) 0 ;
7901 int arg2 ;
7902 void *argp1 = 0 ;
7903 int res1 = 0 ;
7904 int val2 ;
7905 int ecode2 = 0 ;
7906 PyObject *swig_obj[2] ;
7907
7908 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7910 if (!SWIG_IsOK(res1)) {
7911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7912 }
7913 arg1 = reinterpret_cast< wxRect * >(argp1);
7914 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7915 if (!SWIG_IsOK(ecode2)) {
7916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7917 }
7918 arg2 = static_cast< int >(val2);
7919 if (arg1) (arg1)->y = arg2;
7920
7921 resultobj = SWIG_Py_Void();
7922 return resultobj;
7923 fail:
7924 return NULL;
7925 }
7926
7927
7928 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7929 PyObject *resultobj = 0;
7930 wxRect *arg1 = (wxRect *) 0 ;
7931 int result;
7932 void *argp1 = 0 ;
7933 int res1 = 0 ;
7934 PyObject *swig_obj[1] ;
7935
7936 if (!args) SWIG_fail;
7937 swig_obj[0] = args;
7938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7939 if (!SWIG_IsOK(res1)) {
7940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7941 }
7942 arg1 = reinterpret_cast< wxRect * >(argp1);
7943 result = (int) ((arg1)->y);
7944 resultobj = SWIG_From_int(static_cast< int >(result));
7945 return resultobj;
7946 fail:
7947 return NULL;
7948 }
7949
7950
7951 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7952 PyObject *resultobj = 0;
7953 wxRect *arg1 = (wxRect *) 0 ;
7954 int arg2 ;
7955 void *argp1 = 0 ;
7956 int res1 = 0 ;
7957 int val2 ;
7958 int ecode2 = 0 ;
7959 PyObject *swig_obj[2] ;
7960
7961 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7963 if (!SWIG_IsOK(res1)) {
7964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7965 }
7966 arg1 = reinterpret_cast< wxRect * >(argp1);
7967 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7968 if (!SWIG_IsOK(ecode2)) {
7969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7970 }
7971 arg2 = static_cast< int >(val2);
7972 if (arg1) (arg1)->width = arg2;
7973
7974 resultobj = SWIG_Py_Void();
7975 return resultobj;
7976 fail:
7977 return NULL;
7978 }
7979
7980
7981 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7982 PyObject *resultobj = 0;
7983 wxRect *arg1 = (wxRect *) 0 ;
7984 int result;
7985 void *argp1 = 0 ;
7986 int res1 = 0 ;
7987 PyObject *swig_obj[1] ;
7988
7989 if (!args) SWIG_fail;
7990 swig_obj[0] = args;
7991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7992 if (!SWIG_IsOK(res1)) {
7993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7994 }
7995 arg1 = reinterpret_cast< wxRect * >(argp1);
7996 result = (int) ((arg1)->width);
7997 resultobj = SWIG_From_int(static_cast< int >(result));
7998 return resultobj;
7999 fail:
8000 return NULL;
8001 }
8002
8003
8004 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8005 PyObject *resultobj = 0;
8006 wxRect *arg1 = (wxRect *) 0 ;
8007 int arg2 ;
8008 void *argp1 = 0 ;
8009 int res1 = 0 ;
8010 int val2 ;
8011 int ecode2 = 0 ;
8012 PyObject *swig_obj[2] ;
8013
8014 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8016 if (!SWIG_IsOK(res1)) {
8017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8018 }
8019 arg1 = reinterpret_cast< wxRect * >(argp1);
8020 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8021 if (!SWIG_IsOK(ecode2)) {
8022 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8023 }
8024 arg2 = static_cast< int >(val2);
8025 if (arg1) (arg1)->height = arg2;
8026
8027 resultobj = SWIG_Py_Void();
8028 return resultobj;
8029 fail:
8030 return NULL;
8031 }
8032
8033
8034 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8035 PyObject *resultobj = 0;
8036 wxRect *arg1 = (wxRect *) 0 ;
8037 int result;
8038 void *argp1 = 0 ;
8039 int res1 = 0 ;
8040 PyObject *swig_obj[1] ;
8041
8042 if (!args) SWIG_fail;
8043 swig_obj[0] = args;
8044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8045 if (!SWIG_IsOK(res1)) {
8046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8047 }
8048 arg1 = reinterpret_cast< wxRect * >(argp1);
8049 result = (int) ((arg1)->height);
8050 resultobj = SWIG_From_int(static_cast< int >(result));
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj = 0;
8059 wxRect *arg1 = (wxRect *) 0 ;
8060 int arg2 = (int) 0 ;
8061 int arg3 = (int) 0 ;
8062 int arg4 = (int) 0 ;
8063 int arg5 = (int) 0 ;
8064 void *argp1 = 0 ;
8065 int res1 = 0 ;
8066 int val2 ;
8067 int ecode2 = 0 ;
8068 int val3 ;
8069 int ecode3 = 0 ;
8070 int val4 ;
8071 int ecode4 = 0 ;
8072 int val5 ;
8073 int ecode5 = 0 ;
8074 PyObject * obj0 = 0 ;
8075 PyObject * obj1 = 0 ;
8076 PyObject * obj2 = 0 ;
8077 PyObject * obj3 = 0 ;
8078 PyObject * obj4 = 0 ;
8079 char * kwnames[] = {
8080 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8081 };
8082
8083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8085 if (!SWIG_IsOK(res1)) {
8086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8087 }
8088 arg1 = reinterpret_cast< wxRect * >(argp1);
8089 if (obj1) {
8090 ecode2 = SWIG_AsVal_int(obj1, &val2);
8091 if (!SWIG_IsOK(ecode2)) {
8092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8093 }
8094 arg2 = static_cast< int >(val2);
8095 }
8096 if (obj2) {
8097 ecode3 = SWIG_AsVal_int(obj2, &val3);
8098 if (!SWIG_IsOK(ecode3)) {
8099 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8100 }
8101 arg3 = static_cast< int >(val3);
8102 }
8103 if (obj3) {
8104 ecode4 = SWIG_AsVal_int(obj3, &val4);
8105 if (!SWIG_IsOK(ecode4)) {
8106 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8107 }
8108 arg4 = static_cast< int >(val4);
8109 }
8110 if (obj4) {
8111 ecode5 = SWIG_AsVal_int(obj4, &val5);
8112 if (!SWIG_IsOK(ecode5)) {
8113 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8114 }
8115 arg5 = static_cast< int >(val5);
8116 }
8117 {
8118 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8119 if (PyErr_Occurred()) SWIG_fail;
8120 }
8121 resultobj = SWIG_Py_Void();
8122 return resultobj;
8123 fail:
8124 return NULL;
8125 }
8126
8127
8128 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8129 PyObject *resultobj = 0;
8130 wxRect *arg1 = (wxRect *) 0 ;
8131 PyObject *result = 0 ;
8132 void *argp1 = 0 ;
8133 int res1 = 0 ;
8134 PyObject *swig_obj[1] ;
8135
8136 if (!args) SWIG_fail;
8137 swig_obj[0] = args;
8138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8139 if (!SWIG_IsOK(res1)) {
8140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8141 }
8142 arg1 = reinterpret_cast< wxRect * >(argp1);
8143 {
8144 result = (PyObject *)wxRect_Get(arg1);
8145 if (PyErr_Occurred()) SWIG_fail;
8146 }
8147 resultobj = result;
8148 return resultobj;
8149 fail:
8150 return NULL;
8151 }
8152
8153
8154 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8155 PyObject *obj;
8156 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8157 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8158 return SWIG_Py_Void();
8159 }
8160
8161 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8162 return SWIG_Python_InitShadowInstance(args);
8163 }
8164
8165 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8166 PyObject *resultobj = 0;
8167 wxRect *arg1 = (wxRect *) 0 ;
8168 wxRect *arg2 = (wxRect *) 0 ;
8169 PyObject *result = 0 ;
8170 void *argp1 = 0 ;
8171 int res1 = 0 ;
8172 void *argp2 = 0 ;
8173 int res2 = 0 ;
8174 PyObject * obj0 = 0 ;
8175 PyObject * obj1 = 0 ;
8176 char * kwnames[] = {
8177 (char *) "r1",(char *) "r2", NULL
8178 };
8179
8180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8182 if (!SWIG_IsOK(res1)) {
8183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8184 }
8185 arg1 = reinterpret_cast< wxRect * >(argp1);
8186 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8187 if (!SWIG_IsOK(res2)) {
8188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8189 }
8190 arg2 = reinterpret_cast< wxRect * >(argp2);
8191 {
8192 if (!wxPyCheckForApp()) SWIG_fail;
8193 PyThreadState* __tstate = wxPyBeginAllowThreads();
8194 result = (PyObject *)wxIntersectRect(arg1,arg2);
8195 wxPyEndAllowThreads(__tstate);
8196 if (PyErr_Occurred()) SWIG_fail;
8197 }
8198 resultobj = result;
8199 return resultobj;
8200 fail:
8201 return NULL;
8202 }
8203
8204
8205 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8206 PyObject *resultobj = 0;
8207 double arg1 = (double) 0.0 ;
8208 double arg2 = (double) 0.0 ;
8209 wxPoint2D *result = 0 ;
8210 double val1 ;
8211 int ecode1 = 0 ;
8212 double val2 ;
8213 int ecode2 = 0 ;
8214 PyObject * obj0 = 0 ;
8215 PyObject * obj1 = 0 ;
8216 char * kwnames[] = {
8217 (char *) "x",(char *) "y", NULL
8218 };
8219
8220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8221 if (obj0) {
8222 ecode1 = SWIG_AsVal_double(obj0, &val1);
8223 if (!SWIG_IsOK(ecode1)) {
8224 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8225 }
8226 arg1 = static_cast< double >(val1);
8227 }
8228 if (obj1) {
8229 ecode2 = SWIG_AsVal_double(obj1, &val2);
8230 if (!SWIG_IsOK(ecode2)) {
8231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8232 }
8233 arg2 = static_cast< double >(val2);
8234 }
8235 {
8236 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8237 if (PyErr_Occurred()) SWIG_fail;
8238 }
8239 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8240 return resultobj;
8241 fail:
8242 return NULL;
8243 }
8244
8245
8246 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8247 PyObject *resultobj = 0;
8248 wxPoint2D *arg1 = 0 ;
8249 wxPoint2D *result = 0 ;
8250 wxPoint2D temp1 ;
8251 PyObject * obj0 = 0 ;
8252 char * kwnames[] = {
8253 (char *) "pt", NULL
8254 };
8255
8256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8257 {
8258 arg1 = &temp1;
8259 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8260 }
8261 {
8262 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8263 if (PyErr_Occurred()) SWIG_fail;
8264 }
8265 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8266 return resultobj;
8267 fail:
8268 return NULL;
8269 }
8270
8271
8272 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8273 PyObject *resultobj = 0;
8274 wxPoint *arg1 = 0 ;
8275 wxPoint2D *result = 0 ;
8276 wxPoint temp1 ;
8277 PyObject * obj0 = 0 ;
8278 char * kwnames[] = {
8279 (char *) "pt", NULL
8280 };
8281
8282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8283 {
8284 arg1 = &temp1;
8285 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8286 }
8287 {
8288 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8289 if (PyErr_Occurred()) SWIG_fail;
8290 }
8291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8292 return resultobj;
8293 fail:
8294 return NULL;
8295 }
8296
8297
8298 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8299 PyObject *resultobj = 0;
8300 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8301 void *argp1 = 0 ;
8302 int res1 = 0 ;
8303 PyObject *swig_obj[1] ;
8304
8305 if (!args) SWIG_fail;
8306 swig_obj[0] = args;
8307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8308 if (!SWIG_IsOK(res1)) {
8309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8310 }
8311 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8312 {
8313 delete arg1;
8314
8315 if (PyErr_Occurred()) SWIG_fail;
8316 }
8317 resultobj = SWIG_Py_Void();
8318 return resultobj;
8319 fail:
8320 return NULL;
8321 }
8322
8323
8324 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8325 PyObject *resultobj = 0;
8326 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8327 int *arg2 = (int *) 0 ;
8328 int *arg3 = (int *) 0 ;
8329 void *argp1 = 0 ;
8330 int res1 = 0 ;
8331 int temp2 ;
8332 int res2 = SWIG_TMPOBJ ;
8333 int temp3 ;
8334 int res3 = SWIG_TMPOBJ ;
8335 PyObject *swig_obj[1] ;
8336
8337 arg2 = &temp2;
8338 arg3 = &temp3;
8339 if (!args) SWIG_fail;
8340 swig_obj[0] = args;
8341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8342 if (!SWIG_IsOK(res1)) {
8343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8344 }
8345 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8346 {
8347 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8348 if (PyErr_Occurred()) SWIG_fail;
8349 }
8350 resultobj = SWIG_Py_Void();
8351 if (SWIG_IsTmpObj(res2)) {
8352 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8353 } else {
8354 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8355 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8356 }
8357 if (SWIG_IsTmpObj(res3)) {
8358 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8359 } else {
8360 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8361 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8362 }
8363 return resultobj;
8364 fail:
8365 return NULL;
8366 }
8367
8368
8369 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8370 PyObject *resultobj = 0;
8371 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8372 int *arg2 = (int *) 0 ;
8373 int *arg3 = (int *) 0 ;
8374 void *argp1 = 0 ;
8375 int res1 = 0 ;
8376 int temp2 ;
8377 int res2 = SWIG_TMPOBJ ;
8378 int temp3 ;
8379 int res3 = SWIG_TMPOBJ ;
8380 PyObject *swig_obj[1] ;
8381
8382 arg2 = &temp2;
8383 arg3 = &temp3;
8384 if (!args) SWIG_fail;
8385 swig_obj[0] = args;
8386 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8387 if (!SWIG_IsOK(res1)) {
8388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8389 }
8390 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8391 {
8392 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8393 if (PyErr_Occurred()) SWIG_fail;
8394 }
8395 resultobj = SWIG_Py_Void();
8396 if (SWIG_IsTmpObj(res2)) {
8397 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8398 } else {
8399 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8400 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8401 }
8402 if (SWIG_IsTmpObj(res3)) {
8403 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8404 } else {
8405 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8406 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8407 }
8408 return resultobj;
8409 fail:
8410 return NULL;
8411 }
8412
8413
8414 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8415 PyObject *resultobj = 0;
8416 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8417 double result;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 PyObject *swig_obj[1] ;
8421
8422 if (!args) SWIG_fail;
8423 swig_obj[0] = args;
8424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8425 if (!SWIG_IsOK(res1)) {
8426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8427 }
8428 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8429 {
8430 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8431 if (PyErr_Occurred()) SWIG_fail;
8432 }
8433 resultobj = SWIG_From_double(static_cast< double >(result));
8434 return resultobj;
8435 fail:
8436 return NULL;
8437 }
8438
8439
8440 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8441 PyObject *resultobj = 0;
8442 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8443 double result;
8444 void *argp1 = 0 ;
8445 int res1 = 0 ;
8446 PyObject *swig_obj[1] ;
8447
8448 if (!args) SWIG_fail;
8449 swig_obj[0] = args;
8450 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8451 if (!SWIG_IsOK(res1)) {
8452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8453 }
8454 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8455 {
8456 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8457 if (PyErr_Occurred()) SWIG_fail;
8458 }
8459 resultobj = SWIG_From_double(static_cast< double >(result));
8460 return resultobj;
8461 fail:
8462 return NULL;
8463 }
8464
8465
8466 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8467 PyObject *resultobj = 0;
8468 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8469 double arg2 ;
8470 void *argp1 = 0 ;
8471 int res1 = 0 ;
8472 double val2 ;
8473 int ecode2 = 0 ;
8474 PyObject * obj0 = 0 ;
8475 PyObject * obj1 = 0 ;
8476 char * kwnames[] = {
8477 (char *) "self",(char *) "length", NULL
8478 };
8479
8480 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8481 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8482 if (!SWIG_IsOK(res1)) {
8483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8484 }
8485 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8486 ecode2 = SWIG_AsVal_double(obj1, &val2);
8487 if (!SWIG_IsOK(ecode2)) {
8488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8489 }
8490 arg2 = static_cast< double >(val2);
8491 {
8492 (arg1)->SetVectorLength(arg2);
8493 if (PyErr_Occurred()) SWIG_fail;
8494 }
8495 resultobj = SWIG_Py_Void();
8496 return resultobj;
8497 fail:
8498 return NULL;
8499 }
8500
8501
8502 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8503 PyObject *resultobj = 0;
8504 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8505 double arg2 ;
8506 void *argp1 = 0 ;
8507 int res1 = 0 ;
8508 double val2 ;
8509 int ecode2 = 0 ;
8510 PyObject * obj0 = 0 ;
8511 PyObject * obj1 = 0 ;
8512 char * kwnames[] = {
8513 (char *) "self",(char *) "degrees", NULL
8514 };
8515
8516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8518 if (!SWIG_IsOK(res1)) {
8519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8520 }
8521 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8522 ecode2 = SWIG_AsVal_double(obj1, &val2);
8523 if (!SWIG_IsOK(ecode2)) {
8524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8525 }
8526 arg2 = static_cast< double >(val2);
8527 {
8528 (arg1)->SetVectorAngle(arg2);
8529 if (PyErr_Occurred()) SWIG_fail;
8530 }
8531 resultobj = SWIG_Py_Void();
8532 return resultobj;
8533 fail:
8534 return NULL;
8535 }
8536
8537
8538 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8539 PyObject *resultobj = 0;
8540 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8541 wxPoint2D *arg2 = 0 ;
8542 double result;
8543 void *argp1 = 0 ;
8544 int res1 = 0 ;
8545 wxPoint2D temp2 ;
8546 PyObject * obj0 = 0 ;
8547 PyObject * obj1 = 0 ;
8548 char * kwnames[] = {
8549 (char *) "self",(char *) "pt", NULL
8550 };
8551
8552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8554 if (!SWIG_IsOK(res1)) {
8555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8556 }
8557 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8558 {
8559 arg2 = &temp2;
8560 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8561 }
8562 {
8563 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8564 if (PyErr_Occurred()) SWIG_fail;
8565 }
8566 resultobj = SWIG_From_double(static_cast< double >(result));
8567 return resultobj;
8568 fail:
8569 return NULL;
8570 }
8571
8572
8573 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8574 PyObject *resultobj = 0;
8575 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8576 wxPoint2D *arg2 = 0 ;
8577 double result;
8578 void *argp1 = 0 ;
8579 int res1 = 0 ;
8580 wxPoint2D temp2 ;
8581 PyObject * obj0 = 0 ;
8582 PyObject * obj1 = 0 ;
8583 char * kwnames[] = {
8584 (char *) "self",(char *) "pt", NULL
8585 };
8586
8587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8589 if (!SWIG_IsOK(res1)) {
8590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8591 }
8592 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8593 {
8594 arg2 = &temp2;
8595 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8596 }
8597 {
8598 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8599 if (PyErr_Occurred()) SWIG_fail;
8600 }
8601 resultobj = SWIG_From_double(static_cast< double >(result));
8602 return resultobj;
8603 fail:
8604 return NULL;
8605 }
8606
8607
8608 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8609 PyObject *resultobj = 0;
8610 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8611 wxPoint2D *arg2 = 0 ;
8612 double result;
8613 void *argp1 = 0 ;
8614 int res1 = 0 ;
8615 wxPoint2D temp2 ;
8616 PyObject * obj0 = 0 ;
8617 PyObject * obj1 = 0 ;
8618 char * kwnames[] = {
8619 (char *) "self",(char *) "vec", NULL
8620 };
8621
8622 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8623 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8624 if (!SWIG_IsOK(res1)) {
8625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8626 }
8627 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8628 {
8629 arg2 = &temp2;
8630 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8631 }
8632 {
8633 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8634 if (PyErr_Occurred()) SWIG_fail;
8635 }
8636 resultobj = SWIG_From_double(static_cast< double >(result));
8637 return resultobj;
8638 fail:
8639 return NULL;
8640 }
8641
8642
8643 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8644 PyObject *resultobj = 0;
8645 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8646 wxPoint2D *arg2 = 0 ;
8647 double result;
8648 void *argp1 = 0 ;
8649 int res1 = 0 ;
8650 wxPoint2D temp2 ;
8651 PyObject * obj0 = 0 ;
8652 PyObject * obj1 = 0 ;
8653 char * kwnames[] = {
8654 (char *) "self",(char *) "vec", NULL
8655 };
8656
8657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8659 if (!SWIG_IsOK(res1)) {
8660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8661 }
8662 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8663 {
8664 arg2 = &temp2;
8665 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8666 }
8667 {
8668 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8669 if (PyErr_Occurred()) SWIG_fail;
8670 }
8671 resultobj = SWIG_From_double(static_cast< double >(result));
8672 return resultobj;
8673 fail:
8674 return NULL;
8675 }
8676
8677
8678 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8679 PyObject *resultobj = 0;
8680 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8681 wxPoint2D result;
8682 void *argp1 = 0 ;
8683 int res1 = 0 ;
8684 PyObject *swig_obj[1] ;
8685
8686 if (!args) SWIG_fail;
8687 swig_obj[0] = args;
8688 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8689 if (!SWIG_IsOK(res1)) {
8690 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8691 }
8692 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8693 {
8694 result = (arg1)->operator -();
8695 if (PyErr_Occurred()) SWIG_fail;
8696 }
8697 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8698 return resultobj;
8699 fail:
8700 return NULL;
8701 }
8702
8703
8704 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8705 PyObject *resultobj = 0;
8706 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8707 wxPoint2D *arg2 = 0 ;
8708 wxPoint2D *result = 0 ;
8709 void *argp1 = 0 ;
8710 int res1 = 0 ;
8711 wxPoint2D temp2 ;
8712 PyObject * obj0 = 0 ;
8713 PyObject * obj1 = 0 ;
8714 char * kwnames[] = {
8715 (char *) "self",(char *) "pt", NULL
8716 };
8717
8718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8720 if (!SWIG_IsOK(res1)) {
8721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8722 }
8723 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8724 {
8725 arg2 = &temp2;
8726 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8727 }
8728 {
8729 {
8730 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8731 result = (wxPoint2D *) &_result_ref;
8732 }
8733 if (PyErr_Occurred()) SWIG_fail;
8734 }
8735 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8736 return resultobj;
8737 fail:
8738 return NULL;
8739 }
8740
8741
8742 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8743 PyObject *resultobj = 0;
8744 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8745 wxPoint2D *arg2 = 0 ;
8746 wxPoint2D *result = 0 ;
8747 void *argp1 = 0 ;
8748 int res1 = 0 ;
8749 wxPoint2D temp2 ;
8750 PyObject * obj0 = 0 ;
8751 PyObject * obj1 = 0 ;
8752 char * kwnames[] = {
8753 (char *) "self",(char *) "pt", NULL
8754 };
8755
8756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8758 if (!SWIG_IsOK(res1)) {
8759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8760 }
8761 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8762 {
8763 arg2 = &temp2;
8764 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8765 }
8766 {
8767 {
8768 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8769 result = (wxPoint2D *) &_result_ref;
8770 }
8771 if (PyErr_Occurred()) SWIG_fail;
8772 }
8773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8774 return resultobj;
8775 fail:
8776 return NULL;
8777 }
8778
8779
8780 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8781 PyObject *resultobj = 0;
8782 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8783 wxPoint2D *arg2 = 0 ;
8784 wxPoint2D *result = 0 ;
8785 void *argp1 = 0 ;
8786 int res1 = 0 ;
8787 wxPoint2D temp2 ;
8788 PyObject * obj0 = 0 ;
8789 PyObject * obj1 = 0 ;
8790 char * kwnames[] = {
8791 (char *) "self",(char *) "pt", NULL
8792 };
8793
8794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8795 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8796 if (!SWIG_IsOK(res1)) {
8797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8798 }
8799 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8800 {
8801 arg2 = &temp2;
8802 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8803 }
8804 {
8805 {
8806 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8807 result = (wxPoint2D *) &_result_ref;
8808 }
8809 if (PyErr_Occurred()) SWIG_fail;
8810 }
8811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8812 return resultobj;
8813 fail:
8814 return NULL;
8815 }
8816
8817
8818 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8819 PyObject *resultobj = 0;
8820 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8821 wxPoint2D *arg2 = 0 ;
8822 wxPoint2D *result = 0 ;
8823 void *argp1 = 0 ;
8824 int res1 = 0 ;
8825 wxPoint2D temp2 ;
8826 PyObject * obj0 = 0 ;
8827 PyObject * obj1 = 0 ;
8828 char * kwnames[] = {
8829 (char *) "self",(char *) "pt", NULL
8830 };
8831
8832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8834 if (!SWIG_IsOK(res1)) {
8835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8836 }
8837 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8838 {
8839 arg2 = &temp2;
8840 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8841 }
8842 {
8843 {
8844 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8845 result = (wxPoint2D *) &_result_ref;
8846 }
8847 if (PyErr_Occurred()) SWIG_fail;
8848 }
8849 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8850 return resultobj;
8851 fail:
8852 return NULL;
8853 }
8854
8855
8856 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8857 PyObject *resultobj = 0;
8858 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8859 PyObject *arg2 = (PyObject *) 0 ;
8860 bool result;
8861 void *argp1 = 0 ;
8862 int res1 = 0 ;
8863 PyObject * obj0 = 0 ;
8864 PyObject * obj1 = 0 ;
8865 char * kwnames[] = {
8866 (char *) "self",(char *) "other", NULL
8867 };
8868
8869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8871 if (!SWIG_IsOK(res1)) {
8872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8873 }
8874 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8875 arg2 = obj1;
8876 {
8877 result = (bool)wxPoint2D___eq__(arg1,arg2);
8878 if (PyErr_Occurred()) SWIG_fail;
8879 }
8880 {
8881 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8882 }
8883 return resultobj;
8884 fail:
8885 return NULL;
8886 }
8887
8888
8889 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8890 PyObject *resultobj = 0;
8891 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8892 PyObject *arg2 = (PyObject *) 0 ;
8893 bool result;
8894 void *argp1 = 0 ;
8895 int res1 = 0 ;
8896 PyObject * obj0 = 0 ;
8897 PyObject * obj1 = 0 ;
8898 char * kwnames[] = {
8899 (char *) "self",(char *) "other", NULL
8900 };
8901
8902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8903 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8904 if (!SWIG_IsOK(res1)) {
8905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8906 }
8907 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8908 arg2 = obj1;
8909 {
8910 result = (bool)wxPoint2D___ne__(arg1,arg2);
8911 if (PyErr_Occurred()) SWIG_fail;
8912 }
8913 {
8914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8915 }
8916 return resultobj;
8917 fail:
8918 return NULL;
8919 }
8920
8921
8922 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8923 PyObject *resultobj = 0;
8924 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8925 double arg2 ;
8926 void *argp1 = 0 ;
8927 int res1 = 0 ;
8928 double val2 ;
8929 int ecode2 = 0 ;
8930 PyObject *swig_obj[2] ;
8931
8932 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8934 if (!SWIG_IsOK(res1)) {
8935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8936 }
8937 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8938 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8939 if (!SWIG_IsOK(ecode2)) {
8940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8941 }
8942 arg2 = static_cast< double >(val2);
8943 if (arg1) (arg1)->m_x = arg2;
8944
8945 resultobj = SWIG_Py_Void();
8946 return resultobj;
8947 fail:
8948 return NULL;
8949 }
8950
8951
8952 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8953 PyObject *resultobj = 0;
8954 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8955 double result;
8956 void *argp1 = 0 ;
8957 int res1 = 0 ;
8958 PyObject *swig_obj[1] ;
8959
8960 if (!args) SWIG_fail;
8961 swig_obj[0] = args;
8962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8963 if (!SWIG_IsOK(res1)) {
8964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8965 }
8966 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8967 result = (double) ((arg1)->m_x);
8968 resultobj = SWIG_From_double(static_cast< double >(result));
8969 return resultobj;
8970 fail:
8971 return NULL;
8972 }
8973
8974
8975 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8976 PyObject *resultobj = 0;
8977 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8978 double arg2 ;
8979 void *argp1 = 0 ;
8980 int res1 = 0 ;
8981 double val2 ;
8982 int ecode2 = 0 ;
8983 PyObject *swig_obj[2] ;
8984
8985 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8987 if (!SWIG_IsOK(res1)) {
8988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8989 }
8990 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8991 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8992 if (!SWIG_IsOK(ecode2)) {
8993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8994 }
8995 arg2 = static_cast< double >(val2);
8996 if (arg1) (arg1)->m_y = arg2;
8997
8998 resultobj = SWIG_Py_Void();
8999 return resultobj;
9000 fail:
9001 return NULL;
9002 }
9003
9004
9005 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9006 PyObject *resultobj = 0;
9007 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9008 double result;
9009 void *argp1 = 0 ;
9010 int res1 = 0 ;
9011 PyObject *swig_obj[1] ;
9012
9013 if (!args) SWIG_fail;
9014 swig_obj[0] = args;
9015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9016 if (!SWIG_IsOK(res1)) {
9017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9018 }
9019 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9020 result = (double) ((arg1)->m_y);
9021 resultobj = SWIG_From_double(static_cast< double >(result));
9022 return resultobj;
9023 fail:
9024 return NULL;
9025 }
9026
9027
9028 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9029 PyObject *resultobj = 0;
9030 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9031 double arg2 = (double) 0 ;
9032 double arg3 = (double) 0 ;
9033 void *argp1 = 0 ;
9034 int res1 = 0 ;
9035 double val2 ;
9036 int ecode2 = 0 ;
9037 double val3 ;
9038 int ecode3 = 0 ;
9039 PyObject * obj0 = 0 ;
9040 PyObject * obj1 = 0 ;
9041 PyObject * obj2 = 0 ;
9042 char * kwnames[] = {
9043 (char *) "self",(char *) "x",(char *) "y", NULL
9044 };
9045
9046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9048 if (!SWIG_IsOK(res1)) {
9049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9050 }
9051 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9052 if (obj1) {
9053 ecode2 = SWIG_AsVal_double(obj1, &val2);
9054 if (!SWIG_IsOK(ecode2)) {
9055 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9056 }
9057 arg2 = static_cast< double >(val2);
9058 }
9059 if (obj2) {
9060 ecode3 = SWIG_AsVal_double(obj2, &val3);
9061 if (!SWIG_IsOK(ecode3)) {
9062 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9063 }
9064 arg3 = static_cast< double >(val3);
9065 }
9066 {
9067 wxPoint2D_Set(arg1,arg2,arg3);
9068 if (PyErr_Occurred()) SWIG_fail;
9069 }
9070 resultobj = SWIG_Py_Void();
9071 return resultobj;
9072 fail:
9073 return NULL;
9074 }
9075
9076
9077 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9078 PyObject *resultobj = 0;
9079 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9080 PyObject *result = 0 ;
9081 void *argp1 = 0 ;
9082 int res1 = 0 ;
9083 PyObject *swig_obj[1] ;
9084
9085 if (!args) SWIG_fail;
9086 swig_obj[0] = args;
9087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9088 if (!SWIG_IsOK(res1)) {
9089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9090 }
9091 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9092 {
9093 result = (PyObject *)wxPoint2D_Get(arg1);
9094 if (PyErr_Occurred()) SWIG_fail;
9095 }
9096 resultobj = result;
9097 return resultobj;
9098 fail:
9099 return NULL;
9100 }
9101
9102
9103 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9104 PyObject *obj;
9105 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9106 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9107 return SWIG_Py_Void();
9108 }
9109
9110 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9111 return SWIG_Python_InitShadowInstance(args);
9112 }
9113
9114 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9115 PyObject *resultobj = 0;
9116 wxDouble arg1 = (wxDouble) 0.0 ;
9117 wxDouble arg2 = (wxDouble) 0.0 ;
9118 wxDouble arg3 = (wxDouble) 0.0 ;
9119 wxDouble arg4 = (wxDouble) 0.0 ;
9120 wxRect2D *result = 0 ;
9121 void *argp1 ;
9122 int res1 = 0 ;
9123 void *argp2 ;
9124 int res2 = 0 ;
9125 void *argp3 ;
9126 int res3 = 0 ;
9127 void *argp4 ;
9128 int res4 = 0 ;
9129 PyObject * obj0 = 0 ;
9130 PyObject * obj1 = 0 ;
9131 PyObject * obj2 = 0 ;
9132 PyObject * obj3 = 0 ;
9133 char * kwnames[] = {
9134 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9135 };
9136
9137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9138 if (obj0) {
9139 {
9140 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9141 if (!SWIG_IsOK(res1)) {
9142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9143 }
9144 if (!argp1) {
9145 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9146 } else {
9147 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9148 arg1 = *temp;
9149 if (SWIG_IsNewObj(res1)) delete temp;
9150 }
9151 }
9152 }
9153 if (obj1) {
9154 {
9155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9156 if (!SWIG_IsOK(res2)) {
9157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9158 }
9159 if (!argp2) {
9160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9161 } else {
9162 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9163 arg2 = *temp;
9164 if (SWIG_IsNewObj(res2)) delete temp;
9165 }
9166 }
9167 }
9168 if (obj2) {
9169 {
9170 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9171 if (!SWIG_IsOK(res3)) {
9172 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9173 }
9174 if (!argp3) {
9175 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9176 } else {
9177 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9178 arg3 = *temp;
9179 if (SWIG_IsNewObj(res3)) delete temp;
9180 }
9181 }
9182 }
9183 if (obj3) {
9184 {
9185 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9186 if (!SWIG_IsOK(res4)) {
9187 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9188 }
9189 if (!argp4) {
9190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9191 } else {
9192 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9193 arg4 = *temp;
9194 if (SWIG_IsNewObj(res4)) delete temp;
9195 }
9196 }
9197 }
9198 {
9199 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9200 if (PyErr_Occurred()) SWIG_fail;
9201 }
9202 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9203 return resultobj;
9204 fail:
9205 return NULL;
9206 }
9207
9208
9209 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9210 PyObject *resultobj = 0;
9211 wxRect2D *arg1 = (wxRect2D *) 0 ;
9212 void *argp1 = 0 ;
9213 int res1 = 0 ;
9214 PyObject *swig_obj[1] ;
9215
9216 if (!args) SWIG_fail;
9217 swig_obj[0] = args;
9218 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9219 if (!SWIG_IsOK(res1)) {
9220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9221 }
9222 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9223 {
9224 delete arg1;
9225
9226 if (PyErr_Occurred()) SWIG_fail;
9227 }
9228 resultobj = SWIG_Py_Void();
9229 return resultobj;
9230 fail:
9231 return NULL;
9232 }
9233
9234
9235 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9236 PyObject *resultobj = 0;
9237 wxRect2D *arg1 = (wxRect2D *) 0 ;
9238 wxPoint2D result;
9239 void *argp1 = 0 ;
9240 int res1 = 0 ;
9241 PyObject *swig_obj[1] ;
9242
9243 if (!args) SWIG_fail;
9244 swig_obj[0] = args;
9245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9246 if (!SWIG_IsOK(res1)) {
9247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9248 }
9249 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9250 {
9251 result = (arg1)->GetPosition();
9252 if (PyErr_Occurred()) SWIG_fail;
9253 }
9254 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9255 return resultobj;
9256 fail:
9257 return NULL;
9258 }
9259
9260
9261 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9262 PyObject *resultobj = 0;
9263 wxRect2D *arg1 = (wxRect2D *) 0 ;
9264 wxSize result;
9265 void *argp1 = 0 ;
9266 int res1 = 0 ;
9267 PyObject *swig_obj[1] ;
9268
9269 if (!args) SWIG_fail;
9270 swig_obj[0] = args;
9271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9272 if (!SWIG_IsOK(res1)) {
9273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9274 }
9275 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9276 {
9277 result = (arg1)->GetSize();
9278 if (PyErr_Occurred()) SWIG_fail;
9279 }
9280 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9281 return resultobj;
9282 fail:
9283 return NULL;
9284 }
9285
9286
9287 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9288 PyObject *resultobj = 0;
9289 wxRect2D *arg1 = (wxRect2D *) 0 ;
9290 wxDouble result;
9291 void *argp1 = 0 ;
9292 int res1 = 0 ;
9293 PyObject *swig_obj[1] ;
9294
9295 if (!args) SWIG_fail;
9296 swig_obj[0] = args;
9297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9298 if (!SWIG_IsOK(res1)) {
9299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9300 }
9301 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9302 {
9303 result = ((wxRect2D const *)arg1)->GetLeft();
9304 if (PyErr_Occurred()) SWIG_fail;
9305 }
9306 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9307 return resultobj;
9308 fail:
9309 return NULL;
9310 }
9311
9312
9313 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9314 PyObject *resultobj = 0;
9315 wxRect2D *arg1 = (wxRect2D *) 0 ;
9316 wxDouble arg2 ;
9317 void *argp1 = 0 ;
9318 int res1 = 0 ;
9319 void *argp2 ;
9320 int res2 = 0 ;
9321 PyObject * obj0 = 0 ;
9322 PyObject * obj1 = 0 ;
9323 char * kwnames[] = {
9324 (char *) "self",(char *) "n", NULL
9325 };
9326
9327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9329 if (!SWIG_IsOK(res1)) {
9330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9331 }
9332 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9333 {
9334 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9335 if (!SWIG_IsOK(res2)) {
9336 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9337 }
9338 if (!argp2) {
9339 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9340 } else {
9341 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9342 arg2 = *temp;
9343 if (SWIG_IsNewObj(res2)) delete temp;
9344 }
9345 }
9346 {
9347 (arg1)->SetLeft(arg2);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_Py_Void();
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9358 PyObject *resultobj = 0;
9359 wxRect2D *arg1 = (wxRect2D *) 0 ;
9360 wxDouble arg2 ;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 void *argp2 ;
9364 int res2 = 0 ;
9365 PyObject * obj0 = 0 ;
9366 PyObject * obj1 = 0 ;
9367 char * kwnames[] = {
9368 (char *) "self",(char *) "n", NULL
9369 };
9370
9371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9373 if (!SWIG_IsOK(res1)) {
9374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9375 }
9376 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9377 {
9378 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9379 if (!SWIG_IsOK(res2)) {
9380 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9381 }
9382 if (!argp2) {
9383 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9384 } else {
9385 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9386 arg2 = *temp;
9387 if (SWIG_IsNewObj(res2)) delete temp;
9388 }
9389 }
9390 {
9391 (arg1)->MoveLeftTo(arg2);
9392 if (PyErr_Occurred()) SWIG_fail;
9393 }
9394 resultobj = SWIG_Py_Void();
9395 return resultobj;
9396 fail:
9397 return NULL;
9398 }
9399
9400
9401 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9402 PyObject *resultobj = 0;
9403 wxRect2D *arg1 = (wxRect2D *) 0 ;
9404 wxDouble result;
9405 void *argp1 = 0 ;
9406 int res1 = 0 ;
9407 PyObject *swig_obj[1] ;
9408
9409 if (!args) SWIG_fail;
9410 swig_obj[0] = args;
9411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9412 if (!SWIG_IsOK(res1)) {
9413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9414 }
9415 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9416 {
9417 result = ((wxRect2D const *)arg1)->GetTop();
9418 if (PyErr_Occurred()) SWIG_fail;
9419 }
9420 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9421 return resultobj;
9422 fail:
9423 return NULL;
9424 }
9425
9426
9427 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9428 PyObject *resultobj = 0;
9429 wxRect2D *arg1 = (wxRect2D *) 0 ;
9430 wxDouble arg2 ;
9431 void *argp1 = 0 ;
9432 int res1 = 0 ;
9433 void *argp2 ;
9434 int res2 = 0 ;
9435 PyObject * obj0 = 0 ;
9436 PyObject * obj1 = 0 ;
9437 char * kwnames[] = {
9438 (char *) "self",(char *) "n", NULL
9439 };
9440
9441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9443 if (!SWIG_IsOK(res1)) {
9444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9445 }
9446 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9447 {
9448 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9449 if (!SWIG_IsOK(res2)) {
9450 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9451 }
9452 if (!argp2) {
9453 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9454 } else {
9455 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9456 arg2 = *temp;
9457 if (SWIG_IsNewObj(res2)) delete temp;
9458 }
9459 }
9460 {
9461 (arg1)->SetTop(arg2);
9462 if (PyErr_Occurred()) SWIG_fail;
9463 }
9464 resultobj = SWIG_Py_Void();
9465 return resultobj;
9466 fail:
9467 return NULL;
9468 }
9469
9470
9471 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9472 PyObject *resultobj = 0;
9473 wxRect2D *arg1 = (wxRect2D *) 0 ;
9474 wxDouble arg2 ;
9475 void *argp1 = 0 ;
9476 int res1 = 0 ;
9477 void *argp2 ;
9478 int res2 = 0 ;
9479 PyObject * obj0 = 0 ;
9480 PyObject * obj1 = 0 ;
9481 char * kwnames[] = {
9482 (char *) "self",(char *) "n", NULL
9483 };
9484
9485 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9486 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9487 if (!SWIG_IsOK(res1)) {
9488 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9489 }
9490 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9491 {
9492 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9493 if (!SWIG_IsOK(res2)) {
9494 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9495 }
9496 if (!argp2) {
9497 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9498 } else {
9499 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9500 arg2 = *temp;
9501 if (SWIG_IsNewObj(res2)) delete temp;
9502 }
9503 }
9504 {
9505 (arg1)->MoveTopTo(arg2);
9506 if (PyErr_Occurred()) SWIG_fail;
9507 }
9508 resultobj = SWIG_Py_Void();
9509 return resultobj;
9510 fail:
9511 return NULL;
9512 }
9513
9514
9515 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9516 PyObject *resultobj = 0;
9517 wxRect2D *arg1 = (wxRect2D *) 0 ;
9518 wxDouble result;
9519 void *argp1 = 0 ;
9520 int res1 = 0 ;
9521 PyObject *swig_obj[1] ;
9522
9523 if (!args) SWIG_fail;
9524 swig_obj[0] = args;
9525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9526 if (!SWIG_IsOK(res1)) {
9527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9528 }
9529 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9530 {
9531 result = ((wxRect2D const *)arg1)->GetBottom();
9532 if (PyErr_Occurred()) SWIG_fail;
9533 }
9534 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9535 return resultobj;
9536 fail:
9537 return NULL;
9538 }
9539
9540
9541 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9542 PyObject *resultobj = 0;
9543 wxRect2D *arg1 = (wxRect2D *) 0 ;
9544 wxDouble arg2 ;
9545 void *argp1 = 0 ;
9546 int res1 = 0 ;
9547 void *argp2 ;
9548 int res2 = 0 ;
9549 PyObject * obj0 = 0 ;
9550 PyObject * obj1 = 0 ;
9551 char * kwnames[] = {
9552 (char *) "self",(char *) "n", NULL
9553 };
9554
9555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9556 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9557 if (!SWIG_IsOK(res1)) {
9558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9559 }
9560 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9561 {
9562 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9563 if (!SWIG_IsOK(res2)) {
9564 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9565 }
9566 if (!argp2) {
9567 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9568 } else {
9569 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9570 arg2 = *temp;
9571 if (SWIG_IsNewObj(res2)) delete temp;
9572 }
9573 }
9574 {
9575 (arg1)->SetBottom(arg2);
9576 if (PyErr_Occurred()) SWIG_fail;
9577 }
9578 resultobj = SWIG_Py_Void();
9579 return resultobj;
9580 fail:
9581 return NULL;
9582 }
9583
9584
9585 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9586 PyObject *resultobj = 0;
9587 wxRect2D *arg1 = (wxRect2D *) 0 ;
9588 wxDouble arg2 ;
9589 void *argp1 = 0 ;
9590 int res1 = 0 ;
9591 void *argp2 ;
9592 int res2 = 0 ;
9593 PyObject * obj0 = 0 ;
9594 PyObject * obj1 = 0 ;
9595 char * kwnames[] = {
9596 (char *) "self",(char *) "n", NULL
9597 };
9598
9599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9601 if (!SWIG_IsOK(res1)) {
9602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9603 }
9604 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9605 {
9606 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9607 if (!SWIG_IsOK(res2)) {
9608 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9609 }
9610 if (!argp2) {
9611 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9612 } else {
9613 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9614 arg2 = *temp;
9615 if (SWIG_IsNewObj(res2)) delete temp;
9616 }
9617 }
9618 {
9619 (arg1)->MoveBottomTo(arg2);
9620 if (PyErr_Occurred()) SWIG_fail;
9621 }
9622 resultobj = SWIG_Py_Void();
9623 return resultobj;
9624 fail:
9625 return NULL;
9626 }
9627
9628
9629 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9630 PyObject *resultobj = 0;
9631 wxRect2D *arg1 = (wxRect2D *) 0 ;
9632 wxDouble result;
9633 void *argp1 = 0 ;
9634 int res1 = 0 ;
9635 PyObject *swig_obj[1] ;
9636
9637 if (!args) SWIG_fail;
9638 swig_obj[0] = args;
9639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9640 if (!SWIG_IsOK(res1)) {
9641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9642 }
9643 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9644 {
9645 result = ((wxRect2D const *)arg1)->GetRight();
9646 if (PyErr_Occurred()) SWIG_fail;
9647 }
9648 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9649 return resultobj;
9650 fail:
9651 return NULL;
9652 }
9653
9654
9655 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9656 PyObject *resultobj = 0;
9657 wxRect2D *arg1 = (wxRect2D *) 0 ;
9658 wxDouble arg2 ;
9659 void *argp1 = 0 ;
9660 int res1 = 0 ;
9661 void *argp2 ;
9662 int res2 = 0 ;
9663 PyObject * obj0 = 0 ;
9664 PyObject * obj1 = 0 ;
9665 char * kwnames[] = {
9666 (char *) "self",(char *) "n", NULL
9667 };
9668
9669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9670 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9671 if (!SWIG_IsOK(res1)) {
9672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9673 }
9674 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9675 {
9676 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9677 if (!SWIG_IsOK(res2)) {
9678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9679 }
9680 if (!argp2) {
9681 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9682 } else {
9683 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9684 arg2 = *temp;
9685 if (SWIG_IsNewObj(res2)) delete temp;
9686 }
9687 }
9688 {
9689 (arg1)->SetRight(arg2);
9690 if (PyErr_Occurred()) SWIG_fail;
9691 }
9692 resultobj = SWIG_Py_Void();
9693 return resultobj;
9694 fail:
9695 return NULL;
9696 }
9697
9698
9699 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9700 PyObject *resultobj = 0;
9701 wxRect2D *arg1 = (wxRect2D *) 0 ;
9702 wxDouble arg2 ;
9703 void *argp1 = 0 ;
9704 int res1 = 0 ;
9705 void *argp2 ;
9706 int res2 = 0 ;
9707 PyObject * obj0 = 0 ;
9708 PyObject * obj1 = 0 ;
9709 char * kwnames[] = {
9710 (char *) "self",(char *) "n", NULL
9711 };
9712
9713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9714 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9715 if (!SWIG_IsOK(res1)) {
9716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9717 }
9718 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9719 {
9720 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9721 if (!SWIG_IsOK(res2)) {
9722 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9723 }
9724 if (!argp2) {
9725 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9726 } else {
9727 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9728 arg2 = *temp;
9729 if (SWIG_IsNewObj(res2)) delete temp;
9730 }
9731 }
9732 {
9733 (arg1)->MoveRightTo(arg2);
9734 if (PyErr_Occurred()) SWIG_fail;
9735 }
9736 resultobj = SWIG_Py_Void();
9737 return resultobj;
9738 fail:
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9744 PyObject *resultobj = 0;
9745 wxRect2D *arg1 = (wxRect2D *) 0 ;
9746 wxPoint2D result;
9747 void *argp1 = 0 ;
9748 int res1 = 0 ;
9749 PyObject *swig_obj[1] ;
9750
9751 if (!args) SWIG_fail;
9752 swig_obj[0] = args;
9753 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9754 if (!SWIG_IsOK(res1)) {
9755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9756 }
9757 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9758 {
9759 result = ((wxRect2D const *)arg1)->GetLeftTop();
9760 if (PyErr_Occurred()) SWIG_fail;
9761 }
9762 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9763 return resultobj;
9764 fail:
9765 return NULL;
9766 }
9767
9768
9769 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9770 PyObject *resultobj = 0;
9771 wxRect2D *arg1 = (wxRect2D *) 0 ;
9772 wxPoint2D *arg2 = 0 ;
9773 void *argp1 = 0 ;
9774 int res1 = 0 ;
9775 wxPoint2D temp2 ;
9776 PyObject * obj0 = 0 ;
9777 PyObject * obj1 = 0 ;
9778 char * kwnames[] = {
9779 (char *) "self",(char *) "pt", NULL
9780 };
9781
9782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9784 if (!SWIG_IsOK(res1)) {
9785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9786 }
9787 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9788 {
9789 arg2 = &temp2;
9790 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9791 }
9792 {
9793 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9794 if (PyErr_Occurred()) SWIG_fail;
9795 }
9796 resultobj = SWIG_Py_Void();
9797 return resultobj;
9798 fail:
9799 return NULL;
9800 }
9801
9802
9803 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9804 PyObject *resultobj = 0;
9805 wxRect2D *arg1 = (wxRect2D *) 0 ;
9806 wxPoint2D *arg2 = 0 ;
9807 void *argp1 = 0 ;
9808 int res1 = 0 ;
9809 wxPoint2D temp2 ;
9810 PyObject * obj0 = 0 ;
9811 PyObject * obj1 = 0 ;
9812 char * kwnames[] = {
9813 (char *) "self",(char *) "pt", NULL
9814 };
9815
9816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9818 if (!SWIG_IsOK(res1)) {
9819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9820 }
9821 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9822 {
9823 arg2 = &temp2;
9824 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9825 }
9826 {
9827 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9828 if (PyErr_Occurred()) SWIG_fail;
9829 }
9830 resultobj = SWIG_Py_Void();
9831 return resultobj;
9832 fail:
9833 return NULL;
9834 }
9835
9836
9837 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9838 PyObject *resultobj = 0;
9839 wxRect2D *arg1 = (wxRect2D *) 0 ;
9840 wxPoint2D result;
9841 void *argp1 = 0 ;
9842 int res1 = 0 ;
9843 PyObject *swig_obj[1] ;
9844
9845 if (!args) SWIG_fail;
9846 swig_obj[0] = args;
9847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9848 if (!SWIG_IsOK(res1)) {
9849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9850 }
9851 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9852 {
9853 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9854 if (PyErr_Occurred()) SWIG_fail;
9855 }
9856 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9857 return resultobj;
9858 fail:
9859 return NULL;
9860 }
9861
9862
9863 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9864 PyObject *resultobj = 0;
9865 wxRect2D *arg1 = (wxRect2D *) 0 ;
9866 wxPoint2D *arg2 = 0 ;
9867 void *argp1 = 0 ;
9868 int res1 = 0 ;
9869 wxPoint2D temp2 ;
9870 PyObject * obj0 = 0 ;
9871 PyObject * obj1 = 0 ;
9872 char * kwnames[] = {
9873 (char *) "self",(char *) "pt", NULL
9874 };
9875
9876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9877 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9878 if (!SWIG_IsOK(res1)) {
9879 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9880 }
9881 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9882 {
9883 arg2 = &temp2;
9884 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9885 }
9886 {
9887 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9888 if (PyErr_Occurred()) SWIG_fail;
9889 }
9890 resultobj = SWIG_Py_Void();
9891 return resultobj;
9892 fail:
9893 return NULL;
9894 }
9895
9896
9897 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9898 PyObject *resultobj = 0;
9899 wxRect2D *arg1 = (wxRect2D *) 0 ;
9900 wxPoint2D *arg2 = 0 ;
9901 void *argp1 = 0 ;
9902 int res1 = 0 ;
9903 wxPoint2D temp2 ;
9904 PyObject * obj0 = 0 ;
9905 PyObject * obj1 = 0 ;
9906 char * kwnames[] = {
9907 (char *) "self",(char *) "pt", NULL
9908 };
9909
9910 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9911 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9912 if (!SWIG_IsOK(res1)) {
9913 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9914 }
9915 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9916 {
9917 arg2 = &temp2;
9918 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9919 }
9920 {
9921 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9922 if (PyErr_Occurred()) SWIG_fail;
9923 }
9924 resultobj = SWIG_Py_Void();
9925 return resultobj;
9926 fail:
9927 return NULL;
9928 }
9929
9930
9931 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9932 PyObject *resultobj = 0;
9933 wxRect2D *arg1 = (wxRect2D *) 0 ;
9934 wxPoint2D result;
9935 void *argp1 = 0 ;
9936 int res1 = 0 ;
9937 PyObject *swig_obj[1] ;
9938
9939 if (!args) SWIG_fail;
9940 swig_obj[0] = args;
9941 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9942 if (!SWIG_IsOK(res1)) {
9943 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9944 }
9945 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9946 {
9947 result = ((wxRect2D const *)arg1)->GetRightTop();
9948 if (PyErr_Occurred()) SWIG_fail;
9949 }
9950 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9951 return resultobj;
9952 fail:
9953 return NULL;
9954 }
9955
9956
9957 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9958 PyObject *resultobj = 0;
9959 wxRect2D *arg1 = (wxRect2D *) 0 ;
9960 wxPoint2D *arg2 = 0 ;
9961 void *argp1 = 0 ;
9962 int res1 = 0 ;
9963 wxPoint2D temp2 ;
9964 PyObject * obj0 = 0 ;
9965 PyObject * obj1 = 0 ;
9966 char * kwnames[] = {
9967 (char *) "self",(char *) "pt", NULL
9968 };
9969
9970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9972 if (!SWIG_IsOK(res1)) {
9973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9974 }
9975 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9976 {
9977 arg2 = &temp2;
9978 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9979 }
9980 {
9981 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9982 if (PyErr_Occurred()) SWIG_fail;
9983 }
9984 resultobj = SWIG_Py_Void();
9985 return resultobj;
9986 fail:
9987 return NULL;
9988 }
9989
9990
9991 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9992 PyObject *resultobj = 0;
9993 wxRect2D *arg1 = (wxRect2D *) 0 ;
9994 wxPoint2D *arg2 = 0 ;
9995 void *argp1 = 0 ;
9996 int res1 = 0 ;
9997 wxPoint2D temp2 ;
9998 PyObject * obj0 = 0 ;
9999 PyObject * obj1 = 0 ;
10000 char * kwnames[] = {
10001 (char *) "self",(char *) "pt", NULL
10002 };
10003
10004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10006 if (!SWIG_IsOK(res1)) {
10007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10008 }
10009 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10010 {
10011 arg2 = &temp2;
10012 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10013 }
10014 {
10015 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10016 if (PyErr_Occurred()) SWIG_fail;
10017 }
10018 resultobj = SWIG_Py_Void();
10019 return resultobj;
10020 fail:
10021 return NULL;
10022 }
10023
10024
10025 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10026 PyObject *resultobj = 0;
10027 wxRect2D *arg1 = (wxRect2D *) 0 ;
10028 wxPoint2D result;
10029 void *argp1 = 0 ;
10030 int res1 = 0 ;
10031 PyObject *swig_obj[1] ;
10032
10033 if (!args) SWIG_fail;
10034 swig_obj[0] = args;
10035 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10036 if (!SWIG_IsOK(res1)) {
10037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10038 }
10039 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10040 {
10041 result = ((wxRect2D const *)arg1)->GetRightBottom();
10042 if (PyErr_Occurred()) SWIG_fail;
10043 }
10044 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10045 return resultobj;
10046 fail:
10047 return NULL;
10048 }
10049
10050
10051 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10052 PyObject *resultobj = 0;
10053 wxRect2D *arg1 = (wxRect2D *) 0 ;
10054 wxPoint2D *arg2 = 0 ;
10055 void *argp1 = 0 ;
10056 int res1 = 0 ;
10057 wxPoint2D temp2 ;
10058 PyObject * obj0 = 0 ;
10059 PyObject * obj1 = 0 ;
10060 char * kwnames[] = {
10061 (char *) "self",(char *) "pt", NULL
10062 };
10063
10064 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10065 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10066 if (!SWIG_IsOK(res1)) {
10067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10068 }
10069 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10070 {
10071 arg2 = &temp2;
10072 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10073 }
10074 {
10075 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10076 if (PyErr_Occurred()) SWIG_fail;
10077 }
10078 resultobj = SWIG_Py_Void();
10079 return resultobj;
10080 fail:
10081 return NULL;
10082 }
10083
10084
10085 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10086 PyObject *resultobj = 0;
10087 wxRect2D *arg1 = (wxRect2D *) 0 ;
10088 wxPoint2D *arg2 = 0 ;
10089 void *argp1 = 0 ;
10090 int res1 = 0 ;
10091 wxPoint2D temp2 ;
10092 PyObject * obj0 = 0 ;
10093 PyObject * obj1 = 0 ;
10094 char * kwnames[] = {
10095 (char *) "self",(char *) "pt", NULL
10096 };
10097
10098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10100 if (!SWIG_IsOK(res1)) {
10101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10102 }
10103 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10104 {
10105 arg2 = &temp2;
10106 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10107 }
10108 {
10109 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10110 if (PyErr_Occurred()) SWIG_fail;
10111 }
10112 resultobj = SWIG_Py_Void();
10113 return resultobj;
10114 fail:
10115 return NULL;
10116 }
10117
10118
10119 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10120 PyObject *resultobj = 0;
10121 wxRect2D *arg1 = (wxRect2D *) 0 ;
10122 wxPoint2D result;
10123 void *argp1 = 0 ;
10124 int res1 = 0 ;
10125 PyObject *swig_obj[1] ;
10126
10127 if (!args) SWIG_fail;
10128 swig_obj[0] = args;
10129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10130 if (!SWIG_IsOK(res1)) {
10131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10132 }
10133 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10134 {
10135 result = ((wxRect2D const *)arg1)->GetCentre();
10136 if (PyErr_Occurred()) SWIG_fail;
10137 }
10138 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10139 return resultobj;
10140 fail:
10141 return NULL;
10142 }
10143
10144
10145 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10146 PyObject *resultobj = 0;
10147 wxRect2D *arg1 = (wxRect2D *) 0 ;
10148 wxPoint2D *arg2 = 0 ;
10149 void *argp1 = 0 ;
10150 int res1 = 0 ;
10151 wxPoint2D temp2 ;
10152 PyObject * obj0 = 0 ;
10153 PyObject * obj1 = 0 ;
10154 char * kwnames[] = {
10155 (char *) "self",(char *) "pt", NULL
10156 };
10157
10158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10160 if (!SWIG_IsOK(res1)) {
10161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10162 }
10163 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10164 {
10165 arg2 = &temp2;
10166 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10167 }
10168 {
10169 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10170 if (PyErr_Occurred()) SWIG_fail;
10171 }
10172 resultobj = SWIG_Py_Void();
10173 return resultobj;
10174 fail:
10175 return NULL;
10176 }
10177
10178
10179 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10180 PyObject *resultobj = 0;
10181 wxRect2D *arg1 = (wxRect2D *) 0 ;
10182 wxPoint2D *arg2 = 0 ;
10183 void *argp1 = 0 ;
10184 int res1 = 0 ;
10185 wxPoint2D temp2 ;
10186 PyObject * obj0 = 0 ;
10187 PyObject * obj1 = 0 ;
10188 char * kwnames[] = {
10189 (char *) "self",(char *) "pt", NULL
10190 };
10191
10192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10194 if (!SWIG_IsOK(res1)) {
10195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10196 }
10197 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10198 {
10199 arg2 = &temp2;
10200 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10201 }
10202 {
10203 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10204 if (PyErr_Occurred()) SWIG_fail;
10205 }
10206 resultobj = SWIG_Py_Void();
10207 return resultobj;
10208 fail:
10209 return NULL;
10210 }
10211
10212
10213 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10214 PyObject *resultobj = 0;
10215 wxRect2D *arg1 = (wxRect2D *) 0 ;
10216 wxPoint2D *arg2 = 0 ;
10217 wxOutCode result;
10218 void *argp1 = 0 ;
10219 int res1 = 0 ;
10220 wxPoint2D temp2 ;
10221 PyObject * obj0 = 0 ;
10222 PyObject * obj1 = 0 ;
10223 char * kwnames[] = {
10224 (char *) "self",(char *) "pt", NULL
10225 };
10226
10227 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10228 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10229 if (!SWIG_IsOK(res1)) {
10230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10231 }
10232 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10233 {
10234 arg2 = &temp2;
10235 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10236 }
10237 {
10238 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10239 if (PyErr_Occurred()) SWIG_fail;
10240 }
10241 resultobj = SWIG_From_int(static_cast< int >(result));
10242 return resultobj;
10243 fail:
10244 return NULL;
10245 }
10246
10247
10248 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10249 PyObject *resultobj = 0;
10250 wxRect2D *arg1 = (wxRect2D *) 0 ;
10251 wxPoint2D *arg2 = 0 ;
10252 bool result;
10253 void *argp1 = 0 ;
10254 int res1 = 0 ;
10255 wxPoint2D temp2 ;
10256 PyObject * obj0 = 0 ;
10257 PyObject * obj1 = 0 ;
10258 char * kwnames[] = {
10259 (char *) "self",(char *) "pt", NULL
10260 };
10261
10262 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10263 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10264 if (!SWIG_IsOK(res1)) {
10265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10266 }
10267 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10268 {
10269 arg2 = &temp2;
10270 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10271 }
10272 {
10273 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10274 if (PyErr_Occurred()) SWIG_fail;
10275 }
10276 {
10277 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10278 }
10279 return resultobj;
10280 fail:
10281 return NULL;
10282 }
10283
10284
10285 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10286 PyObject *resultobj = 0;
10287 wxRect2D *arg1 = (wxRect2D *) 0 ;
10288 wxRect2D *arg2 = 0 ;
10289 bool result;
10290 void *argp1 = 0 ;
10291 int res1 = 0 ;
10292 wxRect2D temp2 ;
10293 PyObject * obj0 = 0 ;
10294 PyObject * obj1 = 0 ;
10295 char * kwnames[] = {
10296 (char *) "self",(char *) "rect", NULL
10297 };
10298
10299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10301 if (!SWIG_IsOK(res1)) {
10302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10303 }
10304 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10305 {
10306 arg2 = &temp2;
10307 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10308 }
10309 {
10310 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10311 if (PyErr_Occurred()) SWIG_fail;
10312 }
10313 {
10314 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10315 }
10316 return resultobj;
10317 fail:
10318 return NULL;
10319 }
10320
10321
10322 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10323 PyObject *resultobj = 0;
10324 wxRect2D *arg1 = (wxRect2D *) 0 ;
10325 bool result;
10326 void *argp1 = 0 ;
10327 int res1 = 0 ;
10328 PyObject *swig_obj[1] ;
10329
10330 if (!args) SWIG_fail;
10331 swig_obj[0] = args;
10332 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10333 if (!SWIG_IsOK(res1)) {
10334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10335 }
10336 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10337 {
10338 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10339 if (PyErr_Occurred()) SWIG_fail;
10340 }
10341 {
10342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10343 }
10344 return resultobj;
10345 fail:
10346 return NULL;
10347 }
10348
10349
10350 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10351 PyObject *resultobj = 0;
10352 wxRect2D *arg1 = (wxRect2D *) 0 ;
10353 wxRect2D *arg2 = 0 ;
10354 bool result;
10355 void *argp1 = 0 ;
10356 int res1 = 0 ;
10357 wxRect2D temp2 ;
10358 PyObject * obj0 = 0 ;
10359 PyObject * obj1 = 0 ;
10360 char * kwnames[] = {
10361 (char *) "self",(char *) "rect", NULL
10362 };
10363
10364 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10365 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10366 if (!SWIG_IsOK(res1)) {
10367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10368 }
10369 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10370 {
10371 arg2 = &temp2;
10372 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10373 }
10374 {
10375 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10376 if (PyErr_Occurred()) SWIG_fail;
10377 }
10378 {
10379 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10380 }
10381 return resultobj;
10382 fail:
10383 return NULL;
10384 }
10385
10386
10387 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10388 PyObject *resultobj = 0;
10389 wxRect2D *arg1 = (wxRect2D *) 0 ;
10390 wxDouble arg2 ;
10391 wxDouble arg3 ;
10392 void *argp1 = 0 ;
10393 int res1 = 0 ;
10394 void *argp2 ;
10395 int res2 = 0 ;
10396 void *argp3 ;
10397 int res3 = 0 ;
10398
10399 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10401 if (!SWIG_IsOK(res1)) {
10402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10403 }
10404 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10405 {
10406 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10407 if (!SWIG_IsOK(res2)) {
10408 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10409 }
10410 if (!argp2) {
10411 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10412 } else {
10413 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10414 arg2 = *temp;
10415 if (SWIG_IsNewObj(res2)) delete temp;
10416 }
10417 }
10418 {
10419 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10420 if (!SWIG_IsOK(res3)) {
10421 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10422 }
10423 if (!argp3) {
10424 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10425 } else {
10426 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10427 arg3 = *temp;
10428 if (SWIG_IsNewObj(res3)) delete temp;
10429 }
10430 }
10431 {
10432 (arg1)->Inset(arg2,arg3);
10433 if (PyErr_Occurred()) SWIG_fail;
10434 }
10435 resultobj = SWIG_Py_Void();
10436 return resultobj;
10437 fail:
10438 return NULL;
10439 }
10440
10441
10442 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10443 PyObject *resultobj = 0;
10444 wxRect2D *arg1 = (wxRect2D *) 0 ;
10445 wxDouble arg2 ;
10446 wxDouble arg3 ;
10447 wxDouble arg4 ;
10448 wxDouble arg5 ;
10449 void *argp1 = 0 ;
10450 int res1 = 0 ;
10451 void *argp2 ;
10452 int res2 = 0 ;
10453 void *argp3 ;
10454 int res3 = 0 ;
10455 void *argp4 ;
10456 int res4 = 0 ;
10457 void *argp5 ;
10458 int res5 = 0 ;
10459
10460 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10462 if (!SWIG_IsOK(res1)) {
10463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10464 }
10465 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10466 {
10467 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10468 if (!SWIG_IsOK(res2)) {
10469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10470 }
10471 if (!argp2) {
10472 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10473 } else {
10474 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10475 arg2 = *temp;
10476 if (SWIG_IsNewObj(res2)) delete temp;
10477 }
10478 }
10479 {
10480 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10481 if (!SWIG_IsOK(res3)) {
10482 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10483 }
10484 if (!argp3) {
10485 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10486 } else {
10487 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10488 arg3 = *temp;
10489 if (SWIG_IsNewObj(res3)) delete temp;
10490 }
10491 }
10492 {
10493 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10494 if (!SWIG_IsOK(res4)) {
10495 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10496 }
10497 if (!argp4) {
10498 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10499 } else {
10500 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10501 arg4 = *temp;
10502 if (SWIG_IsNewObj(res4)) delete temp;
10503 }
10504 }
10505 {
10506 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10507 if (!SWIG_IsOK(res5)) {
10508 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10509 }
10510 if (!argp5) {
10511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10512 } else {
10513 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10514 arg5 = *temp;
10515 if (SWIG_IsNewObj(res5)) delete temp;
10516 }
10517 }
10518 {
10519 (arg1)->Inset(arg2,arg3,arg4,arg5);
10520 if (PyErr_Occurred()) SWIG_fail;
10521 }
10522 resultobj = SWIG_Py_Void();
10523 return resultobj;
10524 fail:
10525 return NULL;
10526 }
10527
10528
10529 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10530 int argc;
10531 PyObject *argv[6];
10532
10533 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10534 --argc;
10535 if (argc == 3) {
10536 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10537 }
10538 if (argc == 5) {
10539 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10540 }
10541
10542 fail:
10543 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10544 return NULL;
10545 }
10546
10547
10548 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10549 PyObject *resultobj = 0;
10550 wxRect2D *arg1 = (wxRect2D *) 0 ;
10551 wxPoint2D *arg2 = 0 ;
10552 void *argp1 = 0 ;
10553 int res1 = 0 ;
10554 wxPoint2D temp2 ;
10555 PyObject * obj0 = 0 ;
10556 PyObject * obj1 = 0 ;
10557 char * kwnames[] = {
10558 (char *) "self",(char *) "pt", NULL
10559 };
10560
10561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10563 if (!SWIG_IsOK(res1)) {
10564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10565 }
10566 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10567 {
10568 arg2 = &temp2;
10569 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10570 }
10571 {
10572 (arg1)->Offset((wxPoint2D const &)*arg2);
10573 if (PyErr_Occurred()) SWIG_fail;
10574 }
10575 resultobj = SWIG_Py_Void();
10576 return resultobj;
10577 fail:
10578 return NULL;
10579 }
10580
10581
10582 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10583 PyObject *resultobj = 0;
10584 wxRect2D *arg1 = (wxRect2D *) 0 ;
10585 wxRect2D *arg2 = 0 ;
10586 void *argp1 = 0 ;
10587 int res1 = 0 ;
10588 wxRect2D temp2 ;
10589 PyObject * obj0 = 0 ;
10590 PyObject * obj1 = 0 ;
10591 char * kwnames[] = {
10592 (char *) "self",(char *) "rect", NULL
10593 };
10594
10595 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10596 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10597 if (!SWIG_IsOK(res1)) {
10598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10599 }
10600 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10601 {
10602 arg2 = &temp2;
10603 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10604 }
10605 {
10606 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 resultobj = SWIG_Py_Void();
10610 return resultobj;
10611 fail:
10612 return NULL;
10613 }
10614
10615
10616 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10617 PyObject *resultobj = 0;
10618 wxRect2D *arg1 = (wxRect2D *) 0 ;
10619 int arg2 ;
10620 int arg3 ;
10621 wxPoint2D result;
10622 void *argp1 = 0 ;
10623 int res1 = 0 ;
10624 int val2 ;
10625 int ecode2 = 0 ;
10626 int val3 ;
10627 int ecode3 = 0 ;
10628 PyObject * obj0 = 0 ;
10629 PyObject * obj1 = 0 ;
10630 PyObject * obj2 = 0 ;
10631 char * kwnames[] = {
10632 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10633 };
10634
10635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10637 if (!SWIG_IsOK(res1)) {
10638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10639 }
10640 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10641 ecode2 = SWIG_AsVal_int(obj1, &val2);
10642 if (!SWIG_IsOK(ecode2)) {
10643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10644 }
10645 arg2 = static_cast< int >(val2);
10646 ecode3 = SWIG_AsVal_int(obj2, &val3);
10647 if (!SWIG_IsOK(ecode3)) {
10648 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10649 }
10650 arg3 = static_cast< int >(val3);
10651 {
10652 result = (arg1)->Interpolate(arg2,arg3);
10653 if (PyErr_Occurred()) SWIG_fail;
10654 }
10655 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10656 return resultobj;
10657 fail:
10658 return NULL;
10659 }
10660
10661
10662 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10663 PyObject *resultobj = 0;
10664 wxRect2D *arg1 = (wxRect2D *) 0 ;
10665 wxRect2D *arg2 = 0 ;
10666 void *argp1 = 0 ;
10667 int res1 = 0 ;
10668 wxRect2D temp2 ;
10669 PyObject * obj0 = 0 ;
10670 PyObject * obj1 = 0 ;
10671 char * kwnames[] = {
10672 (char *) "self",(char *) "otherRect", NULL
10673 };
10674
10675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10677 if (!SWIG_IsOK(res1)) {
10678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10679 }
10680 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10681 {
10682 arg2 = &temp2;
10683 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10684 }
10685 {
10686 (arg1)->Intersect((wxRect2D const &)*arg2);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 resultobj = SWIG_Py_Void();
10690 return resultobj;
10691 fail:
10692 return NULL;
10693 }
10694
10695
10696 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10697 PyObject *resultobj = 0;
10698 wxRect2D *arg1 = (wxRect2D *) 0 ;
10699 wxRect2D *arg2 = 0 ;
10700 wxRect2D result;
10701 void *argp1 = 0 ;
10702 int res1 = 0 ;
10703 wxRect2D temp2 ;
10704 PyObject * obj0 = 0 ;
10705 PyObject * obj1 = 0 ;
10706 char * kwnames[] = {
10707 (char *) "self",(char *) "otherRect", NULL
10708 };
10709
10710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10712 if (!SWIG_IsOK(res1)) {
10713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10714 }
10715 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10716 {
10717 arg2 = &temp2;
10718 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10719 }
10720 {
10721 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10722 if (PyErr_Occurred()) SWIG_fail;
10723 }
10724 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10725 return resultobj;
10726 fail:
10727 return NULL;
10728 }
10729
10730
10731 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10732 PyObject *resultobj = 0;
10733 wxRect2D *arg1 = (wxRect2D *) 0 ;
10734 wxRect2D *arg2 = 0 ;
10735 bool result;
10736 void *argp1 = 0 ;
10737 int res1 = 0 ;
10738 wxRect2D temp2 ;
10739 PyObject * obj0 = 0 ;
10740 PyObject * obj1 = 0 ;
10741 char * kwnames[] = {
10742 (char *) "self",(char *) "rect", NULL
10743 };
10744
10745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10747 if (!SWIG_IsOK(res1)) {
10748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10749 }
10750 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10751 {
10752 arg2 = &temp2;
10753 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10754 }
10755 {
10756 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10757 if (PyErr_Occurred()) SWIG_fail;
10758 }
10759 {
10760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10761 }
10762 return resultobj;
10763 fail:
10764 return NULL;
10765 }
10766
10767
10768 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10769 PyObject *resultobj = 0;
10770 wxRect2D *arg1 = (wxRect2D *) 0 ;
10771 wxRect2D *arg2 = 0 ;
10772 void *argp1 = 0 ;
10773 int res1 = 0 ;
10774 wxRect2D temp2 ;
10775 PyObject * obj0 = 0 ;
10776 PyObject * obj1 = 0 ;
10777 char * kwnames[] = {
10778 (char *) "self",(char *) "otherRect", NULL
10779 };
10780
10781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10783 if (!SWIG_IsOK(res1)) {
10784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10785 }
10786 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10787 {
10788 arg2 = &temp2;
10789 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10790 }
10791 {
10792 (arg1)->Union((wxRect2D const &)*arg2);
10793 if (PyErr_Occurred()) SWIG_fail;
10794 }
10795 resultobj = SWIG_Py_Void();
10796 return resultobj;
10797 fail:
10798 return NULL;
10799 }
10800
10801
10802 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10803 PyObject *resultobj = 0;
10804 wxRect2D *arg1 = (wxRect2D *) 0 ;
10805 wxRect2D *arg2 = 0 ;
10806 wxRect2D result;
10807 void *argp1 = 0 ;
10808 int res1 = 0 ;
10809 wxRect2D temp2 ;
10810 PyObject * obj0 = 0 ;
10811 PyObject * obj1 = 0 ;
10812 char * kwnames[] = {
10813 (char *) "self",(char *) "otherRect", NULL
10814 };
10815
10816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10818 if (!SWIG_IsOK(res1)) {
10819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10820 }
10821 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10822 {
10823 arg2 = &temp2;
10824 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10825 }
10826 {
10827 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10828 if (PyErr_Occurred()) SWIG_fail;
10829 }
10830 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10831 return resultobj;
10832 fail:
10833 return NULL;
10834 }
10835
10836
10837 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10838 PyObject *resultobj = 0;
10839 wxRect2D *arg1 = (wxRect2D *) 0 ;
10840 wxDouble arg2 ;
10841 void *argp1 = 0 ;
10842 int res1 = 0 ;
10843 void *argp2 ;
10844 int res2 = 0 ;
10845
10846 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10848 if (!SWIG_IsOK(res1)) {
10849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10850 }
10851 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10852 {
10853 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10854 if (!SWIG_IsOK(res2)) {
10855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10856 }
10857 if (!argp2) {
10858 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10859 } else {
10860 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10861 arg2 = *temp;
10862 if (SWIG_IsNewObj(res2)) delete temp;
10863 }
10864 }
10865 {
10866 (arg1)->Scale(arg2);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 resultobj = SWIG_Py_Void();
10870 return resultobj;
10871 fail:
10872 return NULL;
10873 }
10874
10875
10876 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10877 PyObject *resultobj = 0;
10878 wxRect2D *arg1 = (wxRect2D *) 0 ;
10879 int arg2 ;
10880 int arg3 ;
10881 void *argp1 = 0 ;
10882 int res1 = 0 ;
10883 int val2 ;
10884 int ecode2 = 0 ;
10885 int val3 ;
10886 int ecode3 = 0 ;
10887
10888 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10890 if (!SWIG_IsOK(res1)) {
10891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10892 }
10893 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10894 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10895 if (!SWIG_IsOK(ecode2)) {
10896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10897 }
10898 arg2 = static_cast< int >(val2);
10899 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10900 if (!SWIG_IsOK(ecode3)) {
10901 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10902 }
10903 arg3 = static_cast< int >(val3);
10904 {
10905 (arg1)->Scale(arg2,arg3);
10906 if (PyErr_Occurred()) SWIG_fail;
10907 }
10908 resultobj = SWIG_Py_Void();
10909 return resultobj;
10910 fail:
10911 return NULL;
10912 }
10913
10914
10915 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10916 int argc;
10917 PyObject *argv[4];
10918
10919 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10920 --argc;
10921 if (argc == 2) {
10922 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10923 }
10924 if (argc == 3) {
10925 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10926 }
10927
10928 fail:
10929 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10930 return NULL;
10931 }
10932
10933
10934 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10935 PyObject *resultobj = 0;
10936 wxRect2D *arg1 = (wxRect2D *) 0 ;
10937 PyObject *arg2 = (PyObject *) 0 ;
10938 bool result;
10939 void *argp1 = 0 ;
10940 int res1 = 0 ;
10941 PyObject * obj0 = 0 ;
10942 PyObject * obj1 = 0 ;
10943 char * kwnames[] = {
10944 (char *) "self",(char *) "other", NULL
10945 };
10946
10947 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10948 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10949 if (!SWIG_IsOK(res1)) {
10950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10951 }
10952 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10953 arg2 = obj1;
10954 {
10955 result = (bool)wxRect2D___eq__(arg1,arg2);
10956 if (PyErr_Occurred()) SWIG_fail;
10957 }
10958 {
10959 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10960 }
10961 return resultobj;
10962 fail:
10963 return NULL;
10964 }
10965
10966
10967 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10968 PyObject *resultobj = 0;
10969 wxRect2D *arg1 = (wxRect2D *) 0 ;
10970 PyObject *arg2 = (PyObject *) 0 ;
10971 bool result;
10972 void *argp1 = 0 ;
10973 int res1 = 0 ;
10974 PyObject * obj0 = 0 ;
10975 PyObject * obj1 = 0 ;
10976 char * kwnames[] = {
10977 (char *) "self",(char *) "other", NULL
10978 };
10979
10980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10982 if (!SWIG_IsOK(res1)) {
10983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10984 }
10985 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10986 arg2 = obj1;
10987 {
10988 result = (bool)wxRect2D___ne__(arg1,arg2);
10989 if (PyErr_Occurred()) SWIG_fail;
10990 }
10991 {
10992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10993 }
10994 return resultobj;
10995 fail:
10996 return NULL;
10997 }
10998
10999
11000 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11001 PyObject *resultobj = 0;
11002 wxRect2D *arg1 = (wxRect2D *) 0 ;
11003 wxDouble arg2 ;
11004 void *argp1 = 0 ;
11005 int res1 = 0 ;
11006 void *argp2 ;
11007 int res2 = 0 ;
11008 PyObject *swig_obj[2] ;
11009
11010 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11011 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11012 if (!SWIG_IsOK(res1)) {
11013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11014 }
11015 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11016 {
11017 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11018 if (!SWIG_IsOK(res2)) {
11019 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11020 }
11021 if (!argp2) {
11022 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11023 } else {
11024 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11025 arg2 = *temp;
11026 if (SWIG_IsNewObj(res2)) delete temp;
11027 }
11028 }
11029 if (arg1) (arg1)->m_x = arg2;
11030
11031 resultobj = SWIG_Py_Void();
11032 return resultobj;
11033 fail:
11034 return NULL;
11035 }
11036
11037
11038 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11039 PyObject *resultobj = 0;
11040 wxRect2D *arg1 = (wxRect2D *) 0 ;
11041 wxDouble result;
11042 void *argp1 = 0 ;
11043 int res1 = 0 ;
11044 PyObject *swig_obj[1] ;
11045
11046 if (!args) SWIG_fail;
11047 swig_obj[0] = args;
11048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11049 if (!SWIG_IsOK(res1)) {
11050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11051 }
11052 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11053 result = ((arg1)->m_x);
11054 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11055 return resultobj;
11056 fail:
11057 return NULL;
11058 }
11059
11060
11061 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11062 PyObject *resultobj = 0;
11063 wxRect2D *arg1 = (wxRect2D *) 0 ;
11064 wxDouble arg2 ;
11065 void *argp1 = 0 ;
11066 int res1 = 0 ;
11067 void *argp2 ;
11068 int res2 = 0 ;
11069 PyObject *swig_obj[2] ;
11070
11071 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11073 if (!SWIG_IsOK(res1)) {
11074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11075 }
11076 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11077 {
11078 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11079 if (!SWIG_IsOK(res2)) {
11080 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11081 }
11082 if (!argp2) {
11083 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11084 } else {
11085 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11086 arg2 = *temp;
11087 if (SWIG_IsNewObj(res2)) delete temp;
11088 }
11089 }
11090 if (arg1) (arg1)->m_y = arg2;
11091
11092 resultobj = SWIG_Py_Void();
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11100 PyObject *resultobj = 0;
11101 wxRect2D *arg1 = (wxRect2D *) 0 ;
11102 wxDouble result;
11103 void *argp1 = 0 ;
11104 int res1 = 0 ;
11105 PyObject *swig_obj[1] ;
11106
11107 if (!args) SWIG_fail;
11108 swig_obj[0] = args;
11109 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11110 if (!SWIG_IsOK(res1)) {
11111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11112 }
11113 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11114 result = ((arg1)->m_y);
11115 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11116 return resultobj;
11117 fail:
11118 return NULL;
11119 }
11120
11121
11122 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11123 PyObject *resultobj = 0;
11124 wxRect2D *arg1 = (wxRect2D *) 0 ;
11125 wxDouble arg2 ;
11126 void *argp1 = 0 ;
11127 int res1 = 0 ;
11128 void *argp2 ;
11129 int res2 = 0 ;
11130 PyObject *swig_obj[2] ;
11131
11132 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11134 if (!SWIG_IsOK(res1)) {
11135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11136 }
11137 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11138 {
11139 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11140 if (!SWIG_IsOK(res2)) {
11141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11142 }
11143 if (!argp2) {
11144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11145 } else {
11146 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11147 arg2 = *temp;
11148 if (SWIG_IsNewObj(res2)) delete temp;
11149 }
11150 }
11151 if (arg1) (arg1)->m_width = arg2;
11152
11153 resultobj = SWIG_Py_Void();
11154 return resultobj;
11155 fail:
11156 return NULL;
11157 }
11158
11159
11160 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11161 PyObject *resultobj = 0;
11162 wxRect2D *arg1 = (wxRect2D *) 0 ;
11163 wxDouble result;
11164 void *argp1 = 0 ;
11165 int res1 = 0 ;
11166 PyObject *swig_obj[1] ;
11167
11168 if (!args) SWIG_fail;
11169 swig_obj[0] = args;
11170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11171 if (!SWIG_IsOK(res1)) {
11172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11173 }
11174 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11175 result = ((arg1)->m_width);
11176 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11177 return resultobj;
11178 fail:
11179 return NULL;
11180 }
11181
11182
11183 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11184 PyObject *resultobj = 0;
11185 wxRect2D *arg1 = (wxRect2D *) 0 ;
11186 wxDouble arg2 ;
11187 void *argp1 = 0 ;
11188 int res1 = 0 ;
11189 void *argp2 ;
11190 int res2 = 0 ;
11191 PyObject *swig_obj[2] ;
11192
11193 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11195 if (!SWIG_IsOK(res1)) {
11196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11197 }
11198 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11199 {
11200 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11201 if (!SWIG_IsOK(res2)) {
11202 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11203 }
11204 if (!argp2) {
11205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11206 } else {
11207 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11208 arg2 = *temp;
11209 if (SWIG_IsNewObj(res2)) delete temp;
11210 }
11211 }
11212 if (arg1) (arg1)->m_height = arg2;
11213
11214 resultobj = SWIG_Py_Void();
11215 return resultobj;
11216 fail:
11217 return NULL;
11218 }
11219
11220
11221 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11222 PyObject *resultobj = 0;
11223 wxRect2D *arg1 = (wxRect2D *) 0 ;
11224 wxDouble result;
11225 void *argp1 = 0 ;
11226 int res1 = 0 ;
11227 PyObject *swig_obj[1] ;
11228
11229 if (!args) SWIG_fail;
11230 swig_obj[0] = args;
11231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11232 if (!SWIG_IsOK(res1)) {
11233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11234 }
11235 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11236 result = ((arg1)->m_height);
11237 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11238 return resultobj;
11239 fail:
11240 return NULL;
11241 }
11242
11243
11244 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11245 PyObject *resultobj = 0;
11246 wxRect2D *arg1 = (wxRect2D *) 0 ;
11247 wxDouble arg2 = (wxDouble) 0 ;
11248 wxDouble arg3 = (wxDouble) 0 ;
11249 wxDouble arg4 = (wxDouble) 0 ;
11250 wxDouble arg5 = (wxDouble) 0 ;
11251 void *argp1 = 0 ;
11252 int res1 = 0 ;
11253 void *argp2 ;
11254 int res2 = 0 ;
11255 void *argp3 ;
11256 int res3 = 0 ;
11257 void *argp4 ;
11258 int res4 = 0 ;
11259 void *argp5 ;
11260 int res5 = 0 ;
11261 PyObject * obj0 = 0 ;
11262 PyObject * obj1 = 0 ;
11263 PyObject * obj2 = 0 ;
11264 PyObject * obj3 = 0 ;
11265 PyObject * obj4 = 0 ;
11266 char * kwnames[] = {
11267 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11268 };
11269
11270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11272 if (!SWIG_IsOK(res1)) {
11273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11274 }
11275 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11276 if (obj1) {
11277 {
11278 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11279 if (!SWIG_IsOK(res2)) {
11280 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11281 }
11282 if (!argp2) {
11283 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11284 } else {
11285 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11286 arg2 = *temp;
11287 if (SWIG_IsNewObj(res2)) delete temp;
11288 }
11289 }
11290 }
11291 if (obj2) {
11292 {
11293 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11294 if (!SWIG_IsOK(res3)) {
11295 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11296 }
11297 if (!argp3) {
11298 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11299 } else {
11300 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11301 arg3 = *temp;
11302 if (SWIG_IsNewObj(res3)) delete temp;
11303 }
11304 }
11305 }
11306 if (obj3) {
11307 {
11308 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11309 if (!SWIG_IsOK(res4)) {
11310 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11311 }
11312 if (!argp4) {
11313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11314 } else {
11315 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11316 arg4 = *temp;
11317 if (SWIG_IsNewObj(res4)) delete temp;
11318 }
11319 }
11320 }
11321 if (obj4) {
11322 {
11323 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11324 if (!SWIG_IsOK(res5)) {
11325 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11326 }
11327 if (!argp5) {
11328 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11329 } else {
11330 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11331 arg5 = *temp;
11332 if (SWIG_IsNewObj(res5)) delete temp;
11333 }
11334 }
11335 }
11336 {
11337 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11338 if (PyErr_Occurred()) SWIG_fail;
11339 }
11340 resultobj = SWIG_Py_Void();
11341 return resultobj;
11342 fail:
11343 return NULL;
11344 }
11345
11346
11347 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11348 PyObject *resultobj = 0;
11349 wxRect2D *arg1 = (wxRect2D *) 0 ;
11350 PyObject *result = 0 ;
11351 void *argp1 = 0 ;
11352 int res1 = 0 ;
11353 PyObject *swig_obj[1] ;
11354
11355 if (!args) SWIG_fail;
11356 swig_obj[0] = args;
11357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11358 if (!SWIG_IsOK(res1)) {
11359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11360 }
11361 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11362 {
11363 result = (PyObject *)wxRect2D_Get(arg1);
11364 if (PyErr_Occurred()) SWIG_fail;
11365 }
11366 resultobj = result;
11367 return resultobj;
11368 fail:
11369 return NULL;
11370 }
11371
11372
11373 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11374 PyObject *obj;
11375 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11376 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11377 return SWIG_Py_Void();
11378 }
11379
11380 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11381 return SWIG_Python_InitShadowInstance(args);
11382 }
11383
11384 SWIGINTERN int DefaultPosition_set(PyObject *) {
11385 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11386 return 1;
11387 }
11388
11389
11390 SWIGINTERN PyObject *DefaultPosition_get(void) {
11391 PyObject *pyobj = 0;
11392
11393 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11394 return pyobj;
11395 }
11396
11397
11398 SWIGINTERN int DefaultSize_set(PyObject *) {
11399 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11400 return 1;
11401 }
11402
11403
11404 SWIGINTERN PyObject *DefaultSize_get(void) {
11405 PyObject *pyobj = 0;
11406
11407 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11408 return pyobj;
11409 }
11410
11411
11412 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11413 PyObject *resultobj = 0;
11414 PyObject *arg1 = (PyObject *) 0 ;
11415 wxPyInputStream *result = 0 ;
11416 PyObject * obj0 = 0 ;
11417 char * kwnames[] = {
11418 (char *) "p", NULL
11419 };
11420
11421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11422 arg1 = obj0;
11423 {
11424 PyThreadState* __tstate = wxPyBeginAllowThreads();
11425 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11426 wxPyEndAllowThreads(__tstate);
11427 if (PyErr_Occurred()) SWIG_fail;
11428 }
11429 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11430 return resultobj;
11431 fail:
11432 return NULL;
11433 }
11434
11435
11436 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11437 PyObject *resultobj = 0;
11438 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11439 void *argp1 = 0 ;
11440 int res1 = 0 ;
11441 PyObject *swig_obj[1] ;
11442
11443 if (!args) SWIG_fail;
11444 swig_obj[0] = args;
11445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11446 if (!SWIG_IsOK(res1)) {
11447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11448 }
11449 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11450 {
11451 PyThreadState* __tstate = wxPyBeginAllowThreads();
11452 delete arg1;
11453
11454 wxPyEndAllowThreads(__tstate);
11455 if (PyErr_Occurred()) SWIG_fail;
11456 }
11457 resultobj = SWIG_Py_Void();
11458 return resultobj;
11459 fail:
11460 return NULL;
11461 }
11462
11463
11464 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11465 PyObject *resultobj = 0;
11466 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11467 void *argp1 = 0 ;
11468 int res1 = 0 ;
11469 PyObject *swig_obj[1] ;
11470
11471 if (!args) SWIG_fail;
11472 swig_obj[0] = args;
11473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11474 if (!SWIG_IsOK(res1)) {
11475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11476 }
11477 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11478 {
11479 PyThreadState* __tstate = wxPyBeginAllowThreads();
11480 (arg1)->close();
11481 wxPyEndAllowThreads(__tstate);
11482 if (PyErr_Occurred()) SWIG_fail;
11483 }
11484 resultobj = SWIG_Py_Void();
11485 return resultobj;
11486 fail:
11487 return NULL;
11488 }
11489
11490
11491 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11492 PyObject *resultobj = 0;
11493 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11494 void *argp1 = 0 ;
11495 int res1 = 0 ;
11496 PyObject *swig_obj[1] ;
11497
11498 if (!args) SWIG_fail;
11499 swig_obj[0] = args;
11500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11501 if (!SWIG_IsOK(res1)) {
11502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11503 }
11504 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11505 {
11506 PyThreadState* __tstate = wxPyBeginAllowThreads();
11507 (arg1)->flush();
11508 wxPyEndAllowThreads(__tstate);
11509 if (PyErr_Occurred()) SWIG_fail;
11510 }
11511 resultobj = SWIG_Py_Void();
11512 return resultobj;
11513 fail:
11514 return NULL;
11515 }
11516
11517
11518 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11519 PyObject *resultobj = 0;
11520 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11521 bool result;
11522 void *argp1 = 0 ;
11523 int res1 = 0 ;
11524 PyObject *swig_obj[1] ;
11525
11526 if (!args) SWIG_fail;
11527 swig_obj[0] = args;
11528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11529 if (!SWIG_IsOK(res1)) {
11530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11531 }
11532 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11533 {
11534 PyThreadState* __tstate = wxPyBeginAllowThreads();
11535 result = (bool)(arg1)->eof();
11536 wxPyEndAllowThreads(__tstate);
11537 if (PyErr_Occurred()) SWIG_fail;
11538 }
11539 {
11540 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11541 }
11542 return resultobj;
11543 fail:
11544 return NULL;
11545 }
11546
11547
11548 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11549 PyObject *resultobj = 0;
11550 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11551 int arg2 = (int) -1 ;
11552 PyObject *result = 0 ;
11553 void *argp1 = 0 ;
11554 int res1 = 0 ;
11555 int val2 ;
11556 int ecode2 = 0 ;
11557 PyObject * obj0 = 0 ;
11558 PyObject * obj1 = 0 ;
11559 char * kwnames[] = {
11560 (char *) "self",(char *) "size", NULL
11561 };
11562
11563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11565 if (!SWIG_IsOK(res1)) {
11566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11567 }
11568 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11569 if (obj1) {
11570 ecode2 = SWIG_AsVal_int(obj1, &val2);
11571 if (!SWIG_IsOK(ecode2)) {
11572 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11573 }
11574 arg2 = static_cast< int >(val2);
11575 }
11576 {
11577 PyThreadState* __tstate = wxPyBeginAllowThreads();
11578 result = (PyObject *)(arg1)->read(arg2);
11579 wxPyEndAllowThreads(__tstate);
11580 if (PyErr_Occurred()) SWIG_fail;
11581 }
11582 resultobj = result;
11583 return resultobj;
11584 fail:
11585 return NULL;
11586 }
11587
11588
11589 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11590 PyObject *resultobj = 0;
11591 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11592 int arg2 = (int) -1 ;
11593 PyObject *result = 0 ;
11594 void *argp1 = 0 ;
11595 int res1 = 0 ;
11596 int val2 ;
11597 int ecode2 = 0 ;
11598 PyObject * obj0 = 0 ;
11599 PyObject * obj1 = 0 ;
11600 char * kwnames[] = {
11601 (char *) "self",(char *) "size", NULL
11602 };
11603
11604 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11605 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11606 if (!SWIG_IsOK(res1)) {
11607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11608 }
11609 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11610 if (obj1) {
11611 ecode2 = SWIG_AsVal_int(obj1, &val2);
11612 if (!SWIG_IsOK(ecode2)) {
11613 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11614 }
11615 arg2 = static_cast< int >(val2);
11616 }
11617 {
11618 PyThreadState* __tstate = wxPyBeginAllowThreads();
11619 result = (PyObject *)(arg1)->readline(arg2);
11620 wxPyEndAllowThreads(__tstate);
11621 if (PyErr_Occurred()) SWIG_fail;
11622 }
11623 resultobj = result;
11624 return resultobj;
11625 fail:
11626 return NULL;
11627 }
11628
11629
11630 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj = 0;
11632 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11633 int arg2 = (int) -1 ;
11634 PyObject *result = 0 ;
11635 void *argp1 = 0 ;
11636 int res1 = 0 ;
11637 int val2 ;
11638 int ecode2 = 0 ;
11639 PyObject * obj0 = 0 ;
11640 PyObject * obj1 = 0 ;
11641 char * kwnames[] = {
11642 (char *) "self",(char *) "sizehint", NULL
11643 };
11644
11645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11647 if (!SWIG_IsOK(res1)) {
11648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11649 }
11650 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11651 if (obj1) {
11652 ecode2 = SWIG_AsVal_int(obj1, &val2);
11653 if (!SWIG_IsOK(ecode2)) {
11654 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11655 }
11656 arg2 = static_cast< int >(val2);
11657 }
11658 {
11659 PyThreadState* __tstate = wxPyBeginAllowThreads();
11660 result = (PyObject *)(arg1)->readlines(arg2);
11661 wxPyEndAllowThreads(__tstate);
11662 if (PyErr_Occurred()) SWIG_fail;
11663 }
11664 resultobj = result;
11665 return resultobj;
11666 fail:
11667 return NULL;
11668 }
11669
11670
11671 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11672 PyObject *resultobj = 0;
11673 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11674 int arg2 ;
11675 int arg3 = (int) 0 ;
11676 void *argp1 = 0 ;
11677 int res1 = 0 ;
11678 int val2 ;
11679 int ecode2 = 0 ;
11680 int val3 ;
11681 int ecode3 = 0 ;
11682 PyObject * obj0 = 0 ;
11683 PyObject * obj1 = 0 ;
11684 PyObject * obj2 = 0 ;
11685 char * kwnames[] = {
11686 (char *) "self",(char *) "offset",(char *) "whence", NULL
11687 };
11688
11689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11691 if (!SWIG_IsOK(res1)) {
11692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11693 }
11694 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11695 ecode2 = SWIG_AsVal_int(obj1, &val2);
11696 if (!SWIG_IsOK(ecode2)) {
11697 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11698 }
11699 arg2 = static_cast< int >(val2);
11700 if (obj2) {
11701 ecode3 = SWIG_AsVal_int(obj2, &val3);
11702 if (!SWIG_IsOK(ecode3)) {
11703 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11704 }
11705 arg3 = static_cast< int >(val3);
11706 }
11707 {
11708 PyThreadState* __tstate = wxPyBeginAllowThreads();
11709 (arg1)->seek(arg2,arg3);
11710 wxPyEndAllowThreads(__tstate);
11711 if (PyErr_Occurred()) SWIG_fail;
11712 }
11713 resultobj = SWIG_Py_Void();
11714 return resultobj;
11715 fail:
11716 return NULL;
11717 }
11718
11719
11720 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11721 PyObject *resultobj = 0;
11722 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11723 int result;
11724 void *argp1 = 0 ;
11725 int res1 = 0 ;
11726 PyObject *swig_obj[1] ;
11727
11728 if (!args) SWIG_fail;
11729 swig_obj[0] = args;
11730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11731 if (!SWIG_IsOK(res1)) {
11732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11733 }
11734 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11735 {
11736 PyThreadState* __tstate = wxPyBeginAllowThreads();
11737 result = (int)(arg1)->tell();
11738 wxPyEndAllowThreads(__tstate);
11739 if (PyErr_Occurred()) SWIG_fail;
11740 }
11741 resultobj = SWIG_From_int(static_cast< int >(result));
11742 return resultobj;
11743 fail:
11744 return NULL;
11745 }
11746
11747
11748 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11749 PyObject *resultobj = 0;
11750 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11751 char result;
11752 void *argp1 = 0 ;
11753 int res1 = 0 ;
11754 PyObject *swig_obj[1] ;
11755
11756 if (!args) SWIG_fail;
11757 swig_obj[0] = args;
11758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11759 if (!SWIG_IsOK(res1)) {
11760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11761 }
11762 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11763 {
11764 PyThreadState* __tstate = wxPyBeginAllowThreads();
11765 result = (char)(arg1)->Peek();
11766 wxPyEndAllowThreads(__tstate);
11767 if (PyErr_Occurred()) SWIG_fail;
11768 }
11769 resultobj = SWIG_From_char(static_cast< char >(result));
11770 return resultobj;
11771 fail:
11772 return NULL;
11773 }
11774
11775
11776 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11777 PyObject *resultobj = 0;
11778 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11779 char result;
11780 void *argp1 = 0 ;
11781 int res1 = 0 ;
11782 PyObject *swig_obj[1] ;
11783
11784 if (!args) SWIG_fail;
11785 swig_obj[0] = args;
11786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11787 if (!SWIG_IsOK(res1)) {
11788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11789 }
11790 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11791 {
11792 PyThreadState* __tstate = wxPyBeginAllowThreads();
11793 result = (char)(arg1)->GetC();
11794 wxPyEndAllowThreads(__tstate);
11795 if (PyErr_Occurred()) SWIG_fail;
11796 }
11797 resultobj = SWIG_From_char(static_cast< char >(result));
11798 return resultobj;
11799 fail:
11800 return NULL;
11801 }
11802
11803
11804 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11805 PyObject *resultobj = 0;
11806 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11807 size_t result;
11808 void *argp1 = 0 ;
11809 int res1 = 0 ;
11810 PyObject *swig_obj[1] ;
11811
11812 if (!args) SWIG_fail;
11813 swig_obj[0] = args;
11814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11815 if (!SWIG_IsOK(res1)) {
11816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11817 }
11818 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11819 {
11820 PyThreadState* __tstate = wxPyBeginAllowThreads();
11821 result = (size_t)(arg1)->LastRead();
11822 wxPyEndAllowThreads(__tstate);
11823 if (PyErr_Occurred()) SWIG_fail;
11824 }
11825 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11826 return resultobj;
11827 fail:
11828 return NULL;
11829 }
11830
11831
11832 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11833 PyObject *resultobj = 0;
11834 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11835 bool result;
11836 void *argp1 = 0 ;
11837 int res1 = 0 ;
11838 PyObject *swig_obj[1] ;
11839
11840 if (!args) SWIG_fail;
11841 swig_obj[0] = args;
11842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11843 if (!SWIG_IsOK(res1)) {
11844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11845 }
11846 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11847 {
11848 PyThreadState* __tstate = wxPyBeginAllowThreads();
11849 result = (bool)(arg1)->CanRead();
11850 wxPyEndAllowThreads(__tstate);
11851 if (PyErr_Occurred()) SWIG_fail;
11852 }
11853 {
11854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11855 }
11856 return resultobj;
11857 fail:
11858 return NULL;
11859 }
11860
11861
11862 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11863 PyObject *resultobj = 0;
11864 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11865 bool result;
11866 void *argp1 = 0 ;
11867 int res1 = 0 ;
11868 PyObject *swig_obj[1] ;
11869
11870 if (!args) SWIG_fail;
11871 swig_obj[0] = args;
11872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11873 if (!SWIG_IsOK(res1)) {
11874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11875 }
11876 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11877 {
11878 PyThreadState* __tstate = wxPyBeginAllowThreads();
11879 result = (bool)(arg1)->Eof();
11880 wxPyEndAllowThreads(__tstate);
11881 if (PyErr_Occurred()) SWIG_fail;
11882 }
11883 {
11884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11885 }
11886 return resultobj;
11887 fail:
11888 return NULL;
11889 }
11890
11891
11892 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11893 PyObject *resultobj = 0;
11894 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11895 char arg2 ;
11896 bool result;
11897 void *argp1 = 0 ;
11898 int res1 = 0 ;
11899 char val2 ;
11900 int ecode2 = 0 ;
11901 PyObject * obj0 = 0 ;
11902 PyObject * obj1 = 0 ;
11903 char * kwnames[] = {
11904 (char *) "self",(char *) "c", NULL
11905 };
11906
11907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11909 if (!SWIG_IsOK(res1)) {
11910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11911 }
11912 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11913 ecode2 = SWIG_AsVal_char(obj1, &val2);
11914 if (!SWIG_IsOK(ecode2)) {
11915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11916 }
11917 arg2 = static_cast< char >(val2);
11918 {
11919 PyThreadState* __tstate = wxPyBeginAllowThreads();
11920 result = (bool)(arg1)->Ungetch(arg2);
11921 wxPyEndAllowThreads(__tstate);
11922 if (PyErr_Occurred()) SWIG_fail;
11923 }
11924 {
11925 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11926 }
11927 return resultobj;
11928 fail:
11929 return NULL;
11930 }
11931
11932
11933 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11934 PyObject *resultobj = 0;
11935 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11936 long arg2 ;
11937 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11938 long result;
11939 void *argp1 = 0 ;
11940 int res1 = 0 ;
11941 long val2 ;
11942 int ecode2 = 0 ;
11943 int val3 ;
11944 int ecode3 = 0 ;
11945 PyObject * obj0 = 0 ;
11946 PyObject * obj1 = 0 ;
11947 PyObject * obj2 = 0 ;
11948 char * kwnames[] = {
11949 (char *) "self",(char *) "pos",(char *) "mode", NULL
11950 };
11951
11952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11954 if (!SWIG_IsOK(res1)) {
11955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11956 }
11957 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11958 ecode2 = SWIG_AsVal_long(obj1, &val2);
11959 if (!SWIG_IsOK(ecode2)) {
11960 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11961 }
11962 arg2 = static_cast< long >(val2);
11963 if (obj2) {
11964 ecode3 = SWIG_AsVal_int(obj2, &val3);
11965 if (!SWIG_IsOK(ecode3)) {
11966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11967 }
11968 arg3 = static_cast< wxSeekMode >(val3);
11969 }
11970 {
11971 PyThreadState* __tstate = wxPyBeginAllowThreads();
11972 result = (long)(arg1)->SeekI(arg2,arg3);
11973 wxPyEndAllowThreads(__tstate);
11974 if (PyErr_Occurred()) SWIG_fail;
11975 }
11976 resultobj = SWIG_From_long(static_cast< long >(result));
11977 return resultobj;
11978 fail:
11979 return NULL;
11980 }
11981
11982
11983 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11984 PyObject *resultobj = 0;
11985 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11986 long result;
11987 void *argp1 = 0 ;
11988 int res1 = 0 ;
11989 PyObject *swig_obj[1] ;
11990
11991 if (!args) SWIG_fail;
11992 swig_obj[0] = args;
11993 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11994 if (!SWIG_IsOK(res1)) {
11995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11996 }
11997 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11998 {
11999 PyThreadState* __tstate = wxPyBeginAllowThreads();
12000 result = (long)(arg1)->TellI();
12001 wxPyEndAllowThreads(__tstate);
12002 if (PyErr_Occurred()) SWIG_fail;
12003 }
12004 resultobj = SWIG_From_long(static_cast< long >(result));
12005 return resultobj;
12006 fail:
12007 return NULL;
12008 }
12009
12010
12011 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12012 PyObject *obj;
12013 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12014 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12015 return SWIG_Py_Void();
12016 }
12017
12018 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12019 return SWIG_Python_InitShadowInstance(args);
12020 }
12021
12022 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12023 PyObject *resultobj = 0;
12024 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12025 PyObject *arg2 = (PyObject *) 0 ;
12026 void *argp1 = 0 ;
12027 int res1 = 0 ;
12028 PyObject * obj0 = 0 ;
12029 PyObject * obj1 = 0 ;
12030 char * kwnames[] = {
12031 (char *) "self",(char *) "obj", NULL
12032 };
12033
12034 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12035 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12036 if (!SWIG_IsOK(res1)) {
12037 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12038 }
12039 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12040 arg2 = obj1;
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 wxOutputStream_write(arg1,arg2);
12044 wxPyEndAllowThreads(__tstate);
12045 if (PyErr_Occurred()) SWIG_fail;
12046 }
12047 resultobj = SWIG_Py_Void();
12048 return resultobj;
12049 fail:
12050 return NULL;
12051 }
12052
12053
12054 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12055 PyObject *resultobj = 0;
12056 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12057 size_t result;
12058 void *argp1 = 0 ;
12059 int res1 = 0 ;
12060 PyObject *swig_obj[1] ;
12061
12062 if (!args) SWIG_fail;
12063 swig_obj[0] = args;
12064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12065 if (!SWIG_IsOK(res1)) {
12066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12067 }
12068 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12069 {
12070 PyThreadState* __tstate = wxPyBeginAllowThreads();
12071 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12072 wxPyEndAllowThreads(__tstate);
12073 if (PyErr_Occurred()) SWIG_fail;
12074 }
12075 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12076 return resultobj;
12077 fail:
12078 return NULL;
12079 }
12080
12081
12082 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12083 PyObject *obj;
12084 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12085 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12086 return SWIG_Py_Void();
12087 }
12088
12089 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12090 PyObject *resultobj = 0;
12091 wxInputStream *arg1 = (wxInputStream *) 0 ;
12092 wxString *arg2 = 0 ;
12093 wxString *arg3 = 0 ;
12094 wxString *arg4 = 0 ;
12095 wxDateTime arg5 ;
12096 wxFSFile *result = 0 ;
12097 wxPyInputStream *temp1 ;
12098 bool temp2 = false ;
12099 bool temp3 = false ;
12100 bool temp4 = false ;
12101 void *argp5 ;
12102 int res5 = 0 ;
12103 PyObject * obj0 = 0 ;
12104 PyObject * obj1 = 0 ;
12105 PyObject * obj2 = 0 ;
12106 PyObject * obj3 = 0 ;
12107 PyObject * obj4 = 0 ;
12108 char * kwnames[] = {
12109 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12110 };
12111
12112 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12113 {
12114 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12115 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12116 } else {
12117 PyErr_Clear(); // clear the failure of the wxPyConvert above
12118 arg1 = wxPyCBInputStream_create(obj0, true);
12119 if (arg1 == NULL) {
12120 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12121 SWIG_fail;
12122 }
12123 }
12124 }
12125 {
12126 arg2 = wxString_in_helper(obj1);
12127 if (arg2 == NULL) SWIG_fail;
12128 temp2 = true;
12129 }
12130 {
12131 arg3 = wxString_in_helper(obj2);
12132 if (arg3 == NULL) SWIG_fail;
12133 temp3 = true;
12134 }
12135 {
12136 arg4 = wxString_in_helper(obj3);
12137 if (arg4 == NULL) SWIG_fail;
12138 temp4 = true;
12139 }
12140 {
12141 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12142 if (!SWIG_IsOK(res5)) {
12143 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12144 }
12145 if (!argp5) {
12146 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12147 } else {
12148 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12149 arg5 = *temp;
12150 if (SWIG_IsNewObj(res5)) delete temp;
12151 }
12152 }
12153 {
12154 PyThreadState* __tstate = wxPyBeginAllowThreads();
12155 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12156 wxPyEndAllowThreads(__tstate);
12157 if (PyErr_Occurred()) SWIG_fail;
12158 }
12159 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12160 {
12161 if (temp2)
12162 delete arg2;
12163 }
12164 {
12165 if (temp3)
12166 delete arg3;
12167 }
12168 {
12169 if (temp4)
12170 delete arg4;
12171 }
12172 return resultobj;
12173 fail:
12174 {
12175 if (temp2)
12176 delete arg2;
12177 }
12178 {
12179 if (temp3)
12180 delete arg3;
12181 }
12182 {
12183 if (temp4)
12184 delete arg4;
12185 }
12186 return NULL;
12187 }
12188
12189
12190 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12191 PyObject *resultobj = 0;
12192 wxFSFile *arg1 = (wxFSFile *) 0 ;
12193 void *argp1 = 0 ;
12194 int res1 = 0 ;
12195 PyObject *swig_obj[1] ;
12196
12197 if (!args) SWIG_fail;
12198 swig_obj[0] = args;
12199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12200 if (!SWIG_IsOK(res1)) {
12201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12202 }
12203 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12204 {
12205 PyThreadState* __tstate = wxPyBeginAllowThreads();
12206 delete arg1;
12207
12208 wxPyEndAllowThreads(__tstate);
12209 if (PyErr_Occurred()) SWIG_fail;
12210 }
12211 resultobj = SWIG_Py_Void();
12212 return resultobj;
12213 fail:
12214 return NULL;
12215 }
12216
12217
12218 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12219 PyObject *resultobj = 0;
12220 wxFSFile *arg1 = (wxFSFile *) 0 ;
12221 wxInputStream *result = 0 ;
12222 void *argp1 = 0 ;
12223 int res1 = 0 ;
12224 PyObject *swig_obj[1] ;
12225
12226 if (!args) SWIG_fail;
12227 swig_obj[0] = args;
12228 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12229 if (!SWIG_IsOK(res1)) {
12230 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12231 }
12232 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12233 {
12234 PyThreadState* __tstate = wxPyBeginAllowThreads();
12235 result = (wxInputStream *)(arg1)->GetStream();
12236 wxPyEndAllowThreads(__tstate);
12237 if (PyErr_Occurred()) SWIG_fail;
12238 }
12239 {
12240 wxPyInputStream * _ptr = NULL;
12241
12242 if (result) {
12243 _ptr = new wxPyInputStream(result);
12244 }
12245 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12246 }
12247 return resultobj;
12248 fail:
12249 return NULL;
12250 }
12251
12252
12253 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12254 PyObject *resultobj = 0;
12255 wxFSFile *arg1 = (wxFSFile *) 0 ;
12256 void *argp1 = 0 ;
12257 int res1 = 0 ;
12258 PyObject *swig_obj[1] ;
12259
12260 if (!args) SWIG_fail;
12261 swig_obj[0] = args;
12262 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12263 if (!SWIG_IsOK(res1)) {
12264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12265 }
12266 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12267 {
12268 PyThreadState* __tstate = wxPyBeginAllowThreads();
12269 (arg1)->DetachStream();
12270 wxPyEndAllowThreads(__tstate);
12271 if (PyErr_Occurred()) SWIG_fail;
12272 }
12273 resultobj = SWIG_Py_Void();
12274 return resultobj;
12275 fail:
12276 return NULL;
12277 }
12278
12279
12280 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12281 PyObject *resultobj = 0;
12282 wxFSFile *arg1 = (wxFSFile *) 0 ;
12283 wxString *result = 0 ;
12284 void *argp1 = 0 ;
12285 int res1 = 0 ;
12286 PyObject *swig_obj[1] ;
12287
12288 if (!args) SWIG_fail;
12289 swig_obj[0] = args;
12290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12291 if (!SWIG_IsOK(res1)) {
12292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12293 }
12294 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12295 {
12296 PyThreadState* __tstate = wxPyBeginAllowThreads();
12297 {
12298 wxString const &_result_ref = (arg1)->GetMimeType();
12299 result = (wxString *) &_result_ref;
12300 }
12301 wxPyEndAllowThreads(__tstate);
12302 if (PyErr_Occurred()) SWIG_fail;
12303 }
12304 {
12305 #if wxUSE_UNICODE
12306 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12307 #else
12308 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12309 #endif
12310 }
12311 return resultobj;
12312 fail:
12313 return NULL;
12314 }
12315
12316
12317 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12318 PyObject *resultobj = 0;
12319 wxFSFile *arg1 = (wxFSFile *) 0 ;
12320 wxString *result = 0 ;
12321 void *argp1 = 0 ;
12322 int res1 = 0 ;
12323 PyObject *swig_obj[1] ;
12324
12325 if (!args) SWIG_fail;
12326 swig_obj[0] = args;
12327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12328 if (!SWIG_IsOK(res1)) {
12329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12330 }
12331 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12332 {
12333 PyThreadState* __tstate = wxPyBeginAllowThreads();
12334 {
12335 wxString const &_result_ref = (arg1)->GetLocation();
12336 result = (wxString *) &_result_ref;
12337 }
12338 wxPyEndAllowThreads(__tstate);
12339 if (PyErr_Occurred()) SWIG_fail;
12340 }
12341 {
12342 #if wxUSE_UNICODE
12343 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12344 #else
12345 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12346 #endif
12347 }
12348 return resultobj;
12349 fail:
12350 return NULL;
12351 }
12352
12353
12354 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12355 PyObject *resultobj = 0;
12356 wxFSFile *arg1 = (wxFSFile *) 0 ;
12357 wxString *result = 0 ;
12358 void *argp1 = 0 ;
12359 int res1 = 0 ;
12360 PyObject *swig_obj[1] ;
12361
12362 if (!args) SWIG_fail;
12363 swig_obj[0] = args;
12364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12365 if (!SWIG_IsOK(res1)) {
12366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12367 }
12368 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12369 {
12370 PyThreadState* __tstate = wxPyBeginAllowThreads();
12371 {
12372 wxString const &_result_ref = (arg1)->GetAnchor();
12373 result = (wxString *) &_result_ref;
12374 }
12375 wxPyEndAllowThreads(__tstate);
12376 if (PyErr_Occurred()) SWIG_fail;
12377 }
12378 {
12379 #if wxUSE_UNICODE
12380 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12381 #else
12382 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12383 #endif
12384 }
12385 return resultobj;
12386 fail:
12387 return NULL;
12388 }
12389
12390
12391 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12392 PyObject *resultobj = 0;
12393 wxFSFile *arg1 = (wxFSFile *) 0 ;
12394 wxDateTime result;
12395 void *argp1 = 0 ;
12396 int res1 = 0 ;
12397 PyObject *swig_obj[1] ;
12398
12399 if (!args) SWIG_fail;
12400 swig_obj[0] = args;
12401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12402 if (!SWIG_IsOK(res1)) {
12403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12404 }
12405 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12406 {
12407 PyThreadState* __tstate = wxPyBeginAllowThreads();
12408 result = (arg1)->GetModificationTime();
12409 wxPyEndAllowThreads(__tstate);
12410 if (PyErr_Occurred()) SWIG_fail;
12411 }
12412 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12413 return resultobj;
12414 fail:
12415 return NULL;
12416 }
12417
12418
12419 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12420 PyObject *obj;
12421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12422 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12423 return SWIG_Py_Void();
12424 }
12425
12426 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12427 return SWIG_Python_InitShadowInstance(args);
12428 }
12429
12430 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12431 PyObject *resultobj = 0;
12432 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12433 void *argp1 = 0 ;
12434 int res1 = 0 ;
12435 PyObject *swig_obj[1] ;
12436
12437 if (!args) SWIG_fail;
12438 swig_obj[0] = args;
12439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12440 if (!SWIG_IsOK(res1)) {
12441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12442 }
12443 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12444 {
12445 PyThreadState* __tstate = wxPyBeginAllowThreads();
12446 delete arg1;
12447
12448 wxPyEndAllowThreads(__tstate);
12449 if (PyErr_Occurred()) SWIG_fail;
12450 }
12451 resultobj = SWIG_Py_Void();
12452 return resultobj;
12453 fail:
12454 return NULL;
12455 }
12456
12457
12458 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12459 PyObject *obj;
12460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12461 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12462 return SWIG_Py_Void();
12463 }
12464
12465 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12466 PyObject *resultobj = 0;
12467 wxPyFileSystemHandler *result = 0 ;
12468
12469 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12470 {
12471 PyThreadState* __tstate = wxPyBeginAllowThreads();
12472 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12473 wxPyEndAllowThreads(__tstate);
12474 if (PyErr_Occurred()) SWIG_fail;
12475 }
12476 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12477 return resultobj;
12478 fail:
12479 return NULL;
12480 }
12481
12482
12483 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12484 PyObject *resultobj = 0;
12485 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12486 PyObject *arg2 = (PyObject *) 0 ;
12487 PyObject *arg3 = (PyObject *) 0 ;
12488 void *argp1 = 0 ;
12489 int res1 = 0 ;
12490 PyObject * obj0 = 0 ;
12491 PyObject * obj1 = 0 ;
12492 PyObject * obj2 = 0 ;
12493 char * kwnames[] = {
12494 (char *) "self",(char *) "self",(char *) "_class", NULL
12495 };
12496
12497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12499 if (!SWIG_IsOK(res1)) {
12500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12501 }
12502 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12503 arg2 = obj1;
12504 arg3 = obj2;
12505 {
12506 PyThreadState* __tstate = wxPyBeginAllowThreads();
12507 (arg1)->_setCallbackInfo(arg2,arg3);
12508 wxPyEndAllowThreads(__tstate);
12509 if (PyErr_Occurred()) SWIG_fail;
12510 }
12511 resultobj = SWIG_Py_Void();
12512 return resultobj;
12513 fail:
12514 return NULL;
12515 }
12516
12517
12518 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj = 0;
12520 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12521 wxString *arg2 = 0 ;
12522 bool result;
12523 void *argp1 = 0 ;
12524 int res1 = 0 ;
12525 bool temp2 = false ;
12526 PyObject * obj0 = 0 ;
12527 PyObject * obj1 = 0 ;
12528 char * kwnames[] = {
12529 (char *) "self",(char *) "location", NULL
12530 };
12531
12532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12534 if (!SWIG_IsOK(res1)) {
12535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12536 }
12537 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12538 {
12539 arg2 = wxString_in_helper(obj1);
12540 if (arg2 == NULL) SWIG_fail;
12541 temp2 = true;
12542 }
12543 {
12544 PyThreadState* __tstate = wxPyBeginAllowThreads();
12545 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12546 wxPyEndAllowThreads(__tstate);
12547 if (PyErr_Occurred()) SWIG_fail;
12548 }
12549 {
12550 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12551 }
12552 {
12553 if (temp2)
12554 delete arg2;
12555 }
12556 return resultobj;
12557 fail:
12558 {
12559 if (temp2)
12560 delete arg2;
12561 }
12562 return NULL;
12563 }
12564
12565
12566 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12567 PyObject *resultobj = 0;
12568 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12569 wxFileSystem *arg2 = 0 ;
12570 wxString *arg3 = 0 ;
12571 wxFSFile *result = 0 ;
12572 void *argp1 = 0 ;
12573 int res1 = 0 ;
12574 void *argp2 = 0 ;
12575 int res2 = 0 ;
12576 bool temp3 = false ;
12577 PyObject * obj0 = 0 ;
12578 PyObject * obj1 = 0 ;
12579 PyObject * obj2 = 0 ;
12580 char * kwnames[] = {
12581 (char *) "self",(char *) "fs",(char *) "location", NULL
12582 };
12583
12584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12586 if (!SWIG_IsOK(res1)) {
12587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12588 }
12589 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12590 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12591 if (!SWIG_IsOK(res2)) {
12592 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12593 }
12594 if (!argp2) {
12595 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12596 }
12597 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12598 {
12599 arg3 = wxString_in_helper(obj2);
12600 if (arg3 == NULL) SWIG_fail;
12601 temp3 = true;
12602 }
12603 {
12604 PyThreadState* __tstate = wxPyBeginAllowThreads();
12605 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12606 wxPyEndAllowThreads(__tstate);
12607 if (PyErr_Occurred()) SWIG_fail;
12608 }
12609 {
12610 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12611 }
12612 {
12613 if (temp3)
12614 delete arg3;
12615 }
12616 return resultobj;
12617 fail:
12618 {
12619 if (temp3)
12620 delete arg3;
12621 }
12622 return NULL;
12623 }
12624
12625
12626 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12627 PyObject *resultobj = 0;
12628 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12629 wxString *arg2 = 0 ;
12630 int arg3 = (int) 0 ;
12631 wxString result;
12632 void *argp1 = 0 ;
12633 int res1 = 0 ;
12634 bool temp2 = false ;
12635 int val3 ;
12636 int ecode3 = 0 ;
12637 PyObject * obj0 = 0 ;
12638 PyObject * obj1 = 0 ;
12639 PyObject * obj2 = 0 ;
12640 char * kwnames[] = {
12641 (char *) "self",(char *) "spec",(char *) "flags", NULL
12642 };
12643
12644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12646 if (!SWIG_IsOK(res1)) {
12647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12648 }
12649 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12650 {
12651 arg2 = wxString_in_helper(obj1);
12652 if (arg2 == NULL) SWIG_fail;
12653 temp2 = true;
12654 }
12655 if (obj2) {
12656 ecode3 = SWIG_AsVal_int(obj2, &val3);
12657 if (!SWIG_IsOK(ecode3)) {
12658 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12659 }
12660 arg3 = static_cast< int >(val3);
12661 }
12662 {
12663 PyThreadState* __tstate = wxPyBeginAllowThreads();
12664 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12665 wxPyEndAllowThreads(__tstate);
12666 if (PyErr_Occurred()) SWIG_fail;
12667 }
12668 {
12669 #if wxUSE_UNICODE
12670 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12671 #else
12672 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12673 #endif
12674 }
12675 {
12676 if (temp2)
12677 delete arg2;
12678 }
12679 return resultobj;
12680 fail:
12681 {
12682 if (temp2)
12683 delete arg2;
12684 }
12685 return NULL;
12686 }
12687
12688
12689 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12690 PyObject *resultobj = 0;
12691 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12692 wxString result;
12693 void *argp1 = 0 ;
12694 int res1 = 0 ;
12695 PyObject *swig_obj[1] ;
12696
12697 if (!args) SWIG_fail;
12698 swig_obj[0] = args;
12699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12700 if (!SWIG_IsOK(res1)) {
12701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12702 }
12703 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12704 {
12705 PyThreadState* __tstate = wxPyBeginAllowThreads();
12706 result = (arg1)->FindNext();
12707 wxPyEndAllowThreads(__tstate);
12708 if (PyErr_Occurred()) SWIG_fail;
12709 }
12710 {
12711 #if wxUSE_UNICODE
12712 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12713 #else
12714 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12715 #endif
12716 }
12717 return resultobj;
12718 fail:
12719 return NULL;
12720 }
12721
12722
12723 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12724 PyObject *resultobj = 0;
12725 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12726 wxString *arg2 = 0 ;
12727 wxString result;
12728 void *argp1 = 0 ;
12729 int res1 = 0 ;
12730 bool temp2 = false ;
12731 PyObject * obj0 = 0 ;
12732 PyObject * obj1 = 0 ;
12733 char * kwnames[] = {
12734 (char *) "self",(char *) "location", NULL
12735 };
12736
12737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12739 if (!SWIG_IsOK(res1)) {
12740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12741 }
12742 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12743 {
12744 arg2 = wxString_in_helper(obj1);
12745 if (arg2 == NULL) SWIG_fail;
12746 temp2 = true;
12747 }
12748 {
12749 PyThreadState* __tstate = wxPyBeginAllowThreads();
12750 result = (arg1)->GetProtocol((wxString const &)*arg2);
12751 wxPyEndAllowThreads(__tstate);
12752 if (PyErr_Occurred()) SWIG_fail;
12753 }
12754 {
12755 #if wxUSE_UNICODE
12756 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12757 #else
12758 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12759 #endif
12760 }
12761 {
12762 if (temp2)
12763 delete arg2;
12764 }
12765 return resultobj;
12766 fail:
12767 {
12768 if (temp2)
12769 delete arg2;
12770 }
12771 return NULL;
12772 }
12773
12774
12775 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12776 PyObject *resultobj = 0;
12777 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12778 wxString *arg2 = 0 ;
12779 wxString result;
12780 void *argp1 = 0 ;
12781 int res1 = 0 ;
12782 bool temp2 = false ;
12783 PyObject * obj0 = 0 ;
12784 PyObject * obj1 = 0 ;
12785 char * kwnames[] = {
12786 (char *) "self",(char *) "location", NULL
12787 };
12788
12789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12791 if (!SWIG_IsOK(res1)) {
12792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12793 }
12794 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12795 {
12796 arg2 = wxString_in_helper(obj1);
12797 if (arg2 == NULL) SWIG_fail;
12798 temp2 = true;
12799 }
12800 {
12801 PyThreadState* __tstate = wxPyBeginAllowThreads();
12802 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12803 wxPyEndAllowThreads(__tstate);
12804 if (PyErr_Occurred()) SWIG_fail;
12805 }
12806 {
12807 #if wxUSE_UNICODE
12808 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12809 #else
12810 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12811 #endif
12812 }
12813 {
12814 if (temp2)
12815 delete arg2;
12816 }
12817 return resultobj;
12818 fail:
12819 {
12820 if (temp2)
12821 delete arg2;
12822 }
12823 return NULL;
12824 }
12825
12826
12827 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12828 PyObject *resultobj = 0;
12829 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12830 wxString *arg2 = 0 ;
12831 wxString result;
12832 void *argp1 = 0 ;
12833 int res1 = 0 ;
12834 bool temp2 = false ;
12835 PyObject * obj0 = 0 ;
12836 PyObject * obj1 = 0 ;
12837 char * kwnames[] = {
12838 (char *) "self",(char *) "location", NULL
12839 };
12840
12841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12843 if (!SWIG_IsOK(res1)) {
12844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12845 }
12846 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12847 {
12848 arg2 = wxString_in_helper(obj1);
12849 if (arg2 == NULL) SWIG_fail;
12850 temp2 = true;
12851 }
12852 {
12853 PyThreadState* __tstate = wxPyBeginAllowThreads();
12854 result = (arg1)->GetAnchor((wxString const &)*arg2);
12855 wxPyEndAllowThreads(__tstate);
12856 if (PyErr_Occurred()) SWIG_fail;
12857 }
12858 {
12859 #if wxUSE_UNICODE
12860 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12861 #else
12862 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12863 #endif
12864 }
12865 {
12866 if (temp2)
12867 delete arg2;
12868 }
12869 return resultobj;
12870 fail:
12871 {
12872 if (temp2)
12873 delete arg2;
12874 }
12875 return NULL;
12876 }
12877
12878
12879 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12880 PyObject *resultobj = 0;
12881 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12882 wxString *arg2 = 0 ;
12883 wxString result;
12884 void *argp1 = 0 ;
12885 int res1 = 0 ;
12886 bool temp2 = false ;
12887 PyObject * obj0 = 0 ;
12888 PyObject * obj1 = 0 ;
12889 char * kwnames[] = {
12890 (char *) "self",(char *) "location", NULL
12891 };
12892
12893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12895 if (!SWIG_IsOK(res1)) {
12896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12897 }
12898 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12899 {
12900 arg2 = wxString_in_helper(obj1);
12901 if (arg2 == NULL) SWIG_fail;
12902 temp2 = true;
12903 }
12904 {
12905 PyThreadState* __tstate = wxPyBeginAllowThreads();
12906 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12907 wxPyEndAllowThreads(__tstate);
12908 if (PyErr_Occurred()) SWIG_fail;
12909 }
12910 {
12911 #if wxUSE_UNICODE
12912 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12913 #else
12914 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12915 #endif
12916 }
12917 {
12918 if (temp2)
12919 delete arg2;
12920 }
12921 return resultobj;
12922 fail:
12923 {
12924 if (temp2)
12925 delete arg2;
12926 }
12927 return NULL;
12928 }
12929
12930
12931 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12932 PyObject *resultobj = 0;
12933 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12934 wxString *arg2 = 0 ;
12935 wxString result;
12936 void *argp1 = 0 ;
12937 int res1 = 0 ;
12938 bool temp2 = false ;
12939 PyObject * obj0 = 0 ;
12940 PyObject * obj1 = 0 ;
12941 char * kwnames[] = {
12942 (char *) "self",(char *) "location", NULL
12943 };
12944
12945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12947 if (!SWIG_IsOK(res1)) {
12948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12949 }
12950 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12951 {
12952 arg2 = wxString_in_helper(obj1);
12953 if (arg2 == NULL) SWIG_fail;
12954 temp2 = true;
12955 }
12956 {
12957 PyThreadState* __tstate = wxPyBeginAllowThreads();
12958 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12959 wxPyEndAllowThreads(__tstate);
12960 if (PyErr_Occurred()) SWIG_fail;
12961 }
12962 {
12963 #if wxUSE_UNICODE
12964 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12965 #else
12966 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12967 #endif
12968 }
12969 {
12970 if (temp2)
12971 delete arg2;
12972 }
12973 return resultobj;
12974 fail:
12975 {
12976 if (temp2)
12977 delete arg2;
12978 }
12979 return NULL;
12980 }
12981
12982
12983 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12984 PyObject *obj;
12985 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12986 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
12987 return SWIG_Py_Void();
12988 }
12989
12990 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12991 return SWIG_Python_InitShadowInstance(args);
12992 }
12993
12994 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12995 PyObject *resultobj = 0;
12996 wxFileSystem *result = 0 ;
12997
12998 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
12999 {
13000 PyThreadState* __tstate = wxPyBeginAllowThreads();
13001 result = (wxFileSystem *)new wxFileSystem();
13002 wxPyEndAllowThreads(__tstate);
13003 if (PyErr_Occurred()) SWIG_fail;
13004 }
13005 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13006 return resultobj;
13007 fail:
13008 return NULL;
13009 }
13010
13011
13012 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13013 PyObject *resultobj = 0;
13014 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13015 void *argp1 = 0 ;
13016 int res1 = 0 ;
13017 PyObject *swig_obj[1] ;
13018
13019 if (!args) SWIG_fail;
13020 swig_obj[0] = args;
13021 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13022 if (!SWIG_IsOK(res1)) {
13023 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13024 }
13025 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13026 {
13027 PyThreadState* __tstate = wxPyBeginAllowThreads();
13028 delete arg1;
13029
13030 wxPyEndAllowThreads(__tstate);
13031 if (PyErr_Occurred()) SWIG_fail;
13032 }
13033 resultobj = SWIG_Py_Void();
13034 return resultobj;
13035 fail:
13036 return NULL;
13037 }
13038
13039
13040 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13041 PyObject *resultobj = 0;
13042 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13043 wxString *arg2 = 0 ;
13044 bool arg3 = (bool) false ;
13045 void *argp1 = 0 ;
13046 int res1 = 0 ;
13047 bool temp2 = false ;
13048 bool val3 ;
13049 int ecode3 = 0 ;
13050 PyObject * obj0 = 0 ;
13051 PyObject * obj1 = 0 ;
13052 PyObject * obj2 = 0 ;
13053 char * kwnames[] = {
13054 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13055 };
13056
13057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13059 if (!SWIG_IsOK(res1)) {
13060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13061 }
13062 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13063 {
13064 arg2 = wxString_in_helper(obj1);
13065 if (arg2 == NULL) SWIG_fail;
13066 temp2 = true;
13067 }
13068 if (obj2) {
13069 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13070 if (!SWIG_IsOK(ecode3)) {
13071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13072 }
13073 arg3 = static_cast< bool >(val3);
13074 }
13075 {
13076 PyThreadState* __tstate = wxPyBeginAllowThreads();
13077 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13078 wxPyEndAllowThreads(__tstate);
13079 if (PyErr_Occurred()) SWIG_fail;
13080 }
13081 resultobj = SWIG_Py_Void();
13082 {
13083 if (temp2)
13084 delete arg2;
13085 }
13086 return resultobj;
13087 fail:
13088 {
13089 if (temp2)
13090 delete arg2;
13091 }
13092 return NULL;
13093 }
13094
13095
13096 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13097 PyObject *resultobj = 0;
13098 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13099 wxString result;
13100 void *argp1 = 0 ;
13101 int res1 = 0 ;
13102 PyObject *swig_obj[1] ;
13103
13104 if (!args) SWIG_fail;
13105 swig_obj[0] = args;
13106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13107 if (!SWIG_IsOK(res1)) {
13108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13109 }
13110 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13111 {
13112 PyThreadState* __tstate = wxPyBeginAllowThreads();
13113 result = (arg1)->GetPath();
13114 wxPyEndAllowThreads(__tstate);
13115 if (PyErr_Occurred()) SWIG_fail;
13116 }
13117 {
13118 #if wxUSE_UNICODE
13119 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13120 #else
13121 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13122 #endif
13123 }
13124 return resultobj;
13125 fail:
13126 return NULL;
13127 }
13128
13129
13130 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13131 PyObject *resultobj = 0;
13132 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13133 wxString *arg2 = 0 ;
13134 wxFSFile *result = 0 ;
13135 void *argp1 = 0 ;
13136 int res1 = 0 ;
13137 bool temp2 = false ;
13138 PyObject * obj0 = 0 ;
13139 PyObject * obj1 = 0 ;
13140 char * kwnames[] = {
13141 (char *) "self",(char *) "location", NULL
13142 };
13143
13144 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13145 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13146 if (!SWIG_IsOK(res1)) {
13147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13148 }
13149 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13150 {
13151 arg2 = wxString_in_helper(obj1);
13152 if (arg2 == NULL) SWIG_fail;
13153 temp2 = true;
13154 }
13155 {
13156 PyThreadState* __tstate = wxPyBeginAllowThreads();
13157 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13158 wxPyEndAllowThreads(__tstate);
13159 if (PyErr_Occurred()) SWIG_fail;
13160 }
13161 {
13162 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13163 }
13164 {
13165 if (temp2)
13166 delete arg2;
13167 }
13168 return resultobj;
13169 fail:
13170 {
13171 if (temp2)
13172 delete arg2;
13173 }
13174 return NULL;
13175 }
13176
13177
13178 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13179 PyObject *resultobj = 0;
13180 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13181 wxString *arg2 = 0 ;
13182 int arg3 = (int) 0 ;
13183 wxString result;
13184 void *argp1 = 0 ;
13185 int res1 = 0 ;
13186 bool temp2 = false ;
13187 int val3 ;
13188 int ecode3 = 0 ;
13189 PyObject * obj0 = 0 ;
13190 PyObject * obj1 = 0 ;
13191 PyObject * obj2 = 0 ;
13192 char * kwnames[] = {
13193 (char *) "self",(char *) "spec",(char *) "flags", NULL
13194 };
13195
13196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13198 if (!SWIG_IsOK(res1)) {
13199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13200 }
13201 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13202 {
13203 arg2 = wxString_in_helper(obj1);
13204 if (arg2 == NULL) SWIG_fail;
13205 temp2 = true;
13206 }
13207 if (obj2) {
13208 ecode3 = SWIG_AsVal_int(obj2, &val3);
13209 if (!SWIG_IsOK(ecode3)) {
13210 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13211 }
13212 arg3 = static_cast< int >(val3);
13213 }
13214 {
13215 PyThreadState* __tstate = wxPyBeginAllowThreads();
13216 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13217 wxPyEndAllowThreads(__tstate);
13218 if (PyErr_Occurred()) SWIG_fail;
13219 }
13220 {
13221 #if wxUSE_UNICODE
13222 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13223 #else
13224 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13225 #endif
13226 }
13227 {
13228 if (temp2)
13229 delete arg2;
13230 }
13231 return resultobj;
13232 fail:
13233 {
13234 if (temp2)
13235 delete arg2;
13236 }
13237 return NULL;
13238 }
13239
13240
13241 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13242 PyObject *resultobj = 0;
13243 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13244 wxString result;
13245 void *argp1 = 0 ;
13246 int res1 = 0 ;
13247 PyObject *swig_obj[1] ;
13248
13249 if (!args) SWIG_fail;
13250 swig_obj[0] = args;
13251 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13252 if (!SWIG_IsOK(res1)) {
13253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13254 }
13255 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13256 {
13257 PyThreadState* __tstate = wxPyBeginAllowThreads();
13258 result = (arg1)->FindNext();
13259 wxPyEndAllowThreads(__tstate);
13260 if (PyErr_Occurred()) SWIG_fail;
13261 }
13262 {
13263 #if wxUSE_UNICODE
13264 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13265 #else
13266 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13267 #endif
13268 }
13269 return resultobj;
13270 fail:
13271 return NULL;
13272 }
13273
13274
13275 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13276 PyObject *resultobj = 0;
13277 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13278 int res1 = 0 ;
13279 PyObject * obj0 = 0 ;
13280 char * kwnames[] = {
13281 (char *) "handler", NULL
13282 };
13283
13284 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13285 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13286 if (!SWIG_IsOK(res1)) {
13287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13288 }
13289 {
13290 PyThreadState* __tstate = wxPyBeginAllowThreads();
13291 wxFileSystem::AddHandler(arg1);
13292 wxPyEndAllowThreads(__tstate);
13293 if (PyErr_Occurred()) SWIG_fail;
13294 }
13295 resultobj = SWIG_Py_Void();
13296 return resultobj;
13297 fail:
13298 return NULL;
13299 }
13300
13301
13302 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13303 PyObject *resultobj = 0;
13304 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13305 wxFileSystemHandler *result = 0 ;
13306 void *argp1 = 0 ;
13307 int res1 = 0 ;
13308 PyObject * obj0 = 0 ;
13309 char * kwnames[] = {
13310 (char *) "handler", NULL
13311 };
13312
13313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13315 if (!SWIG_IsOK(res1)) {
13316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13317 }
13318 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13319 {
13320 PyThreadState* __tstate = wxPyBeginAllowThreads();
13321 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13322 wxPyEndAllowThreads(__tstate);
13323 if (PyErr_Occurred()) SWIG_fail;
13324 }
13325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13326 return resultobj;
13327 fail:
13328 return NULL;
13329 }
13330
13331
13332 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13333 PyObject *resultobj = 0;
13334
13335 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13336 {
13337 PyThreadState* __tstate = wxPyBeginAllowThreads();
13338 wxFileSystem::CleanUpHandlers();
13339 wxPyEndAllowThreads(__tstate);
13340 if (PyErr_Occurred()) SWIG_fail;
13341 }
13342 resultobj = SWIG_Py_Void();
13343 return resultobj;
13344 fail:
13345 return NULL;
13346 }
13347
13348
13349 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13350 PyObject *resultobj = 0;
13351 wxString *arg1 = 0 ;
13352 wxString result;
13353 bool temp1 = false ;
13354 PyObject * obj0 = 0 ;
13355 char * kwnames[] = {
13356 (char *) "filename", NULL
13357 };
13358
13359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13360 {
13361 arg1 = wxString_in_helper(obj0);
13362 if (arg1 == NULL) SWIG_fail;
13363 temp1 = true;
13364 }
13365 {
13366 PyThreadState* __tstate = wxPyBeginAllowThreads();
13367 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13368 wxPyEndAllowThreads(__tstate);
13369 if (PyErr_Occurred()) SWIG_fail;
13370 }
13371 {
13372 #if wxUSE_UNICODE
13373 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13374 #else
13375 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13376 #endif
13377 }
13378 {
13379 if (temp1)
13380 delete arg1;
13381 }
13382 return resultobj;
13383 fail:
13384 {
13385 if (temp1)
13386 delete arg1;
13387 }
13388 return NULL;
13389 }
13390
13391
13392 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13393 PyObject *resultobj = 0;
13394 wxString *arg1 = 0 ;
13395 wxString result;
13396 bool temp1 = false ;
13397 PyObject * obj0 = 0 ;
13398 char * kwnames[] = {
13399 (char *) "url", NULL
13400 };
13401
13402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13403 {
13404 arg1 = wxString_in_helper(obj0);
13405 if (arg1 == NULL) SWIG_fail;
13406 temp1 = true;
13407 }
13408 {
13409 PyThreadState* __tstate = wxPyBeginAllowThreads();
13410 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13411 wxPyEndAllowThreads(__tstate);
13412 if (PyErr_Occurred()) SWIG_fail;
13413 }
13414 {
13415 #if wxUSE_UNICODE
13416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13417 #else
13418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13419 #endif
13420 }
13421 {
13422 if (temp1)
13423 delete arg1;
13424 }
13425 return resultobj;
13426 fail:
13427 {
13428 if (temp1)
13429 delete arg1;
13430 }
13431 return NULL;
13432 }
13433
13434
13435 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13436 PyObject *obj;
13437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13438 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13439 return SWIG_Py_Void();
13440 }
13441
13442 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13443 return SWIG_Python_InitShadowInstance(args);
13444 }
13445
13446 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13447 PyObject *resultobj = 0;
13448 wxInternetFSHandler *result = 0 ;
13449
13450 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13451 {
13452 PyThreadState* __tstate = wxPyBeginAllowThreads();
13453 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13454 wxPyEndAllowThreads(__tstate);
13455 if (PyErr_Occurred()) SWIG_fail;
13456 }
13457 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13458 return resultobj;
13459 fail:
13460 return NULL;
13461 }
13462
13463
13464 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13465 PyObject *resultobj = 0;
13466 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13467 wxString *arg2 = 0 ;
13468 bool result;
13469 void *argp1 = 0 ;
13470 int res1 = 0 ;
13471 bool temp2 = false ;
13472 PyObject * obj0 = 0 ;
13473 PyObject * obj1 = 0 ;
13474 char * kwnames[] = {
13475 (char *) "self",(char *) "location", NULL
13476 };
13477
13478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13480 if (!SWIG_IsOK(res1)) {
13481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13482 }
13483 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13484 {
13485 arg2 = wxString_in_helper(obj1);
13486 if (arg2 == NULL) SWIG_fail;
13487 temp2 = true;
13488 }
13489 {
13490 PyThreadState* __tstate = wxPyBeginAllowThreads();
13491 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13492 wxPyEndAllowThreads(__tstate);
13493 if (PyErr_Occurred()) SWIG_fail;
13494 }
13495 {
13496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13497 }
13498 {
13499 if (temp2)
13500 delete arg2;
13501 }
13502 return resultobj;
13503 fail:
13504 {
13505 if (temp2)
13506 delete arg2;
13507 }
13508 return NULL;
13509 }
13510
13511
13512 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13513 PyObject *resultobj = 0;
13514 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13515 wxFileSystem *arg2 = 0 ;
13516 wxString *arg3 = 0 ;
13517 wxFSFile *result = 0 ;
13518 void *argp1 = 0 ;
13519 int res1 = 0 ;
13520 void *argp2 = 0 ;
13521 int res2 = 0 ;
13522 bool temp3 = false ;
13523 PyObject * obj0 = 0 ;
13524 PyObject * obj1 = 0 ;
13525 PyObject * obj2 = 0 ;
13526 char * kwnames[] = {
13527 (char *) "self",(char *) "fs",(char *) "location", NULL
13528 };
13529
13530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13532 if (!SWIG_IsOK(res1)) {
13533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13534 }
13535 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13536 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13537 if (!SWIG_IsOK(res2)) {
13538 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13539 }
13540 if (!argp2) {
13541 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13542 }
13543 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13544 {
13545 arg3 = wxString_in_helper(obj2);
13546 if (arg3 == NULL) SWIG_fail;
13547 temp3 = true;
13548 }
13549 {
13550 PyThreadState* __tstate = wxPyBeginAllowThreads();
13551 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13552 wxPyEndAllowThreads(__tstate);
13553 if (PyErr_Occurred()) SWIG_fail;
13554 }
13555 {
13556 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13557 }
13558 {
13559 if (temp3)
13560 delete arg3;
13561 }
13562 return resultobj;
13563 fail:
13564 {
13565 if (temp3)
13566 delete arg3;
13567 }
13568 return NULL;
13569 }
13570
13571
13572 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13573 PyObject *obj;
13574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13575 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13576 return SWIG_Py_Void();
13577 }
13578
13579 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13580 return SWIG_Python_InitShadowInstance(args);
13581 }
13582
13583 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13584 PyObject *resultobj = 0;
13585 wxZipFSHandler *result = 0 ;
13586
13587 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13588 {
13589 PyThreadState* __tstate = wxPyBeginAllowThreads();
13590 result = (wxZipFSHandler *)new wxZipFSHandler();
13591 wxPyEndAllowThreads(__tstate);
13592 if (PyErr_Occurred()) SWIG_fail;
13593 }
13594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13595 return resultobj;
13596 fail:
13597 return NULL;
13598 }
13599
13600
13601 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13602 PyObject *resultobj = 0;
13603 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13604 wxString *arg2 = 0 ;
13605 bool result;
13606 void *argp1 = 0 ;
13607 int res1 = 0 ;
13608 bool temp2 = false ;
13609 PyObject * obj0 = 0 ;
13610 PyObject * obj1 = 0 ;
13611 char * kwnames[] = {
13612 (char *) "self",(char *) "location", NULL
13613 };
13614
13615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13617 if (!SWIG_IsOK(res1)) {
13618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13619 }
13620 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13621 {
13622 arg2 = wxString_in_helper(obj1);
13623 if (arg2 == NULL) SWIG_fail;
13624 temp2 = true;
13625 }
13626 {
13627 PyThreadState* __tstate = wxPyBeginAllowThreads();
13628 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13629 wxPyEndAllowThreads(__tstate);
13630 if (PyErr_Occurred()) SWIG_fail;
13631 }
13632 {
13633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13634 }
13635 {
13636 if (temp2)
13637 delete arg2;
13638 }
13639 return resultobj;
13640 fail:
13641 {
13642 if (temp2)
13643 delete arg2;
13644 }
13645 return NULL;
13646 }
13647
13648
13649 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13650 PyObject *resultobj = 0;
13651 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13652 wxFileSystem *arg2 = 0 ;
13653 wxString *arg3 = 0 ;
13654 wxFSFile *result = 0 ;
13655 void *argp1 = 0 ;
13656 int res1 = 0 ;
13657 void *argp2 = 0 ;
13658 int res2 = 0 ;
13659 bool temp3 = false ;
13660 PyObject * obj0 = 0 ;
13661 PyObject * obj1 = 0 ;
13662 PyObject * obj2 = 0 ;
13663 char * kwnames[] = {
13664 (char *) "self",(char *) "fs",(char *) "location", NULL
13665 };
13666
13667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13668 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13669 if (!SWIG_IsOK(res1)) {
13670 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13671 }
13672 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13673 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13674 if (!SWIG_IsOK(res2)) {
13675 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13676 }
13677 if (!argp2) {
13678 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13679 }
13680 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13681 {
13682 arg3 = wxString_in_helper(obj2);
13683 if (arg3 == NULL) SWIG_fail;
13684 temp3 = true;
13685 }
13686 {
13687 PyThreadState* __tstate = wxPyBeginAllowThreads();
13688 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13689 wxPyEndAllowThreads(__tstate);
13690 if (PyErr_Occurred()) SWIG_fail;
13691 }
13692 {
13693 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13694 }
13695 {
13696 if (temp3)
13697 delete arg3;
13698 }
13699 return resultobj;
13700 fail:
13701 {
13702 if (temp3)
13703 delete arg3;
13704 }
13705 return NULL;
13706 }
13707
13708
13709 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13710 PyObject *resultobj = 0;
13711 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13712 wxString *arg2 = 0 ;
13713 int arg3 = (int) 0 ;
13714 wxString result;
13715 void *argp1 = 0 ;
13716 int res1 = 0 ;
13717 bool temp2 = false ;
13718 int val3 ;
13719 int ecode3 = 0 ;
13720 PyObject * obj0 = 0 ;
13721 PyObject * obj1 = 0 ;
13722 PyObject * obj2 = 0 ;
13723 char * kwnames[] = {
13724 (char *) "self",(char *) "spec",(char *) "flags", NULL
13725 };
13726
13727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13729 if (!SWIG_IsOK(res1)) {
13730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13731 }
13732 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13733 {
13734 arg2 = wxString_in_helper(obj1);
13735 if (arg2 == NULL) SWIG_fail;
13736 temp2 = true;
13737 }
13738 if (obj2) {
13739 ecode3 = SWIG_AsVal_int(obj2, &val3);
13740 if (!SWIG_IsOK(ecode3)) {
13741 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13742 }
13743 arg3 = static_cast< int >(val3);
13744 }
13745 {
13746 PyThreadState* __tstate = wxPyBeginAllowThreads();
13747 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13748 wxPyEndAllowThreads(__tstate);
13749 if (PyErr_Occurred()) SWIG_fail;
13750 }
13751 {
13752 #if wxUSE_UNICODE
13753 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13754 #else
13755 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13756 #endif
13757 }
13758 {
13759 if (temp2)
13760 delete arg2;
13761 }
13762 return resultobj;
13763 fail:
13764 {
13765 if (temp2)
13766 delete arg2;
13767 }
13768 return NULL;
13769 }
13770
13771
13772 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13773 PyObject *resultobj = 0;
13774 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13775 wxString result;
13776 void *argp1 = 0 ;
13777 int res1 = 0 ;
13778 PyObject *swig_obj[1] ;
13779
13780 if (!args) SWIG_fail;
13781 swig_obj[0] = args;
13782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13783 if (!SWIG_IsOK(res1)) {
13784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13785 }
13786 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13787 {
13788 PyThreadState* __tstate = wxPyBeginAllowThreads();
13789 result = (arg1)->FindNext();
13790 wxPyEndAllowThreads(__tstate);
13791 if (PyErr_Occurred()) SWIG_fail;
13792 }
13793 {
13794 #if wxUSE_UNICODE
13795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13796 #else
13797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13798 #endif
13799 }
13800 return resultobj;
13801 fail:
13802 return NULL;
13803 }
13804
13805
13806 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13807 PyObject *obj;
13808 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13809 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13810 return SWIG_Py_Void();
13811 }
13812
13813 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13814 return SWIG_Python_InitShadowInstance(args);
13815 }
13816
13817 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13818 PyObject *resultobj = 0;
13819 wxString *arg1 = 0 ;
13820 wxImage *arg2 = 0 ;
13821 long arg3 ;
13822 bool temp1 = false ;
13823 void *argp2 = 0 ;
13824 int res2 = 0 ;
13825 long val3 ;
13826 int ecode3 = 0 ;
13827 PyObject * obj0 = 0 ;
13828 PyObject * obj1 = 0 ;
13829 PyObject * obj2 = 0 ;
13830 char * kwnames[] = {
13831 (char *) "filename",(char *) "image",(char *) "type", NULL
13832 };
13833
13834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13835 {
13836 arg1 = wxString_in_helper(obj0);
13837 if (arg1 == NULL) SWIG_fail;
13838 temp1 = true;
13839 }
13840 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13841 if (!SWIG_IsOK(res2)) {
13842 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13843 }
13844 if (!argp2) {
13845 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13846 }
13847 arg2 = reinterpret_cast< wxImage * >(argp2);
13848 ecode3 = SWIG_AsVal_long(obj2, &val3);
13849 if (!SWIG_IsOK(ecode3)) {
13850 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13851 }
13852 arg3 = static_cast< long >(val3);
13853 {
13854 PyThreadState* __tstate = wxPyBeginAllowThreads();
13855 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13856 wxPyEndAllowThreads(__tstate);
13857 if (PyErr_Occurred()) SWIG_fail;
13858 }
13859 resultobj = SWIG_Py_Void();
13860 {
13861 if (temp1)
13862 delete arg1;
13863 }
13864 return resultobj;
13865 fail:
13866 {
13867 if (temp1)
13868 delete arg1;
13869 }
13870 return NULL;
13871 }
13872
13873
13874 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13875 PyObject *resultobj = 0;
13876 wxString *arg1 = 0 ;
13877 wxBitmap *arg2 = 0 ;
13878 long arg3 ;
13879 bool temp1 = false ;
13880 void *argp2 = 0 ;
13881 int res2 = 0 ;
13882 long val3 ;
13883 int ecode3 = 0 ;
13884 PyObject * obj0 = 0 ;
13885 PyObject * obj1 = 0 ;
13886 PyObject * obj2 = 0 ;
13887 char * kwnames[] = {
13888 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13889 };
13890
13891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13892 {
13893 arg1 = wxString_in_helper(obj0);
13894 if (arg1 == NULL) SWIG_fail;
13895 temp1 = true;
13896 }
13897 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13898 if (!SWIG_IsOK(res2)) {
13899 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13900 }
13901 if (!argp2) {
13902 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13903 }
13904 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13905 ecode3 = SWIG_AsVal_long(obj2, &val3);
13906 if (!SWIG_IsOK(ecode3)) {
13907 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13908 }
13909 arg3 = static_cast< long >(val3);
13910 {
13911 PyThreadState* __tstate = wxPyBeginAllowThreads();
13912 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13913 wxPyEndAllowThreads(__tstate);
13914 if (PyErr_Occurred()) SWIG_fail;
13915 }
13916 resultobj = SWIG_Py_Void();
13917 {
13918 if (temp1)
13919 delete arg1;
13920 }
13921 return resultobj;
13922 fail:
13923 {
13924 if (temp1)
13925 delete arg1;
13926 }
13927 return NULL;
13928 }
13929
13930
13931 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13932 PyObject *resultobj = 0;
13933 wxString *arg1 = 0 ;
13934 PyObject *arg2 = (PyObject *) 0 ;
13935 bool temp1 = false ;
13936 PyObject * obj0 = 0 ;
13937 PyObject * obj1 = 0 ;
13938 char * kwnames[] = {
13939 (char *) "filename",(char *) "data", NULL
13940 };
13941
13942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13943 {
13944 arg1 = wxString_in_helper(obj0);
13945 if (arg1 == NULL) SWIG_fail;
13946 temp1 = true;
13947 }
13948 arg2 = obj1;
13949 {
13950 PyThreadState* __tstate = wxPyBeginAllowThreads();
13951 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13952 wxPyEndAllowThreads(__tstate);
13953 if (PyErr_Occurred()) SWIG_fail;
13954 }
13955 resultobj = SWIG_Py_Void();
13956 {
13957 if (temp1)
13958 delete arg1;
13959 }
13960 return resultobj;
13961 fail:
13962 {
13963 if (temp1)
13964 delete arg1;
13965 }
13966 return NULL;
13967 }
13968
13969
13970 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13971 PyObject *resultobj = 0;
13972 wxMemoryFSHandler *result = 0 ;
13973
13974 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13975 {
13976 PyThreadState* __tstate = wxPyBeginAllowThreads();
13977 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13978 wxPyEndAllowThreads(__tstate);
13979 if (PyErr_Occurred()) SWIG_fail;
13980 }
13981 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13982 return resultobj;
13983 fail:
13984 return NULL;
13985 }
13986
13987
13988 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13989 PyObject *resultobj = 0;
13990 wxString *arg1 = 0 ;
13991 bool temp1 = false ;
13992 PyObject * obj0 = 0 ;
13993 char * kwnames[] = {
13994 (char *) "filename", NULL
13995 };
13996
13997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
13998 {
13999 arg1 = wxString_in_helper(obj0);
14000 if (arg1 == NULL) SWIG_fail;
14001 temp1 = true;
14002 }
14003 {
14004 PyThreadState* __tstate = wxPyBeginAllowThreads();
14005 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14006 wxPyEndAllowThreads(__tstate);
14007 if (PyErr_Occurred()) SWIG_fail;
14008 }
14009 resultobj = SWIG_Py_Void();
14010 {
14011 if (temp1)
14012 delete arg1;
14013 }
14014 return resultobj;
14015 fail:
14016 {
14017 if (temp1)
14018 delete arg1;
14019 }
14020 return NULL;
14021 }
14022
14023
14024 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14025 PyObject *resultobj = 0;
14026 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14027 wxString *arg2 = 0 ;
14028 bool result;
14029 void *argp1 = 0 ;
14030 int res1 = 0 ;
14031 bool temp2 = false ;
14032 PyObject * obj0 = 0 ;
14033 PyObject * obj1 = 0 ;
14034 char * kwnames[] = {
14035 (char *) "self",(char *) "location", NULL
14036 };
14037
14038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14040 if (!SWIG_IsOK(res1)) {
14041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14042 }
14043 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14044 {
14045 arg2 = wxString_in_helper(obj1);
14046 if (arg2 == NULL) SWIG_fail;
14047 temp2 = true;
14048 }
14049 {
14050 PyThreadState* __tstate = wxPyBeginAllowThreads();
14051 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14052 wxPyEndAllowThreads(__tstate);
14053 if (PyErr_Occurred()) SWIG_fail;
14054 }
14055 {
14056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14057 }
14058 {
14059 if (temp2)
14060 delete arg2;
14061 }
14062 return resultobj;
14063 fail:
14064 {
14065 if (temp2)
14066 delete arg2;
14067 }
14068 return NULL;
14069 }
14070
14071
14072 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14073 PyObject *resultobj = 0;
14074 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14075 wxFileSystem *arg2 = 0 ;
14076 wxString *arg3 = 0 ;
14077 wxFSFile *result = 0 ;
14078 void *argp1 = 0 ;
14079 int res1 = 0 ;
14080 void *argp2 = 0 ;
14081 int res2 = 0 ;
14082 bool temp3 = false ;
14083 PyObject * obj0 = 0 ;
14084 PyObject * obj1 = 0 ;
14085 PyObject * obj2 = 0 ;
14086 char * kwnames[] = {
14087 (char *) "self",(char *) "fs",(char *) "location", NULL
14088 };
14089
14090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14092 if (!SWIG_IsOK(res1)) {
14093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14094 }
14095 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14096 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14097 if (!SWIG_IsOK(res2)) {
14098 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14099 }
14100 if (!argp2) {
14101 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14102 }
14103 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14104 {
14105 arg3 = wxString_in_helper(obj2);
14106 if (arg3 == NULL) SWIG_fail;
14107 temp3 = true;
14108 }
14109 {
14110 PyThreadState* __tstate = wxPyBeginAllowThreads();
14111 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14112 wxPyEndAllowThreads(__tstate);
14113 if (PyErr_Occurred()) SWIG_fail;
14114 }
14115 {
14116 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14117 }
14118 {
14119 if (temp3)
14120 delete arg3;
14121 }
14122 return resultobj;
14123 fail:
14124 {
14125 if (temp3)
14126 delete arg3;
14127 }
14128 return NULL;
14129 }
14130
14131
14132 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14133 PyObject *resultobj = 0;
14134 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14135 wxString *arg2 = 0 ;
14136 int arg3 = (int) 0 ;
14137 wxString result;
14138 void *argp1 = 0 ;
14139 int res1 = 0 ;
14140 bool temp2 = false ;
14141 int val3 ;
14142 int ecode3 = 0 ;
14143 PyObject * obj0 = 0 ;
14144 PyObject * obj1 = 0 ;
14145 PyObject * obj2 = 0 ;
14146 char * kwnames[] = {
14147 (char *) "self",(char *) "spec",(char *) "flags", NULL
14148 };
14149
14150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14152 if (!SWIG_IsOK(res1)) {
14153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14154 }
14155 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14156 {
14157 arg2 = wxString_in_helper(obj1);
14158 if (arg2 == NULL) SWIG_fail;
14159 temp2 = true;
14160 }
14161 if (obj2) {
14162 ecode3 = SWIG_AsVal_int(obj2, &val3);
14163 if (!SWIG_IsOK(ecode3)) {
14164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14165 }
14166 arg3 = static_cast< int >(val3);
14167 }
14168 {
14169 PyThreadState* __tstate = wxPyBeginAllowThreads();
14170 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14171 wxPyEndAllowThreads(__tstate);
14172 if (PyErr_Occurred()) SWIG_fail;
14173 }
14174 {
14175 #if wxUSE_UNICODE
14176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14177 #else
14178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14179 #endif
14180 }
14181 {
14182 if (temp2)
14183 delete arg2;
14184 }
14185 return resultobj;
14186 fail:
14187 {
14188 if (temp2)
14189 delete arg2;
14190 }
14191 return NULL;
14192 }
14193
14194
14195 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14196 PyObject *resultobj = 0;
14197 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14198 wxString result;
14199 void *argp1 = 0 ;
14200 int res1 = 0 ;
14201 PyObject *swig_obj[1] ;
14202
14203 if (!args) SWIG_fail;
14204 swig_obj[0] = args;
14205 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14206 if (!SWIG_IsOK(res1)) {
14207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14208 }
14209 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14210 {
14211 PyThreadState* __tstate = wxPyBeginAllowThreads();
14212 result = (arg1)->FindNext();
14213 wxPyEndAllowThreads(__tstate);
14214 if (PyErr_Occurred()) SWIG_fail;
14215 }
14216 {
14217 #if wxUSE_UNICODE
14218 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14219 #else
14220 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14221 #endif
14222 }
14223 return resultobj;
14224 fail:
14225 return NULL;
14226 }
14227
14228
14229 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14230 PyObject *obj;
14231 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14232 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14233 return SWIG_Py_Void();
14234 }
14235
14236 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14237 return SWIG_Python_InitShadowInstance(args);
14238 }
14239
14240 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14241 PyObject *resultobj = 0;
14242 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14243 wxString result;
14244 void *argp1 = 0 ;
14245 int res1 = 0 ;
14246 PyObject *swig_obj[1] ;
14247
14248 if (!args) SWIG_fail;
14249 swig_obj[0] = args;
14250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14251 if (!SWIG_IsOK(res1)) {
14252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14253 }
14254 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14255 {
14256 PyThreadState* __tstate = wxPyBeginAllowThreads();
14257 result = (arg1)->GetName();
14258 wxPyEndAllowThreads(__tstate);
14259 if (PyErr_Occurred()) SWIG_fail;
14260 }
14261 {
14262 #if wxUSE_UNICODE
14263 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14264 #else
14265 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14266 #endif
14267 }
14268 return resultobj;
14269 fail:
14270 return NULL;
14271 }
14272
14273
14274 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14275 PyObject *resultobj = 0;
14276 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14277 wxString result;
14278 void *argp1 = 0 ;
14279 int res1 = 0 ;
14280 PyObject *swig_obj[1] ;
14281
14282 if (!args) SWIG_fail;
14283 swig_obj[0] = args;
14284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14285 if (!SWIG_IsOK(res1)) {
14286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14287 }
14288 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14289 {
14290 PyThreadState* __tstate = wxPyBeginAllowThreads();
14291 result = (arg1)->GetExtension();
14292 wxPyEndAllowThreads(__tstate);
14293 if (PyErr_Occurred()) SWIG_fail;
14294 }
14295 {
14296 #if wxUSE_UNICODE
14297 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14298 #else
14299 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14300 #endif
14301 }
14302 return resultobj;
14303 fail:
14304 return NULL;
14305 }
14306
14307
14308 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14309 PyObject *resultobj = 0;
14310 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14311 long result;
14312 void *argp1 = 0 ;
14313 int res1 = 0 ;
14314 PyObject *swig_obj[1] ;
14315
14316 if (!args) SWIG_fail;
14317 swig_obj[0] = args;
14318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14319 if (!SWIG_IsOK(res1)) {
14320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14321 }
14322 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14323 {
14324 PyThreadState* __tstate = wxPyBeginAllowThreads();
14325 result = (long)(arg1)->GetType();
14326 wxPyEndAllowThreads(__tstate);
14327 if (PyErr_Occurred()) SWIG_fail;
14328 }
14329 resultobj = SWIG_From_long(static_cast< long >(result));
14330 return resultobj;
14331 fail:
14332 return NULL;
14333 }
14334
14335
14336 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14337 PyObject *resultobj = 0;
14338 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14339 wxString result;
14340 void *argp1 = 0 ;
14341 int res1 = 0 ;
14342 PyObject *swig_obj[1] ;
14343
14344 if (!args) SWIG_fail;
14345 swig_obj[0] = args;
14346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14347 if (!SWIG_IsOK(res1)) {
14348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14349 }
14350 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14351 {
14352 PyThreadState* __tstate = wxPyBeginAllowThreads();
14353 result = (arg1)->GetMimeType();
14354 wxPyEndAllowThreads(__tstate);
14355 if (PyErr_Occurred()) SWIG_fail;
14356 }
14357 {
14358 #if wxUSE_UNICODE
14359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14360 #else
14361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14362 #endif
14363 }
14364 return resultobj;
14365 fail:
14366 return NULL;
14367 }
14368
14369
14370 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14371 PyObject *resultobj = 0;
14372 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14373 wxString *arg2 = 0 ;
14374 bool result;
14375 void *argp1 = 0 ;
14376 int res1 = 0 ;
14377 bool temp2 = false ;
14378 PyObject * obj0 = 0 ;
14379 PyObject * obj1 = 0 ;
14380 char * kwnames[] = {
14381 (char *) "self",(char *) "name", NULL
14382 };
14383
14384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14386 if (!SWIG_IsOK(res1)) {
14387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14388 }
14389 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14390 {
14391 arg2 = wxString_in_helper(obj1);
14392 if (arg2 == NULL) SWIG_fail;
14393 temp2 = true;
14394 }
14395 {
14396 PyThreadState* __tstate = wxPyBeginAllowThreads();
14397 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14398 wxPyEndAllowThreads(__tstate);
14399 if (PyErr_Occurred()) SWIG_fail;
14400 }
14401 {
14402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14403 }
14404 {
14405 if (temp2)
14406 delete arg2;
14407 }
14408 return resultobj;
14409 fail:
14410 {
14411 if (temp2)
14412 delete arg2;
14413 }
14414 return NULL;
14415 }
14416
14417
14418 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14419 PyObject *resultobj = 0;
14420 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14421 wxInputStream *arg2 = 0 ;
14422 bool result;
14423 void *argp1 = 0 ;
14424 int res1 = 0 ;
14425 wxPyInputStream *temp2 ;
14426 bool created2 ;
14427 PyObject * obj0 = 0 ;
14428 PyObject * obj1 = 0 ;
14429 char * kwnames[] = {
14430 (char *) "self",(char *) "stream", NULL
14431 };
14432
14433 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14434 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14435 if (!SWIG_IsOK(res1)) {
14436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14437 }
14438 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14439 {
14440 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14441 arg2 = temp2->m_wxis;
14442 created2 = false;
14443 } else {
14444 PyErr_Clear(); // clear the failure of the wxPyConvert above
14445 arg2 = wxPyCBInputStream_create(obj1, false);
14446 if (arg2 == NULL) {
14447 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14448 SWIG_fail;
14449 }
14450 created2 = true;
14451 }
14452 }
14453 {
14454 PyThreadState* __tstate = wxPyBeginAllowThreads();
14455 result = (bool)(arg1)->CanRead(*arg2);
14456 wxPyEndAllowThreads(__tstate);
14457 if (PyErr_Occurred()) SWIG_fail;
14458 }
14459 {
14460 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14461 }
14462 {
14463 if (created2) delete arg2;
14464 }
14465 return resultobj;
14466 fail:
14467 {
14468 if (created2) delete arg2;
14469 }
14470 return NULL;
14471 }
14472
14473
14474 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14475 PyObject *resultobj = 0;
14476 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14477 wxString *arg2 = 0 ;
14478 void *argp1 = 0 ;
14479 int res1 = 0 ;
14480 bool temp2 = false ;
14481 PyObject * obj0 = 0 ;
14482 PyObject * obj1 = 0 ;
14483 char * kwnames[] = {
14484 (char *) "self",(char *) "name", NULL
14485 };
14486
14487 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14488 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14489 if (!SWIG_IsOK(res1)) {
14490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14491 }
14492 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14493 {
14494 arg2 = wxString_in_helper(obj1);
14495 if (arg2 == NULL) SWIG_fail;
14496 temp2 = true;
14497 }
14498 {
14499 PyThreadState* __tstate = wxPyBeginAllowThreads();
14500 (arg1)->SetName((wxString const &)*arg2);
14501 wxPyEndAllowThreads(__tstate);
14502 if (PyErr_Occurred()) SWIG_fail;
14503 }
14504 resultobj = SWIG_Py_Void();
14505 {
14506 if (temp2)
14507 delete arg2;
14508 }
14509 return resultobj;
14510 fail:
14511 {
14512 if (temp2)
14513 delete arg2;
14514 }
14515 return NULL;
14516 }
14517
14518
14519 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14520 PyObject *resultobj = 0;
14521 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14522 wxString *arg2 = 0 ;
14523 void *argp1 = 0 ;
14524 int res1 = 0 ;
14525 bool temp2 = false ;
14526 PyObject * obj0 = 0 ;
14527 PyObject * obj1 = 0 ;
14528 char * kwnames[] = {
14529 (char *) "self",(char *) "extension", NULL
14530 };
14531
14532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14534 if (!SWIG_IsOK(res1)) {
14535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14536 }
14537 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14538 {
14539 arg2 = wxString_in_helper(obj1);
14540 if (arg2 == NULL) SWIG_fail;
14541 temp2 = true;
14542 }
14543 {
14544 PyThreadState* __tstate = wxPyBeginAllowThreads();
14545 (arg1)->SetExtension((wxString const &)*arg2);
14546 wxPyEndAllowThreads(__tstate);
14547 if (PyErr_Occurred()) SWIG_fail;
14548 }
14549 resultobj = SWIG_Py_Void();
14550 {
14551 if (temp2)
14552 delete arg2;
14553 }
14554 return resultobj;
14555 fail:
14556 {
14557 if (temp2)
14558 delete arg2;
14559 }
14560 return NULL;
14561 }
14562
14563
14564 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14565 PyObject *resultobj = 0;
14566 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14567 long arg2 ;
14568 void *argp1 = 0 ;
14569 int res1 = 0 ;
14570 long val2 ;
14571 int ecode2 = 0 ;
14572 PyObject * obj0 = 0 ;
14573 PyObject * obj1 = 0 ;
14574 char * kwnames[] = {
14575 (char *) "self",(char *) "type", NULL
14576 };
14577
14578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14580 if (!SWIG_IsOK(res1)) {
14581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14582 }
14583 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14584 ecode2 = SWIG_AsVal_long(obj1, &val2);
14585 if (!SWIG_IsOK(ecode2)) {
14586 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14587 }
14588 arg2 = static_cast< long >(val2);
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 (arg1)->SetType(arg2);
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = SWIG_Py_Void();
14596 return resultobj;
14597 fail:
14598 return NULL;
14599 }
14600
14601
14602 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14603 PyObject *resultobj = 0;
14604 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14605 wxString *arg2 = 0 ;
14606 void *argp1 = 0 ;
14607 int res1 = 0 ;
14608 bool temp2 = false ;
14609 PyObject * obj0 = 0 ;
14610 PyObject * obj1 = 0 ;
14611 char * kwnames[] = {
14612 (char *) "self",(char *) "mimetype", NULL
14613 };
14614
14615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14617 if (!SWIG_IsOK(res1)) {
14618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14619 }
14620 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14621 {
14622 arg2 = wxString_in_helper(obj1);
14623 if (arg2 == NULL) SWIG_fail;
14624 temp2 = true;
14625 }
14626 {
14627 PyThreadState* __tstate = wxPyBeginAllowThreads();
14628 (arg1)->SetMimeType((wxString const &)*arg2);
14629 wxPyEndAllowThreads(__tstate);
14630 if (PyErr_Occurred()) SWIG_fail;
14631 }
14632 resultobj = SWIG_Py_Void();
14633 {
14634 if (temp2)
14635 delete arg2;
14636 }
14637 return resultobj;
14638 fail:
14639 {
14640 if (temp2)
14641 delete arg2;
14642 }
14643 return NULL;
14644 }
14645
14646
14647 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14648 PyObject *obj;
14649 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14650 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14651 return SWIG_Py_Void();
14652 }
14653
14654 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14655 PyObject *resultobj = 0;
14656 wxPyImageHandler *result = 0 ;
14657
14658 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14659 {
14660 PyThreadState* __tstate = wxPyBeginAllowThreads();
14661 result = (wxPyImageHandler *)new wxPyImageHandler();
14662 wxPyEndAllowThreads(__tstate);
14663 if (PyErr_Occurred()) SWIG_fail;
14664 }
14665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14666 return resultobj;
14667 fail:
14668 return NULL;
14669 }
14670
14671
14672 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14673 PyObject *resultobj = 0;
14674 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14675 PyObject *arg2 = (PyObject *) 0 ;
14676 void *argp1 = 0 ;
14677 int res1 = 0 ;
14678 PyObject * obj0 = 0 ;
14679 PyObject * obj1 = 0 ;
14680 char * kwnames[] = {
14681 (char *) "self",(char *) "self", NULL
14682 };
14683
14684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14686 if (!SWIG_IsOK(res1)) {
14687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14688 }
14689 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14690 arg2 = obj1;
14691 {
14692 PyThreadState* __tstate = wxPyBeginAllowThreads();
14693 (arg1)->_SetSelf(arg2);
14694 wxPyEndAllowThreads(__tstate);
14695 if (PyErr_Occurred()) SWIG_fail;
14696 }
14697 resultobj = SWIG_Py_Void();
14698 return resultobj;
14699 fail:
14700 return NULL;
14701 }
14702
14703
14704 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14705 PyObject *obj;
14706 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14707 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14708 return SWIG_Py_Void();
14709 }
14710
14711 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14712 return SWIG_Python_InitShadowInstance(args);
14713 }
14714
14715 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14716 PyObject *resultobj = 0;
14717 wxImageHistogram *result = 0 ;
14718
14719 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14720 {
14721 PyThreadState* __tstate = wxPyBeginAllowThreads();
14722 result = (wxImageHistogram *)new wxImageHistogram();
14723 wxPyEndAllowThreads(__tstate);
14724 if (PyErr_Occurred()) SWIG_fail;
14725 }
14726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14727 return resultobj;
14728 fail:
14729 return NULL;
14730 }
14731
14732
14733 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14734 PyObject *resultobj = 0;
14735 byte arg1 ;
14736 byte arg2 ;
14737 byte arg3 ;
14738 unsigned long result;
14739 unsigned char val1 ;
14740 int ecode1 = 0 ;
14741 unsigned char val2 ;
14742 int ecode2 = 0 ;
14743 unsigned char val3 ;
14744 int ecode3 = 0 ;
14745 PyObject * obj0 = 0 ;
14746 PyObject * obj1 = 0 ;
14747 PyObject * obj2 = 0 ;
14748 char * kwnames[] = {
14749 (char *) "r",(char *) "g",(char *) "b", NULL
14750 };
14751
14752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14753 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14754 if (!SWIG_IsOK(ecode1)) {
14755 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14756 }
14757 arg1 = static_cast< byte >(val1);
14758 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14759 if (!SWIG_IsOK(ecode2)) {
14760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14761 }
14762 arg2 = static_cast< byte >(val2);
14763 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14764 if (!SWIG_IsOK(ecode3)) {
14765 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14766 }
14767 arg3 = static_cast< byte >(val3);
14768 {
14769 PyThreadState* __tstate = wxPyBeginAllowThreads();
14770 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14771 wxPyEndAllowThreads(__tstate);
14772 if (PyErr_Occurred()) SWIG_fail;
14773 }
14774 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14775 return resultobj;
14776 fail:
14777 return NULL;
14778 }
14779
14780
14781 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14782 PyObject *resultobj = 0;
14783 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14784 byte *arg2 = (byte *) 0 ;
14785 byte *arg3 = (byte *) 0 ;
14786 byte *arg4 = (byte *) 0 ;
14787 byte arg5 = (byte) 1 ;
14788 byte arg6 = (byte) 0 ;
14789 byte arg7 = (byte) 0 ;
14790 bool result;
14791 void *argp1 = 0 ;
14792 int res1 = 0 ;
14793 byte temp2 ;
14794 int res2 = SWIG_TMPOBJ ;
14795 byte temp3 ;
14796 int res3 = SWIG_TMPOBJ ;
14797 byte temp4 ;
14798 int res4 = SWIG_TMPOBJ ;
14799 unsigned char val5 ;
14800 int ecode5 = 0 ;
14801 unsigned char val6 ;
14802 int ecode6 = 0 ;
14803 unsigned char val7 ;
14804 int ecode7 = 0 ;
14805 PyObject * obj0 = 0 ;
14806 PyObject * obj1 = 0 ;
14807 PyObject * obj2 = 0 ;
14808 PyObject * obj3 = 0 ;
14809 char * kwnames[] = {
14810 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14811 };
14812
14813 arg2 = &temp2;
14814 arg3 = &temp3;
14815 arg4 = &temp4;
14816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14818 if (!SWIG_IsOK(res1)) {
14819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14820 }
14821 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14822 if (obj1) {
14823 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14824 if (!SWIG_IsOK(ecode5)) {
14825 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14826 }
14827 arg5 = static_cast< byte >(val5);
14828 }
14829 if (obj2) {
14830 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14831 if (!SWIG_IsOK(ecode6)) {
14832 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14833 }
14834 arg6 = static_cast< byte >(val6);
14835 }
14836 if (obj3) {
14837 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14838 if (!SWIG_IsOK(ecode7)) {
14839 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14840 }
14841 arg7 = static_cast< byte >(val7);
14842 }
14843 {
14844 PyThreadState* __tstate = wxPyBeginAllowThreads();
14845 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14846 wxPyEndAllowThreads(__tstate);
14847 if (PyErr_Occurred()) SWIG_fail;
14848 }
14849 {
14850 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14851 }
14852 if (SWIG_IsTmpObj(res2)) {
14853 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14854 } else {
14855 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14856 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14857 }
14858 if (SWIG_IsTmpObj(res3)) {
14859 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14860 } else {
14861 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14863 }
14864 if (SWIG_IsTmpObj(res4)) {
14865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14866 } else {
14867 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14869 }
14870 return resultobj;
14871 fail:
14872 return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj = 0;
14878 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14879 unsigned long arg2 ;
14880 unsigned long result;
14881 void *argp1 = 0 ;
14882 int res1 = 0 ;
14883 unsigned long val2 ;
14884 int ecode2 = 0 ;
14885 PyObject * obj0 = 0 ;
14886 PyObject * obj1 = 0 ;
14887 char * kwnames[] = {
14888 (char *) "self",(char *) "key", NULL
14889 };
14890
14891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14893 if (!SWIG_IsOK(res1)) {
14894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14895 }
14896 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14897 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14898 if (!SWIG_IsOK(ecode2)) {
14899 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14900 }
14901 arg2 = static_cast< unsigned long >(val2);
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14905 wxPyEndAllowThreads(__tstate);
14906 if (PyErr_Occurred()) SWIG_fail;
14907 }
14908 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14909 return resultobj;
14910 fail:
14911 return NULL;
14912 }
14913
14914
14915 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14916 PyObject *resultobj = 0;
14917 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14918 byte arg2 ;
14919 byte arg3 ;
14920 byte arg4 ;
14921 unsigned long result;
14922 void *argp1 = 0 ;
14923 int res1 = 0 ;
14924 unsigned char val2 ;
14925 int ecode2 = 0 ;
14926 unsigned char val3 ;
14927 int ecode3 = 0 ;
14928 unsigned char val4 ;
14929 int ecode4 = 0 ;
14930 PyObject * obj0 = 0 ;
14931 PyObject * obj1 = 0 ;
14932 PyObject * obj2 = 0 ;
14933 PyObject * obj3 = 0 ;
14934 char * kwnames[] = {
14935 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14936 };
14937
14938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14940 if (!SWIG_IsOK(res1)) {
14941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14942 }
14943 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14944 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14945 if (!SWIG_IsOK(ecode2)) {
14946 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14947 }
14948 arg2 = static_cast< byte >(val2);
14949 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14950 if (!SWIG_IsOK(ecode3)) {
14951 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14952 }
14953 arg3 = static_cast< byte >(val3);
14954 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14955 if (!SWIG_IsOK(ecode4)) {
14956 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14957 }
14958 arg4 = static_cast< byte >(val4);
14959 {
14960 PyThreadState* __tstate = wxPyBeginAllowThreads();
14961 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14962 wxPyEndAllowThreads(__tstate);
14963 if (PyErr_Occurred()) SWIG_fail;
14964 }
14965 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14966 return resultobj;
14967 fail:
14968 return NULL;
14969 }
14970
14971
14972 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14973 PyObject *resultobj = 0;
14974 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14975 wxColour *arg2 = 0 ;
14976 unsigned long result;
14977 void *argp1 = 0 ;
14978 int res1 = 0 ;
14979 wxColour temp2 ;
14980 PyObject * obj0 = 0 ;
14981 PyObject * obj1 = 0 ;
14982 char * kwnames[] = {
14983 (char *) "self",(char *) "colour", NULL
14984 };
14985
14986 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
14987 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14988 if (!SWIG_IsOK(res1)) {
14989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14990 }
14991 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14992 {
14993 arg2 = &temp2;
14994 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
14995 }
14996 {
14997 PyThreadState* __tstate = wxPyBeginAllowThreads();
14998 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
14999 wxPyEndAllowThreads(__tstate);
15000 if (PyErr_Occurred()) SWIG_fail;
15001 }
15002 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15003 return resultobj;
15004 fail:
15005 return NULL;
15006 }
15007
15008
15009 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15010 PyObject *obj;
15011 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15012 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15013 return SWIG_Py_Void();
15014 }
15015
15016 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15017 return SWIG_Python_InitShadowInstance(args);
15018 }
15019
15020 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15021 PyObject *resultobj = 0;
15022 byte arg1 = (byte) 0 ;
15023 byte arg2 = (byte) 0 ;
15024 byte arg3 = (byte) 0 ;
15025 wxImage_RGBValue *result = 0 ;
15026 unsigned char val1 ;
15027 int ecode1 = 0 ;
15028 unsigned char val2 ;
15029 int ecode2 = 0 ;
15030 unsigned char val3 ;
15031 int ecode3 = 0 ;
15032 PyObject * obj0 = 0 ;
15033 PyObject * obj1 = 0 ;
15034 PyObject * obj2 = 0 ;
15035 char * kwnames[] = {
15036 (char *) "r",(char *) "g",(char *) "b", NULL
15037 };
15038
15039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15040 if (obj0) {
15041 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15042 if (!SWIG_IsOK(ecode1)) {
15043 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15044 }
15045 arg1 = static_cast< byte >(val1);
15046 }
15047 if (obj1) {
15048 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15049 if (!SWIG_IsOK(ecode2)) {
15050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15051 }
15052 arg2 = static_cast< byte >(val2);
15053 }
15054 if (obj2) {
15055 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15056 if (!SWIG_IsOK(ecode3)) {
15057 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15058 }
15059 arg3 = static_cast< byte >(val3);
15060 }
15061 {
15062 PyThreadState* __tstate = wxPyBeginAllowThreads();
15063 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15064 wxPyEndAllowThreads(__tstate);
15065 if (PyErr_Occurred()) SWIG_fail;
15066 }
15067 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15068 return resultobj;
15069 fail:
15070 return NULL;
15071 }
15072
15073
15074 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15075 PyObject *resultobj = 0;
15076 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15077 byte arg2 ;
15078 void *argp1 = 0 ;
15079 int res1 = 0 ;
15080 unsigned char val2 ;
15081 int ecode2 = 0 ;
15082 PyObject *swig_obj[2] ;
15083
15084 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15085 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15086 if (!SWIG_IsOK(res1)) {
15087 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15088 }
15089 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15090 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15091 if (!SWIG_IsOK(ecode2)) {
15092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15093 }
15094 arg2 = static_cast< byte >(val2);
15095 if (arg1) (arg1)->red = arg2;
15096
15097 resultobj = SWIG_Py_Void();
15098 return resultobj;
15099 fail:
15100 return NULL;
15101 }
15102
15103
15104 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15105 PyObject *resultobj = 0;
15106 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15107 byte result;
15108 void *argp1 = 0 ;
15109 int res1 = 0 ;
15110 PyObject *swig_obj[1] ;
15111
15112 if (!args) SWIG_fail;
15113 swig_obj[0] = args;
15114 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15115 if (!SWIG_IsOK(res1)) {
15116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15117 }
15118 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15119 result = (byte) ((arg1)->red);
15120 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15121 return resultobj;
15122 fail:
15123 return NULL;
15124 }
15125
15126
15127 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15128 PyObject *resultobj = 0;
15129 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15130 byte arg2 ;
15131 void *argp1 = 0 ;
15132 int res1 = 0 ;
15133 unsigned char val2 ;
15134 int ecode2 = 0 ;
15135 PyObject *swig_obj[2] ;
15136
15137 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15139 if (!SWIG_IsOK(res1)) {
15140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15141 }
15142 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15143 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15144 if (!SWIG_IsOK(ecode2)) {
15145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15146 }
15147 arg2 = static_cast< byte >(val2);
15148 if (arg1) (arg1)->green = arg2;
15149
15150 resultobj = SWIG_Py_Void();
15151 return resultobj;
15152 fail:
15153 return NULL;
15154 }
15155
15156
15157 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15158 PyObject *resultobj = 0;
15159 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15160 byte result;
15161 void *argp1 = 0 ;
15162 int res1 = 0 ;
15163 PyObject *swig_obj[1] ;
15164
15165 if (!args) SWIG_fail;
15166 swig_obj[0] = args;
15167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15168 if (!SWIG_IsOK(res1)) {
15169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15170 }
15171 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15172 result = (byte) ((arg1)->green);
15173 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15174 return resultobj;
15175 fail:
15176 return NULL;
15177 }
15178
15179
15180 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15181 PyObject *resultobj = 0;
15182 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15183 byte arg2 ;
15184 void *argp1 = 0 ;
15185 int res1 = 0 ;
15186 unsigned char val2 ;
15187 int ecode2 = 0 ;
15188 PyObject *swig_obj[2] ;
15189
15190 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15192 if (!SWIG_IsOK(res1)) {
15193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15194 }
15195 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15196 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15197 if (!SWIG_IsOK(ecode2)) {
15198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15199 }
15200 arg2 = static_cast< byte >(val2);
15201 if (arg1) (arg1)->blue = arg2;
15202
15203 resultobj = SWIG_Py_Void();
15204 return resultobj;
15205 fail:
15206 return NULL;
15207 }
15208
15209
15210 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15211 PyObject *resultobj = 0;
15212 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15213 byte result;
15214 void *argp1 = 0 ;
15215 int res1 = 0 ;
15216 PyObject *swig_obj[1] ;
15217
15218 if (!args) SWIG_fail;
15219 swig_obj[0] = args;
15220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15221 if (!SWIG_IsOK(res1)) {
15222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15223 }
15224 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15225 result = (byte) ((arg1)->blue);
15226 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15227 return resultobj;
15228 fail:
15229 return NULL;
15230 }
15231
15232
15233 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15234 PyObject *obj;
15235 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15236 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15237 return SWIG_Py_Void();
15238 }
15239
15240 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15241 return SWIG_Python_InitShadowInstance(args);
15242 }
15243
15244 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15245 PyObject *resultobj = 0;
15246 double arg1 = (double) 0.0 ;
15247 double arg2 = (double) 0.0 ;
15248 double arg3 = (double) 0.0 ;
15249 wxImage_HSVValue *result = 0 ;
15250 double val1 ;
15251 int ecode1 = 0 ;
15252 double val2 ;
15253 int ecode2 = 0 ;
15254 double val3 ;
15255 int ecode3 = 0 ;
15256 PyObject * obj0 = 0 ;
15257 PyObject * obj1 = 0 ;
15258 PyObject * obj2 = 0 ;
15259 char * kwnames[] = {
15260 (char *) "h",(char *) "s",(char *) "v", NULL
15261 };
15262
15263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15264 if (obj0) {
15265 ecode1 = SWIG_AsVal_double(obj0, &val1);
15266 if (!SWIG_IsOK(ecode1)) {
15267 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15268 }
15269 arg1 = static_cast< double >(val1);
15270 }
15271 if (obj1) {
15272 ecode2 = SWIG_AsVal_double(obj1, &val2);
15273 if (!SWIG_IsOK(ecode2)) {
15274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15275 }
15276 arg2 = static_cast< double >(val2);
15277 }
15278 if (obj2) {
15279 ecode3 = SWIG_AsVal_double(obj2, &val3);
15280 if (!SWIG_IsOK(ecode3)) {
15281 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15282 }
15283 arg3 = static_cast< double >(val3);
15284 }
15285 {
15286 PyThreadState* __tstate = wxPyBeginAllowThreads();
15287 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15288 wxPyEndAllowThreads(__tstate);
15289 if (PyErr_Occurred()) SWIG_fail;
15290 }
15291 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15292 return resultobj;
15293 fail:
15294 return NULL;
15295 }
15296
15297
15298 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15299 PyObject *resultobj = 0;
15300 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15301 double arg2 ;
15302 void *argp1 = 0 ;
15303 int res1 = 0 ;
15304 double val2 ;
15305 int ecode2 = 0 ;
15306 PyObject *swig_obj[2] ;
15307
15308 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15310 if (!SWIG_IsOK(res1)) {
15311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15312 }
15313 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15314 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15315 if (!SWIG_IsOK(ecode2)) {
15316 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15317 }
15318 arg2 = static_cast< double >(val2);
15319 if (arg1) (arg1)->hue = arg2;
15320
15321 resultobj = SWIG_Py_Void();
15322 return resultobj;
15323 fail:
15324 return NULL;
15325 }
15326
15327
15328 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15329 PyObject *resultobj = 0;
15330 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15331 double result;
15332 void *argp1 = 0 ;
15333 int res1 = 0 ;
15334 PyObject *swig_obj[1] ;
15335
15336 if (!args) SWIG_fail;
15337 swig_obj[0] = args;
15338 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15339 if (!SWIG_IsOK(res1)) {
15340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15341 }
15342 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15343 result = (double) ((arg1)->hue);
15344 resultobj = SWIG_From_double(static_cast< double >(result));
15345 return resultobj;
15346 fail:
15347 return NULL;
15348 }
15349
15350
15351 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15352 PyObject *resultobj = 0;
15353 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15354 double arg2 ;
15355 void *argp1 = 0 ;
15356 int res1 = 0 ;
15357 double val2 ;
15358 int ecode2 = 0 ;
15359 PyObject *swig_obj[2] ;
15360
15361 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15363 if (!SWIG_IsOK(res1)) {
15364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15365 }
15366 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15367 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15368 if (!SWIG_IsOK(ecode2)) {
15369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15370 }
15371 arg2 = static_cast< double >(val2);
15372 if (arg1) (arg1)->saturation = arg2;
15373
15374 resultobj = SWIG_Py_Void();
15375 return resultobj;
15376 fail:
15377 return NULL;
15378 }
15379
15380
15381 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15382 PyObject *resultobj = 0;
15383 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15384 double result;
15385 void *argp1 = 0 ;
15386 int res1 = 0 ;
15387 PyObject *swig_obj[1] ;
15388
15389 if (!args) SWIG_fail;
15390 swig_obj[0] = args;
15391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15392 if (!SWIG_IsOK(res1)) {
15393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15394 }
15395 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15396 result = (double) ((arg1)->saturation);
15397 resultobj = SWIG_From_double(static_cast< double >(result));
15398 return resultobj;
15399 fail:
15400 return NULL;
15401 }
15402
15403
15404 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15405 PyObject *resultobj = 0;
15406 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15407 double arg2 ;
15408 void *argp1 = 0 ;
15409 int res1 = 0 ;
15410 double val2 ;
15411 int ecode2 = 0 ;
15412 PyObject *swig_obj[2] ;
15413
15414 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15416 if (!SWIG_IsOK(res1)) {
15417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15418 }
15419 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15420 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15421 if (!SWIG_IsOK(ecode2)) {
15422 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15423 }
15424 arg2 = static_cast< double >(val2);
15425 if (arg1) (arg1)->value = arg2;
15426
15427 resultobj = SWIG_Py_Void();
15428 return resultobj;
15429 fail:
15430 return NULL;
15431 }
15432
15433
15434 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15435 PyObject *resultobj = 0;
15436 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15437 double result;
15438 void *argp1 = 0 ;
15439 int res1 = 0 ;
15440 PyObject *swig_obj[1] ;
15441
15442 if (!args) SWIG_fail;
15443 swig_obj[0] = args;
15444 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15445 if (!SWIG_IsOK(res1)) {
15446 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15447 }
15448 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15449 result = (double) ((arg1)->value);
15450 resultobj = SWIG_From_double(static_cast< double >(result));
15451 return resultobj;
15452 fail:
15453 return NULL;
15454 }
15455
15456
15457 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15458 PyObject *obj;
15459 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15460 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15461 return SWIG_Py_Void();
15462 }
15463
15464 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15465 return SWIG_Python_InitShadowInstance(args);
15466 }
15467
15468 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15469 PyObject *resultobj = 0;
15470 wxString *arg1 = 0 ;
15471 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15472 int arg3 = (int) -1 ;
15473 wxImage *result = 0 ;
15474 bool temp1 = false ;
15475 long val2 ;
15476 int ecode2 = 0 ;
15477 int val3 ;
15478 int ecode3 = 0 ;
15479 PyObject * obj0 = 0 ;
15480 PyObject * obj1 = 0 ;
15481 PyObject * obj2 = 0 ;
15482 char * kwnames[] = {
15483 (char *) "name",(char *) "type",(char *) "index", NULL
15484 };
15485
15486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15487 {
15488 arg1 = wxString_in_helper(obj0);
15489 if (arg1 == NULL) SWIG_fail;
15490 temp1 = true;
15491 }
15492 if (obj1) {
15493 ecode2 = SWIG_AsVal_long(obj1, &val2);
15494 if (!SWIG_IsOK(ecode2)) {
15495 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15496 }
15497 arg2 = static_cast< long >(val2);
15498 }
15499 if (obj2) {
15500 ecode3 = SWIG_AsVal_int(obj2, &val3);
15501 if (!SWIG_IsOK(ecode3)) {
15502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15503 }
15504 arg3 = static_cast< int >(val3);
15505 }
15506 {
15507 PyThreadState* __tstate = wxPyBeginAllowThreads();
15508 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15509 wxPyEndAllowThreads(__tstate);
15510 if (PyErr_Occurred()) SWIG_fail;
15511 }
15512 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15513 {
15514 if (temp1)
15515 delete arg1;
15516 }
15517 return resultobj;
15518 fail:
15519 {
15520 if (temp1)
15521 delete arg1;
15522 }
15523 return NULL;
15524 }
15525
15526
15527 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15528 PyObject *resultobj = 0;
15529 wxImage *arg1 = (wxImage *) 0 ;
15530 void *argp1 = 0 ;
15531 int res1 = 0 ;
15532 PyObject *swig_obj[1] ;
15533
15534 if (!args) SWIG_fail;
15535 swig_obj[0] = args;
15536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15537 if (!SWIG_IsOK(res1)) {
15538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15539 }
15540 arg1 = reinterpret_cast< wxImage * >(argp1);
15541 {
15542 PyThreadState* __tstate = wxPyBeginAllowThreads();
15543 delete arg1;
15544
15545 wxPyEndAllowThreads(__tstate);
15546 if (PyErr_Occurred()) SWIG_fail;
15547 }
15548 resultobj = SWIG_Py_Void();
15549 return resultobj;
15550 fail:
15551 return NULL;
15552 }
15553
15554
15555 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15556 PyObject *resultobj = 0;
15557 wxString *arg1 = 0 ;
15558 wxString *arg2 = 0 ;
15559 int arg3 = (int) -1 ;
15560 wxImage *result = 0 ;
15561 bool temp1 = false ;
15562 bool temp2 = false ;
15563 int val3 ;
15564 int ecode3 = 0 ;
15565 PyObject * obj0 = 0 ;
15566 PyObject * obj1 = 0 ;
15567 PyObject * obj2 = 0 ;
15568 char * kwnames[] = {
15569 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15570 };
15571
15572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15573 {
15574 arg1 = wxString_in_helper(obj0);
15575 if (arg1 == NULL) SWIG_fail;
15576 temp1 = true;
15577 }
15578 {
15579 arg2 = wxString_in_helper(obj1);
15580 if (arg2 == NULL) SWIG_fail;
15581 temp2 = true;
15582 }
15583 if (obj2) {
15584 ecode3 = SWIG_AsVal_int(obj2, &val3);
15585 if (!SWIG_IsOK(ecode3)) {
15586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15587 }
15588 arg3 = static_cast< int >(val3);
15589 }
15590 {
15591 PyThreadState* __tstate = wxPyBeginAllowThreads();
15592 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15593 wxPyEndAllowThreads(__tstate);
15594 if (PyErr_Occurred()) SWIG_fail;
15595 }
15596 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15597 {
15598 if (temp1)
15599 delete arg1;
15600 }
15601 {
15602 if (temp2)
15603 delete arg2;
15604 }
15605 return resultobj;
15606 fail:
15607 {
15608 if (temp1)
15609 delete arg1;
15610 }
15611 {
15612 if (temp2)
15613 delete arg2;
15614 }
15615 return NULL;
15616 }
15617
15618
15619 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15620 PyObject *resultobj = 0;
15621 wxInputStream *arg1 = 0 ;
15622 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15623 int arg3 = (int) -1 ;
15624 wxImage *result = 0 ;
15625 wxPyInputStream *temp1 ;
15626 bool created1 ;
15627 long val2 ;
15628 int ecode2 = 0 ;
15629 int val3 ;
15630 int ecode3 = 0 ;
15631 PyObject * obj0 = 0 ;
15632 PyObject * obj1 = 0 ;
15633 PyObject * obj2 = 0 ;
15634 char * kwnames[] = {
15635 (char *) "stream",(char *) "type",(char *) "index", NULL
15636 };
15637
15638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15639 {
15640 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15641 arg1 = temp1->m_wxis;
15642 created1 = false;
15643 } else {
15644 PyErr_Clear(); // clear the failure of the wxPyConvert above
15645 arg1 = wxPyCBInputStream_create(obj0, false);
15646 if (arg1 == NULL) {
15647 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15648 SWIG_fail;
15649 }
15650 created1 = true;
15651 }
15652 }
15653 if (obj1) {
15654 ecode2 = SWIG_AsVal_long(obj1, &val2);
15655 if (!SWIG_IsOK(ecode2)) {
15656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15657 }
15658 arg2 = static_cast< long >(val2);
15659 }
15660 if (obj2) {
15661 ecode3 = SWIG_AsVal_int(obj2, &val3);
15662 if (!SWIG_IsOK(ecode3)) {
15663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15664 }
15665 arg3 = static_cast< int >(val3);
15666 }
15667 {
15668 PyThreadState* __tstate = wxPyBeginAllowThreads();
15669 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15670 wxPyEndAllowThreads(__tstate);
15671 if (PyErr_Occurred()) SWIG_fail;
15672 }
15673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15674 {
15675 if (created1) delete arg1;
15676 }
15677 return resultobj;
15678 fail:
15679 {
15680 if (created1) delete arg1;
15681 }
15682 return NULL;
15683 }
15684
15685
15686 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15687 PyObject *resultobj = 0;
15688 wxInputStream *arg1 = 0 ;
15689 wxString *arg2 = 0 ;
15690 int arg3 = (int) -1 ;
15691 wxImage *result = 0 ;
15692 wxPyInputStream *temp1 ;
15693 bool created1 ;
15694 bool temp2 = false ;
15695 int val3 ;
15696 int ecode3 = 0 ;
15697 PyObject * obj0 = 0 ;
15698 PyObject * obj1 = 0 ;
15699 PyObject * obj2 = 0 ;
15700 char * kwnames[] = {
15701 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15702 };
15703
15704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15705 {
15706 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15707 arg1 = temp1->m_wxis;
15708 created1 = false;
15709 } else {
15710 PyErr_Clear(); // clear the failure of the wxPyConvert above
15711 arg1 = wxPyCBInputStream_create(obj0, false);
15712 if (arg1 == NULL) {
15713 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15714 SWIG_fail;
15715 }
15716 created1 = true;
15717 }
15718 }
15719 {
15720 arg2 = wxString_in_helper(obj1);
15721 if (arg2 == NULL) SWIG_fail;
15722 temp2 = true;
15723 }
15724 if (obj2) {
15725 ecode3 = SWIG_AsVal_int(obj2, &val3);
15726 if (!SWIG_IsOK(ecode3)) {
15727 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15728 }
15729 arg3 = static_cast< int >(val3);
15730 }
15731 {
15732 PyThreadState* __tstate = wxPyBeginAllowThreads();
15733 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15734 wxPyEndAllowThreads(__tstate);
15735 if (PyErr_Occurred()) SWIG_fail;
15736 }
15737 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15738 {
15739 if (created1) delete arg1;
15740 }
15741 {
15742 if (temp2)
15743 delete arg2;
15744 }
15745 return resultobj;
15746 fail:
15747 {
15748 if (created1) delete arg1;
15749 }
15750 {
15751 if (temp2)
15752 delete arg2;
15753 }
15754 return NULL;
15755 }
15756
15757
15758 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15759 PyObject *resultobj = 0;
15760 int arg1 = (int) 0 ;
15761 int arg2 = (int) 0 ;
15762 bool arg3 = (bool) true ;
15763 wxImage *result = 0 ;
15764 int val1 ;
15765 int ecode1 = 0 ;
15766 int val2 ;
15767 int ecode2 = 0 ;
15768 bool val3 ;
15769 int ecode3 = 0 ;
15770 PyObject * obj0 = 0 ;
15771 PyObject * obj1 = 0 ;
15772 PyObject * obj2 = 0 ;
15773 char * kwnames[] = {
15774 (char *) "width",(char *) "height",(char *) "clear", NULL
15775 };
15776
15777 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15778 if (obj0) {
15779 ecode1 = SWIG_AsVal_int(obj0, &val1);
15780 if (!SWIG_IsOK(ecode1)) {
15781 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15782 }
15783 arg1 = static_cast< int >(val1);
15784 }
15785 if (obj1) {
15786 ecode2 = SWIG_AsVal_int(obj1, &val2);
15787 if (!SWIG_IsOK(ecode2)) {
15788 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15789 }
15790 arg2 = static_cast< int >(val2);
15791 }
15792 if (obj2) {
15793 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15794 if (!SWIG_IsOK(ecode3)) {
15795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15796 }
15797 arg3 = static_cast< bool >(val3);
15798 }
15799 {
15800 PyThreadState* __tstate = wxPyBeginAllowThreads();
15801 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15802 wxPyEndAllowThreads(__tstate);
15803 if (PyErr_Occurred()) SWIG_fail;
15804 }
15805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15806 return resultobj;
15807 fail:
15808 return NULL;
15809 }
15810
15811
15812 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15813 PyObject *resultobj = 0;
15814 wxBitmap *arg1 = 0 ;
15815 wxImage *result = 0 ;
15816 void *argp1 = 0 ;
15817 int res1 = 0 ;
15818 PyObject * obj0 = 0 ;
15819 char * kwnames[] = {
15820 (char *) "bitmap", NULL
15821 };
15822
15823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15824 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15825 if (!SWIG_IsOK(res1)) {
15826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15827 }
15828 if (!argp1) {
15829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15830 }
15831 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15832 {
15833 if (!wxPyCheckForApp()) SWIG_fail;
15834 PyThreadState* __tstate = wxPyBeginAllowThreads();
15835 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15836 wxPyEndAllowThreads(__tstate);
15837 if (PyErr_Occurred()) SWIG_fail;
15838 }
15839 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15840 return resultobj;
15841 fail:
15842 return NULL;
15843 }
15844
15845
15846 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15847 PyObject *resultobj = 0;
15848 int arg1 ;
15849 int arg2 ;
15850 buffer arg3 ;
15851 int arg4 ;
15852 wxImage *result = 0 ;
15853 int val1 ;
15854 int ecode1 = 0 ;
15855 int val2 ;
15856 int ecode2 = 0 ;
15857 Py_ssize_t temp3 ;
15858 PyObject * obj0 = 0 ;
15859 PyObject * obj1 = 0 ;
15860 PyObject * obj2 = 0 ;
15861 char * kwnames[] = {
15862 (char *) "width",(char *) "height",(char *) "data", NULL
15863 };
15864
15865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15866 ecode1 = SWIG_AsVal_int(obj0, &val1);
15867 if (!SWIG_IsOK(ecode1)) {
15868 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15869 }
15870 arg1 = static_cast< int >(val1);
15871 ecode2 = SWIG_AsVal_int(obj1, &val2);
15872 if (!SWIG_IsOK(ecode2)) {
15873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15874 }
15875 arg2 = static_cast< int >(val2);
15876 {
15877 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15878 arg4 = (int)temp3;
15879 }
15880 {
15881 PyThreadState* __tstate = wxPyBeginAllowThreads();
15882 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15883 wxPyEndAllowThreads(__tstate);
15884 if (PyErr_Occurred()) SWIG_fail;
15885 }
15886 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15887 return resultobj;
15888 fail:
15889 return NULL;
15890 }
15891
15892
15893 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15894 PyObject *resultobj = 0;
15895 int arg1 ;
15896 int arg2 ;
15897 buffer arg3 ;
15898 int arg4 ;
15899 buffer arg5 ;
15900 int arg6 ;
15901 wxImage *result = 0 ;
15902 int val1 ;
15903 int ecode1 = 0 ;
15904 int val2 ;
15905 int ecode2 = 0 ;
15906 Py_ssize_t temp3 ;
15907 Py_ssize_t temp5 ;
15908 PyObject * obj0 = 0 ;
15909 PyObject * obj1 = 0 ;
15910 PyObject * obj2 = 0 ;
15911 PyObject * obj3 = 0 ;
15912 char * kwnames[] = {
15913 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15914 };
15915
15916 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15917 ecode1 = SWIG_AsVal_int(obj0, &val1);
15918 if (!SWIG_IsOK(ecode1)) {
15919 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15920 }
15921 arg1 = static_cast< int >(val1);
15922 ecode2 = SWIG_AsVal_int(obj1, &val2);
15923 if (!SWIG_IsOK(ecode2)) {
15924 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15925 }
15926 arg2 = static_cast< int >(val2);
15927 {
15928 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15929 arg4 = (int)temp3;
15930 }
15931 {
15932 if (obj3 != Py_None) {
15933 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15934 arg6 = (int)temp5;
15935 }
15936 }
15937 {
15938 PyThreadState* __tstate = wxPyBeginAllowThreads();
15939 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15940 wxPyEndAllowThreads(__tstate);
15941 if (PyErr_Occurred()) SWIG_fail;
15942 }
15943 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15944 return resultobj;
15945 fail:
15946 return NULL;
15947 }
15948
15949
15950 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15951 PyObject *resultobj = 0;
15952 wxImage *arg1 = (wxImage *) 0 ;
15953 int arg2 ;
15954 int arg3 ;
15955 bool arg4 = (bool) true ;
15956 void *argp1 = 0 ;
15957 int res1 = 0 ;
15958 int val2 ;
15959 int ecode2 = 0 ;
15960 int val3 ;
15961 int ecode3 = 0 ;
15962 bool val4 ;
15963 int ecode4 = 0 ;
15964 PyObject * obj0 = 0 ;
15965 PyObject * obj1 = 0 ;
15966 PyObject * obj2 = 0 ;
15967 PyObject * obj3 = 0 ;
15968 char * kwnames[] = {
15969 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15970 };
15971
15972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15974 if (!SWIG_IsOK(res1)) {
15975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15976 }
15977 arg1 = reinterpret_cast< wxImage * >(argp1);
15978 ecode2 = SWIG_AsVal_int(obj1, &val2);
15979 if (!SWIG_IsOK(ecode2)) {
15980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15981 }
15982 arg2 = static_cast< int >(val2);
15983 ecode3 = SWIG_AsVal_int(obj2, &val3);
15984 if (!SWIG_IsOK(ecode3)) {
15985 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
15986 }
15987 arg3 = static_cast< int >(val3);
15988 if (obj3) {
15989 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15990 if (!SWIG_IsOK(ecode4)) {
15991 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
15992 }
15993 arg4 = static_cast< bool >(val4);
15994 }
15995 {
15996 PyThreadState* __tstate = wxPyBeginAllowThreads();
15997 (arg1)->Create(arg2,arg3,arg4);
15998 wxPyEndAllowThreads(__tstate);
15999 if (PyErr_Occurred()) SWIG_fail;
16000 }
16001 resultobj = SWIG_Py_Void();
16002 return resultobj;
16003 fail:
16004 return NULL;
16005 }
16006
16007
16008 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16009 PyObject *resultobj = 0;
16010 wxImage *arg1 = (wxImage *) 0 ;
16011 void *argp1 = 0 ;
16012 int res1 = 0 ;
16013 PyObject *swig_obj[1] ;
16014
16015 if (!args) SWIG_fail;
16016 swig_obj[0] = args;
16017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16018 if (!SWIG_IsOK(res1)) {
16019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16020 }
16021 arg1 = reinterpret_cast< wxImage * >(argp1);
16022 {
16023 PyThreadState* __tstate = wxPyBeginAllowThreads();
16024 (arg1)->Destroy();
16025 wxPyEndAllowThreads(__tstate);
16026 if (PyErr_Occurred()) SWIG_fail;
16027 }
16028 resultobj = SWIG_Py_Void();
16029 return resultobj;
16030 fail:
16031 return NULL;
16032 }
16033
16034
16035 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16036 PyObject *resultobj = 0;
16037 wxImage *arg1 = (wxImage *) 0 ;
16038 int arg2 ;
16039 int arg3 ;
16040 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16041 SwigValueWrapper<wxImage > result;
16042 void *argp1 = 0 ;
16043 int res1 = 0 ;
16044 int val2 ;
16045 int ecode2 = 0 ;
16046 int val3 ;
16047 int ecode3 = 0 ;
16048 int val4 ;
16049 int ecode4 = 0 ;
16050 PyObject * obj0 = 0 ;
16051 PyObject * obj1 = 0 ;
16052 PyObject * obj2 = 0 ;
16053 PyObject * obj3 = 0 ;
16054 char * kwnames[] = {
16055 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16056 };
16057
16058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16060 if (!SWIG_IsOK(res1)) {
16061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16062 }
16063 arg1 = reinterpret_cast< wxImage * >(argp1);
16064 ecode2 = SWIG_AsVal_int(obj1, &val2);
16065 if (!SWIG_IsOK(ecode2)) {
16066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16067 }
16068 arg2 = static_cast< int >(val2);
16069 ecode3 = SWIG_AsVal_int(obj2, &val3);
16070 if (!SWIG_IsOK(ecode3)) {
16071 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16072 }
16073 arg3 = static_cast< int >(val3);
16074 if (obj3) {
16075 ecode4 = SWIG_AsVal_int(obj3, &val4);
16076 if (!SWIG_IsOK(ecode4)) {
16077 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16078 }
16079 arg4 = static_cast< int >(val4);
16080 }
16081 {
16082 PyThreadState* __tstate = wxPyBeginAllowThreads();
16083 result = (arg1)->Scale(arg2,arg3,arg4);
16084 wxPyEndAllowThreads(__tstate);
16085 if (PyErr_Occurred()) SWIG_fail;
16086 }
16087 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16088 return resultobj;
16089 fail:
16090 return NULL;
16091 }
16092
16093
16094 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16095 PyObject *resultobj = 0;
16096 wxImage *arg1 = (wxImage *) 0 ;
16097 int arg2 ;
16098 int arg3 ;
16099 SwigValueWrapper<wxImage > result;
16100 void *argp1 = 0 ;
16101 int res1 = 0 ;
16102 int val2 ;
16103 int ecode2 = 0 ;
16104 int val3 ;
16105 int ecode3 = 0 ;
16106 PyObject * obj0 = 0 ;
16107 PyObject * obj1 = 0 ;
16108 PyObject * obj2 = 0 ;
16109 char * kwnames[] = {
16110 (char *) "self",(char *) "width",(char *) "height", NULL
16111 };
16112
16113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16115 if (!SWIG_IsOK(res1)) {
16116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16117 }
16118 arg1 = reinterpret_cast< wxImage * >(argp1);
16119 ecode2 = SWIG_AsVal_int(obj1, &val2);
16120 if (!SWIG_IsOK(ecode2)) {
16121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16122 }
16123 arg2 = static_cast< int >(val2);
16124 ecode3 = SWIG_AsVal_int(obj2, &val3);
16125 if (!SWIG_IsOK(ecode3)) {
16126 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16127 }
16128 arg3 = static_cast< int >(val3);
16129 {
16130 PyThreadState* __tstate = wxPyBeginAllowThreads();
16131 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16132 wxPyEndAllowThreads(__tstate);
16133 if (PyErr_Occurred()) SWIG_fail;
16134 }
16135 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16136 return resultobj;
16137 fail:
16138 return NULL;
16139 }
16140
16141
16142 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16143 PyObject *resultobj = 0;
16144 wxImage *arg1 = (wxImage *) 0 ;
16145 int arg2 ;
16146 int arg3 ;
16147 SwigValueWrapper<wxImage > result;
16148 void *argp1 = 0 ;
16149 int res1 = 0 ;
16150 int val2 ;
16151 int ecode2 = 0 ;
16152 int val3 ;
16153 int ecode3 = 0 ;
16154 PyObject * obj0 = 0 ;
16155 PyObject * obj1 = 0 ;
16156 PyObject * obj2 = 0 ;
16157 char * kwnames[] = {
16158 (char *) "self",(char *) "width",(char *) "height", NULL
16159 };
16160
16161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16163 if (!SWIG_IsOK(res1)) {
16164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16165 }
16166 arg1 = reinterpret_cast< wxImage * >(argp1);
16167 ecode2 = SWIG_AsVal_int(obj1, &val2);
16168 if (!SWIG_IsOK(ecode2)) {
16169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16170 }
16171 arg2 = static_cast< int >(val2);
16172 ecode3 = SWIG_AsVal_int(obj2, &val3);
16173 if (!SWIG_IsOK(ecode3)) {
16174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16175 }
16176 arg3 = static_cast< int >(val3);
16177 {
16178 PyThreadState* __tstate = wxPyBeginAllowThreads();
16179 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16180 wxPyEndAllowThreads(__tstate);
16181 if (PyErr_Occurred()) SWIG_fail;
16182 }
16183 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16184 return resultobj;
16185 fail:
16186 return NULL;
16187 }
16188
16189
16190 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16191 PyObject *resultobj = 0;
16192 wxImage *arg1 = (wxImage *) 0 ;
16193 int arg2 ;
16194 SwigValueWrapper<wxImage > result;
16195 void *argp1 = 0 ;
16196 int res1 = 0 ;
16197 int val2 ;
16198 int ecode2 = 0 ;
16199 PyObject * obj0 = 0 ;
16200 PyObject * obj1 = 0 ;
16201 char * kwnames[] = {
16202 (char *) "self",(char *) "radius", NULL
16203 };
16204
16205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16206 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16207 if (!SWIG_IsOK(res1)) {
16208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16209 }
16210 arg1 = reinterpret_cast< wxImage * >(argp1);
16211 ecode2 = SWIG_AsVal_int(obj1, &val2);
16212 if (!SWIG_IsOK(ecode2)) {
16213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16214 }
16215 arg2 = static_cast< int >(val2);
16216 {
16217 PyThreadState* __tstate = wxPyBeginAllowThreads();
16218 result = (arg1)->Blur(arg2);
16219 wxPyEndAllowThreads(__tstate);
16220 if (PyErr_Occurred()) SWIG_fail;
16221 }
16222 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16223 return resultobj;
16224 fail:
16225 return NULL;
16226 }
16227
16228
16229 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16230 PyObject *resultobj = 0;
16231 wxImage *arg1 = (wxImage *) 0 ;
16232 int arg2 ;
16233 SwigValueWrapper<wxImage > result;
16234 void *argp1 = 0 ;
16235 int res1 = 0 ;
16236 int val2 ;
16237 int ecode2 = 0 ;
16238 PyObject * obj0 = 0 ;
16239 PyObject * obj1 = 0 ;
16240 char * kwnames[] = {
16241 (char *) "self",(char *) "radius", NULL
16242 };
16243
16244 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16246 if (!SWIG_IsOK(res1)) {
16247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16248 }
16249 arg1 = reinterpret_cast< wxImage * >(argp1);
16250 ecode2 = SWIG_AsVal_int(obj1, &val2);
16251 if (!SWIG_IsOK(ecode2)) {
16252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16253 }
16254 arg2 = static_cast< int >(val2);
16255 {
16256 PyThreadState* __tstate = wxPyBeginAllowThreads();
16257 result = (arg1)->BlurHorizontal(arg2);
16258 wxPyEndAllowThreads(__tstate);
16259 if (PyErr_Occurred()) SWIG_fail;
16260 }
16261 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16262 return resultobj;
16263 fail:
16264 return NULL;
16265 }
16266
16267
16268 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16269 PyObject *resultobj = 0;
16270 wxImage *arg1 = (wxImage *) 0 ;
16271 int arg2 ;
16272 SwigValueWrapper<wxImage > result;
16273 void *argp1 = 0 ;
16274 int res1 = 0 ;
16275 int val2 ;
16276 int ecode2 = 0 ;
16277 PyObject * obj0 = 0 ;
16278 PyObject * obj1 = 0 ;
16279 char * kwnames[] = {
16280 (char *) "self",(char *) "radius", NULL
16281 };
16282
16283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16285 if (!SWIG_IsOK(res1)) {
16286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16287 }
16288 arg1 = reinterpret_cast< wxImage * >(argp1);
16289 ecode2 = SWIG_AsVal_int(obj1, &val2);
16290 if (!SWIG_IsOK(ecode2)) {
16291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16292 }
16293 arg2 = static_cast< int >(val2);
16294 {
16295 PyThreadState* __tstate = wxPyBeginAllowThreads();
16296 result = (arg1)->BlurVertical(arg2);
16297 wxPyEndAllowThreads(__tstate);
16298 if (PyErr_Occurred()) SWIG_fail;
16299 }
16300 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16301 return resultobj;
16302 fail:
16303 return NULL;
16304 }
16305
16306
16307 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16308 PyObject *resultobj = 0;
16309 wxImage *arg1 = (wxImage *) 0 ;
16310 int arg2 ;
16311 int arg3 ;
16312 SwigValueWrapper<wxImage > result;
16313 void *argp1 = 0 ;
16314 int res1 = 0 ;
16315 int val2 ;
16316 int ecode2 = 0 ;
16317 int val3 ;
16318 int ecode3 = 0 ;
16319 PyObject * obj0 = 0 ;
16320 PyObject * obj1 = 0 ;
16321 PyObject * obj2 = 0 ;
16322 char * kwnames[] = {
16323 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16324 };
16325
16326 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16327 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16328 if (!SWIG_IsOK(res1)) {
16329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16330 }
16331 arg1 = reinterpret_cast< wxImage * >(argp1);
16332 ecode2 = SWIG_AsVal_int(obj1, &val2);
16333 if (!SWIG_IsOK(ecode2)) {
16334 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16335 }
16336 arg2 = static_cast< int >(val2);
16337 ecode3 = SWIG_AsVal_int(obj2, &val3);
16338 if (!SWIG_IsOK(ecode3)) {
16339 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16340 }
16341 arg3 = static_cast< int >(val3);
16342 {
16343 PyThreadState* __tstate = wxPyBeginAllowThreads();
16344 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16345 wxPyEndAllowThreads(__tstate);
16346 if (PyErr_Occurred()) SWIG_fail;
16347 }
16348 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16349 return resultobj;
16350 fail:
16351 return NULL;
16352 }
16353
16354
16355 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16356 PyObject *resultobj = 0;
16357 wxImage *arg1 = (wxImage *) 0 ;
16358 int arg2 ;
16359 int arg3 ;
16360 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16361 wxImage *result = 0 ;
16362 void *argp1 = 0 ;
16363 int res1 = 0 ;
16364 int val2 ;
16365 int ecode2 = 0 ;
16366 int val3 ;
16367 int ecode3 = 0 ;
16368 int val4 ;
16369 int ecode4 = 0 ;
16370 PyObject * obj0 = 0 ;
16371 PyObject * obj1 = 0 ;
16372 PyObject * obj2 = 0 ;
16373 PyObject * obj3 = 0 ;
16374 char * kwnames[] = {
16375 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16376 };
16377
16378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16380 if (!SWIG_IsOK(res1)) {
16381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16382 }
16383 arg1 = reinterpret_cast< wxImage * >(argp1);
16384 ecode2 = SWIG_AsVal_int(obj1, &val2);
16385 if (!SWIG_IsOK(ecode2)) {
16386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16387 }
16388 arg2 = static_cast< int >(val2);
16389 ecode3 = SWIG_AsVal_int(obj2, &val3);
16390 if (!SWIG_IsOK(ecode3)) {
16391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16392 }
16393 arg3 = static_cast< int >(val3);
16394 if (obj3) {
16395 ecode4 = SWIG_AsVal_int(obj3, &val4);
16396 if (!SWIG_IsOK(ecode4)) {
16397 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16398 }
16399 arg4 = static_cast< int >(val4);
16400 }
16401 {
16402 PyThreadState* __tstate = wxPyBeginAllowThreads();
16403 {
16404 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16405 result = (wxImage *) &_result_ref;
16406 }
16407 wxPyEndAllowThreads(__tstate);
16408 if (PyErr_Occurred()) SWIG_fail;
16409 }
16410 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16411 return resultobj;
16412 fail:
16413 return NULL;
16414 }
16415
16416
16417 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16418 PyObject *resultobj = 0;
16419 wxImage *arg1 = (wxImage *) 0 ;
16420 wxSize *arg2 = 0 ;
16421 wxPoint *arg3 = 0 ;
16422 int arg4 = (int) -1 ;
16423 int arg5 = (int) -1 ;
16424 int arg6 = (int) -1 ;
16425 wxImage *result = 0 ;
16426 void *argp1 = 0 ;
16427 int res1 = 0 ;
16428 wxSize temp2 ;
16429 wxPoint temp3 ;
16430 int val4 ;
16431 int ecode4 = 0 ;
16432 int val5 ;
16433 int ecode5 = 0 ;
16434 int val6 ;
16435 int ecode6 = 0 ;
16436 PyObject * obj0 = 0 ;
16437 PyObject * obj1 = 0 ;
16438 PyObject * obj2 = 0 ;
16439 PyObject * obj3 = 0 ;
16440 PyObject * obj4 = 0 ;
16441 PyObject * obj5 = 0 ;
16442 char * kwnames[] = {
16443 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16444 };
16445
16446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16448 if (!SWIG_IsOK(res1)) {
16449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16450 }
16451 arg1 = reinterpret_cast< wxImage * >(argp1);
16452 {
16453 arg2 = &temp2;
16454 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16455 }
16456 {
16457 arg3 = &temp3;
16458 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16459 }
16460 if (obj3) {
16461 ecode4 = SWIG_AsVal_int(obj3, &val4);
16462 if (!SWIG_IsOK(ecode4)) {
16463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16464 }
16465 arg4 = static_cast< int >(val4);
16466 }
16467 if (obj4) {
16468 ecode5 = SWIG_AsVal_int(obj4, &val5);
16469 if (!SWIG_IsOK(ecode5)) {
16470 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16471 }
16472 arg5 = static_cast< int >(val5);
16473 }
16474 if (obj5) {
16475 ecode6 = SWIG_AsVal_int(obj5, &val6);
16476 if (!SWIG_IsOK(ecode6)) {
16477 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16478 }
16479 arg6 = static_cast< int >(val6);
16480 }
16481 {
16482 PyThreadState* __tstate = wxPyBeginAllowThreads();
16483 {
16484 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16485 result = (wxImage *) &_result_ref;
16486 }
16487 wxPyEndAllowThreads(__tstate);
16488 if (PyErr_Occurred()) SWIG_fail;
16489 }
16490 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16491 return resultobj;
16492 fail:
16493 return NULL;
16494 }
16495
16496
16497 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16498 PyObject *resultobj = 0;
16499 wxImage *arg1 = (wxImage *) 0 ;
16500 int arg2 ;
16501 int arg3 ;
16502 byte arg4 ;
16503 byte arg5 ;
16504 byte arg6 ;
16505 void *argp1 = 0 ;
16506 int res1 = 0 ;
16507 int val2 ;
16508 int ecode2 = 0 ;
16509 int val3 ;
16510 int ecode3 = 0 ;
16511 unsigned char val4 ;
16512 int ecode4 = 0 ;
16513 unsigned char val5 ;
16514 int ecode5 = 0 ;
16515 unsigned char val6 ;
16516 int ecode6 = 0 ;
16517 PyObject * obj0 = 0 ;
16518 PyObject * obj1 = 0 ;
16519 PyObject * obj2 = 0 ;
16520 PyObject * obj3 = 0 ;
16521 PyObject * obj4 = 0 ;
16522 PyObject * obj5 = 0 ;
16523 char * kwnames[] = {
16524 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16525 };
16526
16527 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16528 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16529 if (!SWIG_IsOK(res1)) {
16530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16531 }
16532 arg1 = reinterpret_cast< wxImage * >(argp1);
16533 ecode2 = SWIG_AsVal_int(obj1, &val2);
16534 if (!SWIG_IsOK(ecode2)) {
16535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16536 }
16537 arg2 = static_cast< int >(val2);
16538 ecode3 = SWIG_AsVal_int(obj2, &val3);
16539 if (!SWIG_IsOK(ecode3)) {
16540 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16541 }
16542 arg3 = static_cast< int >(val3);
16543 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16544 if (!SWIG_IsOK(ecode4)) {
16545 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16546 }
16547 arg4 = static_cast< byte >(val4);
16548 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16549 if (!SWIG_IsOK(ecode5)) {
16550 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16551 }
16552 arg5 = static_cast< byte >(val5);
16553 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16554 if (!SWIG_IsOK(ecode6)) {
16555 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16556 }
16557 arg6 = static_cast< byte >(val6);
16558 {
16559 PyThreadState* __tstate = wxPyBeginAllowThreads();
16560 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16561 wxPyEndAllowThreads(__tstate);
16562 if (PyErr_Occurred()) SWIG_fail;
16563 }
16564 resultobj = SWIG_Py_Void();
16565 return resultobj;
16566 fail:
16567 return NULL;
16568 }
16569
16570
16571 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16572 PyObject *resultobj = 0;
16573 wxImage *arg1 = (wxImage *) 0 ;
16574 wxRect *arg2 = 0 ;
16575 byte arg3 ;
16576 byte arg4 ;
16577 byte arg5 ;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 wxRect temp2 ;
16581 unsigned char val3 ;
16582 int ecode3 = 0 ;
16583 unsigned char val4 ;
16584 int ecode4 = 0 ;
16585 unsigned char val5 ;
16586 int ecode5 = 0 ;
16587 PyObject * obj0 = 0 ;
16588 PyObject * obj1 = 0 ;
16589 PyObject * obj2 = 0 ;
16590 PyObject * obj3 = 0 ;
16591 PyObject * obj4 = 0 ;
16592 char * kwnames[] = {
16593 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16594 };
16595
16596 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16597 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16598 if (!SWIG_IsOK(res1)) {
16599 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16600 }
16601 arg1 = reinterpret_cast< wxImage * >(argp1);
16602 {
16603 arg2 = &temp2;
16604 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16605 }
16606 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16607 if (!SWIG_IsOK(ecode3)) {
16608 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16609 }
16610 arg3 = static_cast< byte >(val3);
16611 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16612 if (!SWIG_IsOK(ecode4)) {
16613 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16614 }
16615 arg4 = static_cast< byte >(val4);
16616 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16617 if (!SWIG_IsOK(ecode5)) {
16618 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16619 }
16620 arg5 = static_cast< byte >(val5);
16621 {
16622 PyThreadState* __tstate = wxPyBeginAllowThreads();
16623 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16624 wxPyEndAllowThreads(__tstate);
16625 if (PyErr_Occurred()) SWIG_fail;
16626 }
16627 resultobj = SWIG_Py_Void();
16628 return resultobj;
16629 fail:
16630 return NULL;
16631 }
16632
16633
16634 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16635 PyObject *resultobj = 0;
16636 wxImage *arg1 = (wxImage *) 0 ;
16637 int arg2 ;
16638 int arg3 ;
16639 byte result;
16640 void *argp1 = 0 ;
16641 int res1 = 0 ;
16642 int val2 ;
16643 int ecode2 = 0 ;
16644 int val3 ;
16645 int ecode3 = 0 ;
16646 PyObject * obj0 = 0 ;
16647 PyObject * obj1 = 0 ;
16648 PyObject * obj2 = 0 ;
16649 char * kwnames[] = {
16650 (char *) "self",(char *) "x",(char *) "y", NULL
16651 };
16652
16653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16654 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16655 if (!SWIG_IsOK(res1)) {
16656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16657 }
16658 arg1 = reinterpret_cast< wxImage * >(argp1);
16659 ecode2 = SWIG_AsVal_int(obj1, &val2);
16660 if (!SWIG_IsOK(ecode2)) {
16661 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16662 }
16663 arg2 = static_cast< int >(val2);
16664 ecode3 = SWIG_AsVal_int(obj2, &val3);
16665 if (!SWIG_IsOK(ecode3)) {
16666 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16667 }
16668 arg3 = static_cast< int >(val3);
16669 {
16670 PyThreadState* __tstate = wxPyBeginAllowThreads();
16671 result = (byte)(arg1)->GetRed(arg2,arg3);
16672 wxPyEndAllowThreads(__tstate);
16673 if (PyErr_Occurred()) SWIG_fail;
16674 }
16675 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16676 return resultobj;
16677 fail:
16678 return NULL;
16679 }
16680
16681
16682 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16683 PyObject *resultobj = 0;
16684 wxImage *arg1 = (wxImage *) 0 ;
16685 int arg2 ;
16686 int arg3 ;
16687 byte result;
16688 void *argp1 = 0 ;
16689 int res1 = 0 ;
16690 int val2 ;
16691 int ecode2 = 0 ;
16692 int val3 ;
16693 int ecode3 = 0 ;
16694 PyObject * obj0 = 0 ;
16695 PyObject * obj1 = 0 ;
16696 PyObject * obj2 = 0 ;
16697 char * kwnames[] = {
16698 (char *) "self",(char *) "x",(char *) "y", NULL
16699 };
16700
16701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16703 if (!SWIG_IsOK(res1)) {
16704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16705 }
16706 arg1 = reinterpret_cast< wxImage * >(argp1);
16707 ecode2 = SWIG_AsVal_int(obj1, &val2);
16708 if (!SWIG_IsOK(ecode2)) {
16709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16710 }
16711 arg2 = static_cast< int >(val2);
16712 ecode3 = SWIG_AsVal_int(obj2, &val3);
16713 if (!SWIG_IsOK(ecode3)) {
16714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16715 }
16716 arg3 = static_cast< int >(val3);
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 result = (byte)(arg1)->GetGreen(arg2,arg3);
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16731 PyObject *resultobj = 0;
16732 wxImage *arg1 = (wxImage *) 0 ;
16733 int arg2 ;
16734 int arg3 ;
16735 byte result;
16736 void *argp1 = 0 ;
16737 int res1 = 0 ;
16738 int val2 ;
16739 int ecode2 = 0 ;
16740 int val3 ;
16741 int ecode3 = 0 ;
16742 PyObject * obj0 = 0 ;
16743 PyObject * obj1 = 0 ;
16744 PyObject * obj2 = 0 ;
16745 char * kwnames[] = {
16746 (char *) "self",(char *) "x",(char *) "y", NULL
16747 };
16748
16749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16751 if (!SWIG_IsOK(res1)) {
16752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16753 }
16754 arg1 = reinterpret_cast< wxImage * >(argp1);
16755 ecode2 = SWIG_AsVal_int(obj1, &val2);
16756 if (!SWIG_IsOK(ecode2)) {
16757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16758 }
16759 arg2 = static_cast< int >(val2);
16760 ecode3 = SWIG_AsVal_int(obj2, &val3);
16761 if (!SWIG_IsOK(ecode3)) {
16762 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16763 }
16764 arg3 = static_cast< int >(val3);
16765 {
16766 PyThreadState* __tstate = wxPyBeginAllowThreads();
16767 result = (byte)(arg1)->GetBlue(arg2,arg3);
16768 wxPyEndAllowThreads(__tstate);
16769 if (PyErr_Occurred()) SWIG_fail;
16770 }
16771 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16772 return resultobj;
16773 fail:
16774 return NULL;
16775 }
16776
16777
16778 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16779 PyObject *resultobj = 0;
16780 wxImage *arg1 = (wxImage *) 0 ;
16781 int arg2 ;
16782 int arg3 ;
16783 byte arg4 ;
16784 void *argp1 = 0 ;
16785 int res1 = 0 ;
16786 int val2 ;
16787 int ecode2 = 0 ;
16788 int val3 ;
16789 int ecode3 = 0 ;
16790 unsigned char val4 ;
16791 int ecode4 = 0 ;
16792 PyObject * obj0 = 0 ;
16793 PyObject * obj1 = 0 ;
16794 PyObject * obj2 = 0 ;
16795 PyObject * obj3 = 0 ;
16796 char * kwnames[] = {
16797 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16798 };
16799
16800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16801 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16802 if (!SWIG_IsOK(res1)) {
16803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16804 }
16805 arg1 = reinterpret_cast< wxImage * >(argp1);
16806 ecode2 = SWIG_AsVal_int(obj1, &val2);
16807 if (!SWIG_IsOK(ecode2)) {
16808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16809 }
16810 arg2 = static_cast< int >(val2);
16811 ecode3 = SWIG_AsVal_int(obj2, &val3);
16812 if (!SWIG_IsOK(ecode3)) {
16813 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16814 }
16815 arg3 = static_cast< int >(val3);
16816 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16817 if (!SWIG_IsOK(ecode4)) {
16818 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16819 }
16820 arg4 = static_cast< byte >(val4);
16821 {
16822 PyThreadState* __tstate = wxPyBeginAllowThreads();
16823 (arg1)->SetAlpha(arg2,arg3,arg4);
16824 wxPyEndAllowThreads(__tstate);
16825 if (PyErr_Occurred()) SWIG_fail;
16826 }
16827 resultobj = SWIG_Py_Void();
16828 return resultobj;
16829 fail:
16830 return NULL;
16831 }
16832
16833
16834 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16835 PyObject *resultobj = 0;
16836 wxImage *arg1 = (wxImage *) 0 ;
16837 int arg2 ;
16838 int arg3 ;
16839 byte result;
16840 void *argp1 = 0 ;
16841 int res1 = 0 ;
16842 int val2 ;
16843 int ecode2 = 0 ;
16844 int val3 ;
16845 int ecode3 = 0 ;
16846 PyObject * obj0 = 0 ;
16847 PyObject * obj1 = 0 ;
16848 PyObject * obj2 = 0 ;
16849 char * kwnames[] = {
16850 (char *) "self",(char *) "x",(char *) "y", NULL
16851 };
16852
16853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16855 if (!SWIG_IsOK(res1)) {
16856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16857 }
16858 arg1 = reinterpret_cast< wxImage * >(argp1);
16859 ecode2 = SWIG_AsVal_int(obj1, &val2);
16860 if (!SWIG_IsOK(ecode2)) {
16861 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16862 }
16863 arg2 = static_cast< int >(val2);
16864 ecode3 = SWIG_AsVal_int(obj2, &val3);
16865 if (!SWIG_IsOK(ecode3)) {
16866 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16867 }
16868 arg3 = static_cast< int >(val3);
16869 {
16870 PyThreadState* __tstate = wxPyBeginAllowThreads();
16871 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16872 wxPyEndAllowThreads(__tstate);
16873 if (PyErr_Occurred()) SWIG_fail;
16874 }
16875 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16876 return resultobj;
16877 fail:
16878 return NULL;
16879 }
16880
16881
16882 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16883 PyObject *resultobj = 0;
16884 wxImage *arg1 = (wxImage *) 0 ;
16885 bool result;
16886 void *argp1 = 0 ;
16887 int res1 = 0 ;
16888 PyObject *swig_obj[1] ;
16889
16890 if (!args) SWIG_fail;
16891 swig_obj[0] = args;
16892 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16893 if (!SWIG_IsOK(res1)) {
16894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16895 }
16896 arg1 = reinterpret_cast< wxImage * >(argp1);
16897 {
16898 PyThreadState* __tstate = wxPyBeginAllowThreads();
16899 result = (bool)(arg1)->HasAlpha();
16900 wxPyEndAllowThreads(__tstate);
16901 if (PyErr_Occurred()) SWIG_fail;
16902 }
16903 {
16904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16905 }
16906 return resultobj;
16907 fail:
16908 return NULL;
16909 }
16910
16911
16912 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16913 PyObject *resultobj = 0;
16914 wxImage *arg1 = (wxImage *) 0 ;
16915 void *argp1 = 0 ;
16916 int res1 = 0 ;
16917 PyObject *swig_obj[1] ;
16918
16919 if (!args) SWIG_fail;
16920 swig_obj[0] = args;
16921 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16922 if (!SWIG_IsOK(res1)) {
16923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16924 }
16925 arg1 = reinterpret_cast< wxImage * >(argp1);
16926 {
16927 PyThreadState* __tstate = wxPyBeginAllowThreads();
16928 (arg1)->InitAlpha();
16929 wxPyEndAllowThreads(__tstate);
16930 if (PyErr_Occurred()) SWIG_fail;
16931 }
16932 resultobj = SWIG_Py_Void();
16933 return resultobj;
16934 fail:
16935 return NULL;
16936 }
16937
16938
16939 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16940 PyObject *resultobj = 0;
16941 wxImage *arg1 = (wxImage *) 0 ;
16942 int arg2 ;
16943 int arg3 ;
16944 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16945 bool result;
16946 void *argp1 = 0 ;
16947 int res1 = 0 ;
16948 int val2 ;
16949 int ecode2 = 0 ;
16950 int val3 ;
16951 int ecode3 = 0 ;
16952 unsigned char val4 ;
16953 int ecode4 = 0 ;
16954 PyObject * obj0 = 0 ;
16955 PyObject * obj1 = 0 ;
16956 PyObject * obj2 = 0 ;
16957 PyObject * obj3 = 0 ;
16958 char * kwnames[] = {
16959 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16960 };
16961
16962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16964 if (!SWIG_IsOK(res1)) {
16965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16966 }
16967 arg1 = reinterpret_cast< wxImage * >(argp1);
16968 ecode2 = SWIG_AsVal_int(obj1, &val2);
16969 if (!SWIG_IsOK(ecode2)) {
16970 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16971 }
16972 arg2 = static_cast< int >(val2);
16973 ecode3 = SWIG_AsVal_int(obj2, &val3);
16974 if (!SWIG_IsOK(ecode3)) {
16975 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16976 }
16977 arg3 = static_cast< int >(val3);
16978 if (obj3) {
16979 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16980 if (!SWIG_IsOK(ecode4)) {
16981 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16982 }
16983 arg4 = static_cast< byte >(val4);
16984 }
16985 {
16986 PyThreadState* __tstate = wxPyBeginAllowThreads();
16987 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
16988 wxPyEndAllowThreads(__tstate);
16989 if (PyErr_Occurred()) SWIG_fail;
16990 }
16991 {
16992 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16993 }
16994 return resultobj;
16995 fail:
16996 return NULL;
16997 }
16998
16999
17000 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17001 PyObject *resultobj = 0;
17002 wxImage *arg1 = (wxImage *) 0 ;
17003 byte *arg2 = (byte *) 0 ;
17004 byte *arg3 = (byte *) 0 ;
17005 byte *arg4 = (byte *) 0 ;
17006 byte arg5 = (byte) 0 ;
17007 byte arg6 = (byte) 0 ;
17008 byte arg7 = (byte) 0 ;
17009 bool result;
17010 void *argp1 = 0 ;
17011 int res1 = 0 ;
17012 byte temp2 ;
17013 int res2 = SWIG_TMPOBJ ;
17014 byte temp3 ;
17015 int res3 = SWIG_TMPOBJ ;
17016 byte temp4 ;
17017 int res4 = SWIG_TMPOBJ ;
17018 unsigned char val5 ;
17019 int ecode5 = 0 ;
17020 unsigned char val6 ;
17021 int ecode6 = 0 ;
17022 unsigned char val7 ;
17023 int ecode7 = 0 ;
17024 PyObject * obj0 = 0 ;
17025 PyObject * obj1 = 0 ;
17026 PyObject * obj2 = 0 ;
17027 PyObject * obj3 = 0 ;
17028 char * kwnames[] = {
17029 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17030 };
17031
17032 arg2 = &temp2;
17033 arg3 = &temp3;
17034 arg4 = &temp4;
17035 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17036 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17037 if (!SWIG_IsOK(res1)) {
17038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17039 }
17040 arg1 = reinterpret_cast< wxImage * >(argp1);
17041 if (obj1) {
17042 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17043 if (!SWIG_IsOK(ecode5)) {
17044 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17045 }
17046 arg5 = static_cast< byte >(val5);
17047 }
17048 if (obj2) {
17049 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17050 if (!SWIG_IsOK(ecode6)) {
17051 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17052 }
17053 arg6 = static_cast< byte >(val6);
17054 }
17055 if (obj3) {
17056 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17057 if (!SWIG_IsOK(ecode7)) {
17058 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17059 }
17060 arg7 = static_cast< byte >(val7);
17061 }
17062 {
17063 PyThreadState* __tstate = wxPyBeginAllowThreads();
17064 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17065 wxPyEndAllowThreads(__tstate);
17066 if (PyErr_Occurred()) SWIG_fail;
17067 }
17068 {
17069 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17070 }
17071 if (SWIG_IsTmpObj(res2)) {
17072 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17073 } else {
17074 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17075 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17076 }
17077 if (SWIG_IsTmpObj(res3)) {
17078 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17079 } else {
17080 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17081 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17082 }
17083 if (SWIG_IsTmpObj(res4)) {
17084 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17085 } else {
17086 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17088 }
17089 return resultobj;
17090 fail:
17091 return NULL;
17092 }
17093
17094
17095 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17096 PyObject *resultobj = 0;
17097 wxImage *arg1 = (wxImage *) 0 ;
17098 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17099 bool result;
17100 void *argp1 = 0 ;
17101 int res1 = 0 ;
17102 unsigned char val2 ;
17103 int ecode2 = 0 ;
17104 PyObject * obj0 = 0 ;
17105 PyObject * obj1 = 0 ;
17106 char * kwnames[] = {
17107 (char *) "self",(char *) "threshold", NULL
17108 };
17109
17110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17112 if (!SWIG_IsOK(res1)) {
17113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17114 }
17115 arg1 = reinterpret_cast< wxImage * >(argp1);
17116 if (obj1) {
17117 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17118 if (!SWIG_IsOK(ecode2)) {
17119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17120 }
17121 arg2 = static_cast< byte >(val2);
17122 }
17123 {
17124 PyThreadState* __tstate = wxPyBeginAllowThreads();
17125 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17126 wxPyEndAllowThreads(__tstate);
17127 if (PyErr_Occurred()) SWIG_fail;
17128 }
17129 {
17130 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17131 }
17132 return resultobj;
17133 fail:
17134 return NULL;
17135 }
17136
17137
17138 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17139 PyObject *resultobj = 0;
17140 wxImage *arg1 = (wxImage *) 0 ;
17141 byte arg2 ;
17142 byte arg3 ;
17143 byte arg4 ;
17144 bool result;
17145 void *argp1 = 0 ;
17146 int res1 = 0 ;
17147 unsigned char val2 ;
17148 int ecode2 = 0 ;
17149 unsigned char val3 ;
17150 int ecode3 = 0 ;
17151 unsigned char val4 ;
17152 int ecode4 = 0 ;
17153 PyObject * obj0 = 0 ;
17154 PyObject * obj1 = 0 ;
17155 PyObject * obj2 = 0 ;
17156 PyObject * obj3 = 0 ;
17157 char * kwnames[] = {
17158 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17159 };
17160
17161 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17162 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17163 if (!SWIG_IsOK(res1)) {
17164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17165 }
17166 arg1 = reinterpret_cast< wxImage * >(argp1);
17167 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17168 if (!SWIG_IsOK(ecode2)) {
17169 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17170 }
17171 arg2 = static_cast< byte >(val2);
17172 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17173 if (!SWIG_IsOK(ecode3)) {
17174 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17175 }
17176 arg3 = static_cast< byte >(val3);
17177 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17178 if (!SWIG_IsOK(ecode4)) {
17179 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17180 }
17181 arg4 = static_cast< byte >(val4);
17182 {
17183 PyThreadState* __tstate = wxPyBeginAllowThreads();
17184 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17185 wxPyEndAllowThreads(__tstate);
17186 if (PyErr_Occurred()) SWIG_fail;
17187 }
17188 {
17189 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17190 }
17191 return resultobj;
17192 fail:
17193 return NULL;
17194 }
17195
17196
17197 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17198 PyObject *resultobj = 0;
17199 wxImage *arg1 = (wxImage *) 0 ;
17200 wxImage *arg2 = 0 ;
17201 byte arg3 ;
17202 byte arg4 ;
17203 byte arg5 ;
17204 bool result;
17205 void *argp1 = 0 ;
17206 int res1 = 0 ;
17207 void *argp2 = 0 ;
17208 int res2 = 0 ;
17209 unsigned char val3 ;
17210 int ecode3 = 0 ;
17211 unsigned char val4 ;
17212 int ecode4 = 0 ;
17213 unsigned char val5 ;
17214 int ecode5 = 0 ;
17215 PyObject * obj0 = 0 ;
17216 PyObject * obj1 = 0 ;
17217 PyObject * obj2 = 0 ;
17218 PyObject * obj3 = 0 ;
17219 PyObject * obj4 = 0 ;
17220 char * kwnames[] = {
17221 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17222 };
17223
17224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17226 if (!SWIG_IsOK(res1)) {
17227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17228 }
17229 arg1 = reinterpret_cast< wxImage * >(argp1);
17230 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17231 if (!SWIG_IsOK(res2)) {
17232 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17233 }
17234 if (!argp2) {
17235 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17236 }
17237 arg2 = reinterpret_cast< wxImage * >(argp2);
17238 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17239 if (!SWIG_IsOK(ecode3)) {
17240 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17241 }
17242 arg3 = static_cast< byte >(val3);
17243 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17244 if (!SWIG_IsOK(ecode4)) {
17245 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17246 }
17247 arg4 = static_cast< byte >(val4);
17248 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17249 if (!SWIG_IsOK(ecode5)) {
17250 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17251 }
17252 arg5 = static_cast< byte >(val5);
17253 {
17254 PyThreadState* __tstate = wxPyBeginAllowThreads();
17255 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17256 wxPyEndAllowThreads(__tstate);
17257 if (PyErr_Occurred()) SWIG_fail;
17258 }
17259 {
17260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17261 }
17262 return resultobj;
17263 fail:
17264 return NULL;
17265 }
17266
17267
17268 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17269 PyObject *resultobj = 0;
17270 wxString *arg1 = 0 ;
17271 bool result;
17272 bool temp1 = false ;
17273 PyObject * obj0 = 0 ;
17274 char * kwnames[] = {
17275 (char *) "filename", NULL
17276 };
17277
17278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17279 {
17280 arg1 = wxString_in_helper(obj0);
17281 if (arg1 == NULL) SWIG_fail;
17282 temp1 = true;
17283 }
17284 {
17285 PyThreadState* __tstate = wxPyBeginAllowThreads();
17286 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17287 wxPyEndAllowThreads(__tstate);
17288 if (PyErr_Occurred()) SWIG_fail;
17289 }
17290 {
17291 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17292 }
17293 {
17294 if (temp1)
17295 delete arg1;
17296 }
17297 return resultobj;
17298 fail:
17299 {
17300 if (temp1)
17301 delete arg1;
17302 }
17303 return NULL;
17304 }
17305
17306
17307 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17308 PyObject *resultobj = 0;
17309 wxString *arg1 = 0 ;
17310 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17311 int result;
17312 bool temp1 = false ;
17313 long val2 ;
17314 int ecode2 = 0 ;
17315 PyObject * obj0 = 0 ;
17316 PyObject * obj1 = 0 ;
17317 char * kwnames[] = {
17318 (char *) "filename",(char *) "type", NULL
17319 };
17320
17321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17322 {
17323 arg1 = wxString_in_helper(obj0);
17324 if (arg1 == NULL) SWIG_fail;
17325 temp1 = true;
17326 }
17327 if (obj1) {
17328 ecode2 = SWIG_AsVal_long(obj1, &val2);
17329 if (!SWIG_IsOK(ecode2)) {
17330 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17331 }
17332 arg2 = static_cast< long >(val2);
17333 }
17334 {
17335 PyThreadState* __tstate = wxPyBeginAllowThreads();
17336 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17337 wxPyEndAllowThreads(__tstate);
17338 if (PyErr_Occurred()) SWIG_fail;
17339 }
17340 resultobj = SWIG_From_int(static_cast< int >(result));
17341 {
17342 if (temp1)
17343 delete arg1;
17344 }
17345 return resultobj;
17346 fail:
17347 {
17348 if (temp1)
17349 delete arg1;
17350 }
17351 return NULL;
17352 }
17353
17354
17355 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17356 PyObject *resultobj = 0;
17357 wxImage *arg1 = (wxImage *) 0 ;
17358 wxString *arg2 = 0 ;
17359 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17360 int arg4 = (int) -1 ;
17361 bool result;
17362 void *argp1 = 0 ;
17363 int res1 = 0 ;
17364 bool temp2 = false ;
17365 long val3 ;
17366 int ecode3 = 0 ;
17367 int val4 ;
17368 int ecode4 = 0 ;
17369 PyObject * obj0 = 0 ;
17370 PyObject * obj1 = 0 ;
17371 PyObject * obj2 = 0 ;
17372 PyObject * obj3 = 0 ;
17373 char * kwnames[] = {
17374 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17375 };
17376
17377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17379 if (!SWIG_IsOK(res1)) {
17380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17381 }
17382 arg1 = reinterpret_cast< wxImage * >(argp1);
17383 {
17384 arg2 = wxString_in_helper(obj1);
17385 if (arg2 == NULL) SWIG_fail;
17386 temp2 = true;
17387 }
17388 if (obj2) {
17389 ecode3 = SWIG_AsVal_long(obj2, &val3);
17390 if (!SWIG_IsOK(ecode3)) {
17391 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17392 }
17393 arg3 = static_cast< long >(val3);
17394 }
17395 if (obj3) {
17396 ecode4 = SWIG_AsVal_int(obj3, &val4);
17397 if (!SWIG_IsOK(ecode4)) {
17398 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17399 }
17400 arg4 = static_cast< int >(val4);
17401 }
17402 {
17403 PyThreadState* __tstate = wxPyBeginAllowThreads();
17404 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17405 wxPyEndAllowThreads(__tstate);
17406 if (PyErr_Occurred()) SWIG_fail;
17407 }
17408 {
17409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17410 }
17411 {
17412 if (temp2)
17413 delete arg2;
17414 }
17415 return resultobj;
17416 fail:
17417 {
17418 if (temp2)
17419 delete arg2;
17420 }
17421 return NULL;
17422 }
17423
17424
17425 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17426 PyObject *resultobj = 0;
17427 wxImage *arg1 = (wxImage *) 0 ;
17428 wxString *arg2 = 0 ;
17429 wxString *arg3 = 0 ;
17430 int arg4 = (int) -1 ;
17431 bool result;
17432 void *argp1 = 0 ;
17433 int res1 = 0 ;
17434 bool temp2 = false ;
17435 bool temp3 = false ;
17436 int val4 ;
17437 int ecode4 = 0 ;
17438 PyObject * obj0 = 0 ;
17439 PyObject * obj1 = 0 ;
17440 PyObject * obj2 = 0 ;
17441 PyObject * obj3 = 0 ;
17442 char * kwnames[] = {
17443 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17444 };
17445
17446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17448 if (!SWIG_IsOK(res1)) {
17449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17450 }
17451 arg1 = reinterpret_cast< wxImage * >(argp1);
17452 {
17453 arg2 = wxString_in_helper(obj1);
17454 if (arg2 == NULL) SWIG_fail;
17455 temp2 = true;
17456 }
17457 {
17458 arg3 = wxString_in_helper(obj2);
17459 if (arg3 == NULL) SWIG_fail;
17460 temp3 = true;
17461 }
17462 if (obj3) {
17463 ecode4 = SWIG_AsVal_int(obj3, &val4);
17464 if (!SWIG_IsOK(ecode4)) {
17465 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17466 }
17467 arg4 = static_cast< int >(val4);
17468 }
17469 {
17470 PyThreadState* __tstate = wxPyBeginAllowThreads();
17471 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17472 wxPyEndAllowThreads(__tstate);
17473 if (PyErr_Occurred()) SWIG_fail;
17474 }
17475 {
17476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17477 }
17478 {
17479 if (temp2)
17480 delete arg2;
17481 }
17482 {
17483 if (temp3)
17484 delete arg3;
17485 }
17486 return resultobj;
17487 fail:
17488 {
17489 if (temp2)
17490 delete arg2;
17491 }
17492 {
17493 if (temp3)
17494 delete arg3;
17495 }
17496 return NULL;
17497 }
17498
17499
17500 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17501 PyObject *resultobj = 0;
17502 wxImage *arg1 = (wxImage *) 0 ;
17503 wxString *arg2 = 0 ;
17504 int arg3 ;
17505 bool result;
17506 void *argp1 = 0 ;
17507 int res1 = 0 ;
17508 bool temp2 = false ;
17509 int val3 ;
17510 int ecode3 = 0 ;
17511 PyObject * obj0 = 0 ;
17512 PyObject * obj1 = 0 ;
17513 PyObject * obj2 = 0 ;
17514 char * kwnames[] = {
17515 (char *) "self",(char *) "name",(char *) "type", NULL
17516 };
17517
17518 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17519 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17520 if (!SWIG_IsOK(res1)) {
17521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17522 }
17523 arg1 = reinterpret_cast< wxImage * >(argp1);
17524 {
17525 arg2 = wxString_in_helper(obj1);
17526 if (arg2 == NULL) SWIG_fail;
17527 temp2 = true;
17528 }
17529 ecode3 = SWIG_AsVal_int(obj2, &val3);
17530 if (!SWIG_IsOK(ecode3)) {
17531 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17532 }
17533 arg3 = static_cast< int >(val3);
17534 {
17535 PyThreadState* __tstate = wxPyBeginAllowThreads();
17536 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17537 wxPyEndAllowThreads(__tstate);
17538 if (PyErr_Occurred()) SWIG_fail;
17539 }
17540 {
17541 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17542 }
17543 {
17544 if (temp2)
17545 delete arg2;
17546 }
17547 return resultobj;
17548 fail:
17549 {
17550 if (temp2)
17551 delete arg2;
17552 }
17553 return NULL;
17554 }
17555
17556
17557 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17558 PyObject *resultobj = 0;
17559 wxImage *arg1 = (wxImage *) 0 ;
17560 wxString *arg2 = 0 ;
17561 wxString *arg3 = 0 ;
17562 bool result;
17563 void *argp1 = 0 ;
17564 int res1 = 0 ;
17565 bool temp2 = false ;
17566 bool temp3 = false ;
17567 PyObject * obj0 = 0 ;
17568 PyObject * obj1 = 0 ;
17569 PyObject * obj2 = 0 ;
17570 char * kwnames[] = {
17571 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17572 };
17573
17574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17576 if (!SWIG_IsOK(res1)) {
17577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17578 }
17579 arg1 = reinterpret_cast< wxImage * >(argp1);
17580 {
17581 arg2 = wxString_in_helper(obj1);
17582 if (arg2 == NULL) SWIG_fail;
17583 temp2 = true;
17584 }
17585 {
17586 arg3 = wxString_in_helper(obj2);
17587 if (arg3 == NULL) SWIG_fail;
17588 temp3 = true;
17589 }
17590 {
17591 PyThreadState* __tstate = wxPyBeginAllowThreads();
17592 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17593 wxPyEndAllowThreads(__tstate);
17594 if (PyErr_Occurred()) SWIG_fail;
17595 }
17596 {
17597 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17598 }
17599 {
17600 if (temp2)
17601 delete arg2;
17602 }
17603 {
17604 if (temp3)
17605 delete arg3;
17606 }
17607 return resultobj;
17608 fail:
17609 {
17610 if (temp2)
17611 delete arg2;
17612 }
17613 {
17614 if (temp3)
17615 delete arg3;
17616 }
17617 return NULL;
17618 }
17619
17620
17621 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17622 PyObject *resultobj = 0;
17623 wxInputStream *arg1 = 0 ;
17624 bool result;
17625 wxPyInputStream *temp1 ;
17626 bool created1 ;
17627 PyObject * obj0 = 0 ;
17628 char * kwnames[] = {
17629 (char *) "stream", NULL
17630 };
17631
17632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17633 {
17634 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17635 arg1 = temp1->m_wxis;
17636 created1 = false;
17637 } else {
17638 PyErr_Clear(); // clear the failure of the wxPyConvert above
17639 arg1 = wxPyCBInputStream_create(obj0, false);
17640 if (arg1 == NULL) {
17641 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17642 SWIG_fail;
17643 }
17644 created1 = true;
17645 }
17646 }
17647 {
17648 PyThreadState* __tstate = wxPyBeginAllowThreads();
17649 result = (bool)wxImage::CanRead(*arg1);
17650 wxPyEndAllowThreads(__tstate);
17651 if (PyErr_Occurred()) SWIG_fail;
17652 }
17653 {
17654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17655 }
17656 {
17657 if (created1) delete arg1;
17658 }
17659 return resultobj;
17660 fail:
17661 {
17662 if (created1) delete arg1;
17663 }
17664 return NULL;
17665 }
17666
17667
17668 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17669 PyObject *resultobj = 0;
17670 wxImage *arg1 = (wxImage *) 0 ;
17671 wxInputStream *arg2 = 0 ;
17672 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17673 int arg4 = (int) -1 ;
17674 bool result;
17675 void *argp1 = 0 ;
17676 int res1 = 0 ;
17677 wxPyInputStream *temp2 ;
17678 bool created2 ;
17679 long val3 ;
17680 int ecode3 = 0 ;
17681 int val4 ;
17682 int ecode4 = 0 ;
17683 PyObject * obj0 = 0 ;
17684 PyObject * obj1 = 0 ;
17685 PyObject * obj2 = 0 ;
17686 PyObject * obj3 = 0 ;
17687 char * kwnames[] = {
17688 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17689 };
17690
17691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17693 if (!SWIG_IsOK(res1)) {
17694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17695 }
17696 arg1 = reinterpret_cast< wxImage * >(argp1);
17697 {
17698 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17699 arg2 = temp2->m_wxis;
17700 created2 = false;
17701 } else {
17702 PyErr_Clear(); // clear the failure of the wxPyConvert above
17703 arg2 = wxPyCBInputStream_create(obj1, false);
17704 if (arg2 == NULL) {
17705 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17706 SWIG_fail;
17707 }
17708 created2 = true;
17709 }
17710 }
17711 if (obj2) {
17712 ecode3 = SWIG_AsVal_long(obj2, &val3);
17713 if (!SWIG_IsOK(ecode3)) {
17714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17715 }
17716 arg3 = static_cast< long >(val3);
17717 }
17718 if (obj3) {
17719 ecode4 = SWIG_AsVal_int(obj3, &val4);
17720 if (!SWIG_IsOK(ecode4)) {
17721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17722 }
17723 arg4 = static_cast< int >(val4);
17724 }
17725 {
17726 PyThreadState* __tstate = wxPyBeginAllowThreads();
17727 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17728 wxPyEndAllowThreads(__tstate);
17729 if (PyErr_Occurred()) SWIG_fail;
17730 }
17731 {
17732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17733 }
17734 {
17735 if (created2) delete arg2;
17736 }
17737 return resultobj;
17738 fail:
17739 {
17740 if (created2) delete arg2;
17741 }
17742 return NULL;
17743 }
17744
17745
17746 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17747 PyObject *resultobj = 0;
17748 wxImage *arg1 = (wxImage *) 0 ;
17749 wxInputStream *arg2 = 0 ;
17750 wxString *arg3 = 0 ;
17751 int arg4 = (int) -1 ;
17752 bool result;
17753 void *argp1 = 0 ;
17754 int res1 = 0 ;
17755 wxPyInputStream *temp2 ;
17756 bool created2 ;
17757 bool temp3 = false ;
17758 int val4 ;
17759 int ecode4 = 0 ;
17760 PyObject * obj0 = 0 ;
17761 PyObject * obj1 = 0 ;
17762 PyObject * obj2 = 0 ;
17763 PyObject * obj3 = 0 ;
17764 char * kwnames[] = {
17765 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17766 };
17767
17768 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17769 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17770 if (!SWIG_IsOK(res1)) {
17771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17772 }
17773 arg1 = reinterpret_cast< wxImage * >(argp1);
17774 {
17775 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17776 arg2 = temp2->m_wxis;
17777 created2 = false;
17778 } else {
17779 PyErr_Clear(); // clear the failure of the wxPyConvert above
17780 arg2 = wxPyCBInputStream_create(obj1, false);
17781 if (arg2 == NULL) {
17782 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17783 SWIG_fail;
17784 }
17785 created2 = true;
17786 }
17787 }
17788 {
17789 arg3 = wxString_in_helper(obj2);
17790 if (arg3 == NULL) SWIG_fail;
17791 temp3 = true;
17792 }
17793 if (obj3) {
17794 ecode4 = SWIG_AsVal_int(obj3, &val4);
17795 if (!SWIG_IsOK(ecode4)) {
17796 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17797 }
17798 arg4 = static_cast< int >(val4);
17799 }
17800 {
17801 PyThreadState* __tstate = wxPyBeginAllowThreads();
17802 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17803 wxPyEndAllowThreads(__tstate);
17804 if (PyErr_Occurred()) SWIG_fail;
17805 }
17806 {
17807 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17808 }
17809 {
17810 if (created2) delete arg2;
17811 }
17812 {
17813 if (temp3)
17814 delete arg3;
17815 }
17816 return resultobj;
17817 fail:
17818 {
17819 if (created2) delete arg2;
17820 }
17821 {
17822 if (temp3)
17823 delete arg3;
17824 }
17825 return NULL;
17826 }
17827
17828
17829 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17830 PyObject *resultobj = 0;
17831 wxImage *arg1 = (wxImage *) 0 ;
17832 bool result;
17833 void *argp1 = 0 ;
17834 int res1 = 0 ;
17835 PyObject *swig_obj[1] ;
17836
17837 if (!args) SWIG_fail;
17838 swig_obj[0] = args;
17839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17840 if (!SWIG_IsOK(res1)) {
17841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17842 }
17843 arg1 = reinterpret_cast< wxImage * >(argp1);
17844 {
17845 PyThreadState* __tstate = wxPyBeginAllowThreads();
17846 result = (bool)(arg1)->IsOk();
17847 wxPyEndAllowThreads(__tstate);
17848 if (PyErr_Occurred()) SWIG_fail;
17849 }
17850 {
17851 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17852 }
17853 return resultobj;
17854 fail:
17855 return NULL;
17856 }
17857
17858
17859 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17860 PyObject *resultobj = 0;
17861 wxImage *arg1 = (wxImage *) 0 ;
17862 int result;
17863 void *argp1 = 0 ;
17864 int res1 = 0 ;
17865 PyObject *swig_obj[1] ;
17866
17867 if (!args) SWIG_fail;
17868 swig_obj[0] = args;
17869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17870 if (!SWIG_IsOK(res1)) {
17871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17872 }
17873 arg1 = reinterpret_cast< wxImage * >(argp1);
17874 {
17875 PyThreadState* __tstate = wxPyBeginAllowThreads();
17876 result = (int)(arg1)->GetWidth();
17877 wxPyEndAllowThreads(__tstate);
17878 if (PyErr_Occurred()) SWIG_fail;
17879 }
17880 resultobj = SWIG_From_int(static_cast< int >(result));
17881 return resultobj;
17882 fail:
17883 return NULL;
17884 }
17885
17886
17887 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17888 PyObject *resultobj = 0;
17889 wxImage *arg1 = (wxImage *) 0 ;
17890 int result;
17891 void *argp1 = 0 ;
17892 int res1 = 0 ;
17893 PyObject *swig_obj[1] ;
17894
17895 if (!args) SWIG_fail;
17896 swig_obj[0] = args;
17897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17898 if (!SWIG_IsOK(res1)) {
17899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17900 }
17901 arg1 = reinterpret_cast< wxImage * >(argp1);
17902 {
17903 PyThreadState* __tstate = wxPyBeginAllowThreads();
17904 result = (int)(arg1)->GetHeight();
17905 wxPyEndAllowThreads(__tstate);
17906 if (PyErr_Occurred()) SWIG_fail;
17907 }
17908 resultobj = SWIG_From_int(static_cast< int >(result));
17909 return resultobj;
17910 fail:
17911 return NULL;
17912 }
17913
17914
17915 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17916 PyObject *resultobj = 0;
17917 wxImage *arg1 = (wxImage *) 0 ;
17918 wxSize result;
17919 void *argp1 = 0 ;
17920 int res1 = 0 ;
17921 PyObject *swig_obj[1] ;
17922
17923 if (!args) SWIG_fail;
17924 swig_obj[0] = args;
17925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17926 if (!SWIG_IsOK(res1)) {
17927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17928 }
17929 arg1 = reinterpret_cast< wxImage * >(argp1);
17930 {
17931 PyThreadState* __tstate = wxPyBeginAllowThreads();
17932 result = wxImage_GetSize(arg1);
17933 wxPyEndAllowThreads(__tstate);
17934 if (PyErr_Occurred()) SWIG_fail;
17935 }
17936 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17937 return resultobj;
17938 fail:
17939 return NULL;
17940 }
17941
17942
17943 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17944 PyObject *resultobj = 0;
17945 wxImage *arg1 = (wxImage *) 0 ;
17946 wxRect *arg2 = 0 ;
17947 SwigValueWrapper<wxImage > result;
17948 void *argp1 = 0 ;
17949 int res1 = 0 ;
17950 wxRect temp2 ;
17951 PyObject * obj0 = 0 ;
17952 PyObject * obj1 = 0 ;
17953 char * kwnames[] = {
17954 (char *) "self",(char *) "rect", NULL
17955 };
17956
17957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17959 if (!SWIG_IsOK(res1)) {
17960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17961 }
17962 arg1 = reinterpret_cast< wxImage * >(argp1);
17963 {
17964 arg2 = &temp2;
17965 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17966 }
17967 {
17968 PyThreadState* __tstate = wxPyBeginAllowThreads();
17969 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17970 wxPyEndAllowThreads(__tstate);
17971 if (PyErr_Occurred()) SWIG_fail;
17972 }
17973 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17974 return resultobj;
17975 fail:
17976 return NULL;
17977 }
17978
17979
17980 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17981 PyObject *resultobj = 0;
17982 wxImage *arg1 = (wxImage *) 0 ;
17983 wxSize *arg2 = 0 ;
17984 wxPoint *arg3 = 0 ;
17985 int arg4 = (int) -1 ;
17986 int arg5 = (int) -1 ;
17987 int arg6 = (int) -1 ;
17988 SwigValueWrapper<wxImage > result;
17989 void *argp1 = 0 ;
17990 int res1 = 0 ;
17991 wxSize temp2 ;
17992 wxPoint temp3 ;
17993 int val4 ;
17994 int ecode4 = 0 ;
17995 int val5 ;
17996 int ecode5 = 0 ;
17997 int val6 ;
17998 int ecode6 = 0 ;
17999 PyObject * obj0 = 0 ;
18000 PyObject * obj1 = 0 ;
18001 PyObject * obj2 = 0 ;
18002 PyObject * obj3 = 0 ;
18003 PyObject * obj4 = 0 ;
18004 PyObject * obj5 = 0 ;
18005 char * kwnames[] = {
18006 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18007 };
18008
18009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18011 if (!SWIG_IsOK(res1)) {
18012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18013 }
18014 arg1 = reinterpret_cast< wxImage * >(argp1);
18015 {
18016 arg2 = &temp2;
18017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18018 }
18019 {
18020 arg3 = &temp3;
18021 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18022 }
18023 if (obj3) {
18024 ecode4 = SWIG_AsVal_int(obj3, &val4);
18025 if (!SWIG_IsOK(ecode4)) {
18026 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18027 }
18028 arg4 = static_cast< int >(val4);
18029 }
18030 if (obj4) {
18031 ecode5 = SWIG_AsVal_int(obj4, &val5);
18032 if (!SWIG_IsOK(ecode5)) {
18033 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18034 }
18035 arg5 = static_cast< int >(val5);
18036 }
18037 if (obj5) {
18038 ecode6 = SWIG_AsVal_int(obj5, &val6);
18039 if (!SWIG_IsOK(ecode6)) {
18040 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18041 }
18042 arg6 = static_cast< int >(val6);
18043 }
18044 {
18045 PyThreadState* __tstate = wxPyBeginAllowThreads();
18046 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18047 wxPyEndAllowThreads(__tstate);
18048 if (PyErr_Occurred()) SWIG_fail;
18049 }
18050 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18051 return resultobj;
18052 fail:
18053 return NULL;
18054 }
18055
18056
18057 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18058 PyObject *resultobj = 0;
18059 wxImage *arg1 = (wxImage *) 0 ;
18060 SwigValueWrapper<wxImage > result;
18061 void *argp1 = 0 ;
18062 int res1 = 0 ;
18063 PyObject *swig_obj[1] ;
18064
18065 if (!args) SWIG_fail;
18066 swig_obj[0] = args;
18067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18068 if (!SWIG_IsOK(res1)) {
18069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18070 }
18071 arg1 = reinterpret_cast< wxImage * >(argp1);
18072 {
18073 PyThreadState* __tstate = wxPyBeginAllowThreads();
18074 result = (arg1)->Copy();
18075 wxPyEndAllowThreads(__tstate);
18076 if (PyErr_Occurred()) SWIG_fail;
18077 }
18078 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18079 return resultobj;
18080 fail:
18081 return NULL;
18082 }
18083
18084
18085 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18086 PyObject *resultobj = 0;
18087 wxImage *arg1 = (wxImage *) 0 ;
18088 wxImage *arg2 = 0 ;
18089 int arg3 ;
18090 int arg4 ;
18091 void *argp1 = 0 ;
18092 int res1 = 0 ;
18093 void *argp2 = 0 ;
18094 int res2 = 0 ;
18095 int val3 ;
18096 int ecode3 = 0 ;
18097 int val4 ;
18098 int ecode4 = 0 ;
18099 PyObject * obj0 = 0 ;
18100 PyObject * obj1 = 0 ;
18101 PyObject * obj2 = 0 ;
18102 PyObject * obj3 = 0 ;
18103 char * kwnames[] = {
18104 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18105 };
18106
18107 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18108 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18109 if (!SWIG_IsOK(res1)) {
18110 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18111 }
18112 arg1 = reinterpret_cast< wxImage * >(argp1);
18113 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18114 if (!SWIG_IsOK(res2)) {
18115 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18116 }
18117 if (!argp2) {
18118 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18119 }
18120 arg2 = reinterpret_cast< wxImage * >(argp2);
18121 ecode3 = SWIG_AsVal_int(obj2, &val3);
18122 if (!SWIG_IsOK(ecode3)) {
18123 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18124 }
18125 arg3 = static_cast< int >(val3);
18126 ecode4 = SWIG_AsVal_int(obj3, &val4);
18127 if (!SWIG_IsOK(ecode4)) {
18128 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18129 }
18130 arg4 = static_cast< int >(val4);
18131 {
18132 PyThreadState* __tstate = wxPyBeginAllowThreads();
18133 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18134 wxPyEndAllowThreads(__tstate);
18135 if (PyErr_Occurred()) SWIG_fail;
18136 }
18137 resultobj = SWIG_Py_Void();
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18145 PyObject *resultobj = 0;
18146 wxImage *arg1 = (wxImage *) 0 ;
18147 PyObject *result = 0 ;
18148 void *argp1 = 0 ;
18149 int res1 = 0 ;
18150 PyObject *swig_obj[1] ;
18151
18152 if (!args) SWIG_fail;
18153 swig_obj[0] = args;
18154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18155 if (!SWIG_IsOK(res1)) {
18156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18157 }
18158 arg1 = reinterpret_cast< wxImage * >(argp1);
18159 {
18160 PyThreadState* __tstate = wxPyBeginAllowThreads();
18161 result = (PyObject *)wxImage_GetData(arg1);
18162 wxPyEndAllowThreads(__tstate);
18163 if (PyErr_Occurred()) SWIG_fail;
18164 }
18165 resultobj = result;
18166 return resultobj;
18167 fail:
18168 return NULL;
18169 }
18170
18171
18172 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18173 PyObject *resultobj = 0;
18174 wxImage *arg1 = (wxImage *) 0 ;
18175 buffer arg2 ;
18176 int arg3 ;
18177 void *argp1 = 0 ;
18178 int res1 = 0 ;
18179 Py_ssize_t temp2 ;
18180 PyObject * obj0 = 0 ;
18181 PyObject * obj1 = 0 ;
18182 char * kwnames[] = {
18183 (char *) "self",(char *) "data", NULL
18184 };
18185
18186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18188 if (!SWIG_IsOK(res1)) {
18189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18190 }
18191 arg1 = reinterpret_cast< wxImage * >(argp1);
18192 {
18193 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18194 arg3 = (int)temp2;
18195 }
18196 {
18197 PyThreadState* __tstate = wxPyBeginAllowThreads();
18198 wxImage_SetData(arg1,arg2,arg3);
18199 wxPyEndAllowThreads(__tstate);
18200 if (PyErr_Occurred()) SWIG_fail;
18201 }
18202 resultobj = SWIG_Py_Void();
18203 return resultobj;
18204 fail:
18205 return NULL;
18206 }
18207
18208
18209 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18210 PyObject *resultobj = 0;
18211 wxImage *arg1 = (wxImage *) 0 ;
18212 PyObject *result = 0 ;
18213 void *argp1 = 0 ;
18214 int res1 = 0 ;
18215 PyObject *swig_obj[1] ;
18216
18217 if (!args) SWIG_fail;
18218 swig_obj[0] = args;
18219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18220 if (!SWIG_IsOK(res1)) {
18221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18222 }
18223 arg1 = reinterpret_cast< wxImage * >(argp1);
18224 {
18225 PyThreadState* __tstate = wxPyBeginAllowThreads();
18226 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18227 wxPyEndAllowThreads(__tstate);
18228 if (PyErr_Occurred()) SWIG_fail;
18229 }
18230 resultobj = result;
18231 return resultobj;
18232 fail:
18233 return NULL;
18234 }
18235
18236
18237 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18238 PyObject *resultobj = 0;
18239 wxImage *arg1 = (wxImage *) 0 ;
18240 buffer arg2 ;
18241 int arg3 ;
18242 void *argp1 = 0 ;
18243 int res1 = 0 ;
18244 Py_ssize_t temp2 ;
18245 PyObject * obj0 = 0 ;
18246 PyObject * obj1 = 0 ;
18247 char * kwnames[] = {
18248 (char *) "self",(char *) "data", NULL
18249 };
18250
18251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18253 if (!SWIG_IsOK(res1)) {
18254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18255 }
18256 arg1 = reinterpret_cast< wxImage * >(argp1);
18257 {
18258 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18259 arg3 = (int)temp2;
18260 }
18261 {
18262 PyThreadState* __tstate = wxPyBeginAllowThreads();
18263 wxImage_SetDataBuffer(arg1,arg2,arg3);
18264 wxPyEndAllowThreads(__tstate);
18265 if (PyErr_Occurred()) SWIG_fail;
18266 }
18267 resultobj = SWIG_Py_Void();
18268 return resultobj;
18269 fail:
18270 return NULL;
18271 }
18272
18273
18274 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18275 PyObject *resultobj = 0;
18276 wxImage *arg1 = (wxImage *) 0 ;
18277 PyObject *result = 0 ;
18278 void *argp1 = 0 ;
18279 int res1 = 0 ;
18280 PyObject *swig_obj[1] ;
18281
18282 if (!args) SWIG_fail;
18283 swig_obj[0] = args;
18284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18285 if (!SWIG_IsOK(res1)) {
18286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18287 }
18288 arg1 = reinterpret_cast< wxImage * >(argp1);
18289 {
18290 PyThreadState* __tstate = wxPyBeginAllowThreads();
18291 result = (PyObject *)wxImage_GetAlphaData(arg1);
18292 wxPyEndAllowThreads(__tstate);
18293 if (PyErr_Occurred()) SWIG_fail;
18294 }
18295 resultobj = result;
18296 return resultobj;
18297 fail:
18298 return NULL;
18299 }
18300
18301
18302 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18303 PyObject *resultobj = 0;
18304 wxImage *arg1 = (wxImage *) 0 ;
18305 buffer arg2 ;
18306 int arg3 ;
18307 void *argp1 = 0 ;
18308 int res1 = 0 ;
18309 Py_ssize_t temp2 ;
18310 PyObject * obj0 = 0 ;
18311 PyObject * obj1 = 0 ;
18312 char * kwnames[] = {
18313 (char *) "self",(char *) "alpha", NULL
18314 };
18315
18316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18318 if (!SWIG_IsOK(res1)) {
18319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18320 }
18321 arg1 = reinterpret_cast< wxImage * >(argp1);
18322 {
18323 if (obj1 != Py_None) {
18324 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18325 arg3 = (int)temp2;
18326 }
18327 }
18328 {
18329 PyThreadState* __tstate = wxPyBeginAllowThreads();
18330 wxImage_SetAlphaData(arg1,arg2,arg3);
18331 wxPyEndAllowThreads(__tstate);
18332 if (PyErr_Occurred()) SWIG_fail;
18333 }
18334 resultobj = SWIG_Py_Void();
18335 return resultobj;
18336 fail:
18337 return NULL;
18338 }
18339
18340
18341 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18342 PyObject *resultobj = 0;
18343 wxImage *arg1 = (wxImage *) 0 ;
18344 PyObject *result = 0 ;
18345 void *argp1 = 0 ;
18346 int res1 = 0 ;
18347 PyObject *swig_obj[1] ;
18348
18349 if (!args) SWIG_fail;
18350 swig_obj[0] = args;
18351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18352 if (!SWIG_IsOK(res1)) {
18353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18354 }
18355 arg1 = reinterpret_cast< wxImage * >(argp1);
18356 {
18357 PyThreadState* __tstate = wxPyBeginAllowThreads();
18358 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18359 wxPyEndAllowThreads(__tstate);
18360 if (PyErr_Occurred()) SWIG_fail;
18361 }
18362 resultobj = result;
18363 return resultobj;
18364 fail:
18365 return NULL;
18366 }
18367
18368
18369 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18370 PyObject *resultobj = 0;
18371 wxImage *arg1 = (wxImage *) 0 ;
18372 buffer arg2 ;
18373 int arg3 ;
18374 void *argp1 = 0 ;
18375 int res1 = 0 ;
18376 Py_ssize_t temp2 ;
18377 PyObject * obj0 = 0 ;
18378 PyObject * obj1 = 0 ;
18379 char * kwnames[] = {
18380 (char *) "self",(char *) "alpha", NULL
18381 };
18382
18383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18385 if (!SWIG_IsOK(res1)) {
18386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18387 }
18388 arg1 = reinterpret_cast< wxImage * >(argp1);
18389 {
18390 if (obj1 != Py_None) {
18391 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18392 arg3 = (int)temp2;
18393 }
18394 }
18395 {
18396 PyThreadState* __tstate = wxPyBeginAllowThreads();
18397 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18398 wxPyEndAllowThreads(__tstate);
18399 if (PyErr_Occurred()) SWIG_fail;
18400 }
18401 resultobj = SWIG_Py_Void();
18402 return resultobj;
18403 fail:
18404 return NULL;
18405 }
18406
18407
18408 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18409 PyObject *resultobj = 0;
18410 wxImage *arg1 = (wxImage *) 0 ;
18411 byte arg2 ;
18412 byte arg3 ;
18413 byte arg4 ;
18414 void *argp1 = 0 ;
18415 int res1 = 0 ;
18416 unsigned char val2 ;
18417 int ecode2 = 0 ;
18418 unsigned char val3 ;
18419 int ecode3 = 0 ;
18420 unsigned char val4 ;
18421 int ecode4 = 0 ;
18422 PyObject * obj0 = 0 ;
18423 PyObject * obj1 = 0 ;
18424 PyObject * obj2 = 0 ;
18425 PyObject * obj3 = 0 ;
18426 char * kwnames[] = {
18427 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18428 };
18429
18430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18432 if (!SWIG_IsOK(res1)) {
18433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18434 }
18435 arg1 = reinterpret_cast< wxImage * >(argp1);
18436 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18437 if (!SWIG_IsOK(ecode2)) {
18438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18439 }
18440 arg2 = static_cast< byte >(val2);
18441 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18442 if (!SWIG_IsOK(ecode3)) {
18443 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18444 }
18445 arg3 = static_cast< byte >(val3);
18446 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18447 if (!SWIG_IsOK(ecode4)) {
18448 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18449 }
18450 arg4 = static_cast< byte >(val4);
18451 {
18452 PyThreadState* __tstate = wxPyBeginAllowThreads();
18453 (arg1)->SetMaskColour(arg2,arg3,arg4);
18454 wxPyEndAllowThreads(__tstate);
18455 if (PyErr_Occurred()) SWIG_fail;
18456 }
18457 resultobj = SWIG_Py_Void();
18458 return resultobj;
18459 fail:
18460 return NULL;
18461 }
18462
18463
18464 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18465 PyObject *resultobj = 0;
18466 wxImage *arg1 = (wxImage *) 0 ;
18467 byte *arg2 = (byte *) 0 ;
18468 byte *arg3 = (byte *) 0 ;
18469 byte *arg4 = (byte *) 0 ;
18470 void *argp1 = 0 ;
18471 int res1 = 0 ;
18472 byte temp2 ;
18473 int res2 = SWIG_TMPOBJ ;
18474 byte temp3 ;
18475 int res3 = SWIG_TMPOBJ ;
18476 byte temp4 ;
18477 int res4 = SWIG_TMPOBJ ;
18478 PyObject *swig_obj[1] ;
18479
18480 arg2 = &temp2;
18481 arg3 = &temp3;
18482 arg4 = &temp4;
18483 if (!args) SWIG_fail;
18484 swig_obj[0] = args;
18485 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18486 if (!SWIG_IsOK(res1)) {
18487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18488 }
18489 arg1 = reinterpret_cast< wxImage * >(argp1);
18490 {
18491 PyThreadState* __tstate = wxPyBeginAllowThreads();
18492 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18493 wxPyEndAllowThreads(__tstate);
18494 if (PyErr_Occurred()) SWIG_fail;
18495 }
18496 resultobj = SWIG_Py_Void();
18497 if (SWIG_IsTmpObj(res2)) {
18498 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18499 } else {
18500 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18501 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18502 }
18503 if (SWIG_IsTmpObj(res3)) {
18504 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18505 } else {
18506 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18507 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18508 }
18509 if (SWIG_IsTmpObj(res4)) {
18510 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18511 } else {
18512 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18514 }
18515 return resultobj;
18516 fail:
18517 return NULL;
18518 }
18519
18520
18521 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18522 PyObject *resultobj = 0;
18523 wxImage *arg1 = (wxImage *) 0 ;
18524 byte result;
18525 void *argp1 = 0 ;
18526 int res1 = 0 ;
18527 PyObject *swig_obj[1] ;
18528
18529 if (!args) SWIG_fail;
18530 swig_obj[0] = args;
18531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18532 if (!SWIG_IsOK(res1)) {
18533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18534 }
18535 arg1 = reinterpret_cast< wxImage * >(argp1);
18536 {
18537 PyThreadState* __tstate = wxPyBeginAllowThreads();
18538 result = (byte)(arg1)->GetMaskRed();
18539 wxPyEndAllowThreads(__tstate);
18540 if (PyErr_Occurred()) SWIG_fail;
18541 }
18542 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18543 return resultobj;
18544 fail:
18545 return NULL;
18546 }
18547
18548
18549 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18550 PyObject *resultobj = 0;
18551 wxImage *arg1 = (wxImage *) 0 ;
18552 byte result;
18553 void *argp1 = 0 ;
18554 int res1 = 0 ;
18555 PyObject *swig_obj[1] ;
18556
18557 if (!args) SWIG_fail;
18558 swig_obj[0] = args;
18559 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18560 if (!SWIG_IsOK(res1)) {
18561 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18562 }
18563 arg1 = reinterpret_cast< wxImage * >(argp1);
18564 {
18565 PyThreadState* __tstate = wxPyBeginAllowThreads();
18566 result = (byte)(arg1)->GetMaskGreen();
18567 wxPyEndAllowThreads(__tstate);
18568 if (PyErr_Occurred()) SWIG_fail;
18569 }
18570 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18571 return resultobj;
18572 fail:
18573 return NULL;
18574 }
18575
18576
18577 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18578 PyObject *resultobj = 0;
18579 wxImage *arg1 = (wxImage *) 0 ;
18580 byte result;
18581 void *argp1 = 0 ;
18582 int res1 = 0 ;
18583 PyObject *swig_obj[1] ;
18584
18585 if (!args) SWIG_fail;
18586 swig_obj[0] = args;
18587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18588 if (!SWIG_IsOK(res1)) {
18589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18590 }
18591 arg1 = reinterpret_cast< wxImage * >(argp1);
18592 {
18593 PyThreadState* __tstate = wxPyBeginAllowThreads();
18594 result = (byte)(arg1)->GetMaskBlue();
18595 wxPyEndAllowThreads(__tstate);
18596 if (PyErr_Occurred()) SWIG_fail;
18597 }
18598 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18599 return resultobj;
18600 fail:
18601 return NULL;
18602 }
18603
18604
18605 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18606 PyObject *resultobj = 0;
18607 wxImage *arg1 = (wxImage *) 0 ;
18608 bool arg2 = (bool) true ;
18609 void *argp1 = 0 ;
18610 int res1 = 0 ;
18611 bool val2 ;
18612 int ecode2 = 0 ;
18613 PyObject * obj0 = 0 ;
18614 PyObject * obj1 = 0 ;
18615 char * kwnames[] = {
18616 (char *) "self",(char *) "mask", NULL
18617 };
18618
18619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18621 if (!SWIG_IsOK(res1)) {
18622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18623 }
18624 arg1 = reinterpret_cast< wxImage * >(argp1);
18625 if (obj1) {
18626 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18627 if (!SWIG_IsOK(ecode2)) {
18628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18629 }
18630 arg2 = static_cast< bool >(val2);
18631 }
18632 {
18633 PyThreadState* __tstate = wxPyBeginAllowThreads();
18634 (arg1)->SetMask(arg2);
18635 wxPyEndAllowThreads(__tstate);
18636 if (PyErr_Occurred()) SWIG_fail;
18637 }
18638 resultobj = SWIG_Py_Void();
18639 return resultobj;
18640 fail:
18641 return NULL;
18642 }
18643
18644
18645 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18646 PyObject *resultobj = 0;
18647 wxImage *arg1 = (wxImage *) 0 ;
18648 bool result;
18649 void *argp1 = 0 ;
18650 int res1 = 0 ;
18651 PyObject *swig_obj[1] ;
18652
18653 if (!args) SWIG_fail;
18654 swig_obj[0] = args;
18655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18656 if (!SWIG_IsOK(res1)) {
18657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18658 }
18659 arg1 = reinterpret_cast< wxImage * >(argp1);
18660 {
18661 PyThreadState* __tstate = wxPyBeginAllowThreads();
18662 result = (bool)(arg1)->HasMask();
18663 wxPyEndAllowThreads(__tstate);
18664 if (PyErr_Occurred()) SWIG_fail;
18665 }
18666 {
18667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18668 }
18669 return resultobj;
18670 fail:
18671 return NULL;
18672 }
18673
18674
18675 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18676 PyObject *resultobj = 0;
18677 wxImage *arg1 = (wxImage *) 0 ;
18678 double arg2 ;
18679 wxPoint *arg3 = 0 ;
18680 bool arg4 = (bool) true ;
18681 wxPoint *arg5 = (wxPoint *) NULL ;
18682 SwigValueWrapper<wxImage > result;
18683 void *argp1 = 0 ;
18684 int res1 = 0 ;
18685 double val2 ;
18686 int ecode2 = 0 ;
18687 wxPoint temp3 ;
18688 bool val4 ;
18689 int ecode4 = 0 ;
18690 void *argp5 = 0 ;
18691 int res5 = 0 ;
18692 PyObject * obj0 = 0 ;
18693 PyObject * obj1 = 0 ;
18694 PyObject * obj2 = 0 ;
18695 PyObject * obj3 = 0 ;
18696 PyObject * obj4 = 0 ;
18697 char * kwnames[] = {
18698 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18699 };
18700
18701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18703 if (!SWIG_IsOK(res1)) {
18704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18705 }
18706 arg1 = reinterpret_cast< wxImage * >(argp1);
18707 ecode2 = SWIG_AsVal_double(obj1, &val2);
18708 if (!SWIG_IsOK(ecode2)) {
18709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18710 }
18711 arg2 = static_cast< double >(val2);
18712 {
18713 arg3 = &temp3;
18714 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18715 }
18716 if (obj3) {
18717 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18718 if (!SWIG_IsOK(ecode4)) {
18719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18720 }
18721 arg4 = static_cast< bool >(val4);
18722 }
18723 if (obj4) {
18724 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18725 if (!SWIG_IsOK(res5)) {
18726 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18727 }
18728 arg5 = reinterpret_cast< wxPoint * >(argp5);
18729 }
18730 {
18731 PyThreadState* __tstate = wxPyBeginAllowThreads();
18732 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18733 wxPyEndAllowThreads(__tstate);
18734 if (PyErr_Occurred()) SWIG_fail;
18735 }
18736 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18737 return resultobj;
18738 fail:
18739 return NULL;
18740 }
18741
18742
18743 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18744 PyObject *resultobj = 0;
18745 wxImage *arg1 = (wxImage *) 0 ;
18746 bool arg2 = (bool) true ;
18747 SwigValueWrapper<wxImage > result;
18748 void *argp1 = 0 ;
18749 int res1 = 0 ;
18750 bool val2 ;
18751 int ecode2 = 0 ;
18752 PyObject * obj0 = 0 ;
18753 PyObject * obj1 = 0 ;
18754 char * kwnames[] = {
18755 (char *) "self",(char *) "clockwise", NULL
18756 };
18757
18758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18760 if (!SWIG_IsOK(res1)) {
18761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18762 }
18763 arg1 = reinterpret_cast< wxImage * >(argp1);
18764 if (obj1) {
18765 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18766 if (!SWIG_IsOK(ecode2)) {
18767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18768 }
18769 arg2 = static_cast< bool >(val2);
18770 }
18771 {
18772 PyThreadState* __tstate = wxPyBeginAllowThreads();
18773 result = (arg1)->Rotate90(arg2);
18774 wxPyEndAllowThreads(__tstate);
18775 if (PyErr_Occurred()) SWIG_fail;
18776 }
18777 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18778 return resultobj;
18779 fail:
18780 return NULL;
18781 }
18782
18783
18784 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18785 PyObject *resultobj = 0;
18786 wxImage *arg1 = (wxImage *) 0 ;
18787 bool arg2 = (bool) true ;
18788 SwigValueWrapper<wxImage > result;
18789 void *argp1 = 0 ;
18790 int res1 = 0 ;
18791 bool val2 ;
18792 int ecode2 = 0 ;
18793 PyObject * obj0 = 0 ;
18794 PyObject * obj1 = 0 ;
18795 char * kwnames[] = {
18796 (char *) "self",(char *) "horizontally", NULL
18797 };
18798
18799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18801 if (!SWIG_IsOK(res1)) {
18802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18803 }
18804 arg1 = reinterpret_cast< wxImage * >(argp1);
18805 if (obj1) {
18806 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18807 if (!SWIG_IsOK(ecode2)) {
18808 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18809 }
18810 arg2 = static_cast< bool >(val2);
18811 }
18812 {
18813 PyThreadState* __tstate = wxPyBeginAllowThreads();
18814 result = (arg1)->Mirror(arg2);
18815 wxPyEndAllowThreads(__tstate);
18816 if (PyErr_Occurred()) SWIG_fail;
18817 }
18818 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18819 return resultobj;
18820 fail:
18821 return NULL;
18822 }
18823
18824
18825 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18826 PyObject *resultobj = 0;
18827 wxImage *arg1 = (wxImage *) 0 ;
18828 byte arg2 ;
18829 byte arg3 ;
18830 byte arg4 ;
18831 byte arg5 ;
18832 byte arg6 ;
18833 byte arg7 ;
18834 void *argp1 = 0 ;
18835 int res1 = 0 ;
18836 unsigned char val2 ;
18837 int ecode2 = 0 ;
18838 unsigned char val3 ;
18839 int ecode3 = 0 ;
18840 unsigned char val4 ;
18841 int ecode4 = 0 ;
18842 unsigned char val5 ;
18843 int ecode5 = 0 ;
18844 unsigned char val6 ;
18845 int ecode6 = 0 ;
18846 unsigned char val7 ;
18847 int ecode7 = 0 ;
18848 PyObject * obj0 = 0 ;
18849 PyObject * obj1 = 0 ;
18850 PyObject * obj2 = 0 ;
18851 PyObject * obj3 = 0 ;
18852 PyObject * obj4 = 0 ;
18853 PyObject * obj5 = 0 ;
18854 PyObject * obj6 = 0 ;
18855 char * kwnames[] = {
18856 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18857 };
18858
18859 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18860 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18861 if (!SWIG_IsOK(res1)) {
18862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18863 }
18864 arg1 = reinterpret_cast< wxImage * >(argp1);
18865 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18866 if (!SWIG_IsOK(ecode2)) {
18867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18868 }
18869 arg2 = static_cast< byte >(val2);
18870 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18871 if (!SWIG_IsOK(ecode3)) {
18872 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18873 }
18874 arg3 = static_cast< byte >(val3);
18875 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18876 if (!SWIG_IsOK(ecode4)) {
18877 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18878 }
18879 arg4 = static_cast< byte >(val4);
18880 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18881 if (!SWIG_IsOK(ecode5)) {
18882 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18883 }
18884 arg5 = static_cast< byte >(val5);
18885 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18886 if (!SWIG_IsOK(ecode6)) {
18887 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18888 }
18889 arg6 = static_cast< byte >(val6);
18890 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18891 if (!SWIG_IsOK(ecode7)) {
18892 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18893 }
18894 arg7 = static_cast< byte >(val7);
18895 {
18896 PyThreadState* __tstate = wxPyBeginAllowThreads();
18897 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18898 wxPyEndAllowThreads(__tstate);
18899 if (PyErr_Occurred()) SWIG_fail;
18900 }
18901 resultobj = SWIG_Py_Void();
18902 return resultobj;
18903 fail:
18904 return NULL;
18905 }
18906
18907
18908 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18909 PyObject *resultobj = 0;
18910 wxImage *arg1 = (wxImage *) 0 ;
18911 double arg2 = (double) 0.299 ;
18912 double arg3 = (double) 0.587 ;
18913 double arg4 = (double) 0.114 ;
18914 SwigValueWrapper<wxImage > result;
18915 void *argp1 = 0 ;
18916 int res1 = 0 ;
18917 double val2 ;
18918 int ecode2 = 0 ;
18919 double val3 ;
18920 int ecode3 = 0 ;
18921 double val4 ;
18922 int ecode4 = 0 ;
18923 PyObject * obj0 = 0 ;
18924 PyObject * obj1 = 0 ;
18925 PyObject * obj2 = 0 ;
18926 PyObject * obj3 = 0 ;
18927 char * kwnames[] = {
18928 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18929 };
18930
18931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18933 if (!SWIG_IsOK(res1)) {
18934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18935 }
18936 arg1 = reinterpret_cast< wxImage * >(argp1);
18937 if (obj1) {
18938 ecode2 = SWIG_AsVal_double(obj1, &val2);
18939 if (!SWIG_IsOK(ecode2)) {
18940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18941 }
18942 arg2 = static_cast< double >(val2);
18943 }
18944 if (obj2) {
18945 ecode3 = SWIG_AsVal_double(obj2, &val3);
18946 if (!SWIG_IsOK(ecode3)) {
18947 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18948 }
18949 arg3 = static_cast< double >(val3);
18950 }
18951 if (obj3) {
18952 ecode4 = SWIG_AsVal_double(obj3, &val4);
18953 if (!SWIG_IsOK(ecode4)) {
18954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18955 }
18956 arg4 = static_cast< double >(val4);
18957 }
18958 {
18959 PyThreadState* __tstate = wxPyBeginAllowThreads();
18960 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18961 wxPyEndAllowThreads(__tstate);
18962 if (PyErr_Occurred()) SWIG_fail;
18963 }
18964 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18965 return resultobj;
18966 fail:
18967 return NULL;
18968 }
18969
18970
18971 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18972 PyObject *resultobj = 0;
18973 wxImage *arg1 = (wxImage *) 0 ;
18974 byte arg2 ;
18975 byte arg3 ;
18976 byte arg4 ;
18977 SwigValueWrapper<wxImage > result;
18978 void *argp1 = 0 ;
18979 int res1 = 0 ;
18980 unsigned char val2 ;
18981 int ecode2 = 0 ;
18982 unsigned char val3 ;
18983 int ecode3 = 0 ;
18984 unsigned char val4 ;
18985 int ecode4 = 0 ;
18986 PyObject * obj0 = 0 ;
18987 PyObject * obj1 = 0 ;
18988 PyObject * obj2 = 0 ;
18989 PyObject * obj3 = 0 ;
18990 char * kwnames[] = {
18991 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18992 };
18993
18994 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18995 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18996 if (!SWIG_IsOK(res1)) {
18997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
18998 }
18999 arg1 = reinterpret_cast< wxImage * >(argp1);
19000 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19001 if (!SWIG_IsOK(ecode2)) {
19002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19003 }
19004 arg2 = static_cast< byte >(val2);
19005 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19006 if (!SWIG_IsOK(ecode3)) {
19007 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19008 }
19009 arg3 = static_cast< byte >(val3);
19010 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19011 if (!SWIG_IsOK(ecode4)) {
19012 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19013 }
19014 arg4 = static_cast< byte >(val4);
19015 {
19016 PyThreadState* __tstate = wxPyBeginAllowThreads();
19017 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19018 wxPyEndAllowThreads(__tstate);
19019 if (PyErr_Occurred()) SWIG_fail;
19020 }
19021 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19022 return resultobj;
19023 fail:
19024 return NULL;
19025 }
19026
19027
19028 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19029 PyObject *resultobj = 0;
19030 wxImage *arg1 = (wxImage *) 0 ;
19031 wxString *arg2 = 0 ;
19032 wxString *arg3 = 0 ;
19033 void *argp1 = 0 ;
19034 int res1 = 0 ;
19035 bool temp2 = false ;
19036 bool temp3 = false ;
19037 PyObject * obj0 = 0 ;
19038 PyObject * obj1 = 0 ;
19039 PyObject * obj2 = 0 ;
19040 char * kwnames[] = {
19041 (char *) "self",(char *) "name",(char *) "value", NULL
19042 };
19043
19044 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19045 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19046 if (!SWIG_IsOK(res1)) {
19047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19048 }
19049 arg1 = reinterpret_cast< wxImage * >(argp1);
19050 {
19051 arg2 = wxString_in_helper(obj1);
19052 if (arg2 == NULL) SWIG_fail;
19053 temp2 = true;
19054 }
19055 {
19056 arg3 = wxString_in_helper(obj2);
19057 if (arg3 == NULL) SWIG_fail;
19058 temp3 = true;
19059 }
19060 {
19061 PyThreadState* __tstate = wxPyBeginAllowThreads();
19062 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19063 wxPyEndAllowThreads(__tstate);
19064 if (PyErr_Occurred()) SWIG_fail;
19065 }
19066 resultobj = SWIG_Py_Void();
19067 {
19068 if (temp2)
19069 delete arg2;
19070 }
19071 {
19072 if (temp3)
19073 delete arg3;
19074 }
19075 return resultobj;
19076 fail:
19077 {
19078 if (temp2)
19079 delete arg2;
19080 }
19081 {
19082 if (temp3)
19083 delete arg3;
19084 }
19085 return NULL;
19086 }
19087
19088
19089 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19090 PyObject *resultobj = 0;
19091 wxImage *arg1 = (wxImage *) 0 ;
19092 wxString *arg2 = 0 ;
19093 int arg3 ;
19094 void *argp1 = 0 ;
19095 int res1 = 0 ;
19096 bool temp2 = false ;
19097 int val3 ;
19098 int ecode3 = 0 ;
19099 PyObject * obj0 = 0 ;
19100 PyObject * obj1 = 0 ;
19101 PyObject * obj2 = 0 ;
19102 char * kwnames[] = {
19103 (char *) "self",(char *) "name",(char *) "value", NULL
19104 };
19105
19106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19108 if (!SWIG_IsOK(res1)) {
19109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19110 }
19111 arg1 = reinterpret_cast< wxImage * >(argp1);
19112 {
19113 arg2 = wxString_in_helper(obj1);
19114 if (arg2 == NULL) SWIG_fail;
19115 temp2 = true;
19116 }
19117 ecode3 = SWIG_AsVal_int(obj2, &val3);
19118 if (!SWIG_IsOK(ecode3)) {
19119 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19120 }
19121 arg3 = static_cast< int >(val3);
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 (arg1)->SetOption((wxString const &)*arg2,arg3);
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 resultobj = SWIG_Py_Void();
19129 {
19130 if (temp2)
19131 delete arg2;
19132 }
19133 return resultobj;
19134 fail:
19135 {
19136 if (temp2)
19137 delete arg2;
19138 }
19139 return NULL;
19140 }
19141
19142
19143 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19144 PyObject *resultobj = 0;
19145 wxImage *arg1 = (wxImage *) 0 ;
19146 wxString *arg2 = 0 ;
19147 wxString result;
19148 void *argp1 = 0 ;
19149 int res1 = 0 ;
19150 bool temp2 = false ;
19151 PyObject * obj0 = 0 ;
19152 PyObject * obj1 = 0 ;
19153 char * kwnames[] = {
19154 (char *) "self",(char *) "name", NULL
19155 };
19156
19157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19159 if (!SWIG_IsOK(res1)) {
19160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19161 }
19162 arg1 = reinterpret_cast< wxImage * >(argp1);
19163 {
19164 arg2 = wxString_in_helper(obj1);
19165 if (arg2 == NULL) SWIG_fail;
19166 temp2 = true;
19167 }
19168 {
19169 PyThreadState* __tstate = wxPyBeginAllowThreads();
19170 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19171 wxPyEndAllowThreads(__tstate);
19172 if (PyErr_Occurred()) SWIG_fail;
19173 }
19174 {
19175 #if wxUSE_UNICODE
19176 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19177 #else
19178 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19179 #endif
19180 }
19181 {
19182 if (temp2)
19183 delete arg2;
19184 }
19185 return resultobj;
19186 fail:
19187 {
19188 if (temp2)
19189 delete arg2;
19190 }
19191 return NULL;
19192 }
19193
19194
19195 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19196 PyObject *resultobj = 0;
19197 wxImage *arg1 = (wxImage *) 0 ;
19198 wxString *arg2 = 0 ;
19199 int result;
19200 void *argp1 = 0 ;
19201 int res1 = 0 ;
19202 bool temp2 = false ;
19203 PyObject * obj0 = 0 ;
19204 PyObject * obj1 = 0 ;
19205 char * kwnames[] = {
19206 (char *) "self",(char *) "name", NULL
19207 };
19208
19209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19211 if (!SWIG_IsOK(res1)) {
19212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19213 }
19214 arg1 = reinterpret_cast< wxImage * >(argp1);
19215 {
19216 arg2 = wxString_in_helper(obj1);
19217 if (arg2 == NULL) SWIG_fail;
19218 temp2 = true;
19219 }
19220 {
19221 PyThreadState* __tstate = wxPyBeginAllowThreads();
19222 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19223 wxPyEndAllowThreads(__tstate);
19224 if (PyErr_Occurred()) SWIG_fail;
19225 }
19226 resultobj = SWIG_From_int(static_cast< int >(result));
19227 {
19228 if (temp2)
19229 delete arg2;
19230 }
19231 return resultobj;
19232 fail:
19233 {
19234 if (temp2)
19235 delete arg2;
19236 }
19237 return NULL;
19238 }
19239
19240
19241 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19242 PyObject *resultobj = 0;
19243 wxImage *arg1 = (wxImage *) 0 ;
19244 wxString *arg2 = 0 ;
19245 bool result;
19246 void *argp1 = 0 ;
19247 int res1 = 0 ;
19248 bool temp2 = false ;
19249 PyObject * obj0 = 0 ;
19250 PyObject * obj1 = 0 ;
19251 char * kwnames[] = {
19252 (char *) "self",(char *) "name", NULL
19253 };
19254
19255 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19256 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19257 if (!SWIG_IsOK(res1)) {
19258 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19259 }
19260 arg1 = reinterpret_cast< wxImage * >(argp1);
19261 {
19262 arg2 = wxString_in_helper(obj1);
19263 if (arg2 == NULL) SWIG_fail;
19264 temp2 = true;
19265 }
19266 {
19267 PyThreadState* __tstate = wxPyBeginAllowThreads();
19268 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19269 wxPyEndAllowThreads(__tstate);
19270 if (PyErr_Occurred()) SWIG_fail;
19271 }
19272 {
19273 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19274 }
19275 {
19276 if (temp2)
19277 delete arg2;
19278 }
19279 return resultobj;
19280 fail:
19281 {
19282 if (temp2)
19283 delete arg2;
19284 }
19285 return NULL;
19286 }
19287
19288
19289 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19290 PyObject *resultobj = 0;
19291 wxImage *arg1 = (wxImage *) 0 ;
19292 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19293 unsigned long result;
19294 void *argp1 = 0 ;
19295 int res1 = 0 ;
19296 unsigned long val2 ;
19297 int ecode2 = 0 ;
19298 PyObject * obj0 = 0 ;
19299 PyObject * obj1 = 0 ;
19300 char * kwnames[] = {
19301 (char *) "self",(char *) "stopafter", NULL
19302 };
19303
19304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19306 if (!SWIG_IsOK(res1)) {
19307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19308 }
19309 arg1 = reinterpret_cast< wxImage * >(argp1);
19310 if (obj1) {
19311 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19312 if (!SWIG_IsOK(ecode2)) {
19313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19314 }
19315 arg2 = static_cast< unsigned long >(val2);
19316 }
19317 {
19318 PyThreadState* __tstate = wxPyBeginAllowThreads();
19319 result = (unsigned long)(arg1)->CountColours(arg2);
19320 wxPyEndAllowThreads(__tstate);
19321 if (PyErr_Occurred()) SWIG_fail;
19322 }
19323 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19324 return resultobj;
19325 fail:
19326 return NULL;
19327 }
19328
19329
19330 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19331 PyObject *resultobj = 0;
19332 wxImage *arg1 = (wxImage *) 0 ;
19333 wxImageHistogram *arg2 = 0 ;
19334 unsigned long result;
19335 void *argp1 = 0 ;
19336 int res1 = 0 ;
19337 void *argp2 = 0 ;
19338 int res2 = 0 ;
19339 PyObject * obj0 = 0 ;
19340 PyObject * obj1 = 0 ;
19341 char * kwnames[] = {
19342 (char *) "self",(char *) "h", NULL
19343 };
19344
19345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19347 if (!SWIG_IsOK(res1)) {
19348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19349 }
19350 arg1 = reinterpret_cast< wxImage * >(argp1);
19351 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19352 if (!SWIG_IsOK(res2)) {
19353 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19354 }
19355 if (!argp2) {
19356 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19357 }
19358 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19359 {
19360 PyThreadState* __tstate = wxPyBeginAllowThreads();
19361 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19362 wxPyEndAllowThreads(__tstate);
19363 if (PyErr_Occurred()) SWIG_fail;
19364 }
19365 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19366 return resultobj;
19367 fail:
19368 return NULL;
19369 }
19370
19371
19372 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19373 PyObject *resultobj = 0;
19374 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19375 void *argp1 = 0 ;
19376 int res1 = 0 ;
19377 PyObject * obj0 = 0 ;
19378 char * kwnames[] = {
19379 (char *) "handler", NULL
19380 };
19381
19382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19384 if (!SWIG_IsOK(res1)) {
19385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19386 }
19387 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19388 {
19389 PyThreadState* __tstate = wxPyBeginAllowThreads();
19390 wxImage::AddHandler(arg1);
19391 wxPyEndAllowThreads(__tstate);
19392 if (PyErr_Occurred()) SWIG_fail;
19393 }
19394 resultobj = SWIG_Py_Void();
19395 return resultobj;
19396 fail:
19397 return NULL;
19398 }
19399
19400
19401 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19402 PyObject *resultobj = 0;
19403 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19404 void *argp1 = 0 ;
19405 int res1 = 0 ;
19406 PyObject * obj0 = 0 ;
19407 char * kwnames[] = {
19408 (char *) "handler", NULL
19409 };
19410
19411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19412 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19413 if (!SWIG_IsOK(res1)) {
19414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19415 }
19416 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19417 {
19418 PyThreadState* __tstate = wxPyBeginAllowThreads();
19419 wxImage::InsertHandler(arg1);
19420 wxPyEndAllowThreads(__tstate);
19421 if (PyErr_Occurred()) SWIG_fail;
19422 }
19423 resultobj = SWIG_Py_Void();
19424 return resultobj;
19425 fail:
19426 return NULL;
19427 }
19428
19429
19430 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19431 PyObject *resultobj = 0;
19432 wxString *arg1 = 0 ;
19433 bool result;
19434 bool temp1 = false ;
19435 PyObject * obj0 = 0 ;
19436 char * kwnames[] = {
19437 (char *) "name", NULL
19438 };
19439
19440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19441 {
19442 arg1 = wxString_in_helper(obj0);
19443 if (arg1 == NULL) SWIG_fail;
19444 temp1 = true;
19445 }
19446 {
19447 PyThreadState* __tstate = wxPyBeginAllowThreads();
19448 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19449 wxPyEndAllowThreads(__tstate);
19450 if (PyErr_Occurred()) SWIG_fail;
19451 }
19452 {
19453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19454 }
19455 {
19456 if (temp1)
19457 delete arg1;
19458 }
19459 return resultobj;
19460 fail:
19461 {
19462 if (temp1)
19463 delete arg1;
19464 }
19465 return NULL;
19466 }
19467
19468
19469 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19470 PyObject *resultobj = 0;
19471 PyObject *result = 0 ;
19472
19473 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19474 {
19475 PyThreadState* __tstate = wxPyBeginAllowThreads();
19476 result = (PyObject *)wxImage_GetHandlers();
19477 wxPyEndAllowThreads(__tstate);
19478 if (PyErr_Occurred()) SWIG_fail;
19479 }
19480 resultobj = result;
19481 return resultobj;
19482 fail:
19483 return NULL;
19484 }
19485
19486
19487 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19488 PyObject *resultobj = 0;
19489 wxString result;
19490
19491 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19492 {
19493 PyThreadState* __tstate = wxPyBeginAllowThreads();
19494 result = wxImage::GetImageExtWildcard();
19495 wxPyEndAllowThreads(__tstate);
19496 if (PyErr_Occurred()) SWIG_fail;
19497 }
19498 {
19499 #if wxUSE_UNICODE
19500 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19501 #else
19502 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19503 #endif
19504 }
19505 return resultobj;
19506 fail:
19507 return NULL;
19508 }
19509
19510
19511 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19512 PyObject *resultobj = 0;
19513 wxImage *arg1 = (wxImage *) 0 ;
19514 int arg2 = (int) -1 ;
19515 wxBitmap result;
19516 void *argp1 = 0 ;
19517 int res1 = 0 ;
19518 int val2 ;
19519 int ecode2 = 0 ;
19520 PyObject * obj0 = 0 ;
19521 PyObject * obj1 = 0 ;
19522 char * kwnames[] = {
19523 (char *) "self",(char *) "depth", NULL
19524 };
19525
19526 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19527 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19528 if (!SWIG_IsOK(res1)) {
19529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19530 }
19531 arg1 = reinterpret_cast< wxImage * >(argp1);
19532 if (obj1) {
19533 ecode2 = SWIG_AsVal_int(obj1, &val2);
19534 if (!SWIG_IsOK(ecode2)) {
19535 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19536 }
19537 arg2 = static_cast< int >(val2);
19538 }
19539 {
19540 if (!wxPyCheckForApp()) SWIG_fail;
19541 PyThreadState* __tstate = wxPyBeginAllowThreads();
19542 result = wxImage_ConvertToBitmap(arg1,arg2);
19543 wxPyEndAllowThreads(__tstate);
19544 if (PyErr_Occurred()) SWIG_fail;
19545 }
19546 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19547 return resultobj;
19548 fail:
19549 return NULL;
19550 }
19551
19552
19553 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19554 PyObject *resultobj = 0;
19555 wxImage *arg1 = (wxImage *) 0 ;
19556 byte arg2 ;
19557 byte arg3 ;
19558 byte arg4 ;
19559 wxBitmap result;
19560 void *argp1 = 0 ;
19561 int res1 = 0 ;
19562 unsigned char val2 ;
19563 int ecode2 = 0 ;
19564 unsigned char val3 ;
19565 int ecode3 = 0 ;
19566 unsigned char val4 ;
19567 int ecode4 = 0 ;
19568 PyObject * obj0 = 0 ;
19569 PyObject * obj1 = 0 ;
19570 PyObject * obj2 = 0 ;
19571 PyObject * obj3 = 0 ;
19572 char * kwnames[] = {
19573 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19574 };
19575
19576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19578 if (!SWIG_IsOK(res1)) {
19579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19580 }
19581 arg1 = reinterpret_cast< wxImage * >(argp1);
19582 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19583 if (!SWIG_IsOK(ecode2)) {
19584 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19585 }
19586 arg2 = static_cast< byte >(val2);
19587 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19588 if (!SWIG_IsOK(ecode3)) {
19589 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19590 }
19591 arg3 = static_cast< byte >(val3);
19592 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19593 if (!SWIG_IsOK(ecode4)) {
19594 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19595 }
19596 arg4 = static_cast< byte >(val4);
19597 {
19598 if (!wxPyCheckForApp()) SWIG_fail;
19599 PyThreadState* __tstate = wxPyBeginAllowThreads();
19600 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19601 wxPyEndAllowThreads(__tstate);
19602 if (PyErr_Occurred()) SWIG_fail;
19603 }
19604 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19605 return resultobj;
19606 fail:
19607 return NULL;
19608 }
19609
19610
19611 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19612 PyObject *resultobj = 0;
19613 wxImage *arg1 = (wxImage *) 0 ;
19614 double arg2 ;
19615 void *argp1 = 0 ;
19616 int res1 = 0 ;
19617 double val2 ;
19618 int ecode2 = 0 ;
19619 PyObject * obj0 = 0 ;
19620 PyObject * obj1 = 0 ;
19621 char * kwnames[] = {
19622 (char *) "self",(char *) "angle", NULL
19623 };
19624
19625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19627 if (!SWIG_IsOK(res1)) {
19628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19629 }
19630 arg1 = reinterpret_cast< wxImage * >(argp1);
19631 ecode2 = SWIG_AsVal_double(obj1, &val2);
19632 if (!SWIG_IsOK(ecode2)) {
19633 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19634 }
19635 arg2 = static_cast< double >(val2);
19636 {
19637 PyThreadState* __tstate = wxPyBeginAllowThreads();
19638 (arg1)->RotateHue(arg2);
19639 wxPyEndAllowThreads(__tstate);
19640 if (PyErr_Occurred()) SWIG_fail;
19641 }
19642 resultobj = SWIG_Py_Void();
19643 return resultobj;
19644 fail:
19645 return NULL;
19646 }
19647
19648
19649 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19650 PyObject *resultobj = 0;
19651 wxImage_RGBValue arg1 ;
19652 wxImage_HSVValue result;
19653 void *argp1 ;
19654 int res1 = 0 ;
19655 PyObject * obj0 = 0 ;
19656 char * kwnames[] = {
19657 (char *) "rgb", NULL
19658 };
19659
19660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19661 {
19662 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19663 if (!SWIG_IsOK(res1)) {
19664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19665 }
19666 if (!argp1) {
19667 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19668 } else {
19669 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19670 arg1 = *temp;
19671 if (SWIG_IsNewObj(res1)) delete temp;
19672 }
19673 }
19674 {
19675 PyThreadState* __tstate = wxPyBeginAllowThreads();
19676 result = wxImage::RGBtoHSV(arg1);
19677 wxPyEndAllowThreads(__tstate);
19678 if (PyErr_Occurred()) SWIG_fail;
19679 }
19680 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19681 return resultobj;
19682 fail:
19683 return NULL;
19684 }
19685
19686
19687 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19688 PyObject *resultobj = 0;
19689 wxImage_HSVValue arg1 ;
19690 wxImage_RGBValue result;
19691 void *argp1 ;
19692 int res1 = 0 ;
19693 PyObject * obj0 = 0 ;
19694 char * kwnames[] = {
19695 (char *) "hsv", NULL
19696 };
19697
19698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19699 {
19700 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19701 if (!SWIG_IsOK(res1)) {
19702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19703 }
19704 if (!argp1) {
19705 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19706 } else {
19707 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19708 arg1 = *temp;
19709 if (SWIG_IsNewObj(res1)) delete temp;
19710 }
19711 }
19712 {
19713 PyThreadState* __tstate = wxPyBeginAllowThreads();
19714 result = wxImage::HSVtoRGB(arg1);
19715 wxPyEndAllowThreads(__tstate);
19716 if (PyErr_Occurred()) SWIG_fail;
19717 }
19718 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19719 return resultobj;
19720 fail:
19721 return NULL;
19722 }
19723
19724
19725 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19726 PyObject *obj;
19727 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19728 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19729 return SWIG_Py_Void();
19730 }
19731
19732 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19733 return SWIG_Python_InitShadowInstance(args);
19734 }
19735
19736 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19737 PyObject *resultobj = 0;
19738 int arg1 ;
19739 int arg2 ;
19740 buffer arg3 ;
19741 int arg4 ;
19742 buffer arg5 = (buffer) NULL ;
19743 int arg6 = (int) 0 ;
19744 wxImage *result = 0 ;
19745 int val1 ;
19746 int ecode1 = 0 ;
19747 int val2 ;
19748 int ecode2 = 0 ;
19749 Py_ssize_t temp3 ;
19750 Py_ssize_t temp5 ;
19751 PyObject * obj0 = 0 ;
19752 PyObject * obj1 = 0 ;
19753 PyObject * obj2 = 0 ;
19754 PyObject * obj3 = 0 ;
19755 char * kwnames[] = {
19756 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19757 };
19758
19759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19760 ecode1 = SWIG_AsVal_int(obj0, &val1);
19761 if (!SWIG_IsOK(ecode1)) {
19762 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19763 }
19764 arg1 = static_cast< int >(val1);
19765 ecode2 = SWIG_AsVal_int(obj1, &val2);
19766 if (!SWIG_IsOK(ecode2)) {
19767 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19768 }
19769 arg2 = static_cast< int >(val2);
19770 {
19771 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19772 arg4 = (int)temp3;
19773 }
19774 if (obj3) {
19775 {
19776 if (obj3 != Py_None) {
19777 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19778 arg6 = (int)temp5;
19779 }
19780 }
19781 }
19782 {
19783 PyThreadState* __tstate = wxPyBeginAllowThreads();
19784 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19785 wxPyEndAllowThreads(__tstate);
19786 if (PyErr_Occurred()) SWIG_fail;
19787 }
19788 {
19789 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19790 }
19791 return resultobj;
19792 fail:
19793 return NULL;
19794 }
19795
19796
19797 SWIGINTERN int NullImage_set(PyObject *) {
19798 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19799 return 1;
19800 }
19801
19802
19803 SWIGINTERN PyObject *NullImage_get(void) {
19804 PyObject *pyobj = 0;
19805
19806 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19807 return pyobj;
19808 }
19809
19810
19811 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19812 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19813 return 1;
19814 }
19815
19816
19817 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19818 PyObject *pyobj = 0;
19819
19820 {
19821 #if wxUSE_UNICODE
19822 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19823 #else
19824 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19825 #endif
19826 }
19827 return pyobj;
19828 }
19829
19830
19831 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19832 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19833 return 1;
19834 }
19835
19836
19837 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19838 PyObject *pyobj = 0;
19839
19840 {
19841 #if wxUSE_UNICODE
19842 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19843 #else
19844 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19845 #endif
19846 }
19847 return pyobj;
19848 }
19849
19850
19851 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19852 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19853 return 1;
19854 }
19855
19856
19857 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19858 PyObject *pyobj = 0;
19859
19860 {
19861 #if wxUSE_UNICODE
19862 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19863 #else
19864 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19865 #endif
19866 }
19867 return pyobj;
19868 }
19869
19870
19871 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19872 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19873 return 1;
19874 }
19875
19876
19877 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19878 PyObject *pyobj = 0;
19879
19880 {
19881 #if wxUSE_UNICODE
19882 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19883 #else
19884 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19885 #endif
19886 }
19887 return pyobj;
19888 }
19889
19890
19891 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19892 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19893 return 1;
19894 }
19895
19896
19897 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19898 PyObject *pyobj = 0;
19899
19900 {
19901 #if wxUSE_UNICODE
19902 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19903 #else
19904 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19905 #endif
19906 }
19907 return pyobj;
19908 }
19909
19910
19911 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19912 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19913 return 1;
19914 }
19915
19916
19917 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19918 PyObject *pyobj = 0;
19919
19920 {
19921 #if wxUSE_UNICODE
19922 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19923 #else
19924 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19925 #endif
19926 }
19927 return pyobj;
19928 }
19929
19930
19931 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19932 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19933 return 1;
19934 }
19935
19936
19937 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19938 PyObject *pyobj = 0;
19939
19940 {
19941 #if wxUSE_UNICODE
19942 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19943 #else
19944 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19945 #endif
19946 }
19947 return pyobj;
19948 }
19949
19950
19951 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19952 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19953 return 1;
19954 }
19955
19956
19957 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19958 PyObject *pyobj = 0;
19959
19960 {
19961 #if wxUSE_UNICODE
19962 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19963 #else
19964 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19965 #endif
19966 }
19967 return pyobj;
19968 }
19969
19970
19971 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19972 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19973 return 1;
19974 }
19975
19976
19977 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19978 PyObject *pyobj = 0;
19979
19980 {
19981 #if wxUSE_UNICODE
19982 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19983 #else
19984 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19985 #endif
19986 }
19987 return pyobj;
19988 }
19989
19990
19991 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
19992 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
19993 return 1;
19994 }
19995
19996
19997 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
19998 PyObject *pyobj = 0;
19999
20000 {
20001 #if wxUSE_UNICODE
20002 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20003 #else
20004 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20005 #endif
20006 }
20007 return pyobj;
20008 }
20009
20010
20011 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20012 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20013 return 1;
20014 }
20015
20016
20017 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20018 PyObject *pyobj = 0;
20019
20020 {
20021 #if wxUSE_UNICODE
20022 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20023 #else
20024 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20025 #endif
20026 }
20027 return pyobj;
20028 }
20029
20030
20031 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20032 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20033 return 1;
20034 }
20035
20036
20037 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20038 PyObject *pyobj = 0;
20039
20040 {
20041 #if wxUSE_UNICODE
20042 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20043 #else
20044 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20045 #endif
20046 }
20047 return pyobj;
20048 }
20049
20050
20051 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20052 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20053 return 1;
20054 }
20055
20056
20057 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20058 PyObject *pyobj = 0;
20059
20060 {
20061 #if wxUSE_UNICODE
20062 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20063 #else
20064 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20065 #endif
20066 }
20067 return pyobj;
20068 }
20069
20070
20071 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20072 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20073 return 1;
20074 }
20075
20076
20077 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20078 PyObject *pyobj = 0;
20079
20080 {
20081 #if wxUSE_UNICODE
20082 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20083 #else
20084 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20085 #endif
20086 }
20087 return pyobj;
20088 }
20089
20090
20091 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20092 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20093 return 1;
20094 }
20095
20096
20097 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20098 PyObject *pyobj = 0;
20099
20100 {
20101 #if wxUSE_UNICODE
20102 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20103 #else
20104 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20105 #endif
20106 }
20107 return pyobj;
20108 }
20109
20110
20111 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20112 PyObject *resultobj = 0;
20113 wxBMPHandler *result = 0 ;
20114
20115 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20116 {
20117 PyThreadState* __tstate = wxPyBeginAllowThreads();
20118 result = (wxBMPHandler *)new wxBMPHandler();
20119 wxPyEndAllowThreads(__tstate);
20120 if (PyErr_Occurred()) SWIG_fail;
20121 }
20122 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20123 return resultobj;
20124 fail:
20125 return NULL;
20126 }
20127
20128
20129 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20130 PyObject *obj;
20131 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20132 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20133 return SWIG_Py_Void();
20134 }
20135
20136 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20137 return SWIG_Python_InitShadowInstance(args);
20138 }
20139
20140 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20141 PyObject *resultobj = 0;
20142 wxICOHandler *result = 0 ;
20143
20144 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20145 {
20146 PyThreadState* __tstate = wxPyBeginAllowThreads();
20147 result = (wxICOHandler *)new wxICOHandler();
20148 wxPyEndAllowThreads(__tstate);
20149 if (PyErr_Occurred()) SWIG_fail;
20150 }
20151 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20152 return resultobj;
20153 fail:
20154 return NULL;
20155 }
20156
20157
20158 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20159 PyObject *obj;
20160 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20161 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20162 return SWIG_Py_Void();
20163 }
20164
20165 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20166 return SWIG_Python_InitShadowInstance(args);
20167 }
20168
20169 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20170 PyObject *resultobj = 0;
20171 wxCURHandler *result = 0 ;
20172
20173 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20174 {
20175 PyThreadState* __tstate = wxPyBeginAllowThreads();
20176 result = (wxCURHandler *)new wxCURHandler();
20177 wxPyEndAllowThreads(__tstate);
20178 if (PyErr_Occurred()) SWIG_fail;
20179 }
20180 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20181 return resultobj;
20182 fail:
20183 return NULL;
20184 }
20185
20186
20187 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20188 PyObject *obj;
20189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20190 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20191 return SWIG_Py_Void();
20192 }
20193
20194 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20195 return SWIG_Python_InitShadowInstance(args);
20196 }
20197
20198 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20199 PyObject *resultobj = 0;
20200 wxANIHandler *result = 0 ;
20201
20202 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20203 {
20204 PyThreadState* __tstate = wxPyBeginAllowThreads();
20205 result = (wxANIHandler *)new wxANIHandler();
20206 wxPyEndAllowThreads(__tstate);
20207 if (PyErr_Occurred()) SWIG_fail;
20208 }
20209 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20210 return resultobj;
20211 fail:
20212 return NULL;
20213 }
20214
20215
20216 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20217 PyObject *obj;
20218 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20219 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20220 return SWIG_Py_Void();
20221 }
20222
20223 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20224 return SWIG_Python_InitShadowInstance(args);
20225 }
20226
20227 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20228 PyObject *resultobj = 0;
20229 wxPNGHandler *result = 0 ;
20230
20231 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20232 {
20233 PyThreadState* __tstate = wxPyBeginAllowThreads();
20234 result = (wxPNGHandler *)new wxPNGHandler();
20235 wxPyEndAllowThreads(__tstate);
20236 if (PyErr_Occurred()) SWIG_fail;
20237 }
20238 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20239 return resultobj;
20240 fail:
20241 return NULL;
20242 }
20243
20244
20245 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20246 PyObject *obj;
20247 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20248 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20249 return SWIG_Py_Void();
20250 }
20251
20252 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20253 return SWIG_Python_InitShadowInstance(args);
20254 }
20255
20256 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20257 PyObject *resultobj = 0;
20258 wxGIFHandler *result = 0 ;
20259
20260 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20261 {
20262 PyThreadState* __tstate = wxPyBeginAllowThreads();
20263 result = (wxGIFHandler *)new wxGIFHandler();
20264 wxPyEndAllowThreads(__tstate);
20265 if (PyErr_Occurred()) SWIG_fail;
20266 }
20267 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20268 return resultobj;
20269 fail:
20270 return NULL;
20271 }
20272
20273
20274 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20275 PyObject *obj;
20276 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20277 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20278 return SWIG_Py_Void();
20279 }
20280
20281 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20282 return SWIG_Python_InitShadowInstance(args);
20283 }
20284
20285 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20286 PyObject *resultobj = 0;
20287 wxPCXHandler *result = 0 ;
20288
20289 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20290 {
20291 PyThreadState* __tstate = wxPyBeginAllowThreads();
20292 result = (wxPCXHandler *)new wxPCXHandler();
20293 wxPyEndAllowThreads(__tstate);
20294 if (PyErr_Occurred()) SWIG_fail;
20295 }
20296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20297 return resultobj;
20298 fail:
20299 return NULL;
20300 }
20301
20302
20303 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20304 PyObject *obj;
20305 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20306 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20307 return SWIG_Py_Void();
20308 }
20309
20310 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20311 return SWIG_Python_InitShadowInstance(args);
20312 }
20313
20314 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20315 PyObject *resultobj = 0;
20316 wxJPEGHandler *result = 0 ;
20317
20318 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20319 {
20320 PyThreadState* __tstate = wxPyBeginAllowThreads();
20321 result = (wxJPEGHandler *)new wxJPEGHandler();
20322 wxPyEndAllowThreads(__tstate);
20323 if (PyErr_Occurred()) SWIG_fail;
20324 }
20325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20326 return resultobj;
20327 fail:
20328 return NULL;
20329 }
20330
20331
20332 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20333 PyObject *obj;
20334 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20335 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20336 return SWIG_Py_Void();
20337 }
20338
20339 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20340 return SWIG_Python_InitShadowInstance(args);
20341 }
20342
20343 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20344 PyObject *resultobj = 0;
20345 wxPNMHandler *result = 0 ;
20346
20347 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20348 {
20349 PyThreadState* __tstate = wxPyBeginAllowThreads();
20350 result = (wxPNMHandler *)new wxPNMHandler();
20351 wxPyEndAllowThreads(__tstate);
20352 if (PyErr_Occurred()) SWIG_fail;
20353 }
20354 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20355 return resultobj;
20356 fail:
20357 return NULL;
20358 }
20359
20360
20361 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20362 PyObject *obj;
20363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20364 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20365 return SWIG_Py_Void();
20366 }
20367
20368 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20369 return SWIG_Python_InitShadowInstance(args);
20370 }
20371
20372 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20373 PyObject *resultobj = 0;
20374 wxXPMHandler *result = 0 ;
20375
20376 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20377 {
20378 PyThreadState* __tstate = wxPyBeginAllowThreads();
20379 result = (wxXPMHandler *)new wxXPMHandler();
20380 wxPyEndAllowThreads(__tstate);
20381 if (PyErr_Occurred()) SWIG_fail;
20382 }
20383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20384 return resultobj;
20385 fail:
20386 return NULL;
20387 }
20388
20389
20390 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20391 PyObject *obj;
20392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20393 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20394 return SWIG_Py_Void();
20395 }
20396
20397 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20398 return SWIG_Python_InitShadowInstance(args);
20399 }
20400
20401 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20402 PyObject *resultobj = 0;
20403 wxTIFFHandler *result = 0 ;
20404
20405 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20406 {
20407 PyThreadState* __tstate = wxPyBeginAllowThreads();
20408 result = (wxTIFFHandler *)new wxTIFFHandler();
20409 wxPyEndAllowThreads(__tstate);
20410 if (PyErr_Occurred()) SWIG_fail;
20411 }
20412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20413 return resultobj;
20414 fail:
20415 return NULL;
20416 }
20417
20418
20419 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20420 PyObject *obj;
20421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20422 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20423 return SWIG_Py_Void();
20424 }
20425
20426 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20427 return SWIG_Python_InitShadowInstance(args);
20428 }
20429
20430 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20431 PyObject *resultobj = 0;
20432 wxTGAHandler *result = 0 ;
20433
20434 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20435 {
20436 PyThreadState* __tstate = wxPyBeginAllowThreads();
20437 result = (wxTGAHandler *)new wxTGAHandler();
20438 wxPyEndAllowThreads(__tstate);
20439 if (PyErr_Occurred()) SWIG_fail;
20440 }
20441 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20442 return resultobj;
20443 fail:
20444 return NULL;
20445 }
20446
20447
20448 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20449 PyObject *obj;
20450 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20451 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20452 return SWIG_Py_Void();
20453 }
20454
20455 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20456 return SWIG_Python_InitShadowInstance(args);
20457 }
20458
20459 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20460 PyObject *resultobj = 0;
20461 wxImage *arg1 = 0 ;
20462 wxImage *arg2 = 0 ;
20463 int arg3 = (int) 236 ;
20464 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20465 bool result;
20466 void *argp1 = 0 ;
20467 int res1 = 0 ;
20468 void *argp2 = 0 ;
20469 int res2 = 0 ;
20470 int val3 ;
20471 int ecode3 = 0 ;
20472 int val4 ;
20473 int ecode4 = 0 ;
20474 PyObject * obj0 = 0 ;
20475 PyObject * obj1 = 0 ;
20476 PyObject * obj2 = 0 ;
20477 PyObject * obj3 = 0 ;
20478 char * kwnames[] = {
20479 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20480 };
20481
20482 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20483 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20484 if (!SWIG_IsOK(res1)) {
20485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20486 }
20487 if (!argp1) {
20488 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20489 }
20490 arg1 = reinterpret_cast< wxImage * >(argp1);
20491 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20492 if (!SWIG_IsOK(res2)) {
20493 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20494 }
20495 if (!argp2) {
20496 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20497 }
20498 arg2 = reinterpret_cast< wxImage * >(argp2);
20499 if (obj2) {
20500 ecode3 = SWIG_AsVal_int(obj2, &val3);
20501 if (!SWIG_IsOK(ecode3)) {
20502 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20503 }
20504 arg3 = static_cast< int >(val3);
20505 }
20506 if (obj3) {
20507 ecode4 = SWIG_AsVal_int(obj3, &val4);
20508 if (!SWIG_IsOK(ecode4)) {
20509 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20510 }
20511 arg4 = static_cast< int >(val4);
20512 }
20513 {
20514 PyThreadState* __tstate = wxPyBeginAllowThreads();
20515 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20516 wxPyEndAllowThreads(__tstate);
20517 if (PyErr_Occurred()) SWIG_fail;
20518 }
20519 {
20520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20521 }
20522 return resultobj;
20523 fail:
20524 return NULL;
20525 }
20526
20527
20528 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20529 PyObject *obj;
20530 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20531 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20532 return SWIG_Py_Void();
20533 }
20534
20535 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20536 PyObject *resultobj = 0;
20537 wxEvtHandler *result = 0 ;
20538
20539 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20540 {
20541 PyThreadState* __tstate = wxPyBeginAllowThreads();
20542 result = (wxEvtHandler *)new wxEvtHandler();
20543 wxPyEndAllowThreads(__tstate);
20544 if (PyErr_Occurred()) SWIG_fail;
20545 }
20546 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20547 return resultobj;
20548 fail:
20549 return NULL;
20550 }
20551
20552
20553 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20554 PyObject *resultobj = 0;
20555 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20556 wxEvtHandler *result = 0 ;
20557 void *argp1 = 0 ;
20558 int res1 = 0 ;
20559 PyObject *swig_obj[1] ;
20560
20561 if (!args) SWIG_fail;
20562 swig_obj[0] = args;
20563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20564 if (!SWIG_IsOK(res1)) {
20565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20566 }
20567 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20568 {
20569 PyThreadState* __tstate = wxPyBeginAllowThreads();
20570 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20571 wxPyEndAllowThreads(__tstate);
20572 if (PyErr_Occurred()) SWIG_fail;
20573 }
20574 {
20575 resultobj = wxPyMake_wxObject(result, 0);
20576 }
20577 return resultobj;
20578 fail:
20579 return NULL;
20580 }
20581
20582
20583 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20584 PyObject *resultobj = 0;
20585 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20586 wxEvtHandler *result = 0 ;
20587 void *argp1 = 0 ;
20588 int res1 = 0 ;
20589 PyObject *swig_obj[1] ;
20590
20591 if (!args) SWIG_fail;
20592 swig_obj[0] = args;
20593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20594 if (!SWIG_IsOK(res1)) {
20595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20596 }
20597 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20598 {
20599 PyThreadState* __tstate = wxPyBeginAllowThreads();
20600 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20601 wxPyEndAllowThreads(__tstate);
20602 if (PyErr_Occurred()) SWIG_fail;
20603 }
20604 {
20605 resultobj = wxPyMake_wxObject(result, 0);
20606 }
20607 return resultobj;
20608 fail:
20609 return NULL;
20610 }
20611
20612
20613 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20614 PyObject *resultobj = 0;
20615 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20616 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20617 void *argp1 = 0 ;
20618 int res1 = 0 ;
20619 void *argp2 = 0 ;
20620 int res2 = 0 ;
20621 PyObject * obj0 = 0 ;
20622 PyObject * obj1 = 0 ;
20623 char * kwnames[] = {
20624 (char *) "self",(char *) "handler", NULL
20625 };
20626
20627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20629 if (!SWIG_IsOK(res1)) {
20630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20631 }
20632 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20633 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20634 if (!SWIG_IsOK(res2)) {
20635 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20636 }
20637 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20638 {
20639 PyThreadState* __tstate = wxPyBeginAllowThreads();
20640 (arg1)->SetNextHandler(arg2);
20641 wxPyEndAllowThreads(__tstate);
20642 if (PyErr_Occurred()) SWIG_fail;
20643 }
20644 resultobj = SWIG_Py_Void();
20645 return resultobj;
20646 fail:
20647 return NULL;
20648 }
20649
20650
20651 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20652 PyObject *resultobj = 0;
20653 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20654 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20655 void *argp1 = 0 ;
20656 int res1 = 0 ;
20657 void *argp2 = 0 ;
20658 int res2 = 0 ;
20659 PyObject * obj0 = 0 ;
20660 PyObject * obj1 = 0 ;
20661 char * kwnames[] = {
20662 (char *) "self",(char *) "handler", NULL
20663 };
20664
20665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20667 if (!SWIG_IsOK(res1)) {
20668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20669 }
20670 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20671 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20672 if (!SWIG_IsOK(res2)) {
20673 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20674 }
20675 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20676 {
20677 PyThreadState* __tstate = wxPyBeginAllowThreads();
20678 (arg1)->SetPreviousHandler(arg2);
20679 wxPyEndAllowThreads(__tstate);
20680 if (PyErr_Occurred()) SWIG_fail;
20681 }
20682 resultobj = SWIG_Py_Void();
20683 return resultobj;
20684 fail:
20685 return NULL;
20686 }
20687
20688
20689 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20690 PyObject *resultobj = 0;
20691 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20692 bool result;
20693 void *argp1 = 0 ;
20694 int res1 = 0 ;
20695 PyObject *swig_obj[1] ;
20696
20697 if (!args) SWIG_fail;
20698 swig_obj[0] = args;
20699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20700 if (!SWIG_IsOK(res1)) {
20701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20702 }
20703 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20704 {
20705 PyThreadState* __tstate = wxPyBeginAllowThreads();
20706 result = (bool)(arg1)->GetEvtHandlerEnabled();
20707 wxPyEndAllowThreads(__tstate);
20708 if (PyErr_Occurred()) SWIG_fail;
20709 }
20710 {
20711 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20712 }
20713 return resultobj;
20714 fail:
20715 return NULL;
20716 }
20717
20718
20719 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20720 PyObject *resultobj = 0;
20721 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20722 bool arg2 ;
20723 void *argp1 = 0 ;
20724 int res1 = 0 ;
20725 bool val2 ;
20726 int ecode2 = 0 ;
20727 PyObject * obj0 = 0 ;
20728 PyObject * obj1 = 0 ;
20729 char * kwnames[] = {
20730 (char *) "self",(char *) "enabled", NULL
20731 };
20732
20733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20735 if (!SWIG_IsOK(res1)) {
20736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20737 }
20738 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20739 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20740 if (!SWIG_IsOK(ecode2)) {
20741 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20742 }
20743 arg2 = static_cast< bool >(val2);
20744 {
20745 PyThreadState* __tstate = wxPyBeginAllowThreads();
20746 (arg1)->SetEvtHandlerEnabled(arg2);
20747 wxPyEndAllowThreads(__tstate);
20748 if (PyErr_Occurred()) SWIG_fail;
20749 }
20750 resultobj = SWIG_Py_Void();
20751 return resultobj;
20752 fail:
20753 return NULL;
20754 }
20755
20756
20757 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20758 PyObject *resultobj = 0;
20759 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20760 wxEvent *arg2 = 0 ;
20761 bool result;
20762 void *argp1 = 0 ;
20763 int res1 = 0 ;
20764 void *argp2 = 0 ;
20765 int res2 = 0 ;
20766 PyObject * obj0 = 0 ;
20767 PyObject * obj1 = 0 ;
20768 char * kwnames[] = {
20769 (char *) "self",(char *) "event", NULL
20770 };
20771
20772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20774 if (!SWIG_IsOK(res1)) {
20775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20776 }
20777 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20778 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20779 if (!SWIG_IsOK(res2)) {
20780 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20781 }
20782 if (!argp2) {
20783 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20784 }
20785 arg2 = reinterpret_cast< wxEvent * >(argp2);
20786 {
20787 PyThreadState* __tstate = wxPyBeginAllowThreads();
20788 result = (bool)(arg1)->ProcessEvent(*arg2);
20789 wxPyEndAllowThreads(__tstate);
20790 if (PyErr_Occurred()) SWIG_fail;
20791 }
20792 {
20793 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20794 }
20795 return resultobj;
20796 fail:
20797 return NULL;
20798 }
20799
20800
20801 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20802 PyObject *resultobj = 0;
20803 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20804 wxEvent *arg2 = 0 ;
20805 void *argp1 = 0 ;
20806 int res1 = 0 ;
20807 void *argp2 = 0 ;
20808 int res2 = 0 ;
20809 PyObject * obj0 = 0 ;
20810 PyObject * obj1 = 0 ;
20811 char * kwnames[] = {
20812 (char *) "self",(char *) "event", NULL
20813 };
20814
20815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20817 if (!SWIG_IsOK(res1)) {
20818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20819 }
20820 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20821 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20822 if (!SWIG_IsOK(res2)) {
20823 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20824 }
20825 if (!argp2) {
20826 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20827 }
20828 arg2 = reinterpret_cast< wxEvent * >(argp2);
20829 {
20830 PyThreadState* __tstate = wxPyBeginAllowThreads();
20831 (arg1)->AddPendingEvent(*arg2);
20832 wxPyEndAllowThreads(__tstate);
20833 if (PyErr_Occurred()) SWIG_fail;
20834 }
20835 resultobj = SWIG_Py_Void();
20836 return resultobj;
20837 fail:
20838 return NULL;
20839 }
20840
20841
20842 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20843 PyObject *resultobj = 0;
20844 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20845 void *argp1 = 0 ;
20846 int res1 = 0 ;
20847 PyObject *swig_obj[1] ;
20848
20849 if (!args) SWIG_fail;
20850 swig_obj[0] = args;
20851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20852 if (!SWIG_IsOK(res1)) {
20853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20854 }
20855 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20856 {
20857 PyThreadState* __tstate = wxPyBeginAllowThreads();
20858 (arg1)->ProcessPendingEvents();
20859 wxPyEndAllowThreads(__tstate);
20860 if (PyErr_Occurred()) SWIG_fail;
20861 }
20862 resultobj = SWIG_Py_Void();
20863 return resultobj;
20864 fail:
20865 return NULL;
20866 }
20867
20868
20869 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20870 PyObject *resultobj = 0;
20871 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20872 int arg2 ;
20873 int arg3 ;
20874 int arg4 ;
20875 PyObject *arg5 = (PyObject *) 0 ;
20876 void *argp1 = 0 ;
20877 int res1 = 0 ;
20878 int val2 ;
20879 int ecode2 = 0 ;
20880 int val3 ;
20881 int ecode3 = 0 ;
20882 int val4 ;
20883 int ecode4 = 0 ;
20884 PyObject * obj0 = 0 ;
20885 PyObject * obj1 = 0 ;
20886 PyObject * obj2 = 0 ;
20887 PyObject * obj3 = 0 ;
20888 PyObject * obj4 = 0 ;
20889 char * kwnames[] = {
20890 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20891 };
20892
20893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20895 if (!SWIG_IsOK(res1)) {
20896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20897 }
20898 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20899 ecode2 = SWIG_AsVal_int(obj1, &val2);
20900 if (!SWIG_IsOK(ecode2)) {
20901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20902 }
20903 arg2 = static_cast< int >(val2);
20904 ecode3 = SWIG_AsVal_int(obj2, &val3);
20905 if (!SWIG_IsOK(ecode3)) {
20906 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20907 }
20908 arg3 = static_cast< int >(val3);
20909 ecode4 = SWIG_AsVal_int(obj3, &val4);
20910 if (!SWIG_IsOK(ecode4)) {
20911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20912 }
20913 arg4 = static_cast< int >(val4);
20914 arg5 = obj4;
20915 {
20916 PyThreadState* __tstate = wxPyBeginAllowThreads();
20917 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20918 wxPyEndAllowThreads(__tstate);
20919 if (PyErr_Occurred()) SWIG_fail;
20920 }
20921 resultobj = SWIG_Py_Void();
20922 return resultobj;
20923 fail:
20924 return NULL;
20925 }
20926
20927
20928 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20929 PyObject *resultobj = 0;
20930 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20931 int arg2 ;
20932 int arg3 = (int) -1 ;
20933 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20934 bool result;
20935 void *argp1 = 0 ;
20936 int res1 = 0 ;
20937 int val2 ;
20938 int ecode2 = 0 ;
20939 int val3 ;
20940 int ecode3 = 0 ;
20941 int val4 ;
20942 int ecode4 = 0 ;
20943 PyObject * obj0 = 0 ;
20944 PyObject * obj1 = 0 ;
20945 PyObject * obj2 = 0 ;
20946 PyObject * obj3 = 0 ;
20947 char * kwnames[] = {
20948 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20949 };
20950
20951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20953 if (!SWIG_IsOK(res1)) {
20954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20955 }
20956 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20957 ecode2 = SWIG_AsVal_int(obj1, &val2);
20958 if (!SWIG_IsOK(ecode2)) {
20959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20960 }
20961 arg2 = static_cast< int >(val2);
20962 if (obj2) {
20963 ecode3 = SWIG_AsVal_int(obj2, &val3);
20964 if (!SWIG_IsOK(ecode3)) {
20965 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20966 }
20967 arg3 = static_cast< int >(val3);
20968 }
20969 if (obj3) {
20970 ecode4 = SWIG_AsVal_int(obj3, &val4);
20971 if (!SWIG_IsOK(ecode4)) {
20972 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20973 }
20974 arg4 = static_cast< wxEventType >(val4);
20975 }
20976 {
20977 PyThreadState* __tstate = wxPyBeginAllowThreads();
20978 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20979 wxPyEndAllowThreads(__tstate);
20980 if (PyErr_Occurred()) SWIG_fail;
20981 }
20982 {
20983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20984 }
20985 return resultobj;
20986 fail:
20987 return NULL;
20988 }
20989
20990
20991 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20992 PyObject *resultobj = 0;
20993 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20994 PyObject *arg2 = (PyObject *) 0 ;
20995 bool arg3 = (bool) true ;
20996 void *argp1 = 0 ;
20997 int res1 = 0 ;
20998 bool val3 ;
20999 int ecode3 = 0 ;
21000 PyObject * obj0 = 0 ;
21001 PyObject * obj1 = 0 ;
21002 PyObject * obj2 = 0 ;
21003 char * kwnames[] = {
21004 (char *) "self",(char *) "_self",(char *) "incref", NULL
21005 };
21006
21007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21009 if (!SWIG_IsOK(res1)) {
21010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21011 }
21012 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21013 arg2 = obj1;
21014 if (obj2) {
21015 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21016 if (!SWIG_IsOK(ecode3)) {
21017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21018 }
21019 arg3 = static_cast< bool >(val3);
21020 }
21021 {
21022 PyThreadState* __tstate = wxPyBeginAllowThreads();
21023 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21024 wxPyEndAllowThreads(__tstate);
21025 if (PyErr_Occurred()) SWIG_fail;
21026 }
21027 resultobj = SWIG_Py_Void();
21028 return resultobj;
21029 fail:
21030 return NULL;
21031 }
21032
21033
21034 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21035 PyObject *obj;
21036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21037 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21038 return SWIG_Py_Void();
21039 }
21040
21041 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21042 return SWIG_Python_InitShadowInstance(args);
21043 }
21044
21045 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21046 PyObject *resultobj = 0;
21047 wxEventType result;
21048
21049 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21050 {
21051 PyThreadState* __tstate = wxPyBeginAllowThreads();
21052 result = (wxEventType)wxNewEventType();
21053 wxPyEndAllowThreads(__tstate);
21054 if (PyErr_Occurred()) SWIG_fail;
21055 }
21056 resultobj = SWIG_From_int(static_cast< int >(result));
21057 return resultobj;
21058 fail:
21059 return NULL;
21060 }
21061
21062
21063 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21064 PyObject *resultobj = 0;
21065 wxEvent *arg1 = (wxEvent *) 0 ;
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_wxEvent, SWIG_POINTER_DISOWN | 0 );
21073 if (!SWIG_IsOK(res1)) {
21074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21075 }
21076 arg1 = reinterpret_cast< wxEvent * >(argp1);
21077 {
21078 PyThreadState* __tstate = wxPyBeginAllowThreads();
21079 delete arg1;
21080
21081 wxPyEndAllowThreads(__tstate);
21082 if (PyErr_Occurred()) SWIG_fail;
21083 }
21084 resultobj = SWIG_Py_Void();
21085 return resultobj;
21086 fail:
21087 return NULL;
21088 }
21089
21090
21091 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21092 PyObject *resultobj = 0;
21093 wxEvent *arg1 = (wxEvent *) 0 ;
21094 wxEventType arg2 ;
21095 void *argp1 = 0 ;
21096 int res1 = 0 ;
21097 int val2 ;
21098 int ecode2 = 0 ;
21099 PyObject * obj0 = 0 ;
21100 PyObject * obj1 = 0 ;
21101 char * kwnames[] = {
21102 (char *) "self",(char *) "typ", NULL
21103 };
21104
21105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21107 if (!SWIG_IsOK(res1)) {
21108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21109 }
21110 arg1 = reinterpret_cast< wxEvent * >(argp1);
21111 ecode2 = SWIG_AsVal_int(obj1, &val2);
21112 if (!SWIG_IsOK(ecode2)) {
21113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21114 }
21115 arg2 = static_cast< wxEventType >(val2);
21116 {
21117 PyThreadState* __tstate = wxPyBeginAllowThreads();
21118 (arg1)->SetEventType(arg2);
21119 wxPyEndAllowThreads(__tstate);
21120 if (PyErr_Occurred()) SWIG_fail;
21121 }
21122 resultobj = SWIG_Py_Void();
21123 return resultobj;
21124 fail:
21125 return NULL;
21126 }
21127
21128
21129 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21130 PyObject *resultobj = 0;
21131 wxEvent *arg1 = (wxEvent *) 0 ;
21132 wxEventType result;
21133 void *argp1 = 0 ;
21134 int res1 = 0 ;
21135 PyObject *swig_obj[1] ;
21136
21137 if (!args) SWIG_fail;
21138 swig_obj[0] = args;
21139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21140 if (!SWIG_IsOK(res1)) {
21141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21142 }
21143 arg1 = reinterpret_cast< wxEvent * >(argp1);
21144 {
21145 PyThreadState* __tstate = wxPyBeginAllowThreads();
21146 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21147 wxPyEndAllowThreads(__tstate);
21148 if (PyErr_Occurred()) SWIG_fail;
21149 }
21150 resultobj = SWIG_From_int(static_cast< int >(result));
21151 return resultobj;
21152 fail:
21153 return NULL;
21154 }
21155
21156
21157 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21158 PyObject *resultobj = 0;
21159 wxEvent *arg1 = (wxEvent *) 0 ;
21160 wxObject *result = 0 ;
21161 void *argp1 = 0 ;
21162 int res1 = 0 ;
21163 PyObject *swig_obj[1] ;
21164
21165 if (!args) SWIG_fail;
21166 swig_obj[0] = args;
21167 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21168 if (!SWIG_IsOK(res1)) {
21169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21170 }
21171 arg1 = reinterpret_cast< wxEvent * >(argp1);
21172 {
21173 PyThreadState* __tstate = wxPyBeginAllowThreads();
21174 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21175 wxPyEndAllowThreads(__tstate);
21176 if (PyErr_Occurred()) SWIG_fail;
21177 }
21178 {
21179 resultobj = wxPyMake_wxObject(result, (bool)0);
21180 }
21181 return resultobj;
21182 fail:
21183 return NULL;
21184 }
21185
21186
21187 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21188 PyObject *resultobj = 0;
21189 wxEvent *arg1 = (wxEvent *) 0 ;
21190 wxObject *arg2 = (wxObject *) 0 ;
21191 void *argp1 = 0 ;
21192 int res1 = 0 ;
21193 void *argp2 = 0 ;
21194 int res2 = 0 ;
21195 PyObject * obj0 = 0 ;
21196 PyObject * obj1 = 0 ;
21197 char * kwnames[] = {
21198 (char *) "self",(char *) "obj", NULL
21199 };
21200
21201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21203 if (!SWIG_IsOK(res1)) {
21204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21205 }
21206 arg1 = reinterpret_cast< wxEvent * >(argp1);
21207 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21208 if (!SWIG_IsOK(res2)) {
21209 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21210 }
21211 arg2 = reinterpret_cast< wxObject * >(argp2);
21212 {
21213 PyThreadState* __tstate = wxPyBeginAllowThreads();
21214 (arg1)->SetEventObject(arg2);
21215 wxPyEndAllowThreads(__tstate);
21216 if (PyErr_Occurred()) SWIG_fail;
21217 }
21218 resultobj = SWIG_Py_Void();
21219 return resultobj;
21220 fail:
21221 return NULL;
21222 }
21223
21224
21225 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21226 PyObject *resultobj = 0;
21227 wxEvent *arg1 = (wxEvent *) 0 ;
21228 long 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_wxEvent, 0 | 0 );
21236 if (!SWIG_IsOK(res1)) {
21237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21238 }
21239 arg1 = reinterpret_cast< wxEvent * >(argp1);
21240 {
21241 PyThreadState* __tstate = wxPyBeginAllowThreads();
21242 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21243 wxPyEndAllowThreads(__tstate);
21244 if (PyErr_Occurred()) SWIG_fail;
21245 }
21246 resultobj = SWIG_From_long(static_cast< long >(result));
21247 return resultobj;
21248 fail:
21249 return NULL;
21250 }
21251
21252
21253 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21254 PyObject *resultobj = 0;
21255 wxEvent *arg1 = (wxEvent *) 0 ;
21256 long arg2 = (long) 0 ;
21257 void *argp1 = 0 ;
21258 int res1 = 0 ;
21259 long val2 ;
21260 int ecode2 = 0 ;
21261 PyObject * obj0 = 0 ;
21262 PyObject * obj1 = 0 ;
21263 char * kwnames[] = {
21264 (char *) "self",(char *) "ts", NULL
21265 };
21266
21267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21269 if (!SWIG_IsOK(res1)) {
21270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21271 }
21272 arg1 = reinterpret_cast< wxEvent * >(argp1);
21273 if (obj1) {
21274 ecode2 = SWIG_AsVal_long(obj1, &val2);
21275 if (!SWIG_IsOK(ecode2)) {
21276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21277 }
21278 arg2 = static_cast< long >(val2);
21279 }
21280 {
21281 PyThreadState* __tstate = wxPyBeginAllowThreads();
21282 (arg1)->SetTimestamp(arg2);
21283 wxPyEndAllowThreads(__tstate);
21284 if (PyErr_Occurred()) SWIG_fail;
21285 }
21286 resultobj = SWIG_Py_Void();
21287 return resultobj;
21288 fail:
21289 return NULL;
21290 }
21291
21292
21293 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21294 PyObject *resultobj = 0;
21295 wxEvent *arg1 = (wxEvent *) 0 ;
21296 int result;
21297 void *argp1 = 0 ;
21298 int res1 = 0 ;
21299 PyObject *swig_obj[1] ;
21300
21301 if (!args) SWIG_fail;
21302 swig_obj[0] = args;
21303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21304 if (!SWIG_IsOK(res1)) {
21305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21306 }
21307 arg1 = reinterpret_cast< wxEvent * >(argp1);
21308 {
21309 PyThreadState* __tstate = wxPyBeginAllowThreads();
21310 result = (int)((wxEvent const *)arg1)->GetId();
21311 wxPyEndAllowThreads(__tstate);
21312 if (PyErr_Occurred()) SWIG_fail;
21313 }
21314 resultobj = SWIG_From_int(static_cast< int >(result));
21315 return resultobj;
21316 fail:
21317 return NULL;
21318 }
21319
21320
21321 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21322 PyObject *resultobj = 0;
21323 wxEvent *arg1 = (wxEvent *) 0 ;
21324 int arg2 ;
21325 void *argp1 = 0 ;
21326 int res1 = 0 ;
21327 int val2 ;
21328 int ecode2 = 0 ;
21329 PyObject * obj0 = 0 ;
21330 PyObject * obj1 = 0 ;
21331 char * kwnames[] = {
21332 (char *) "self",(char *) "Id", NULL
21333 };
21334
21335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21337 if (!SWIG_IsOK(res1)) {
21338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21339 }
21340 arg1 = reinterpret_cast< wxEvent * >(argp1);
21341 ecode2 = SWIG_AsVal_int(obj1, &val2);
21342 if (!SWIG_IsOK(ecode2)) {
21343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21344 }
21345 arg2 = static_cast< int >(val2);
21346 {
21347 PyThreadState* __tstate = wxPyBeginAllowThreads();
21348 (arg1)->SetId(arg2);
21349 wxPyEndAllowThreads(__tstate);
21350 if (PyErr_Occurred()) SWIG_fail;
21351 }
21352 resultobj = SWIG_Py_Void();
21353 return resultobj;
21354 fail:
21355 return NULL;
21356 }
21357
21358
21359 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21360 PyObject *resultobj = 0;
21361 wxEvent *arg1 = (wxEvent *) 0 ;
21362 bool result;
21363 void *argp1 = 0 ;
21364 int res1 = 0 ;
21365 PyObject *swig_obj[1] ;
21366
21367 if (!args) SWIG_fail;
21368 swig_obj[0] = args;
21369 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21370 if (!SWIG_IsOK(res1)) {
21371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21372 }
21373 arg1 = reinterpret_cast< wxEvent * >(argp1);
21374 {
21375 PyThreadState* __tstate = wxPyBeginAllowThreads();
21376 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21377 wxPyEndAllowThreads(__tstate);
21378 if (PyErr_Occurred()) SWIG_fail;
21379 }
21380 {
21381 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21382 }
21383 return resultobj;
21384 fail:
21385 return NULL;
21386 }
21387
21388
21389 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21390 PyObject *resultobj = 0;
21391 wxEvent *arg1 = (wxEvent *) 0 ;
21392 bool arg2 = (bool) true ;
21393 void *argp1 = 0 ;
21394 int res1 = 0 ;
21395 bool val2 ;
21396 int ecode2 = 0 ;
21397 PyObject * obj0 = 0 ;
21398 PyObject * obj1 = 0 ;
21399 char * kwnames[] = {
21400 (char *) "self",(char *) "skip", NULL
21401 };
21402
21403 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21404 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21405 if (!SWIG_IsOK(res1)) {
21406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21407 }
21408 arg1 = reinterpret_cast< wxEvent * >(argp1);
21409 if (obj1) {
21410 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21411 if (!SWIG_IsOK(ecode2)) {
21412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21413 }
21414 arg2 = static_cast< bool >(val2);
21415 }
21416 {
21417 PyThreadState* __tstate = wxPyBeginAllowThreads();
21418 (arg1)->Skip(arg2);
21419 wxPyEndAllowThreads(__tstate);
21420 if (PyErr_Occurred()) SWIG_fail;
21421 }
21422 resultobj = SWIG_Py_Void();
21423 return resultobj;
21424 fail:
21425 return NULL;
21426 }
21427
21428
21429 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21430 PyObject *resultobj = 0;
21431 wxEvent *arg1 = (wxEvent *) 0 ;
21432 bool result;
21433 void *argp1 = 0 ;
21434 int res1 = 0 ;
21435 PyObject *swig_obj[1] ;
21436
21437 if (!args) SWIG_fail;
21438 swig_obj[0] = args;
21439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21440 if (!SWIG_IsOK(res1)) {
21441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21442 }
21443 arg1 = reinterpret_cast< wxEvent * >(argp1);
21444 {
21445 PyThreadState* __tstate = wxPyBeginAllowThreads();
21446 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21447 wxPyEndAllowThreads(__tstate);
21448 if (PyErr_Occurred()) SWIG_fail;
21449 }
21450 {
21451 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21452 }
21453 return resultobj;
21454 fail:
21455 return NULL;
21456 }
21457
21458
21459 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21460 PyObject *resultobj = 0;
21461 wxEvent *arg1 = (wxEvent *) 0 ;
21462 bool result;
21463 void *argp1 = 0 ;
21464 int res1 = 0 ;
21465 PyObject *swig_obj[1] ;
21466
21467 if (!args) SWIG_fail;
21468 swig_obj[0] = args;
21469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21470 if (!SWIG_IsOK(res1)) {
21471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21472 }
21473 arg1 = reinterpret_cast< wxEvent * >(argp1);
21474 {
21475 PyThreadState* __tstate = wxPyBeginAllowThreads();
21476 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21477 wxPyEndAllowThreads(__tstate);
21478 if (PyErr_Occurred()) SWIG_fail;
21479 }
21480 {
21481 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21482 }
21483 return resultobj;
21484 fail:
21485 return NULL;
21486 }
21487
21488
21489 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21490 PyObject *resultobj = 0;
21491 wxEvent *arg1 = (wxEvent *) 0 ;
21492 int result;
21493 void *argp1 = 0 ;
21494 int res1 = 0 ;
21495 PyObject *swig_obj[1] ;
21496
21497 if (!args) SWIG_fail;
21498 swig_obj[0] = args;
21499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21500 if (!SWIG_IsOK(res1)) {
21501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21502 }
21503 arg1 = reinterpret_cast< wxEvent * >(argp1);
21504 {
21505 PyThreadState* __tstate = wxPyBeginAllowThreads();
21506 result = (int)(arg1)->StopPropagation();
21507 wxPyEndAllowThreads(__tstate);
21508 if (PyErr_Occurred()) SWIG_fail;
21509 }
21510 resultobj = SWIG_From_int(static_cast< int >(result));
21511 return resultobj;
21512 fail:
21513 return NULL;
21514 }
21515
21516
21517 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21518 PyObject *resultobj = 0;
21519 wxEvent *arg1 = (wxEvent *) 0 ;
21520 int arg2 ;
21521 void *argp1 = 0 ;
21522 int res1 = 0 ;
21523 int val2 ;
21524 int ecode2 = 0 ;
21525 PyObject * obj0 = 0 ;
21526 PyObject * obj1 = 0 ;
21527 char * kwnames[] = {
21528 (char *) "self",(char *) "propagationLevel", NULL
21529 };
21530
21531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21533 if (!SWIG_IsOK(res1)) {
21534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21535 }
21536 arg1 = reinterpret_cast< wxEvent * >(argp1);
21537 ecode2 = SWIG_AsVal_int(obj1, &val2);
21538 if (!SWIG_IsOK(ecode2)) {
21539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21540 }
21541 arg2 = static_cast< int >(val2);
21542 {
21543 PyThreadState* __tstate = wxPyBeginAllowThreads();
21544 (arg1)->ResumePropagation(arg2);
21545 wxPyEndAllowThreads(__tstate);
21546 if (PyErr_Occurred()) SWIG_fail;
21547 }
21548 resultobj = SWIG_Py_Void();
21549 return resultobj;
21550 fail:
21551 return NULL;
21552 }
21553
21554
21555 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21556 PyObject *resultobj = 0;
21557 wxEvent *arg1 = (wxEvent *) 0 ;
21558 wxEvent *result = 0 ;
21559 void *argp1 = 0 ;
21560 int res1 = 0 ;
21561 PyObject *swig_obj[1] ;
21562
21563 if (!args) SWIG_fail;
21564 swig_obj[0] = args;
21565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21566 if (!SWIG_IsOK(res1)) {
21567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21568 }
21569 arg1 = reinterpret_cast< wxEvent * >(argp1);
21570 {
21571 PyThreadState* __tstate = wxPyBeginAllowThreads();
21572 result = (wxEvent *)(arg1)->Clone();
21573 wxPyEndAllowThreads(__tstate);
21574 if (PyErr_Occurred()) SWIG_fail;
21575 }
21576 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21577 return resultobj;
21578 fail:
21579 return NULL;
21580 }
21581
21582
21583 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21584 PyObject *obj;
21585 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21586 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21587 return SWIG_Py_Void();
21588 }
21589
21590 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21591 PyObject *resultobj = 0;
21592 wxEvent *arg1 = 0 ;
21593 wxPropagationDisabler *result = 0 ;
21594 void *argp1 = 0 ;
21595 int res1 = 0 ;
21596 PyObject * obj0 = 0 ;
21597 char * kwnames[] = {
21598 (char *) "event", NULL
21599 };
21600
21601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21602 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21603 if (!SWIG_IsOK(res1)) {
21604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21605 }
21606 if (!argp1) {
21607 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21608 }
21609 arg1 = reinterpret_cast< wxEvent * >(argp1);
21610 {
21611 PyThreadState* __tstate = wxPyBeginAllowThreads();
21612 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21613 wxPyEndAllowThreads(__tstate);
21614 if (PyErr_Occurred()) SWIG_fail;
21615 }
21616 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21617 return resultobj;
21618 fail:
21619 return NULL;
21620 }
21621
21622
21623 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21624 PyObject *resultobj = 0;
21625 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21626 void *argp1 = 0 ;
21627 int res1 = 0 ;
21628 PyObject *swig_obj[1] ;
21629
21630 if (!args) SWIG_fail;
21631 swig_obj[0] = args;
21632 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21633 if (!SWIG_IsOK(res1)) {
21634 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21635 }
21636 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21637 {
21638 PyThreadState* __tstate = wxPyBeginAllowThreads();
21639 delete arg1;
21640
21641 wxPyEndAllowThreads(__tstate);
21642 if (PyErr_Occurred()) SWIG_fail;
21643 }
21644 resultobj = SWIG_Py_Void();
21645 return resultobj;
21646 fail:
21647 return NULL;
21648 }
21649
21650
21651 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21652 PyObject *obj;
21653 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21654 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21655 return SWIG_Py_Void();
21656 }
21657
21658 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21659 return SWIG_Python_InitShadowInstance(args);
21660 }
21661
21662 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21663 PyObject *resultobj = 0;
21664 wxEvent *arg1 = 0 ;
21665 wxPropagateOnce *result = 0 ;
21666 void *argp1 = 0 ;
21667 int res1 = 0 ;
21668 PyObject * obj0 = 0 ;
21669 char * kwnames[] = {
21670 (char *) "event", NULL
21671 };
21672
21673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21674 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21675 if (!SWIG_IsOK(res1)) {
21676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21677 }
21678 if (!argp1) {
21679 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21680 }
21681 arg1 = reinterpret_cast< wxEvent * >(argp1);
21682 {
21683 PyThreadState* __tstate = wxPyBeginAllowThreads();
21684 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21685 wxPyEndAllowThreads(__tstate);
21686 if (PyErr_Occurred()) SWIG_fail;
21687 }
21688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21689 return resultobj;
21690 fail:
21691 return NULL;
21692 }
21693
21694
21695 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21696 PyObject *resultobj = 0;
21697 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21698 void *argp1 = 0 ;
21699 int res1 = 0 ;
21700 PyObject *swig_obj[1] ;
21701
21702 if (!args) SWIG_fail;
21703 swig_obj[0] = args;
21704 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21705 if (!SWIG_IsOK(res1)) {
21706 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21707 }
21708 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21709 {
21710 PyThreadState* __tstate = wxPyBeginAllowThreads();
21711 delete arg1;
21712
21713 wxPyEndAllowThreads(__tstate);
21714 if (PyErr_Occurred()) SWIG_fail;
21715 }
21716 resultobj = SWIG_Py_Void();
21717 return resultobj;
21718 fail:
21719 return NULL;
21720 }
21721
21722
21723 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21724 PyObject *obj;
21725 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21726 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21727 return SWIG_Py_Void();
21728 }
21729
21730 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21731 return SWIG_Python_InitShadowInstance(args);
21732 }
21733
21734 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21735 PyObject *resultobj = 0;
21736 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21737 int arg2 = (int) 0 ;
21738 wxCommandEvent *result = 0 ;
21739 int val1 ;
21740 int ecode1 = 0 ;
21741 int val2 ;
21742 int ecode2 = 0 ;
21743 PyObject * obj0 = 0 ;
21744 PyObject * obj1 = 0 ;
21745 char * kwnames[] = {
21746 (char *) "commandType",(char *) "winid", NULL
21747 };
21748
21749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21750 if (obj0) {
21751 ecode1 = SWIG_AsVal_int(obj0, &val1);
21752 if (!SWIG_IsOK(ecode1)) {
21753 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21754 }
21755 arg1 = static_cast< wxEventType >(val1);
21756 }
21757 if (obj1) {
21758 ecode2 = SWIG_AsVal_int(obj1, &val2);
21759 if (!SWIG_IsOK(ecode2)) {
21760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21761 }
21762 arg2 = static_cast< int >(val2);
21763 }
21764 {
21765 PyThreadState* __tstate = wxPyBeginAllowThreads();
21766 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21767 wxPyEndAllowThreads(__tstate);
21768 if (PyErr_Occurred()) SWIG_fail;
21769 }
21770 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21771 return resultobj;
21772 fail:
21773 return NULL;
21774 }
21775
21776
21777 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21778 PyObject *resultobj = 0;
21779 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21780 int result;
21781 void *argp1 = 0 ;
21782 int res1 = 0 ;
21783 PyObject *swig_obj[1] ;
21784
21785 if (!args) SWIG_fail;
21786 swig_obj[0] = args;
21787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21788 if (!SWIG_IsOK(res1)) {
21789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21790 }
21791 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21792 {
21793 PyThreadState* __tstate = wxPyBeginAllowThreads();
21794 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21795 wxPyEndAllowThreads(__tstate);
21796 if (PyErr_Occurred()) SWIG_fail;
21797 }
21798 resultobj = SWIG_From_int(static_cast< int >(result));
21799 return resultobj;
21800 fail:
21801 return NULL;
21802 }
21803
21804
21805 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21806 PyObject *resultobj = 0;
21807 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21808 wxString *arg2 = 0 ;
21809 void *argp1 = 0 ;
21810 int res1 = 0 ;
21811 bool temp2 = false ;
21812 PyObject * obj0 = 0 ;
21813 PyObject * obj1 = 0 ;
21814 char * kwnames[] = {
21815 (char *) "self",(char *) "s", NULL
21816 };
21817
21818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21820 if (!SWIG_IsOK(res1)) {
21821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21822 }
21823 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21824 {
21825 arg2 = wxString_in_helper(obj1);
21826 if (arg2 == NULL) SWIG_fail;
21827 temp2 = true;
21828 }
21829 {
21830 PyThreadState* __tstate = wxPyBeginAllowThreads();
21831 (arg1)->SetString((wxString const &)*arg2);
21832 wxPyEndAllowThreads(__tstate);
21833 if (PyErr_Occurred()) SWIG_fail;
21834 }
21835 resultobj = SWIG_Py_Void();
21836 {
21837 if (temp2)
21838 delete arg2;
21839 }
21840 return resultobj;
21841 fail:
21842 {
21843 if (temp2)
21844 delete arg2;
21845 }
21846 return NULL;
21847 }
21848
21849
21850 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21851 PyObject *resultobj = 0;
21852 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21853 wxString result;
21854 void *argp1 = 0 ;
21855 int res1 = 0 ;
21856 PyObject *swig_obj[1] ;
21857
21858 if (!args) SWIG_fail;
21859 swig_obj[0] = args;
21860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21861 if (!SWIG_IsOK(res1)) {
21862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21863 }
21864 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21865 {
21866 PyThreadState* __tstate = wxPyBeginAllowThreads();
21867 result = ((wxCommandEvent const *)arg1)->GetString();
21868 wxPyEndAllowThreads(__tstate);
21869 if (PyErr_Occurred()) SWIG_fail;
21870 }
21871 {
21872 #if wxUSE_UNICODE
21873 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21874 #else
21875 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21876 #endif
21877 }
21878 return resultobj;
21879 fail:
21880 return NULL;
21881 }
21882
21883
21884 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21885 PyObject *resultobj = 0;
21886 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21887 bool result;
21888 void *argp1 = 0 ;
21889 int res1 = 0 ;
21890 PyObject *swig_obj[1] ;
21891
21892 if (!args) SWIG_fail;
21893 swig_obj[0] = args;
21894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21895 if (!SWIG_IsOK(res1)) {
21896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21897 }
21898 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21899 {
21900 PyThreadState* __tstate = wxPyBeginAllowThreads();
21901 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21902 wxPyEndAllowThreads(__tstate);
21903 if (PyErr_Occurred()) SWIG_fail;
21904 }
21905 {
21906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21907 }
21908 return resultobj;
21909 fail:
21910 return NULL;
21911 }
21912
21913
21914 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21915 PyObject *resultobj = 0;
21916 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21917 bool result;
21918 void *argp1 = 0 ;
21919 int res1 = 0 ;
21920 PyObject *swig_obj[1] ;
21921
21922 if (!args) SWIG_fail;
21923 swig_obj[0] = args;
21924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21925 if (!SWIG_IsOK(res1)) {
21926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21927 }
21928 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21929 {
21930 PyThreadState* __tstate = wxPyBeginAllowThreads();
21931 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21932 wxPyEndAllowThreads(__tstate);
21933 if (PyErr_Occurred()) SWIG_fail;
21934 }
21935 {
21936 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21937 }
21938 return resultobj;
21939 fail:
21940 return NULL;
21941 }
21942
21943
21944 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21945 PyObject *resultobj = 0;
21946 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21947 long arg2 ;
21948 void *argp1 = 0 ;
21949 int res1 = 0 ;
21950 long val2 ;
21951 int ecode2 = 0 ;
21952 PyObject * obj0 = 0 ;
21953 PyObject * obj1 = 0 ;
21954 char * kwnames[] = {
21955 (char *) "self",(char *) "extraLong", NULL
21956 };
21957
21958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21960 if (!SWIG_IsOK(res1)) {
21961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21962 }
21963 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21964 ecode2 = SWIG_AsVal_long(obj1, &val2);
21965 if (!SWIG_IsOK(ecode2)) {
21966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21967 }
21968 arg2 = static_cast< long >(val2);
21969 {
21970 PyThreadState* __tstate = wxPyBeginAllowThreads();
21971 (arg1)->SetExtraLong(arg2);
21972 wxPyEndAllowThreads(__tstate);
21973 if (PyErr_Occurred()) SWIG_fail;
21974 }
21975 resultobj = SWIG_Py_Void();
21976 return resultobj;
21977 fail:
21978 return NULL;
21979 }
21980
21981
21982 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21983 PyObject *resultobj = 0;
21984 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21985 long result;
21986 void *argp1 = 0 ;
21987 int res1 = 0 ;
21988 PyObject *swig_obj[1] ;
21989
21990 if (!args) SWIG_fail;
21991 swig_obj[0] = args;
21992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21993 if (!SWIG_IsOK(res1)) {
21994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21995 }
21996 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21997 {
21998 PyThreadState* __tstate = wxPyBeginAllowThreads();
21999 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22000 wxPyEndAllowThreads(__tstate);
22001 if (PyErr_Occurred()) SWIG_fail;
22002 }
22003 resultobj = SWIG_From_long(static_cast< long >(result));
22004 return resultobj;
22005 fail:
22006 return NULL;
22007 }
22008
22009
22010 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22011 PyObject *resultobj = 0;
22012 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22013 int arg2 ;
22014 void *argp1 = 0 ;
22015 int res1 = 0 ;
22016 int val2 ;
22017 int ecode2 = 0 ;
22018 PyObject * obj0 = 0 ;
22019 PyObject * obj1 = 0 ;
22020 char * kwnames[] = {
22021 (char *) "self",(char *) "i", NULL
22022 };
22023
22024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22026 if (!SWIG_IsOK(res1)) {
22027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22028 }
22029 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22030 ecode2 = SWIG_AsVal_int(obj1, &val2);
22031 if (!SWIG_IsOK(ecode2)) {
22032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22033 }
22034 arg2 = static_cast< int >(val2);
22035 {
22036 PyThreadState* __tstate = wxPyBeginAllowThreads();
22037 (arg1)->SetInt(arg2);
22038 wxPyEndAllowThreads(__tstate);
22039 if (PyErr_Occurred()) SWIG_fail;
22040 }
22041 resultobj = SWIG_Py_Void();
22042 return resultobj;
22043 fail:
22044 return NULL;
22045 }
22046
22047
22048 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22049 PyObject *resultobj = 0;
22050 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22051 int result;
22052 void *argp1 = 0 ;
22053 int res1 = 0 ;
22054 PyObject *swig_obj[1] ;
22055
22056 if (!args) SWIG_fail;
22057 swig_obj[0] = args;
22058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22059 if (!SWIG_IsOK(res1)) {
22060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22061 }
22062 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22063 {
22064 PyThreadState* __tstate = wxPyBeginAllowThreads();
22065 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22066 wxPyEndAllowThreads(__tstate);
22067 if (PyErr_Occurred()) SWIG_fail;
22068 }
22069 resultobj = SWIG_From_int(static_cast< int >(result));
22070 return resultobj;
22071 fail:
22072 return NULL;
22073 }
22074
22075
22076 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22077 PyObject *resultobj = 0;
22078 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22079 PyObject *result = 0 ;
22080 void *argp1 = 0 ;
22081 int res1 = 0 ;
22082 PyObject *swig_obj[1] ;
22083
22084 if (!args) SWIG_fail;
22085 swig_obj[0] = args;
22086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22087 if (!SWIG_IsOK(res1)) {
22088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22089 }
22090 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22091 {
22092 PyThreadState* __tstate = wxPyBeginAllowThreads();
22093 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22094 wxPyEndAllowThreads(__tstate);
22095 if (PyErr_Occurred()) SWIG_fail;
22096 }
22097 resultobj = result;
22098 return resultobj;
22099 fail:
22100 return NULL;
22101 }
22102
22103
22104 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22105 PyObject *resultobj = 0;
22106 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22107 PyObject *arg2 = (PyObject *) 0 ;
22108 void *argp1 = 0 ;
22109 int res1 = 0 ;
22110 PyObject * obj0 = 0 ;
22111 PyObject * obj1 = 0 ;
22112 char * kwnames[] = {
22113 (char *) "self",(char *) "clientData", NULL
22114 };
22115
22116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22118 if (!SWIG_IsOK(res1)) {
22119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22120 }
22121 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22122 arg2 = obj1;
22123 {
22124 PyThreadState* __tstate = wxPyBeginAllowThreads();
22125 wxCommandEvent_SetClientData(arg1,arg2);
22126 wxPyEndAllowThreads(__tstate);
22127 if (PyErr_Occurred()) SWIG_fail;
22128 }
22129 resultobj = SWIG_Py_Void();
22130 return resultobj;
22131 fail:
22132 return NULL;
22133 }
22134
22135
22136 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22137 PyObject *resultobj = 0;
22138 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22139 wxEvent *result = 0 ;
22140 void *argp1 = 0 ;
22141 int res1 = 0 ;
22142 PyObject *swig_obj[1] ;
22143
22144 if (!args) SWIG_fail;
22145 swig_obj[0] = args;
22146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22147 if (!SWIG_IsOK(res1)) {
22148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22149 }
22150 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22151 {
22152 PyThreadState* __tstate = wxPyBeginAllowThreads();
22153 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22154 wxPyEndAllowThreads(__tstate);
22155 if (PyErr_Occurred()) SWIG_fail;
22156 }
22157 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22158 return resultobj;
22159 fail:
22160 return NULL;
22161 }
22162
22163
22164 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22165 PyObject *obj;
22166 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22167 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22168 return SWIG_Py_Void();
22169 }
22170
22171 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22172 return SWIG_Python_InitShadowInstance(args);
22173 }
22174
22175 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22176 PyObject *resultobj = 0;
22177 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22178 int arg2 = (int) 0 ;
22179 wxNotifyEvent *result = 0 ;
22180 int val1 ;
22181 int ecode1 = 0 ;
22182 int val2 ;
22183 int ecode2 = 0 ;
22184 PyObject * obj0 = 0 ;
22185 PyObject * obj1 = 0 ;
22186 char * kwnames[] = {
22187 (char *) "commandType",(char *) "winid", NULL
22188 };
22189
22190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22191 if (obj0) {
22192 ecode1 = SWIG_AsVal_int(obj0, &val1);
22193 if (!SWIG_IsOK(ecode1)) {
22194 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22195 }
22196 arg1 = static_cast< wxEventType >(val1);
22197 }
22198 if (obj1) {
22199 ecode2 = SWIG_AsVal_int(obj1, &val2);
22200 if (!SWIG_IsOK(ecode2)) {
22201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22202 }
22203 arg2 = static_cast< int >(val2);
22204 }
22205 {
22206 PyThreadState* __tstate = wxPyBeginAllowThreads();
22207 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22208 wxPyEndAllowThreads(__tstate);
22209 if (PyErr_Occurred()) SWIG_fail;
22210 }
22211 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22212 return resultobj;
22213 fail:
22214 return NULL;
22215 }
22216
22217
22218 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22219 PyObject *resultobj = 0;
22220 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22221 void *argp1 = 0 ;
22222 int res1 = 0 ;
22223 PyObject *swig_obj[1] ;
22224
22225 if (!args) SWIG_fail;
22226 swig_obj[0] = args;
22227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22228 if (!SWIG_IsOK(res1)) {
22229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22230 }
22231 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22232 {
22233 PyThreadState* __tstate = wxPyBeginAllowThreads();
22234 (arg1)->Veto();
22235 wxPyEndAllowThreads(__tstate);
22236 if (PyErr_Occurred()) SWIG_fail;
22237 }
22238 resultobj = SWIG_Py_Void();
22239 return resultobj;
22240 fail:
22241 return NULL;
22242 }
22243
22244
22245 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22246 PyObject *resultobj = 0;
22247 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22248 void *argp1 = 0 ;
22249 int res1 = 0 ;
22250 PyObject *swig_obj[1] ;
22251
22252 if (!args) SWIG_fail;
22253 swig_obj[0] = args;
22254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22255 if (!SWIG_IsOK(res1)) {
22256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22257 }
22258 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22259 {
22260 PyThreadState* __tstate = wxPyBeginAllowThreads();
22261 (arg1)->Allow();
22262 wxPyEndAllowThreads(__tstate);
22263 if (PyErr_Occurred()) SWIG_fail;
22264 }
22265 resultobj = SWIG_Py_Void();
22266 return resultobj;
22267 fail:
22268 return NULL;
22269 }
22270
22271
22272 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22273 PyObject *resultobj = 0;
22274 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22275 bool result;
22276 void *argp1 = 0 ;
22277 int res1 = 0 ;
22278 PyObject *swig_obj[1] ;
22279
22280 if (!args) SWIG_fail;
22281 swig_obj[0] = args;
22282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22283 if (!SWIG_IsOK(res1)) {
22284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22285 }
22286 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22287 {
22288 PyThreadState* __tstate = wxPyBeginAllowThreads();
22289 result = (bool)(arg1)->IsAllowed();
22290 wxPyEndAllowThreads(__tstate);
22291 if (PyErr_Occurred()) SWIG_fail;
22292 }
22293 {
22294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22295 }
22296 return resultobj;
22297 fail:
22298 return NULL;
22299 }
22300
22301
22302 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22303 PyObject *obj;
22304 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22305 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22306 return SWIG_Py_Void();
22307 }
22308
22309 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22310 return SWIG_Python_InitShadowInstance(args);
22311 }
22312
22313 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22314 PyObject *resultobj = 0;
22315 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22316 int arg2 = (int) 0 ;
22317 int arg3 = (int) 0 ;
22318 int arg4 = (int) 0 ;
22319 wxScrollEvent *result = 0 ;
22320 int val1 ;
22321 int ecode1 = 0 ;
22322 int val2 ;
22323 int ecode2 = 0 ;
22324 int val3 ;
22325 int ecode3 = 0 ;
22326 int val4 ;
22327 int ecode4 = 0 ;
22328 PyObject * obj0 = 0 ;
22329 PyObject * obj1 = 0 ;
22330 PyObject * obj2 = 0 ;
22331 PyObject * obj3 = 0 ;
22332 char * kwnames[] = {
22333 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22334 };
22335
22336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22337 if (obj0) {
22338 ecode1 = SWIG_AsVal_int(obj0, &val1);
22339 if (!SWIG_IsOK(ecode1)) {
22340 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22341 }
22342 arg1 = static_cast< wxEventType >(val1);
22343 }
22344 if (obj1) {
22345 ecode2 = SWIG_AsVal_int(obj1, &val2);
22346 if (!SWIG_IsOK(ecode2)) {
22347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22348 }
22349 arg2 = static_cast< int >(val2);
22350 }
22351 if (obj2) {
22352 ecode3 = SWIG_AsVal_int(obj2, &val3);
22353 if (!SWIG_IsOK(ecode3)) {
22354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22355 }
22356 arg3 = static_cast< int >(val3);
22357 }
22358 if (obj3) {
22359 ecode4 = SWIG_AsVal_int(obj3, &val4);
22360 if (!SWIG_IsOK(ecode4)) {
22361 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22362 }
22363 arg4 = static_cast< int >(val4);
22364 }
22365 {
22366 PyThreadState* __tstate = wxPyBeginAllowThreads();
22367 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22368 wxPyEndAllowThreads(__tstate);
22369 if (PyErr_Occurred()) SWIG_fail;
22370 }
22371 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22372 return resultobj;
22373 fail:
22374 return NULL;
22375 }
22376
22377
22378 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22379 PyObject *resultobj = 0;
22380 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22381 int result;
22382 void *argp1 = 0 ;
22383 int res1 = 0 ;
22384 PyObject *swig_obj[1] ;
22385
22386 if (!args) SWIG_fail;
22387 swig_obj[0] = args;
22388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22389 if (!SWIG_IsOK(res1)) {
22390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22391 }
22392 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22393 {
22394 PyThreadState* __tstate = wxPyBeginAllowThreads();
22395 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22396 wxPyEndAllowThreads(__tstate);
22397 if (PyErr_Occurred()) SWIG_fail;
22398 }
22399 resultobj = SWIG_From_int(static_cast< int >(result));
22400 return resultobj;
22401 fail:
22402 return NULL;
22403 }
22404
22405
22406 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22407 PyObject *resultobj = 0;
22408 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22409 int result;
22410 void *argp1 = 0 ;
22411 int res1 = 0 ;
22412 PyObject *swig_obj[1] ;
22413
22414 if (!args) SWIG_fail;
22415 swig_obj[0] = args;
22416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22417 if (!SWIG_IsOK(res1)) {
22418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22419 }
22420 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22421 {
22422 PyThreadState* __tstate = wxPyBeginAllowThreads();
22423 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22424 wxPyEndAllowThreads(__tstate);
22425 if (PyErr_Occurred()) SWIG_fail;
22426 }
22427 resultobj = SWIG_From_int(static_cast< int >(result));
22428 return resultobj;
22429 fail:
22430 return NULL;
22431 }
22432
22433
22434 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22435 PyObject *resultobj = 0;
22436 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22437 int arg2 ;
22438 void *argp1 = 0 ;
22439 int res1 = 0 ;
22440 int val2 ;
22441 int ecode2 = 0 ;
22442 PyObject * obj0 = 0 ;
22443 PyObject * obj1 = 0 ;
22444 char * kwnames[] = {
22445 (char *) "self",(char *) "orient", NULL
22446 };
22447
22448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22450 if (!SWIG_IsOK(res1)) {
22451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22452 }
22453 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22454 ecode2 = SWIG_AsVal_int(obj1, &val2);
22455 if (!SWIG_IsOK(ecode2)) {
22456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22457 }
22458 arg2 = static_cast< int >(val2);
22459 {
22460 PyThreadState* __tstate = wxPyBeginAllowThreads();
22461 (arg1)->SetOrientation(arg2);
22462 wxPyEndAllowThreads(__tstate);
22463 if (PyErr_Occurred()) SWIG_fail;
22464 }
22465 resultobj = SWIG_Py_Void();
22466 return resultobj;
22467 fail:
22468 return NULL;
22469 }
22470
22471
22472 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22473 PyObject *resultobj = 0;
22474 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22475 int arg2 ;
22476 void *argp1 = 0 ;
22477 int res1 = 0 ;
22478 int val2 ;
22479 int ecode2 = 0 ;
22480 PyObject * obj0 = 0 ;
22481 PyObject * obj1 = 0 ;
22482 char * kwnames[] = {
22483 (char *) "self",(char *) "pos", NULL
22484 };
22485
22486 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22487 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22488 if (!SWIG_IsOK(res1)) {
22489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22490 }
22491 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22492 ecode2 = SWIG_AsVal_int(obj1, &val2);
22493 if (!SWIG_IsOK(ecode2)) {
22494 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22495 }
22496 arg2 = static_cast< int >(val2);
22497 {
22498 PyThreadState* __tstate = wxPyBeginAllowThreads();
22499 (arg1)->SetPosition(arg2);
22500 wxPyEndAllowThreads(__tstate);
22501 if (PyErr_Occurred()) SWIG_fail;
22502 }
22503 resultobj = SWIG_Py_Void();
22504 return resultobj;
22505 fail:
22506 return NULL;
22507 }
22508
22509
22510 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22511 PyObject *obj;
22512 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22513 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22514 return SWIG_Py_Void();
22515 }
22516
22517 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22518 return SWIG_Python_InitShadowInstance(args);
22519 }
22520
22521 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22522 PyObject *resultobj = 0;
22523 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22524 int arg2 = (int) 0 ;
22525 int arg3 = (int) 0 ;
22526 wxScrollWinEvent *result = 0 ;
22527 int val1 ;
22528 int ecode1 = 0 ;
22529 int val2 ;
22530 int ecode2 = 0 ;
22531 int val3 ;
22532 int ecode3 = 0 ;
22533 PyObject * obj0 = 0 ;
22534 PyObject * obj1 = 0 ;
22535 PyObject * obj2 = 0 ;
22536 char * kwnames[] = {
22537 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22538 };
22539
22540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22541 if (obj0) {
22542 ecode1 = SWIG_AsVal_int(obj0, &val1);
22543 if (!SWIG_IsOK(ecode1)) {
22544 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22545 }
22546 arg1 = static_cast< wxEventType >(val1);
22547 }
22548 if (obj1) {
22549 ecode2 = SWIG_AsVal_int(obj1, &val2);
22550 if (!SWIG_IsOK(ecode2)) {
22551 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22552 }
22553 arg2 = static_cast< int >(val2);
22554 }
22555 if (obj2) {
22556 ecode3 = SWIG_AsVal_int(obj2, &val3);
22557 if (!SWIG_IsOK(ecode3)) {
22558 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22559 }
22560 arg3 = static_cast< int >(val3);
22561 }
22562 {
22563 PyThreadState* __tstate = wxPyBeginAllowThreads();
22564 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22565 wxPyEndAllowThreads(__tstate);
22566 if (PyErr_Occurred()) SWIG_fail;
22567 }
22568 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22569 return resultobj;
22570 fail:
22571 return NULL;
22572 }
22573
22574
22575 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22576 PyObject *resultobj = 0;
22577 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22578 int result;
22579 void *argp1 = 0 ;
22580 int res1 = 0 ;
22581 PyObject *swig_obj[1] ;
22582
22583 if (!args) SWIG_fail;
22584 swig_obj[0] = args;
22585 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22586 if (!SWIG_IsOK(res1)) {
22587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22588 }
22589 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22590 {
22591 PyThreadState* __tstate = wxPyBeginAllowThreads();
22592 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22593 wxPyEndAllowThreads(__tstate);
22594 if (PyErr_Occurred()) SWIG_fail;
22595 }
22596 resultobj = SWIG_From_int(static_cast< int >(result));
22597 return resultobj;
22598 fail:
22599 return NULL;
22600 }
22601
22602
22603 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22604 PyObject *resultobj = 0;
22605 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22606 int result;
22607 void *argp1 = 0 ;
22608 int res1 = 0 ;
22609 PyObject *swig_obj[1] ;
22610
22611 if (!args) SWIG_fail;
22612 swig_obj[0] = args;
22613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22614 if (!SWIG_IsOK(res1)) {
22615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22616 }
22617 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22618 {
22619 PyThreadState* __tstate = wxPyBeginAllowThreads();
22620 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22621 wxPyEndAllowThreads(__tstate);
22622 if (PyErr_Occurred()) SWIG_fail;
22623 }
22624 resultobj = SWIG_From_int(static_cast< int >(result));
22625 return resultobj;
22626 fail:
22627 return NULL;
22628 }
22629
22630
22631 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22632 PyObject *resultobj = 0;
22633 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22634 int arg2 ;
22635 void *argp1 = 0 ;
22636 int res1 = 0 ;
22637 int val2 ;
22638 int ecode2 = 0 ;
22639 PyObject * obj0 = 0 ;
22640 PyObject * obj1 = 0 ;
22641 char * kwnames[] = {
22642 (char *) "self",(char *) "orient", NULL
22643 };
22644
22645 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22646 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22647 if (!SWIG_IsOK(res1)) {
22648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22649 }
22650 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22651 ecode2 = SWIG_AsVal_int(obj1, &val2);
22652 if (!SWIG_IsOK(ecode2)) {
22653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22654 }
22655 arg2 = static_cast< int >(val2);
22656 {
22657 PyThreadState* __tstate = wxPyBeginAllowThreads();
22658 (arg1)->SetOrientation(arg2);
22659 wxPyEndAllowThreads(__tstate);
22660 if (PyErr_Occurred()) SWIG_fail;
22661 }
22662 resultobj = SWIG_Py_Void();
22663 return resultobj;
22664 fail:
22665 return NULL;
22666 }
22667
22668
22669 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22670 PyObject *resultobj = 0;
22671 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22672 int arg2 ;
22673 void *argp1 = 0 ;
22674 int res1 = 0 ;
22675 int val2 ;
22676 int ecode2 = 0 ;
22677 PyObject * obj0 = 0 ;
22678 PyObject * obj1 = 0 ;
22679 char * kwnames[] = {
22680 (char *) "self",(char *) "pos", NULL
22681 };
22682
22683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22684 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22685 if (!SWIG_IsOK(res1)) {
22686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22687 }
22688 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22689 ecode2 = SWIG_AsVal_int(obj1, &val2);
22690 if (!SWIG_IsOK(ecode2)) {
22691 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22692 }
22693 arg2 = static_cast< int >(val2);
22694 {
22695 PyThreadState* __tstate = wxPyBeginAllowThreads();
22696 (arg1)->SetPosition(arg2);
22697 wxPyEndAllowThreads(__tstate);
22698 if (PyErr_Occurred()) SWIG_fail;
22699 }
22700 resultobj = SWIG_Py_Void();
22701 return resultobj;
22702 fail:
22703 return NULL;
22704 }
22705
22706
22707 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22708 PyObject *obj;
22709 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22710 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22711 return SWIG_Py_Void();
22712 }
22713
22714 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22715 return SWIG_Python_InitShadowInstance(args);
22716 }
22717
22718 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22719 PyObject *resultobj = 0;
22720 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22721 wxMouseEvent *result = 0 ;
22722 int val1 ;
22723 int ecode1 = 0 ;
22724 PyObject * obj0 = 0 ;
22725 char * kwnames[] = {
22726 (char *) "mouseType", NULL
22727 };
22728
22729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22730 if (obj0) {
22731 ecode1 = SWIG_AsVal_int(obj0, &val1);
22732 if (!SWIG_IsOK(ecode1)) {
22733 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22734 }
22735 arg1 = static_cast< wxEventType >(val1);
22736 }
22737 {
22738 PyThreadState* __tstate = wxPyBeginAllowThreads();
22739 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22740 wxPyEndAllowThreads(__tstate);
22741 if (PyErr_Occurred()) SWIG_fail;
22742 }
22743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22744 return resultobj;
22745 fail:
22746 return NULL;
22747 }
22748
22749
22750 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22751 PyObject *resultobj = 0;
22752 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22753 bool result;
22754 void *argp1 = 0 ;
22755 int res1 = 0 ;
22756 PyObject *swig_obj[1] ;
22757
22758 if (!args) SWIG_fail;
22759 swig_obj[0] = args;
22760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22761 if (!SWIG_IsOK(res1)) {
22762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22763 }
22764 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22765 {
22766 PyThreadState* __tstate = wxPyBeginAllowThreads();
22767 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22768 wxPyEndAllowThreads(__tstate);
22769 if (PyErr_Occurred()) SWIG_fail;
22770 }
22771 {
22772 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22773 }
22774 return resultobj;
22775 fail:
22776 return NULL;
22777 }
22778
22779
22780 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22781 PyObject *resultobj = 0;
22782 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22783 int arg2 = (int) wxMOUSE_BTN_ANY ;
22784 bool result;
22785 void *argp1 = 0 ;
22786 int res1 = 0 ;
22787 int val2 ;
22788 int ecode2 = 0 ;
22789 PyObject * obj0 = 0 ;
22790 PyObject * obj1 = 0 ;
22791 char * kwnames[] = {
22792 (char *) "self",(char *) "but", NULL
22793 };
22794
22795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22797 if (!SWIG_IsOK(res1)) {
22798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22799 }
22800 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22801 if (obj1) {
22802 ecode2 = SWIG_AsVal_int(obj1, &val2);
22803 if (!SWIG_IsOK(ecode2)) {
22804 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22805 }
22806 arg2 = static_cast< int >(val2);
22807 }
22808 {
22809 PyThreadState* __tstate = wxPyBeginAllowThreads();
22810 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22811 wxPyEndAllowThreads(__tstate);
22812 if (PyErr_Occurred()) SWIG_fail;
22813 }
22814 {
22815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22816 }
22817 return resultobj;
22818 fail:
22819 return NULL;
22820 }
22821
22822
22823 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22824 PyObject *resultobj = 0;
22825 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22826 int arg2 = (int) wxMOUSE_BTN_ANY ;
22827 bool result;
22828 void *argp1 = 0 ;
22829 int res1 = 0 ;
22830 int val2 ;
22831 int ecode2 = 0 ;
22832 PyObject * obj0 = 0 ;
22833 PyObject * obj1 = 0 ;
22834 char * kwnames[] = {
22835 (char *) "self",(char *) "but", NULL
22836 };
22837
22838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22840 if (!SWIG_IsOK(res1)) {
22841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22842 }
22843 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22844 if (obj1) {
22845 ecode2 = SWIG_AsVal_int(obj1, &val2);
22846 if (!SWIG_IsOK(ecode2)) {
22847 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22848 }
22849 arg2 = static_cast< int >(val2);
22850 }
22851 {
22852 PyThreadState* __tstate = wxPyBeginAllowThreads();
22853 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22854 wxPyEndAllowThreads(__tstate);
22855 if (PyErr_Occurred()) SWIG_fail;
22856 }
22857 {
22858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22859 }
22860 return resultobj;
22861 fail:
22862 return NULL;
22863 }
22864
22865
22866 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22867 PyObject *resultobj = 0;
22868 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22869 int arg2 = (int) wxMOUSE_BTN_ANY ;
22870 bool result;
22871 void *argp1 = 0 ;
22872 int res1 = 0 ;
22873 int val2 ;
22874 int ecode2 = 0 ;
22875 PyObject * obj0 = 0 ;
22876 PyObject * obj1 = 0 ;
22877 char * kwnames[] = {
22878 (char *) "self",(char *) "but", NULL
22879 };
22880
22881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22883 if (!SWIG_IsOK(res1)) {
22884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22885 }
22886 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22887 if (obj1) {
22888 ecode2 = SWIG_AsVal_int(obj1, &val2);
22889 if (!SWIG_IsOK(ecode2)) {
22890 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22891 }
22892 arg2 = static_cast< int >(val2);
22893 }
22894 {
22895 PyThreadState* __tstate = wxPyBeginAllowThreads();
22896 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22897 wxPyEndAllowThreads(__tstate);
22898 if (PyErr_Occurred()) SWIG_fail;
22899 }
22900 {
22901 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22902 }
22903 return resultobj;
22904 fail:
22905 return NULL;
22906 }
22907
22908
22909 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22910 PyObject *resultobj = 0;
22911 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22912 int arg2 ;
22913 bool result;
22914 void *argp1 = 0 ;
22915 int res1 = 0 ;
22916 int val2 ;
22917 int ecode2 = 0 ;
22918 PyObject * obj0 = 0 ;
22919 PyObject * obj1 = 0 ;
22920 char * kwnames[] = {
22921 (char *) "self",(char *) "button", NULL
22922 };
22923
22924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22926 if (!SWIG_IsOK(res1)) {
22927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22928 }
22929 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22930 ecode2 = SWIG_AsVal_int(obj1, &val2);
22931 if (!SWIG_IsOK(ecode2)) {
22932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22933 }
22934 arg2 = static_cast< int >(val2);
22935 {
22936 PyThreadState* __tstate = wxPyBeginAllowThreads();
22937 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22938 wxPyEndAllowThreads(__tstate);
22939 if (PyErr_Occurred()) SWIG_fail;
22940 }
22941 {
22942 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22943 }
22944 return resultobj;
22945 fail:
22946 return NULL;
22947 }
22948
22949
22950 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22951 PyObject *resultobj = 0;
22952 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22953 int arg2 ;
22954 bool result;
22955 void *argp1 = 0 ;
22956 int res1 = 0 ;
22957 int val2 ;
22958 int ecode2 = 0 ;
22959 PyObject * obj0 = 0 ;
22960 PyObject * obj1 = 0 ;
22961 char * kwnames[] = {
22962 (char *) "self",(char *) "but", NULL
22963 };
22964
22965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22967 if (!SWIG_IsOK(res1)) {
22968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22969 }
22970 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22971 ecode2 = SWIG_AsVal_int(obj1, &val2);
22972 if (!SWIG_IsOK(ecode2)) {
22973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22974 }
22975 arg2 = static_cast< int >(val2);
22976 {
22977 PyThreadState* __tstate = wxPyBeginAllowThreads();
22978 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22979 wxPyEndAllowThreads(__tstate);
22980 if (PyErr_Occurred()) SWIG_fail;
22981 }
22982 {
22983 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22984 }
22985 return resultobj;
22986 fail:
22987 return NULL;
22988 }
22989
22990
22991 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22992 PyObject *resultobj = 0;
22993 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22994 int result;
22995 void *argp1 = 0 ;
22996 int res1 = 0 ;
22997 PyObject *swig_obj[1] ;
22998
22999 if (!args) SWIG_fail;
23000 swig_obj[0] = args;
23001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23002 if (!SWIG_IsOK(res1)) {
23003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23004 }
23005 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23006 {
23007 PyThreadState* __tstate = wxPyBeginAllowThreads();
23008 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23009 wxPyEndAllowThreads(__tstate);
23010 if (PyErr_Occurred()) SWIG_fail;
23011 }
23012 resultobj = SWIG_From_int(static_cast< int >(result));
23013 return resultobj;
23014 fail:
23015 return NULL;
23016 }
23017
23018
23019 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23020 PyObject *resultobj = 0;
23021 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23022 bool result;
23023 void *argp1 = 0 ;
23024 int res1 = 0 ;
23025 PyObject *swig_obj[1] ;
23026
23027 if (!args) SWIG_fail;
23028 swig_obj[0] = args;
23029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23030 if (!SWIG_IsOK(res1)) {
23031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23032 }
23033 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23034 {
23035 PyThreadState* __tstate = wxPyBeginAllowThreads();
23036 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23037 wxPyEndAllowThreads(__tstate);
23038 if (PyErr_Occurred()) SWIG_fail;
23039 }
23040 {
23041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23042 }
23043 return resultobj;
23044 fail:
23045 return NULL;
23046 }
23047
23048
23049 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23050 PyObject *resultobj = 0;
23051 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23052 bool result;
23053 void *argp1 = 0 ;
23054 int res1 = 0 ;
23055 PyObject *swig_obj[1] ;
23056
23057 if (!args) SWIG_fail;
23058 swig_obj[0] = args;
23059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23060 if (!SWIG_IsOK(res1)) {
23061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23062 }
23063 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23064 {
23065 PyThreadState* __tstate = wxPyBeginAllowThreads();
23066 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23067 wxPyEndAllowThreads(__tstate);
23068 if (PyErr_Occurred()) SWIG_fail;
23069 }
23070 {
23071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23072 }
23073 return resultobj;
23074 fail:
23075 return NULL;
23076 }
23077
23078
23079 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23080 PyObject *resultobj = 0;
23081 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23082 bool result;
23083 void *argp1 = 0 ;
23084 int res1 = 0 ;
23085 PyObject *swig_obj[1] ;
23086
23087 if (!args) SWIG_fail;
23088 swig_obj[0] = args;
23089 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23090 if (!SWIG_IsOK(res1)) {
23091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23092 }
23093 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23094 {
23095 PyThreadState* __tstate = wxPyBeginAllowThreads();
23096 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23097 wxPyEndAllowThreads(__tstate);
23098 if (PyErr_Occurred()) SWIG_fail;
23099 }
23100 {
23101 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23102 }
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 PyObject *resultobj = 0;
23111 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23112 bool result;
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_wxMouseEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23122 }
23123 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 {
23131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23132 }
23133 return resultobj;
23134 fail:
23135 return NULL;
23136 }
23137
23138
23139 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23140 PyObject *resultobj = 0;
23141 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23142 bool result;
23143 void *argp1 = 0 ;
23144 int res1 = 0 ;
23145 PyObject *swig_obj[1] ;
23146
23147 if (!args) SWIG_fail;
23148 swig_obj[0] = args;
23149 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23150 if (!SWIG_IsOK(res1)) {
23151 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23152 }
23153 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23154 {
23155 PyThreadState* __tstate = wxPyBeginAllowThreads();
23156 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23157 wxPyEndAllowThreads(__tstate);
23158 if (PyErr_Occurred()) SWIG_fail;
23159 }
23160 {
23161 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23162 }
23163 return resultobj;
23164 fail:
23165 return NULL;
23166 }
23167
23168
23169 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23170 PyObject *resultobj = 0;
23171 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23172 bool result;
23173 void *argp1 = 0 ;
23174 int res1 = 0 ;
23175 PyObject *swig_obj[1] ;
23176
23177 if (!args) SWIG_fail;
23178 swig_obj[0] = args;
23179 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23180 if (!SWIG_IsOK(res1)) {
23181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23182 }
23183 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23184 {
23185 PyThreadState* __tstate = wxPyBeginAllowThreads();
23186 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23187 wxPyEndAllowThreads(__tstate);
23188 if (PyErr_Occurred()) SWIG_fail;
23189 }
23190 {
23191 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23192 }
23193 return resultobj;
23194 fail:
23195 return NULL;
23196 }
23197
23198
23199 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23200 PyObject *resultobj = 0;
23201 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23202 bool result;
23203 void *argp1 = 0 ;
23204 int res1 = 0 ;
23205 PyObject *swig_obj[1] ;
23206
23207 if (!args) SWIG_fail;
23208 swig_obj[0] = args;
23209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23210 if (!SWIG_IsOK(res1)) {
23211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23212 }
23213 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23214 {
23215 PyThreadState* __tstate = wxPyBeginAllowThreads();
23216 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23217 wxPyEndAllowThreads(__tstate);
23218 if (PyErr_Occurred()) SWIG_fail;
23219 }
23220 {
23221 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23222 }
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23230 PyObject *resultobj = 0;
23231 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23232 bool result;
23233 void *argp1 = 0 ;
23234 int res1 = 0 ;
23235 PyObject *swig_obj[1] ;
23236
23237 if (!args) SWIG_fail;
23238 swig_obj[0] = args;
23239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23240 if (!SWIG_IsOK(res1)) {
23241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23242 }
23243 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23244 {
23245 PyThreadState* __tstate = wxPyBeginAllowThreads();
23246 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23247 wxPyEndAllowThreads(__tstate);
23248 if (PyErr_Occurred()) SWIG_fail;
23249 }
23250 {
23251 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23252 }
23253 return resultobj;
23254 fail:
23255 return NULL;
23256 }
23257
23258
23259 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23260 PyObject *resultobj = 0;
23261 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23262 bool result;
23263 void *argp1 = 0 ;
23264 int res1 = 0 ;
23265 PyObject *swig_obj[1] ;
23266
23267 if (!args) SWIG_fail;
23268 swig_obj[0] = args;
23269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23270 if (!SWIG_IsOK(res1)) {
23271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23272 }
23273 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23274 {
23275 PyThreadState* __tstate = wxPyBeginAllowThreads();
23276 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23277 wxPyEndAllowThreads(__tstate);
23278 if (PyErr_Occurred()) SWIG_fail;
23279 }
23280 {
23281 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23282 }
23283 return resultobj;
23284 fail:
23285 return NULL;
23286 }
23287
23288
23289 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23290 PyObject *resultobj = 0;
23291 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23292 bool result;
23293 void *argp1 = 0 ;
23294 int res1 = 0 ;
23295 PyObject *swig_obj[1] ;
23296
23297 if (!args) SWIG_fail;
23298 swig_obj[0] = args;
23299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23300 if (!SWIG_IsOK(res1)) {
23301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23302 }
23303 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23304 {
23305 PyThreadState* __tstate = wxPyBeginAllowThreads();
23306 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23307 wxPyEndAllowThreads(__tstate);
23308 if (PyErr_Occurred()) SWIG_fail;
23309 }
23310 {
23311 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23312 }
23313 return resultobj;
23314 fail:
23315 return NULL;
23316 }
23317
23318
23319 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23320 PyObject *resultobj = 0;
23321 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23322 bool result;
23323 void *argp1 = 0 ;
23324 int res1 = 0 ;
23325 PyObject *swig_obj[1] ;
23326
23327 if (!args) SWIG_fail;
23328 swig_obj[0] = args;
23329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23330 if (!SWIG_IsOK(res1)) {
23331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23332 }
23333 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23334 {
23335 PyThreadState* __tstate = wxPyBeginAllowThreads();
23336 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23337 wxPyEndAllowThreads(__tstate);
23338 if (PyErr_Occurred()) SWIG_fail;
23339 }
23340 {
23341 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23342 }
23343 return resultobj;
23344 fail:
23345 return NULL;
23346 }
23347
23348
23349 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23350 PyObject *resultobj = 0;
23351 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23352 bool result;
23353 void *argp1 = 0 ;
23354 int res1 = 0 ;
23355 PyObject *swig_obj[1] ;
23356
23357 if (!args) SWIG_fail;
23358 swig_obj[0] = args;
23359 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23360 if (!SWIG_IsOK(res1)) {
23361 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23362 }
23363 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23364 {
23365 PyThreadState* __tstate = wxPyBeginAllowThreads();
23366 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23367 wxPyEndAllowThreads(__tstate);
23368 if (PyErr_Occurred()) SWIG_fail;
23369 }
23370 {
23371 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23372 }
23373 return resultobj;
23374 fail:
23375 return NULL;
23376 }
23377
23378
23379 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23380 PyObject *resultobj = 0;
23381 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23382 bool result;
23383 void *argp1 = 0 ;
23384 int res1 = 0 ;
23385 PyObject *swig_obj[1] ;
23386
23387 if (!args) SWIG_fail;
23388 swig_obj[0] = args;
23389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23390 if (!SWIG_IsOK(res1)) {
23391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23392 }
23393 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23394 {
23395 PyThreadState* __tstate = wxPyBeginAllowThreads();
23396 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23397 wxPyEndAllowThreads(__tstate);
23398 if (PyErr_Occurred()) SWIG_fail;
23399 }
23400 {
23401 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23402 }
23403 return resultobj;
23404 fail:
23405 return NULL;
23406 }
23407
23408
23409 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23410 PyObject *resultobj = 0;
23411 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23412 bool result;
23413 void *argp1 = 0 ;
23414 int res1 = 0 ;
23415 PyObject *swig_obj[1] ;
23416
23417 if (!args) SWIG_fail;
23418 swig_obj[0] = args;
23419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23420 if (!SWIG_IsOK(res1)) {
23421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23422 }
23423 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23424 {
23425 PyThreadState* __tstate = wxPyBeginAllowThreads();
23426 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23427 wxPyEndAllowThreads(__tstate);
23428 if (PyErr_Occurred()) SWIG_fail;
23429 }
23430 {
23431 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23432 }
23433 return resultobj;
23434 fail:
23435 return NULL;
23436 }
23437
23438
23439 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23440 PyObject *resultobj = 0;
23441 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23442 bool result;
23443 void *argp1 = 0 ;
23444 int res1 = 0 ;
23445 PyObject *swig_obj[1] ;
23446
23447 if (!args) SWIG_fail;
23448 swig_obj[0] = args;
23449 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23450 if (!SWIG_IsOK(res1)) {
23451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23452 }
23453 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23454 {
23455 PyThreadState* __tstate = wxPyBeginAllowThreads();
23456 result = (bool)(arg1)->LeftIsDown();
23457 wxPyEndAllowThreads(__tstate);
23458 if (PyErr_Occurred()) SWIG_fail;
23459 }
23460 {
23461 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23462 }
23463 return resultobj;
23464 fail:
23465 return NULL;
23466 }
23467
23468
23469 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23470 PyObject *resultobj = 0;
23471 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23472 bool result;
23473 void *argp1 = 0 ;
23474 int res1 = 0 ;
23475 PyObject *swig_obj[1] ;
23476
23477 if (!args) SWIG_fail;
23478 swig_obj[0] = args;
23479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23480 if (!SWIG_IsOK(res1)) {
23481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23482 }
23483 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23484 {
23485 PyThreadState* __tstate = wxPyBeginAllowThreads();
23486 result = (bool)(arg1)->MiddleIsDown();
23487 wxPyEndAllowThreads(__tstate);
23488 if (PyErr_Occurred()) SWIG_fail;
23489 }
23490 {
23491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23492 }
23493 return resultobj;
23494 fail:
23495 return NULL;
23496 }
23497
23498
23499 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23500 PyObject *resultobj = 0;
23501 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23502 bool result;
23503 void *argp1 = 0 ;
23504 int res1 = 0 ;
23505 PyObject *swig_obj[1] ;
23506
23507 if (!args) SWIG_fail;
23508 swig_obj[0] = args;
23509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23510 if (!SWIG_IsOK(res1)) {
23511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23512 }
23513 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23514 {
23515 PyThreadState* __tstate = wxPyBeginAllowThreads();
23516 result = (bool)(arg1)->RightIsDown();
23517 wxPyEndAllowThreads(__tstate);
23518 if (PyErr_Occurred()) SWIG_fail;
23519 }
23520 {
23521 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23522 }
23523 return resultobj;
23524 fail:
23525 return NULL;
23526 }
23527
23528
23529 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23530 PyObject *resultobj = 0;
23531 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23532 bool result;
23533 void *argp1 = 0 ;
23534 int res1 = 0 ;
23535 PyObject *swig_obj[1] ;
23536
23537 if (!args) SWIG_fail;
23538 swig_obj[0] = args;
23539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23540 if (!SWIG_IsOK(res1)) {
23541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23542 }
23543 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23544 {
23545 PyThreadState* __tstate = wxPyBeginAllowThreads();
23546 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23547 wxPyEndAllowThreads(__tstate);
23548 if (PyErr_Occurred()) SWIG_fail;
23549 }
23550 {
23551 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23552 }
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23560 PyObject *resultobj = 0;
23561 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23562 bool result;
23563 void *argp1 = 0 ;
23564 int res1 = 0 ;
23565 PyObject *swig_obj[1] ;
23566
23567 if (!args) SWIG_fail;
23568 swig_obj[0] = args;
23569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23570 if (!SWIG_IsOK(res1)) {
23571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23572 }
23573 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23574 {
23575 PyThreadState* __tstate = wxPyBeginAllowThreads();
23576 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23577 wxPyEndAllowThreads(__tstate);
23578 if (PyErr_Occurred()) SWIG_fail;
23579 }
23580 {
23581 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23582 }
23583 return resultobj;
23584 fail:
23585 return NULL;
23586 }
23587
23588
23589 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23590 PyObject *resultobj = 0;
23591 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23592 bool result;
23593 void *argp1 = 0 ;
23594 int res1 = 0 ;
23595 PyObject *swig_obj[1] ;
23596
23597 if (!args) SWIG_fail;
23598 swig_obj[0] = args;
23599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23600 if (!SWIG_IsOK(res1)) {
23601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23602 }
23603 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23604 {
23605 PyThreadState* __tstate = wxPyBeginAllowThreads();
23606 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23607 wxPyEndAllowThreads(__tstate);
23608 if (PyErr_Occurred()) SWIG_fail;
23609 }
23610 {
23611 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23612 }
23613 return resultobj;
23614 fail:
23615 return NULL;
23616 }
23617
23618
23619 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23620 PyObject *resultobj = 0;
23621 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23622 bool result;
23623 void *argp1 = 0 ;
23624 int res1 = 0 ;
23625 PyObject *swig_obj[1] ;
23626
23627 if (!args) SWIG_fail;
23628 swig_obj[0] = args;
23629 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23630 if (!SWIG_IsOK(res1)) {
23631 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23632 }
23633 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23634 {
23635 PyThreadState* __tstate = wxPyBeginAllowThreads();
23636 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23637 wxPyEndAllowThreads(__tstate);
23638 if (PyErr_Occurred()) SWIG_fail;
23639 }
23640 {
23641 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23642 }
23643 return resultobj;
23644 fail:
23645 return NULL;
23646 }
23647
23648
23649 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23650 PyObject *resultobj = 0;
23651 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23652 wxPoint result;
23653 void *argp1 = 0 ;
23654 int res1 = 0 ;
23655 PyObject *swig_obj[1] ;
23656
23657 if (!args) SWIG_fail;
23658 swig_obj[0] = args;
23659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23660 if (!SWIG_IsOK(res1)) {
23661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23662 }
23663 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23664 {
23665 PyThreadState* __tstate = wxPyBeginAllowThreads();
23666 result = (arg1)->GetPosition();
23667 wxPyEndAllowThreads(__tstate);
23668 if (PyErr_Occurred()) SWIG_fail;
23669 }
23670 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23671 return resultobj;
23672 fail:
23673 return NULL;
23674 }
23675
23676
23677 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23678 PyObject *resultobj = 0;
23679 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23680 long *arg2 = (long *) 0 ;
23681 long *arg3 = (long *) 0 ;
23682 void *argp1 = 0 ;
23683 int res1 = 0 ;
23684 long temp2 ;
23685 int res2 = SWIG_TMPOBJ ;
23686 long temp3 ;
23687 int res3 = SWIG_TMPOBJ ;
23688 PyObject *swig_obj[1] ;
23689
23690 arg2 = &temp2;
23691 arg3 = &temp3;
23692 if (!args) SWIG_fail;
23693 swig_obj[0] = args;
23694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23695 if (!SWIG_IsOK(res1)) {
23696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23697 }
23698 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23699 {
23700 PyThreadState* __tstate = wxPyBeginAllowThreads();
23701 (arg1)->GetPosition(arg2,arg3);
23702 wxPyEndAllowThreads(__tstate);
23703 if (PyErr_Occurred()) SWIG_fail;
23704 }
23705 resultobj = SWIG_Py_Void();
23706 if (SWIG_IsTmpObj(res2)) {
23707 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23708 } else {
23709 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23710 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23711 }
23712 if (SWIG_IsTmpObj(res3)) {
23713 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23714 } else {
23715 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23716 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23717 }
23718 return resultobj;
23719 fail:
23720 return NULL;
23721 }
23722
23723
23724 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23725 PyObject *resultobj = 0;
23726 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23727 wxDC *arg2 = 0 ;
23728 wxPoint result;
23729 void *argp1 = 0 ;
23730 int res1 = 0 ;
23731 void *argp2 = 0 ;
23732 int res2 = 0 ;
23733 PyObject * obj0 = 0 ;
23734 PyObject * obj1 = 0 ;
23735 char * kwnames[] = {
23736 (char *) "self",(char *) "dc", NULL
23737 };
23738
23739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23741 if (!SWIG_IsOK(res1)) {
23742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23743 }
23744 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23745 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23746 if (!SWIG_IsOK(res2)) {
23747 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23748 }
23749 if (!argp2) {
23750 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23751 }
23752 arg2 = reinterpret_cast< wxDC * >(argp2);
23753 {
23754 PyThreadState* __tstate = wxPyBeginAllowThreads();
23755 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23756 wxPyEndAllowThreads(__tstate);
23757 if (PyErr_Occurred()) SWIG_fail;
23758 }
23759 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23760 return resultobj;
23761 fail:
23762 return NULL;
23763 }
23764
23765
23766 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23767 PyObject *resultobj = 0;
23768 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23769 int result;
23770 void *argp1 = 0 ;
23771 int res1 = 0 ;
23772 PyObject *swig_obj[1] ;
23773
23774 if (!args) SWIG_fail;
23775 swig_obj[0] = args;
23776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23777 if (!SWIG_IsOK(res1)) {
23778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23779 }
23780 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23781 {
23782 PyThreadState* __tstate = wxPyBeginAllowThreads();
23783 result = (int)((wxMouseEvent const *)arg1)->GetX();
23784 wxPyEndAllowThreads(__tstate);
23785 if (PyErr_Occurred()) SWIG_fail;
23786 }
23787 resultobj = SWIG_From_int(static_cast< int >(result));
23788 return resultobj;
23789 fail:
23790 return NULL;
23791 }
23792
23793
23794 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23795 PyObject *resultobj = 0;
23796 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23797 int result;
23798 void *argp1 = 0 ;
23799 int res1 = 0 ;
23800 PyObject *swig_obj[1] ;
23801
23802 if (!args) SWIG_fail;
23803 swig_obj[0] = args;
23804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23805 if (!SWIG_IsOK(res1)) {
23806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23807 }
23808 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23809 {
23810 PyThreadState* __tstate = wxPyBeginAllowThreads();
23811 result = (int)((wxMouseEvent const *)arg1)->GetY();
23812 wxPyEndAllowThreads(__tstate);
23813 if (PyErr_Occurred()) SWIG_fail;
23814 }
23815 resultobj = SWIG_From_int(static_cast< int >(result));
23816 return resultobj;
23817 fail:
23818 return NULL;
23819 }
23820
23821
23822 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23823 PyObject *resultobj = 0;
23824 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23825 int result;
23826 void *argp1 = 0 ;
23827 int res1 = 0 ;
23828 PyObject *swig_obj[1] ;
23829
23830 if (!args) SWIG_fail;
23831 swig_obj[0] = args;
23832 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23833 if (!SWIG_IsOK(res1)) {
23834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23835 }
23836 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23837 {
23838 PyThreadState* __tstate = wxPyBeginAllowThreads();
23839 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23840 wxPyEndAllowThreads(__tstate);
23841 if (PyErr_Occurred()) SWIG_fail;
23842 }
23843 resultobj = SWIG_From_int(static_cast< int >(result));
23844 return resultobj;
23845 fail:
23846 return NULL;
23847 }
23848
23849
23850 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23851 PyObject *resultobj = 0;
23852 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23853 int result;
23854 void *argp1 = 0 ;
23855 int res1 = 0 ;
23856 PyObject *swig_obj[1] ;
23857
23858 if (!args) SWIG_fail;
23859 swig_obj[0] = args;
23860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23861 if (!SWIG_IsOK(res1)) {
23862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23863 }
23864 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23865 {
23866 PyThreadState* __tstate = wxPyBeginAllowThreads();
23867 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23868 wxPyEndAllowThreads(__tstate);
23869 if (PyErr_Occurred()) SWIG_fail;
23870 }
23871 resultobj = SWIG_From_int(static_cast< int >(result));
23872 return resultobj;
23873 fail:
23874 return NULL;
23875 }
23876
23877
23878 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23879 PyObject *resultobj = 0;
23880 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23881 int result;
23882 void *argp1 = 0 ;
23883 int res1 = 0 ;
23884 PyObject *swig_obj[1] ;
23885
23886 if (!args) SWIG_fail;
23887 swig_obj[0] = args;
23888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23889 if (!SWIG_IsOK(res1)) {
23890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23891 }
23892 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23893 {
23894 PyThreadState* __tstate = wxPyBeginAllowThreads();
23895 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23896 wxPyEndAllowThreads(__tstate);
23897 if (PyErr_Occurred()) SWIG_fail;
23898 }
23899 resultobj = SWIG_From_int(static_cast< int >(result));
23900 return resultobj;
23901 fail:
23902 return NULL;
23903 }
23904
23905
23906 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23907 PyObject *resultobj = 0;
23908 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23909 int result;
23910 void *argp1 = 0 ;
23911 int res1 = 0 ;
23912 PyObject *swig_obj[1] ;
23913
23914 if (!args) SWIG_fail;
23915 swig_obj[0] = args;
23916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23917 if (!SWIG_IsOK(res1)) {
23918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23919 }
23920 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23921 {
23922 PyThreadState* __tstate = wxPyBeginAllowThreads();
23923 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23924 wxPyEndAllowThreads(__tstate);
23925 if (PyErr_Occurred()) SWIG_fail;
23926 }
23927 resultobj = SWIG_From_int(static_cast< int >(result));
23928 return resultobj;
23929 fail:
23930 return NULL;
23931 }
23932
23933
23934 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23935 PyObject *resultobj = 0;
23936 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23937 bool 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_wxMouseEvent, 0 | 0 );
23945 if (!SWIG_IsOK(res1)) {
23946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23947 }
23948 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23949 {
23950 PyThreadState* __tstate = wxPyBeginAllowThreads();
23951 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23952 wxPyEndAllowThreads(__tstate);
23953 if (PyErr_Occurred()) SWIG_fail;
23954 }
23955 {
23956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23957 }
23958 return resultobj;
23959 fail:
23960 return NULL;
23961 }
23962
23963
23964 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23965 PyObject *resultobj = 0;
23966 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23967 int arg2 ;
23968 void *argp1 = 0 ;
23969 int res1 = 0 ;
23970 int val2 ;
23971 int ecode2 = 0 ;
23972 PyObject *swig_obj[2] ;
23973
23974 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23975 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23976 if (!SWIG_IsOK(res1)) {
23977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23978 }
23979 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23980 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23981 if (!SWIG_IsOK(ecode2)) {
23982 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23983 }
23984 arg2 = static_cast< int >(val2);
23985 if (arg1) (arg1)->m_x = arg2;
23986
23987 resultobj = SWIG_Py_Void();
23988 return resultobj;
23989 fail:
23990 return NULL;
23991 }
23992
23993
23994 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23995 PyObject *resultobj = 0;
23996 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23997 int result;
23998 void *argp1 = 0 ;
23999 int res1 = 0 ;
24000 PyObject *swig_obj[1] ;
24001
24002 if (!args) SWIG_fail;
24003 swig_obj[0] = args;
24004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24005 if (!SWIG_IsOK(res1)) {
24006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24007 }
24008 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24009 result = (int) ((arg1)->m_x);
24010 resultobj = SWIG_From_int(static_cast< int >(result));
24011 return resultobj;
24012 fail:
24013 return NULL;
24014 }
24015
24016
24017 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24018 PyObject *resultobj = 0;
24019 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24020 int arg2 ;
24021 void *argp1 = 0 ;
24022 int res1 = 0 ;
24023 int val2 ;
24024 int ecode2 = 0 ;
24025 PyObject *swig_obj[2] ;
24026
24027 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24028 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24029 if (!SWIG_IsOK(res1)) {
24030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24031 }
24032 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24033 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24034 if (!SWIG_IsOK(ecode2)) {
24035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24036 }
24037 arg2 = static_cast< int >(val2);
24038 if (arg1) (arg1)->m_y = arg2;
24039
24040 resultobj = SWIG_Py_Void();
24041 return resultobj;
24042 fail:
24043 return NULL;
24044 }
24045
24046
24047 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24048 PyObject *resultobj = 0;
24049 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24050 int result;
24051 void *argp1 = 0 ;
24052 int res1 = 0 ;
24053 PyObject *swig_obj[1] ;
24054
24055 if (!args) SWIG_fail;
24056 swig_obj[0] = args;
24057 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24058 if (!SWIG_IsOK(res1)) {
24059 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24060 }
24061 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24062 result = (int) ((arg1)->m_y);
24063 resultobj = SWIG_From_int(static_cast< int >(result));
24064 return resultobj;
24065 fail:
24066 return NULL;
24067 }
24068
24069
24070 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24071 PyObject *resultobj = 0;
24072 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24073 bool arg2 ;
24074 void *argp1 = 0 ;
24075 int res1 = 0 ;
24076 bool val2 ;
24077 int ecode2 = 0 ;
24078 PyObject *swig_obj[2] ;
24079
24080 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24082 if (!SWIG_IsOK(res1)) {
24083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24084 }
24085 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24086 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24087 if (!SWIG_IsOK(ecode2)) {
24088 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24089 }
24090 arg2 = static_cast< bool >(val2);
24091 if (arg1) (arg1)->m_leftDown = arg2;
24092
24093 resultobj = SWIG_Py_Void();
24094 return resultobj;
24095 fail:
24096 return NULL;
24097 }
24098
24099
24100 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24101 PyObject *resultobj = 0;
24102 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24103 bool result;
24104 void *argp1 = 0 ;
24105 int res1 = 0 ;
24106 PyObject *swig_obj[1] ;
24107
24108 if (!args) SWIG_fail;
24109 swig_obj[0] = args;
24110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24111 if (!SWIG_IsOK(res1)) {
24112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24113 }
24114 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24115 result = (bool) ((arg1)->m_leftDown);
24116 {
24117 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24118 }
24119 return resultobj;
24120 fail:
24121 return NULL;
24122 }
24123
24124
24125 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24126 PyObject *resultobj = 0;
24127 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24128 bool arg2 ;
24129 void *argp1 = 0 ;
24130 int res1 = 0 ;
24131 bool val2 ;
24132 int ecode2 = 0 ;
24133 PyObject *swig_obj[2] ;
24134
24135 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24136 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24137 if (!SWIG_IsOK(res1)) {
24138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24139 }
24140 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24141 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24142 if (!SWIG_IsOK(ecode2)) {
24143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24144 }
24145 arg2 = static_cast< bool >(val2);
24146 if (arg1) (arg1)->m_middleDown = arg2;
24147
24148 resultobj = SWIG_Py_Void();
24149 return resultobj;
24150 fail:
24151 return NULL;
24152 }
24153
24154
24155 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24156 PyObject *resultobj = 0;
24157 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24158 bool result;
24159 void *argp1 = 0 ;
24160 int res1 = 0 ;
24161 PyObject *swig_obj[1] ;
24162
24163 if (!args) SWIG_fail;
24164 swig_obj[0] = args;
24165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24166 if (!SWIG_IsOK(res1)) {
24167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24168 }
24169 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24170 result = (bool) ((arg1)->m_middleDown);
24171 {
24172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24173 }
24174 return resultobj;
24175 fail:
24176 return NULL;
24177 }
24178
24179
24180 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24181 PyObject *resultobj = 0;
24182 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24183 bool arg2 ;
24184 void *argp1 = 0 ;
24185 int res1 = 0 ;
24186 bool val2 ;
24187 int ecode2 = 0 ;
24188 PyObject *swig_obj[2] ;
24189
24190 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24191 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24192 if (!SWIG_IsOK(res1)) {
24193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24194 }
24195 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24196 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24197 if (!SWIG_IsOK(ecode2)) {
24198 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24199 }
24200 arg2 = static_cast< bool >(val2);
24201 if (arg1) (arg1)->m_rightDown = arg2;
24202
24203 resultobj = SWIG_Py_Void();
24204 return resultobj;
24205 fail:
24206 return NULL;
24207 }
24208
24209
24210 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24211 PyObject *resultobj = 0;
24212 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24213 bool result;
24214 void *argp1 = 0 ;
24215 int res1 = 0 ;
24216 PyObject *swig_obj[1] ;
24217
24218 if (!args) SWIG_fail;
24219 swig_obj[0] = args;
24220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24221 if (!SWIG_IsOK(res1)) {
24222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24223 }
24224 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24225 result = (bool) ((arg1)->m_rightDown);
24226 {
24227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24228 }
24229 return resultobj;
24230 fail:
24231 return NULL;
24232 }
24233
24234
24235 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24236 PyObject *resultobj = 0;
24237 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24238 bool arg2 ;
24239 void *argp1 = 0 ;
24240 int res1 = 0 ;
24241 bool val2 ;
24242 int ecode2 = 0 ;
24243 PyObject *swig_obj[2] ;
24244
24245 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24247 if (!SWIG_IsOK(res1)) {
24248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24249 }
24250 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24251 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24252 if (!SWIG_IsOK(ecode2)) {
24253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24254 }
24255 arg2 = static_cast< bool >(val2);
24256 if (arg1) (arg1)->m_controlDown = arg2;
24257
24258 resultobj = SWIG_Py_Void();
24259 return resultobj;
24260 fail:
24261 return NULL;
24262 }
24263
24264
24265 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24266 PyObject *resultobj = 0;
24267 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24268 bool result;
24269 void *argp1 = 0 ;
24270 int res1 = 0 ;
24271 PyObject *swig_obj[1] ;
24272
24273 if (!args) SWIG_fail;
24274 swig_obj[0] = args;
24275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24276 if (!SWIG_IsOK(res1)) {
24277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24278 }
24279 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24280 result = (bool) ((arg1)->m_controlDown);
24281 {
24282 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24283 }
24284 return resultobj;
24285 fail:
24286 return NULL;
24287 }
24288
24289
24290 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24291 PyObject *resultobj = 0;
24292 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24293 bool arg2 ;
24294 void *argp1 = 0 ;
24295 int res1 = 0 ;
24296 bool val2 ;
24297 int ecode2 = 0 ;
24298 PyObject *swig_obj[2] ;
24299
24300 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24302 if (!SWIG_IsOK(res1)) {
24303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24304 }
24305 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24306 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24307 if (!SWIG_IsOK(ecode2)) {
24308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24309 }
24310 arg2 = static_cast< bool >(val2);
24311 if (arg1) (arg1)->m_shiftDown = arg2;
24312
24313 resultobj = SWIG_Py_Void();
24314 return resultobj;
24315 fail:
24316 return NULL;
24317 }
24318
24319
24320 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24321 PyObject *resultobj = 0;
24322 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24323 bool result;
24324 void *argp1 = 0 ;
24325 int res1 = 0 ;
24326 PyObject *swig_obj[1] ;
24327
24328 if (!args) SWIG_fail;
24329 swig_obj[0] = args;
24330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24331 if (!SWIG_IsOK(res1)) {
24332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24333 }
24334 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24335 result = (bool) ((arg1)->m_shiftDown);
24336 {
24337 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24338 }
24339 return resultobj;
24340 fail:
24341 return NULL;
24342 }
24343
24344
24345 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24346 PyObject *resultobj = 0;
24347 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24348 bool arg2 ;
24349 void *argp1 = 0 ;
24350 int res1 = 0 ;
24351 bool val2 ;
24352 int ecode2 = 0 ;
24353 PyObject *swig_obj[2] ;
24354
24355 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24357 if (!SWIG_IsOK(res1)) {
24358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24359 }
24360 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24361 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24362 if (!SWIG_IsOK(ecode2)) {
24363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24364 }
24365 arg2 = static_cast< bool >(val2);
24366 if (arg1) (arg1)->m_altDown = arg2;
24367
24368 resultobj = SWIG_Py_Void();
24369 return resultobj;
24370 fail:
24371 return NULL;
24372 }
24373
24374
24375 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24376 PyObject *resultobj = 0;
24377 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24378 bool result;
24379 void *argp1 = 0 ;
24380 int res1 = 0 ;
24381 PyObject *swig_obj[1] ;
24382
24383 if (!args) SWIG_fail;
24384 swig_obj[0] = args;
24385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24386 if (!SWIG_IsOK(res1)) {
24387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24388 }
24389 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24390 result = (bool) ((arg1)->m_altDown);
24391 {
24392 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24393 }
24394 return resultobj;
24395 fail:
24396 return NULL;
24397 }
24398
24399
24400 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24401 PyObject *resultobj = 0;
24402 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24403 bool arg2 ;
24404 void *argp1 = 0 ;
24405 int res1 = 0 ;
24406 bool val2 ;
24407 int ecode2 = 0 ;
24408 PyObject *swig_obj[2] ;
24409
24410 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24411 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24412 if (!SWIG_IsOK(res1)) {
24413 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24414 }
24415 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24416 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24417 if (!SWIG_IsOK(ecode2)) {
24418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24419 }
24420 arg2 = static_cast< bool >(val2);
24421 if (arg1) (arg1)->m_metaDown = arg2;
24422
24423 resultobj = SWIG_Py_Void();
24424 return resultobj;
24425 fail:
24426 return NULL;
24427 }
24428
24429
24430 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24431 PyObject *resultobj = 0;
24432 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24433 bool result;
24434 void *argp1 = 0 ;
24435 int res1 = 0 ;
24436 PyObject *swig_obj[1] ;
24437
24438 if (!args) SWIG_fail;
24439 swig_obj[0] = args;
24440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24441 if (!SWIG_IsOK(res1)) {
24442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24443 }
24444 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24445 result = (bool) ((arg1)->m_metaDown);
24446 {
24447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24448 }
24449 return resultobj;
24450 fail:
24451 return NULL;
24452 }
24453
24454
24455 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24456 PyObject *resultobj = 0;
24457 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24458 int arg2 ;
24459 void *argp1 = 0 ;
24460 int res1 = 0 ;
24461 int val2 ;
24462 int ecode2 = 0 ;
24463 PyObject *swig_obj[2] ;
24464
24465 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24467 if (!SWIG_IsOK(res1)) {
24468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24469 }
24470 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24471 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24472 if (!SWIG_IsOK(ecode2)) {
24473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24474 }
24475 arg2 = static_cast< int >(val2);
24476 if (arg1) (arg1)->m_wheelRotation = arg2;
24477
24478 resultobj = SWIG_Py_Void();
24479 return resultobj;
24480 fail:
24481 return NULL;
24482 }
24483
24484
24485 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24486 PyObject *resultobj = 0;
24487 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24488 int result;
24489 void *argp1 = 0 ;
24490 int res1 = 0 ;
24491 PyObject *swig_obj[1] ;
24492
24493 if (!args) SWIG_fail;
24494 swig_obj[0] = args;
24495 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24496 if (!SWIG_IsOK(res1)) {
24497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24498 }
24499 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24500 result = (int) ((arg1)->m_wheelRotation);
24501 resultobj = SWIG_From_int(static_cast< int >(result));
24502 return resultobj;
24503 fail:
24504 return NULL;
24505 }
24506
24507
24508 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24509 PyObject *resultobj = 0;
24510 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24511 int arg2 ;
24512 void *argp1 = 0 ;
24513 int res1 = 0 ;
24514 int val2 ;
24515 int ecode2 = 0 ;
24516 PyObject *swig_obj[2] ;
24517
24518 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24519 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24520 if (!SWIG_IsOK(res1)) {
24521 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24522 }
24523 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24524 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24525 if (!SWIG_IsOK(ecode2)) {
24526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24527 }
24528 arg2 = static_cast< int >(val2);
24529 if (arg1) (arg1)->m_wheelDelta = arg2;
24530
24531 resultobj = SWIG_Py_Void();
24532 return resultobj;
24533 fail:
24534 return NULL;
24535 }
24536
24537
24538 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24539 PyObject *resultobj = 0;
24540 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24541 int result;
24542 void *argp1 = 0 ;
24543 int res1 = 0 ;
24544 PyObject *swig_obj[1] ;
24545
24546 if (!args) SWIG_fail;
24547 swig_obj[0] = args;
24548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24549 if (!SWIG_IsOK(res1)) {
24550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24551 }
24552 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24553 result = (int) ((arg1)->m_wheelDelta);
24554 resultobj = SWIG_From_int(static_cast< int >(result));
24555 return resultobj;
24556 fail:
24557 return NULL;
24558 }
24559
24560
24561 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24562 PyObject *resultobj = 0;
24563 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24564 int arg2 ;
24565 void *argp1 = 0 ;
24566 int res1 = 0 ;
24567 int val2 ;
24568 int ecode2 = 0 ;
24569 PyObject *swig_obj[2] ;
24570
24571 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24573 if (!SWIG_IsOK(res1)) {
24574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24575 }
24576 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24577 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24578 if (!SWIG_IsOK(ecode2)) {
24579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24580 }
24581 arg2 = static_cast< int >(val2);
24582 if (arg1) (arg1)->m_linesPerAction = arg2;
24583
24584 resultobj = SWIG_Py_Void();
24585 return resultobj;
24586 fail:
24587 return NULL;
24588 }
24589
24590
24591 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24592 PyObject *resultobj = 0;
24593 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24594 int result;
24595 void *argp1 = 0 ;
24596 int res1 = 0 ;
24597 PyObject *swig_obj[1] ;
24598
24599 if (!args) SWIG_fail;
24600 swig_obj[0] = args;
24601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24602 if (!SWIG_IsOK(res1)) {
24603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24604 }
24605 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24606 result = (int) ((arg1)->m_linesPerAction);
24607 resultobj = SWIG_From_int(static_cast< int >(result));
24608 return resultobj;
24609 fail:
24610 return NULL;
24611 }
24612
24613
24614 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24615 PyObject *obj;
24616 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24617 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24618 return SWIG_Py_Void();
24619 }
24620
24621 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24622 return SWIG_Python_InitShadowInstance(args);
24623 }
24624
24625 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24626 PyObject *resultobj = 0;
24627 int arg1 = (int) 0 ;
24628 int arg2 = (int) 0 ;
24629 wxSetCursorEvent *result = 0 ;
24630 int val1 ;
24631 int ecode1 = 0 ;
24632 int val2 ;
24633 int ecode2 = 0 ;
24634 PyObject * obj0 = 0 ;
24635 PyObject * obj1 = 0 ;
24636 char * kwnames[] = {
24637 (char *) "x",(char *) "y", NULL
24638 };
24639
24640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24641 if (obj0) {
24642 ecode1 = SWIG_AsVal_int(obj0, &val1);
24643 if (!SWIG_IsOK(ecode1)) {
24644 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24645 }
24646 arg1 = static_cast< int >(val1);
24647 }
24648 if (obj1) {
24649 ecode2 = SWIG_AsVal_int(obj1, &val2);
24650 if (!SWIG_IsOK(ecode2)) {
24651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24652 }
24653 arg2 = static_cast< int >(val2);
24654 }
24655 {
24656 PyThreadState* __tstate = wxPyBeginAllowThreads();
24657 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24658 wxPyEndAllowThreads(__tstate);
24659 if (PyErr_Occurred()) SWIG_fail;
24660 }
24661 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24662 return resultobj;
24663 fail:
24664 return NULL;
24665 }
24666
24667
24668 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24669 PyObject *resultobj = 0;
24670 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24671 int result;
24672 void *argp1 = 0 ;
24673 int res1 = 0 ;
24674 PyObject *swig_obj[1] ;
24675
24676 if (!args) SWIG_fail;
24677 swig_obj[0] = args;
24678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24679 if (!SWIG_IsOK(res1)) {
24680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24681 }
24682 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24683 {
24684 PyThreadState* __tstate = wxPyBeginAllowThreads();
24685 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24686 wxPyEndAllowThreads(__tstate);
24687 if (PyErr_Occurred()) SWIG_fail;
24688 }
24689 resultobj = SWIG_From_int(static_cast< int >(result));
24690 return resultobj;
24691 fail:
24692 return NULL;
24693 }
24694
24695
24696 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24697 PyObject *resultobj = 0;
24698 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24699 int result;
24700 void *argp1 = 0 ;
24701 int res1 = 0 ;
24702 PyObject *swig_obj[1] ;
24703
24704 if (!args) SWIG_fail;
24705 swig_obj[0] = args;
24706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24707 if (!SWIG_IsOK(res1)) {
24708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24709 }
24710 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24711 {
24712 PyThreadState* __tstate = wxPyBeginAllowThreads();
24713 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24714 wxPyEndAllowThreads(__tstate);
24715 if (PyErr_Occurred()) SWIG_fail;
24716 }
24717 resultobj = SWIG_From_int(static_cast< int >(result));
24718 return resultobj;
24719 fail:
24720 return NULL;
24721 }
24722
24723
24724 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24725 PyObject *resultobj = 0;
24726 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24727 wxCursor *arg2 = 0 ;
24728 void *argp1 = 0 ;
24729 int res1 = 0 ;
24730 void *argp2 = 0 ;
24731 int res2 = 0 ;
24732 PyObject * obj0 = 0 ;
24733 PyObject * obj1 = 0 ;
24734 char * kwnames[] = {
24735 (char *) "self",(char *) "cursor", NULL
24736 };
24737
24738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24740 if (!SWIG_IsOK(res1)) {
24741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24742 }
24743 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24744 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24745 if (!SWIG_IsOK(res2)) {
24746 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24747 }
24748 if (!argp2) {
24749 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24750 }
24751 arg2 = reinterpret_cast< wxCursor * >(argp2);
24752 {
24753 PyThreadState* __tstate = wxPyBeginAllowThreads();
24754 (arg1)->SetCursor((wxCursor const &)*arg2);
24755 wxPyEndAllowThreads(__tstate);
24756 if (PyErr_Occurred()) SWIG_fail;
24757 }
24758 resultobj = SWIG_Py_Void();
24759 return resultobj;
24760 fail:
24761 return NULL;
24762 }
24763
24764
24765 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24766 PyObject *resultobj = 0;
24767 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24768 wxCursor *result = 0 ;
24769 void *argp1 = 0 ;
24770 int res1 = 0 ;
24771 PyObject *swig_obj[1] ;
24772
24773 if (!args) SWIG_fail;
24774 swig_obj[0] = args;
24775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24776 if (!SWIG_IsOK(res1)) {
24777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24778 }
24779 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24780 {
24781 PyThreadState* __tstate = wxPyBeginAllowThreads();
24782 {
24783 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24784 result = (wxCursor *) &_result_ref;
24785 }
24786 wxPyEndAllowThreads(__tstate);
24787 if (PyErr_Occurred()) SWIG_fail;
24788 }
24789 {
24790 wxCursor* resultptr = new wxCursor(*result);
24791 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24792 }
24793 return resultobj;
24794 fail:
24795 return NULL;
24796 }
24797
24798
24799 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24800 PyObject *resultobj = 0;
24801 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24802 bool result;
24803 void *argp1 = 0 ;
24804 int res1 = 0 ;
24805 PyObject *swig_obj[1] ;
24806
24807 if (!args) SWIG_fail;
24808 swig_obj[0] = args;
24809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24810 if (!SWIG_IsOK(res1)) {
24811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24812 }
24813 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24814 {
24815 PyThreadState* __tstate = wxPyBeginAllowThreads();
24816 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24817 wxPyEndAllowThreads(__tstate);
24818 if (PyErr_Occurred()) SWIG_fail;
24819 }
24820 {
24821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24822 }
24823 return resultobj;
24824 fail:
24825 return NULL;
24826 }
24827
24828
24829 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24830 PyObject *obj;
24831 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24832 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24833 return SWIG_Py_Void();
24834 }
24835
24836 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24837 return SWIG_Python_InitShadowInstance(args);
24838 }
24839
24840 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24841 PyObject *resultobj = 0;
24842 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24843 wxKeyEvent *result = 0 ;
24844 int val1 ;
24845 int ecode1 = 0 ;
24846 PyObject * obj0 = 0 ;
24847 char * kwnames[] = {
24848 (char *) "eventType", NULL
24849 };
24850
24851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24852 if (obj0) {
24853 ecode1 = SWIG_AsVal_int(obj0, &val1);
24854 if (!SWIG_IsOK(ecode1)) {
24855 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24856 }
24857 arg1 = static_cast< wxEventType >(val1);
24858 }
24859 {
24860 PyThreadState* __tstate = wxPyBeginAllowThreads();
24861 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24862 wxPyEndAllowThreads(__tstate);
24863 if (PyErr_Occurred()) SWIG_fail;
24864 }
24865 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24866 return resultobj;
24867 fail:
24868 return NULL;
24869 }
24870
24871
24872 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24873 PyObject *resultobj = 0;
24874 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24875 int result;
24876 void *argp1 = 0 ;
24877 int res1 = 0 ;
24878 PyObject *swig_obj[1] ;
24879
24880 if (!args) SWIG_fail;
24881 swig_obj[0] = args;
24882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24883 if (!SWIG_IsOK(res1)) {
24884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24885 }
24886 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24887 {
24888 PyThreadState* __tstate = wxPyBeginAllowThreads();
24889 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24890 wxPyEndAllowThreads(__tstate);
24891 if (PyErr_Occurred()) SWIG_fail;
24892 }
24893 resultobj = SWIG_From_int(static_cast< int >(result));
24894 return resultobj;
24895 fail:
24896 return NULL;
24897 }
24898
24899
24900 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24901 PyObject *resultobj = 0;
24902 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24903 bool result;
24904 void *argp1 = 0 ;
24905 int res1 = 0 ;
24906 PyObject *swig_obj[1] ;
24907
24908 if (!args) SWIG_fail;
24909 swig_obj[0] = args;
24910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24911 if (!SWIG_IsOK(res1)) {
24912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24913 }
24914 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24915 {
24916 PyThreadState* __tstate = wxPyBeginAllowThreads();
24917 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24918 wxPyEndAllowThreads(__tstate);
24919 if (PyErr_Occurred()) SWIG_fail;
24920 }
24921 {
24922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24923 }
24924 return resultobj;
24925 fail:
24926 return NULL;
24927 }
24928
24929
24930 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24931 PyObject *resultobj = 0;
24932 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24933 bool result;
24934 void *argp1 = 0 ;
24935 int res1 = 0 ;
24936 PyObject *swig_obj[1] ;
24937
24938 if (!args) SWIG_fail;
24939 swig_obj[0] = args;
24940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24941 if (!SWIG_IsOK(res1)) {
24942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24943 }
24944 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24945 {
24946 PyThreadState* __tstate = wxPyBeginAllowThreads();
24947 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24948 wxPyEndAllowThreads(__tstate);
24949 if (PyErr_Occurred()) SWIG_fail;
24950 }
24951 {
24952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24953 }
24954 return resultobj;
24955 fail:
24956 return NULL;
24957 }
24958
24959
24960 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24961 PyObject *resultobj = 0;
24962 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24963 bool result;
24964 void *argp1 = 0 ;
24965 int res1 = 0 ;
24966 PyObject *swig_obj[1] ;
24967
24968 if (!args) SWIG_fail;
24969 swig_obj[0] = args;
24970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24971 if (!SWIG_IsOK(res1)) {
24972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24973 }
24974 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24975 {
24976 PyThreadState* __tstate = wxPyBeginAllowThreads();
24977 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24978 wxPyEndAllowThreads(__tstate);
24979 if (PyErr_Occurred()) SWIG_fail;
24980 }
24981 {
24982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24983 }
24984 return resultobj;
24985 fail:
24986 return NULL;
24987 }
24988
24989
24990 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24991 PyObject *resultobj = 0;
24992 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24993 bool result;
24994 void *argp1 = 0 ;
24995 int res1 = 0 ;
24996 PyObject *swig_obj[1] ;
24997
24998 if (!args) SWIG_fail;
24999 swig_obj[0] = args;
25000 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25001 if (!SWIG_IsOK(res1)) {
25002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25003 }
25004 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25005 {
25006 PyThreadState* __tstate = wxPyBeginAllowThreads();
25007 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25008 wxPyEndAllowThreads(__tstate);
25009 if (PyErr_Occurred()) SWIG_fail;
25010 }
25011 {
25012 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25013 }
25014 return resultobj;
25015 fail:
25016 return NULL;
25017 }
25018
25019
25020 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25021 PyObject *resultobj = 0;
25022 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25023 bool result;
25024 void *argp1 = 0 ;
25025 int res1 = 0 ;
25026 PyObject *swig_obj[1] ;
25027
25028 if (!args) SWIG_fail;
25029 swig_obj[0] = args;
25030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25031 if (!SWIG_IsOK(res1)) {
25032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25033 }
25034 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25035 {
25036 PyThreadState* __tstate = wxPyBeginAllowThreads();
25037 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25038 wxPyEndAllowThreads(__tstate);
25039 if (PyErr_Occurred()) SWIG_fail;
25040 }
25041 {
25042 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25043 }
25044 return resultobj;
25045 fail:
25046 return NULL;
25047 }
25048
25049
25050 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25051 PyObject *resultobj = 0;
25052 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25053 bool result;
25054 void *argp1 = 0 ;
25055 int res1 = 0 ;
25056 PyObject *swig_obj[1] ;
25057
25058 if (!args) SWIG_fail;
25059 swig_obj[0] = args;
25060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25061 if (!SWIG_IsOK(res1)) {
25062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25063 }
25064 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25065 {
25066 PyThreadState* __tstate = wxPyBeginAllowThreads();
25067 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25068 wxPyEndAllowThreads(__tstate);
25069 if (PyErr_Occurred()) SWIG_fail;
25070 }
25071 {
25072 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25073 }
25074 return resultobj;
25075 fail:
25076 return NULL;
25077 }
25078
25079
25080 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25081 PyObject *resultobj = 0;
25082 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25083 int result;
25084 void *argp1 = 0 ;
25085 int res1 = 0 ;
25086 PyObject *swig_obj[1] ;
25087
25088 if (!args) SWIG_fail;
25089 swig_obj[0] = args;
25090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25091 if (!SWIG_IsOK(res1)) {
25092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25093 }
25094 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25095 {
25096 PyThreadState* __tstate = wxPyBeginAllowThreads();
25097 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25098 wxPyEndAllowThreads(__tstate);
25099 if (PyErr_Occurred()) SWIG_fail;
25100 }
25101 resultobj = SWIG_From_int(static_cast< int >(result));
25102 return resultobj;
25103 fail:
25104 return NULL;
25105 }
25106
25107
25108 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25109 PyObject *resultobj = 0;
25110 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25111 int result;
25112 void *argp1 = 0 ;
25113 int res1 = 0 ;
25114 PyObject *swig_obj[1] ;
25115
25116 if (!args) SWIG_fail;
25117 swig_obj[0] = args;
25118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25119 if (!SWIG_IsOK(res1)) {
25120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25121 }
25122 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25123 {
25124 PyThreadState* __tstate = wxPyBeginAllowThreads();
25125 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25126 wxPyEndAllowThreads(__tstate);
25127 if (PyErr_Occurred()) SWIG_fail;
25128 }
25129 resultobj = SWIG_From_int(static_cast< int >(result));
25130 return resultobj;
25131 fail:
25132 return NULL;
25133 }
25134
25135
25136 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25137 PyObject *resultobj = 0;
25138 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25139 int arg2 ;
25140 void *argp1 = 0 ;
25141 int res1 = 0 ;
25142 int val2 ;
25143 int ecode2 = 0 ;
25144 PyObject * obj0 = 0 ;
25145 PyObject * obj1 = 0 ;
25146 char * kwnames[] = {
25147 (char *) "self",(char *) "uniChar", NULL
25148 };
25149
25150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25152 if (!SWIG_IsOK(res1)) {
25153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25154 }
25155 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25156 ecode2 = SWIG_AsVal_int(obj1, &val2);
25157 if (!SWIG_IsOK(ecode2)) {
25158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25159 }
25160 arg2 = static_cast< int >(val2);
25161 {
25162 PyThreadState* __tstate = wxPyBeginAllowThreads();
25163 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25164 wxPyEndAllowThreads(__tstate);
25165 if (PyErr_Occurred()) SWIG_fail;
25166 }
25167 resultobj = SWIG_Py_Void();
25168 return resultobj;
25169 fail:
25170 return NULL;
25171 }
25172
25173
25174 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25175 PyObject *resultobj = 0;
25176 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25177 unsigned int result;
25178 void *argp1 = 0 ;
25179 int res1 = 0 ;
25180 PyObject *swig_obj[1] ;
25181
25182 if (!args) SWIG_fail;
25183 swig_obj[0] = args;
25184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25185 if (!SWIG_IsOK(res1)) {
25186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25187 }
25188 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25189 {
25190 PyThreadState* __tstate = wxPyBeginAllowThreads();
25191 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25192 wxPyEndAllowThreads(__tstate);
25193 if (PyErr_Occurred()) SWIG_fail;
25194 }
25195 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25196 return resultobj;
25197 fail:
25198 return NULL;
25199 }
25200
25201
25202 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25203 PyObject *resultobj = 0;
25204 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25205 unsigned int result;
25206 void *argp1 = 0 ;
25207 int res1 = 0 ;
25208 PyObject *swig_obj[1] ;
25209
25210 if (!args) SWIG_fail;
25211 swig_obj[0] = args;
25212 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25213 if (!SWIG_IsOK(res1)) {
25214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25215 }
25216 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25217 {
25218 PyThreadState* __tstate = wxPyBeginAllowThreads();
25219 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25220 wxPyEndAllowThreads(__tstate);
25221 if (PyErr_Occurred()) SWIG_fail;
25222 }
25223 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25224 return resultobj;
25225 fail:
25226 return NULL;
25227 }
25228
25229
25230 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25231 PyObject *resultobj = 0;
25232 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25233 wxPoint result;
25234 void *argp1 = 0 ;
25235 int res1 = 0 ;
25236 PyObject *swig_obj[1] ;
25237
25238 if (!args) SWIG_fail;
25239 swig_obj[0] = args;
25240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25241 if (!SWIG_IsOK(res1)) {
25242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25243 }
25244 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25245 {
25246 PyThreadState* __tstate = wxPyBeginAllowThreads();
25247 result = (arg1)->GetPosition();
25248 wxPyEndAllowThreads(__tstate);
25249 if (PyErr_Occurred()) SWIG_fail;
25250 }
25251 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25252 return resultobj;
25253 fail:
25254 return NULL;
25255 }
25256
25257
25258 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25259 PyObject *resultobj = 0;
25260 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25261 long *arg2 = (long *) 0 ;
25262 long *arg3 = (long *) 0 ;
25263 void *argp1 = 0 ;
25264 int res1 = 0 ;
25265 long temp2 ;
25266 int res2 = SWIG_TMPOBJ ;
25267 long temp3 ;
25268 int res3 = SWIG_TMPOBJ ;
25269 PyObject *swig_obj[1] ;
25270
25271 arg2 = &temp2;
25272 arg3 = &temp3;
25273 if (!args) SWIG_fail;
25274 swig_obj[0] = args;
25275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25276 if (!SWIG_IsOK(res1)) {
25277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25278 }
25279 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25280 {
25281 PyThreadState* __tstate = wxPyBeginAllowThreads();
25282 (arg1)->GetPosition(arg2,arg3);
25283 wxPyEndAllowThreads(__tstate);
25284 if (PyErr_Occurred()) SWIG_fail;
25285 }
25286 resultobj = SWIG_Py_Void();
25287 if (SWIG_IsTmpObj(res2)) {
25288 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25289 } else {
25290 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25291 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25292 }
25293 if (SWIG_IsTmpObj(res3)) {
25294 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25295 } else {
25296 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25297 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25298 }
25299 return resultobj;
25300 fail:
25301 return NULL;
25302 }
25303
25304
25305 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25306 PyObject *resultobj = 0;
25307 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25308 int result;
25309 void *argp1 = 0 ;
25310 int res1 = 0 ;
25311 PyObject *swig_obj[1] ;
25312
25313 if (!args) SWIG_fail;
25314 swig_obj[0] = args;
25315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25316 if (!SWIG_IsOK(res1)) {
25317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25318 }
25319 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25320 {
25321 PyThreadState* __tstate = wxPyBeginAllowThreads();
25322 result = (int)((wxKeyEvent const *)arg1)->GetX();
25323 wxPyEndAllowThreads(__tstate);
25324 if (PyErr_Occurred()) SWIG_fail;
25325 }
25326 resultobj = SWIG_From_int(static_cast< int >(result));
25327 return resultobj;
25328 fail:
25329 return NULL;
25330 }
25331
25332
25333 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25334 PyObject *resultobj = 0;
25335 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25336 int result;
25337 void *argp1 = 0 ;
25338 int res1 = 0 ;
25339 PyObject *swig_obj[1] ;
25340
25341 if (!args) SWIG_fail;
25342 swig_obj[0] = args;
25343 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25344 if (!SWIG_IsOK(res1)) {
25345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25346 }
25347 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 result = (int)((wxKeyEvent const *)arg1)->GetY();
25351 wxPyEndAllowThreads(__tstate);
25352 if (PyErr_Occurred()) SWIG_fail;
25353 }
25354 resultobj = SWIG_From_int(static_cast< int >(result));
25355 return resultobj;
25356 fail:
25357 return NULL;
25358 }
25359
25360
25361 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 PyObject *resultobj = 0;
25363 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25364 int arg2 ;
25365 void *argp1 = 0 ;
25366 int res1 = 0 ;
25367 int val2 ;
25368 int ecode2 = 0 ;
25369 PyObject *swig_obj[2] ;
25370
25371 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25373 if (!SWIG_IsOK(res1)) {
25374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25375 }
25376 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25377 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25378 if (!SWIG_IsOK(ecode2)) {
25379 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25380 }
25381 arg2 = static_cast< int >(val2);
25382 if (arg1) (arg1)->m_x = arg2;
25383
25384 resultobj = SWIG_Py_Void();
25385 return resultobj;
25386 fail:
25387 return NULL;
25388 }
25389
25390
25391 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25392 PyObject *resultobj = 0;
25393 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25394 int result;
25395 void *argp1 = 0 ;
25396 int res1 = 0 ;
25397 PyObject *swig_obj[1] ;
25398
25399 if (!args) SWIG_fail;
25400 swig_obj[0] = args;
25401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25402 if (!SWIG_IsOK(res1)) {
25403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25404 }
25405 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25406 result = (int) ((arg1)->m_x);
25407 resultobj = SWIG_From_int(static_cast< int >(result));
25408 return resultobj;
25409 fail:
25410 return NULL;
25411 }
25412
25413
25414 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25415 PyObject *resultobj = 0;
25416 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25417 int arg2 ;
25418 void *argp1 = 0 ;
25419 int res1 = 0 ;
25420 int val2 ;
25421 int ecode2 = 0 ;
25422 PyObject *swig_obj[2] ;
25423
25424 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25426 if (!SWIG_IsOK(res1)) {
25427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25428 }
25429 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25430 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25431 if (!SWIG_IsOK(ecode2)) {
25432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25433 }
25434 arg2 = static_cast< int >(val2);
25435 if (arg1) (arg1)->m_y = arg2;
25436
25437 resultobj = SWIG_Py_Void();
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *resultobj = 0;
25446 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25447 int result;
25448 void *argp1 = 0 ;
25449 int res1 = 0 ;
25450 PyObject *swig_obj[1] ;
25451
25452 if (!args) SWIG_fail;
25453 swig_obj[0] = args;
25454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25455 if (!SWIG_IsOK(res1)) {
25456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25457 }
25458 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25459 result = (int) ((arg1)->m_y);
25460 resultobj = SWIG_From_int(static_cast< int >(result));
25461 return resultobj;
25462 fail:
25463 return NULL;
25464 }
25465
25466
25467 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25468 PyObject *resultobj = 0;
25469 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25470 long arg2 ;
25471 void *argp1 = 0 ;
25472 int res1 = 0 ;
25473 long val2 ;
25474 int ecode2 = 0 ;
25475 PyObject *swig_obj[2] ;
25476
25477 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25478 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25479 if (!SWIG_IsOK(res1)) {
25480 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25481 }
25482 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25483 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25484 if (!SWIG_IsOK(ecode2)) {
25485 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25486 }
25487 arg2 = static_cast< long >(val2);
25488 if (arg1) (arg1)->m_keyCode = arg2;
25489
25490 resultobj = SWIG_Py_Void();
25491 return resultobj;
25492 fail:
25493 return NULL;
25494 }
25495
25496
25497 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25498 PyObject *resultobj = 0;
25499 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25500 long result;
25501 void *argp1 = 0 ;
25502 int res1 = 0 ;
25503 PyObject *swig_obj[1] ;
25504
25505 if (!args) SWIG_fail;
25506 swig_obj[0] = args;
25507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25508 if (!SWIG_IsOK(res1)) {
25509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25510 }
25511 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25512 result = (long) ((arg1)->m_keyCode);
25513 resultobj = SWIG_From_long(static_cast< long >(result));
25514 return resultobj;
25515 fail:
25516 return NULL;
25517 }
25518
25519
25520 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25521 PyObject *resultobj = 0;
25522 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25523 bool arg2 ;
25524 void *argp1 = 0 ;
25525 int res1 = 0 ;
25526 bool val2 ;
25527 int ecode2 = 0 ;
25528 PyObject *swig_obj[2] ;
25529
25530 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25532 if (!SWIG_IsOK(res1)) {
25533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25534 }
25535 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25536 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25537 if (!SWIG_IsOK(ecode2)) {
25538 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25539 }
25540 arg2 = static_cast< bool >(val2);
25541 if (arg1) (arg1)->m_controlDown = arg2;
25542
25543 resultobj = SWIG_Py_Void();
25544 return resultobj;
25545 fail:
25546 return NULL;
25547 }
25548
25549
25550 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25551 PyObject *resultobj = 0;
25552 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25553 bool result;
25554 void *argp1 = 0 ;
25555 int res1 = 0 ;
25556 PyObject *swig_obj[1] ;
25557
25558 if (!args) SWIG_fail;
25559 swig_obj[0] = args;
25560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25561 if (!SWIG_IsOK(res1)) {
25562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25563 }
25564 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25565 result = (bool) ((arg1)->m_controlDown);
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 *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25576 PyObject *resultobj = 0;
25577 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25578 bool arg2 ;
25579 void *argp1 = 0 ;
25580 int res1 = 0 ;
25581 bool val2 ;
25582 int ecode2 = 0 ;
25583 PyObject *swig_obj[2] ;
25584
25585 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25586 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25587 if (!SWIG_IsOK(res1)) {
25588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25589 }
25590 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25591 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25592 if (!SWIG_IsOK(ecode2)) {
25593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25594 }
25595 arg2 = static_cast< bool >(val2);
25596 if (arg1) (arg1)->m_shiftDown = arg2;
25597
25598 resultobj = SWIG_Py_Void();
25599 return resultobj;
25600 fail:
25601 return NULL;
25602 }
25603
25604
25605 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25606 PyObject *resultobj = 0;
25607 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25608 bool result;
25609 void *argp1 = 0 ;
25610 int res1 = 0 ;
25611 PyObject *swig_obj[1] ;
25612
25613 if (!args) SWIG_fail;
25614 swig_obj[0] = args;
25615 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25616 if (!SWIG_IsOK(res1)) {
25617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25618 }
25619 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25620 result = (bool) ((arg1)->m_shiftDown);
25621 {
25622 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25623 }
25624 return resultobj;
25625 fail:
25626 return NULL;
25627 }
25628
25629
25630 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25631 PyObject *resultobj = 0;
25632 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25633 bool arg2 ;
25634 void *argp1 = 0 ;
25635 int res1 = 0 ;
25636 bool val2 ;
25637 int ecode2 = 0 ;
25638 PyObject *swig_obj[2] ;
25639
25640 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25642 if (!SWIG_IsOK(res1)) {
25643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25644 }
25645 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25646 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25647 if (!SWIG_IsOK(ecode2)) {
25648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25649 }
25650 arg2 = static_cast< bool >(val2);
25651 if (arg1) (arg1)->m_altDown = arg2;
25652
25653 resultobj = SWIG_Py_Void();
25654 return resultobj;
25655 fail:
25656 return NULL;
25657 }
25658
25659
25660 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25661 PyObject *resultobj = 0;
25662 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25663 bool result;
25664 void *argp1 = 0 ;
25665 int res1 = 0 ;
25666 PyObject *swig_obj[1] ;
25667
25668 if (!args) SWIG_fail;
25669 swig_obj[0] = args;
25670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25671 if (!SWIG_IsOK(res1)) {
25672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25673 }
25674 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25675 result = (bool) ((arg1)->m_altDown);
25676 {
25677 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25678 }
25679 return resultobj;
25680 fail:
25681 return NULL;
25682 }
25683
25684
25685 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25686 PyObject *resultobj = 0;
25687 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25688 bool arg2 ;
25689 void *argp1 = 0 ;
25690 int res1 = 0 ;
25691 bool val2 ;
25692 int ecode2 = 0 ;
25693 PyObject *swig_obj[2] ;
25694
25695 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25697 if (!SWIG_IsOK(res1)) {
25698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25699 }
25700 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25701 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25702 if (!SWIG_IsOK(ecode2)) {
25703 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25704 }
25705 arg2 = static_cast< bool >(val2);
25706 if (arg1) (arg1)->m_metaDown = arg2;
25707
25708 resultobj = SWIG_Py_Void();
25709 return resultobj;
25710 fail:
25711 return NULL;
25712 }
25713
25714
25715 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25716 PyObject *resultobj = 0;
25717 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25718 bool result;
25719 void *argp1 = 0 ;
25720 int res1 = 0 ;
25721 PyObject *swig_obj[1] ;
25722
25723 if (!args) SWIG_fail;
25724 swig_obj[0] = args;
25725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25726 if (!SWIG_IsOK(res1)) {
25727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25728 }
25729 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25730 result = (bool) ((arg1)->m_metaDown);
25731 {
25732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25733 }
25734 return resultobj;
25735 fail:
25736 return NULL;
25737 }
25738
25739
25740 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25741 PyObject *resultobj = 0;
25742 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25743 bool arg2 ;
25744 void *argp1 = 0 ;
25745 int res1 = 0 ;
25746 bool val2 ;
25747 int ecode2 = 0 ;
25748 PyObject *swig_obj[2] ;
25749
25750 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25752 if (!SWIG_IsOK(res1)) {
25753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25754 }
25755 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25756 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25757 if (!SWIG_IsOK(ecode2)) {
25758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25759 }
25760 arg2 = static_cast< bool >(val2);
25761 if (arg1) (arg1)->m_scanCode = arg2;
25762
25763 resultobj = SWIG_Py_Void();
25764 return resultobj;
25765 fail:
25766 return NULL;
25767 }
25768
25769
25770 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25771 PyObject *resultobj = 0;
25772 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25773 bool result;
25774 void *argp1 = 0 ;
25775 int res1 = 0 ;
25776 PyObject *swig_obj[1] ;
25777
25778 if (!args) SWIG_fail;
25779 swig_obj[0] = args;
25780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25781 if (!SWIG_IsOK(res1)) {
25782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25783 }
25784 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25785 result = (bool) ((arg1)->m_scanCode);
25786 {
25787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25788 }
25789 return resultobj;
25790 fail:
25791 return NULL;
25792 }
25793
25794
25795 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25796 PyObject *resultobj = 0;
25797 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25798 unsigned int arg2 ;
25799 void *argp1 = 0 ;
25800 int res1 = 0 ;
25801 unsigned int val2 ;
25802 int ecode2 = 0 ;
25803 PyObject *swig_obj[2] ;
25804
25805 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25806 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25807 if (!SWIG_IsOK(res1)) {
25808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25809 }
25810 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25811 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25812 if (!SWIG_IsOK(ecode2)) {
25813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25814 }
25815 arg2 = static_cast< unsigned int >(val2);
25816 if (arg1) (arg1)->m_rawCode = arg2;
25817
25818 resultobj = SWIG_Py_Void();
25819 return resultobj;
25820 fail:
25821 return NULL;
25822 }
25823
25824
25825 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25826 PyObject *resultobj = 0;
25827 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25828 unsigned int result;
25829 void *argp1 = 0 ;
25830 int res1 = 0 ;
25831 PyObject *swig_obj[1] ;
25832
25833 if (!args) SWIG_fail;
25834 swig_obj[0] = args;
25835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25836 if (!SWIG_IsOK(res1)) {
25837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25838 }
25839 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25840 result = (unsigned int) ((arg1)->m_rawCode);
25841 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25842 return resultobj;
25843 fail:
25844 return NULL;
25845 }
25846
25847
25848 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25849 PyObject *resultobj = 0;
25850 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25851 unsigned int arg2 ;
25852 void *argp1 = 0 ;
25853 int res1 = 0 ;
25854 unsigned int val2 ;
25855 int ecode2 = 0 ;
25856 PyObject *swig_obj[2] ;
25857
25858 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25860 if (!SWIG_IsOK(res1)) {
25861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25862 }
25863 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25864 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25865 if (!SWIG_IsOK(ecode2)) {
25866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25867 }
25868 arg2 = static_cast< unsigned int >(val2);
25869 if (arg1) (arg1)->m_rawFlags = arg2;
25870
25871 resultobj = SWIG_Py_Void();
25872 return resultobj;
25873 fail:
25874 return NULL;
25875 }
25876
25877
25878 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25879 PyObject *resultobj = 0;
25880 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25881 unsigned int result;
25882 void *argp1 = 0 ;
25883 int res1 = 0 ;
25884 PyObject *swig_obj[1] ;
25885
25886 if (!args) SWIG_fail;
25887 swig_obj[0] = args;
25888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25889 if (!SWIG_IsOK(res1)) {
25890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25891 }
25892 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25893 result = (unsigned int) ((arg1)->m_rawFlags);
25894 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25895 return resultobj;
25896 fail:
25897 return NULL;
25898 }
25899
25900
25901 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25902 PyObject *obj;
25903 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25904 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25905 return SWIG_Py_Void();
25906 }
25907
25908 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25909 return SWIG_Python_InitShadowInstance(args);
25910 }
25911
25912 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25913 PyObject *resultobj = 0;
25914 wxSize const &arg1_defvalue = wxDefaultSize ;
25915 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25916 int arg2 = (int) 0 ;
25917 wxSizeEvent *result = 0 ;
25918 wxSize temp1 ;
25919 int val2 ;
25920 int ecode2 = 0 ;
25921 PyObject * obj0 = 0 ;
25922 PyObject * obj1 = 0 ;
25923 char * kwnames[] = {
25924 (char *) "sz",(char *) "winid", NULL
25925 };
25926
25927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25928 if (obj0) {
25929 {
25930 arg1 = &temp1;
25931 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25932 }
25933 }
25934 if (obj1) {
25935 ecode2 = SWIG_AsVal_int(obj1, &val2);
25936 if (!SWIG_IsOK(ecode2)) {
25937 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25938 }
25939 arg2 = static_cast< int >(val2);
25940 }
25941 {
25942 PyThreadState* __tstate = wxPyBeginAllowThreads();
25943 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25944 wxPyEndAllowThreads(__tstate);
25945 if (PyErr_Occurred()) SWIG_fail;
25946 }
25947 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25948 return resultobj;
25949 fail:
25950 return NULL;
25951 }
25952
25953
25954 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25955 PyObject *resultobj = 0;
25956 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25957 wxSize result;
25958 void *argp1 = 0 ;
25959 int res1 = 0 ;
25960 PyObject *swig_obj[1] ;
25961
25962 if (!args) SWIG_fail;
25963 swig_obj[0] = args;
25964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25965 if (!SWIG_IsOK(res1)) {
25966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25967 }
25968 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25969 {
25970 PyThreadState* __tstate = wxPyBeginAllowThreads();
25971 result = ((wxSizeEvent const *)arg1)->GetSize();
25972 wxPyEndAllowThreads(__tstate);
25973 if (PyErr_Occurred()) SWIG_fail;
25974 }
25975 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25976 return resultobj;
25977 fail:
25978 return NULL;
25979 }
25980
25981
25982 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25983 PyObject *resultobj = 0;
25984 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25985 wxRect result;
25986 void *argp1 = 0 ;
25987 int res1 = 0 ;
25988 PyObject *swig_obj[1] ;
25989
25990 if (!args) SWIG_fail;
25991 swig_obj[0] = args;
25992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25993 if (!SWIG_IsOK(res1)) {
25994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25995 }
25996 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25997 {
25998 PyThreadState* __tstate = wxPyBeginAllowThreads();
25999 result = ((wxSizeEvent const *)arg1)->GetRect();
26000 wxPyEndAllowThreads(__tstate);
26001 if (PyErr_Occurred()) SWIG_fail;
26002 }
26003 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26004 return resultobj;
26005 fail:
26006 return NULL;
26007 }
26008
26009
26010 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26011 PyObject *resultobj = 0;
26012 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26013 wxRect arg2 ;
26014 void *argp1 = 0 ;
26015 int res1 = 0 ;
26016 void *argp2 ;
26017 int res2 = 0 ;
26018 PyObject * obj0 = 0 ;
26019 PyObject * obj1 = 0 ;
26020 char * kwnames[] = {
26021 (char *) "self",(char *) "rect", NULL
26022 };
26023
26024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26026 if (!SWIG_IsOK(res1)) {
26027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26028 }
26029 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26030 {
26031 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26032 if (!SWIG_IsOK(res2)) {
26033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26034 }
26035 if (!argp2) {
26036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26037 } else {
26038 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26039 arg2 = *temp;
26040 if (SWIG_IsNewObj(res2)) delete temp;
26041 }
26042 }
26043 {
26044 PyThreadState* __tstate = wxPyBeginAllowThreads();
26045 (arg1)->SetRect(arg2);
26046 wxPyEndAllowThreads(__tstate);
26047 if (PyErr_Occurred()) SWIG_fail;
26048 }
26049 resultobj = SWIG_Py_Void();
26050 return resultobj;
26051 fail:
26052 return NULL;
26053 }
26054
26055
26056 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26057 PyObject *resultobj = 0;
26058 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26059 wxSize arg2 ;
26060 void *argp1 = 0 ;
26061 int res1 = 0 ;
26062 void *argp2 ;
26063 int res2 = 0 ;
26064 PyObject * obj0 = 0 ;
26065 PyObject * obj1 = 0 ;
26066 char * kwnames[] = {
26067 (char *) "self",(char *) "size", NULL
26068 };
26069
26070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26072 if (!SWIG_IsOK(res1)) {
26073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26074 }
26075 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26076 {
26077 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26078 if (!SWIG_IsOK(res2)) {
26079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26080 }
26081 if (!argp2) {
26082 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26083 } else {
26084 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26085 arg2 = *temp;
26086 if (SWIG_IsNewObj(res2)) delete temp;
26087 }
26088 }
26089 {
26090 PyThreadState* __tstate = wxPyBeginAllowThreads();
26091 wxSizeEvent_SetSize(arg1,arg2);
26092 wxPyEndAllowThreads(__tstate);
26093 if (PyErr_Occurred()) SWIG_fail;
26094 }
26095 resultobj = SWIG_Py_Void();
26096 return resultobj;
26097 fail:
26098 return NULL;
26099 }
26100
26101
26102 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26103 PyObject *resultobj = 0;
26104 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26105 wxSize *arg2 = (wxSize *) 0 ;
26106 void *argp1 = 0 ;
26107 int res1 = 0 ;
26108 void *argp2 = 0 ;
26109 int res2 = 0 ;
26110 PyObject *swig_obj[2] ;
26111
26112 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26114 if (!SWIG_IsOK(res1)) {
26115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26116 }
26117 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26118 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26119 if (!SWIG_IsOK(res2)) {
26120 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26121 }
26122 arg2 = reinterpret_cast< wxSize * >(argp2);
26123 if (arg1) (arg1)->m_size = *arg2;
26124
26125 resultobj = SWIG_Py_Void();
26126 return resultobj;
26127 fail:
26128 return NULL;
26129 }
26130
26131
26132 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26133 PyObject *resultobj = 0;
26134 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26135 wxSize *result = 0 ;
26136 void *argp1 = 0 ;
26137 int res1 = 0 ;
26138 PyObject *swig_obj[1] ;
26139
26140 if (!args) SWIG_fail;
26141 swig_obj[0] = args;
26142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26143 if (!SWIG_IsOK(res1)) {
26144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26145 }
26146 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26147 result = (wxSize *)& ((arg1)->m_size);
26148 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26149 return resultobj;
26150 fail:
26151 return NULL;
26152 }
26153
26154
26155 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26156 PyObject *resultobj = 0;
26157 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26158 wxRect *arg2 = (wxRect *) 0 ;
26159 void *argp1 = 0 ;
26160 int res1 = 0 ;
26161 void *argp2 = 0 ;
26162 int res2 = 0 ;
26163 PyObject *swig_obj[2] ;
26164
26165 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26167 if (!SWIG_IsOK(res1)) {
26168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26169 }
26170 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26171 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26172 if (!SWIG_IsOK(res2)) {
26173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26174 }
26175 arg2 = reinterpret_cast< wxRect * >(argp2);
26176 if (arg1) (arg1)->m_rect = *arg2;
26177
26178 resultobj = SWIG_Py_Void();
26179 return resultobj;
26180 fail:
26181 return NULL;
26182 }
26183
26184
26185 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26186 PyObject *resultobj = 0;
26187 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26188 wxRect *result = 0 ;
26189 void *argp1 = 0 ;
26190 int res1 = 0 ;
26191 PyObject *swig_obj[1] ;
26192
26193 if (!args) SWIG_fail;
26194 swig_obj[0] = args;
26195 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26196 if (!SWIG_IsOK(res1)) {
26197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26198 }
26199 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26200 result = (wxRect *)& ((arg1)->m_rect);
26201 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26202 return resultobj;
26203 fail:
26204 return NULL;
26205 }
26206
26207
26208 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26209 PyObject *obj;
26210 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26211 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26212 return SWIG_Py_Void();
26213 }
26214
26215 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26216 return SWIG_Python_InitShadowInstance(args);
26217 }
26218
26219 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26220 PyObject *resultobj = 0;
26221 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26222 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26223 int arg2 = (int) 0 ;
26224 wxMoveEvent *result = 0 ;
26225 wxPoint temp1 ;
26226 int val2 ;
26227 int ecode2 = 0 ;
26228 PyObject * obj0 = 0 ;
26229 PyObject * obj1 = 0 ;
26230 char * kwnames[] = {
26231 (char *) "pos",(char *) "winid", NULL
26232 };
26233
26234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26235 if (obj0) {
26236 {
26237 arg1 = &temp1;
26238 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26239 }
26240 }
26241 if (obj1) {
26242 ecode2 = SWIG_AsVal_int(obj1, &val2);
26243 if (!SWIG_IsOK(ecode2)) {
26244 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26245 }
26246 arg2 = static_cast< int >(val2);
26247 }
26248 {
26249 PyThreadState* __tstate = wxPyBeginAllowThreads();
26250 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26251 wxPyEndAllowThreads(__tstate);
26252 if (PyErr_Occurred()) SWIG_fail;
26253 }
26254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26255 return resultobj;
26256 fail:
26257 return NULL;
26258 }
26259
26260
26261 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26262 PyObject *resultobj = 0;
26263 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26264 wxPoint result;
26265 void *argp1 = 0 ;
26266 int res1 = 0 ;
26267 PyObject *swig_obj[1] ;
26268
26269 if (!args) SWIG_fail;
26270 swig_obj[0] = args;
26271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26272 if (!SWIG_IsOK(res1)) {
26273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26274 }
26275 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26276 {
26277 PyThreadState* __tstate = wxPyBeginAllowThreads();
26278 result = ((wxMoveEvent const *)arg1)->GetPosition();
26279 wxPyEndAllowThreads(__tstate);
26280 if (PyErr_Occurred()) SWIG_fail;
26281 }
26282 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26283 return resultobj;
26284 fail:
26285 return NULL;
26286 }
26287
26288
26289 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26290 PyObject *resultobj = 0;
26291 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26292 wxRect result;
26293 void *argp1 = 0 ;
26294 int res1 = 0 ;
26295 PyObject *swig_obj[1] ;
26296
26297 if (!args) SWIG_fail;
26298 swig_obj[0] = args;
26299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26300 if (!SWIG_IsOK(res1)) {
26301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26302 }
26303 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = ((wxMoveEvent const *)arg1)->GetRect();
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26311 return resultobj;
26312 fail:
26313 return NULL;
26314 }
26315
26316
26317 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26318 PyObject *resultobj = 0;
26319 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26320 wxRect *arg2 = 0 ;
26321 void *argp1 = 0 ;
26322 int res1 = 0 ;
26323 wxRect temp2 ;
26324 PyObject * obj0 = 0 ;
26325 PyObject * obj1 = 0 ;
26326 char * kwnames[] = {
26327 (char *) "self",(char *) "rect", NULL
26328 };
26329
26330 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26331 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26332 if (!SWIG_IsOK(res1)) {
26333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26334 }
26335 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26336 {
26337 arg2 = &temp2;
26338 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26339 }
26340 {
26341 PyThreadState* __tstate = wxPyBeginAllowThreads();
26342 (arg1)->SetRect((wxRect const &)*arg2);
26343 wxPyEndAllowThreads(__tstate);
26344 if (PyErr_Occurred()) SWIG_fail;
26345 }
26346 resultobj = SWIG_Py_Void();
26347 return resultobj;
26348 fail:
26349 return NULL;
26350 }
26351
26352
26353 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26354 PyObject *resultobj = 0;
26355 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26356 wxPoint *arg2 = 0 ;
26357 void *argp1 = 0 ;
26358 int res1 = 0 ;
26359 wxPoint temp2 ;
26360 PyObject * obj0 = 0 ;
26361 PyObject * obj1 = 0 ;
26362 char * kwnames[] = {
26363 (char *) "self",(char *) "pos", NULL
26364 };
26365
26366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26368 if (!SWIG_IsOK(res1)) {
26369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26370 }
26371 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26372 {
26373 arg2 = &temp2;
26374 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26375 }
26376 {
26377 PyThreadState* __tstate = wxPyBeginAllowThreads();
26378 (arg1)->SetPosition((wxPoint const &)*arg2);
26379 wxPyEndAllowThreads(__tstate);
26380 if (PyErr_Occurred()) SWIG_fail;
26381 }
26382 resultobj = SWIG_Py_Void();
26383 return resultobj;
26384 fail:
26385 return NULL;
26386 }
26387
26388
26389 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26390 PyObject *obj;
26391 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26392 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26393 return SWIG_Py_Void();
26394 }
26395
26396 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26397 return SWIG_Python_InitShadowInstance(args);
26398 }
26399
26400 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26401 PyObject *resultobj = 0;
26402 int arg1 = (int) 0 ;
26403 wxPaintEvent *result = 0 ;
26404 int val1 ;
26405 int ecode1 = 0 ;
26406 PyObject * obj0 = 0 ;
26407 char * kwnames[] = {
26408 (char *) "Id", NULL
26409 };
26410
26411 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26412 if (obj0) {
26413 ecode1 = SWIG_AsVal_int(obj0, &val1);
26414 if (!SWIG_IsOK(ecode1)) {
26415 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26416 }
26417 arg1 = static_cast< int >(val1);
26418 }
26419 {
26420 PyThreadState* __tstate = wxPyBeginAllowThreads();
26421 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26422 wxPyEndAllowThreads(__tstate);
26423 if (PyErr_Occurred()) SWIG_fail;
26424 }
26425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26426 return resultobj;
26427 fail:
26428 return NULL;
26429 }
26430
26431
26432 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26433 PyObject *obj;
26434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26435 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26436 return SWIG_Py_Void();
26437 }
26438
26439 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26440 return SWIG_Python_InitShadowInstance(args);
26441 }
26442
26443 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26444 PyObject *resultobj = 0;
26445 int arg1 = (int) 0 ;
26446 wxNcPaintEvent *result = 0 ;
26447 int val1 ;
26448 int ecode1 = 0 ;
26449 PyObject * obj0 = 0 ;
26450 char * kwnames[] = {
26451 (char *) "winid", NULL
26452 };
26453
26454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26455 if (obj0) {
26456 ecode1 = SWIG_AsVal_int(obj0, &val1);
26457 if (!SWIG_IsOK(ecode1)) {
26458 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26459 }
26460 arg1 = static_cast< int >(val1);
26461 }
26462 {
26463 PyThreadState* __tstate = wxPyBeginAllowThreads();
26464 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26465 wxPyEndAllowThreads(__tstate);
26466 if (PyErr_Occurred()) SWIG_fail;
26467 }
26468 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26469 return resultobj;
26470 fail:
26471 return NULL;
26472 }
26473
26474
26475 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26476 PyObject *obj;
26477 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26478 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26479 return SWIG_Py_Void();
26480 }
26481
26482 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26483 return SWIG_Python_InitShadowInstance(args);
26484 }
26485
26486 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26487 PyObject *resultobj = 0;
26488 int arg1 = (int) 0 ;
26489 wxDC *arg2 = (wxDC *) NULL ;
26490 wxEraseEvent *result = 0 ;
26491 int val1 ;
26492 int ecode1 = 0 ;
26493 void *argp2 = 0 ;
26494 int res2 = 0 ;
26495 PyObject * obj0 = 0 ;
26496 PyObject * obj1 = 0 ;
26497 char * kwnames[] = {
26498 (char *) "Id",(char *) "dc", NULL
26499 };
26500
26501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26502 if (obj0) {
26503 ecode1 = SWIG_AsVal_int(obj0, &val1);
26504 if (!SWIG_IsOK(ecode1)) {
26505 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26506 }
26507 arg1 = static_cast< int >(val1);
26508 }
26509 if (obj1) {
26510 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26511 if (!SWIG_IsOK(res2)) {
26512 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26513 }
26514 arg2 = reinterpret_cast< wxDC * >(argp2);
26515 }
26516 {
26517 PyThreadState* __tstate = wxPyBeginAllowThreads();
26518 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26519 wxPyEndAllowThreads(__tstate);
26520 if (PyErr_Occurred()) SWIG_fail;
26521 }
26522 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26523 return resultobj;
26524 fail:
26525 return NULL;
26526 }
26527
26528
26529 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26530 PyObject *resultobj = 0;
26531 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26532 wxDC *result = 0 ;
26533 void *argp1 = 0 ;
26534 int res1 = 0 ;
26535 PyObject *swig_obj[1] ;
26536
26537 if (!args) SWIG_fail;
26538 swig_obj[0] = args;
26539 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26540 if (!SWIG_IsOK(res1)) {
26541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26542 }
26543 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26544 {
26545 PyThreadState* __tstate = wxPyBeginAllowThreads();
26546 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26547 wxPyEndAllowThreads(__tstate);
26548 if (PyErr_Occurred()) SWIG_fail;
26549 }
26550 {
26551 resultobj = wxPyMake_wxObject(result, (bool)0);
26552 }
26553 return resultobj;
26554 fail:
26555 return NULL;
26556 }
26557
26558
26559 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26560 PyObject *obj;
26561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26562 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26563 return SWIG_Py_Void();
26564 }
26565
26566 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26567 return SWIG_Python_InitShadowInstance(args);
26568 }
26569
26570 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26571 PyObject *resultobj = 0;
26572 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26573 int arg2 = (int) 0 ;
26574 wxFocusEvent *result = 0 ;
26575 int val1 ;
26576 int ecode1 = 0 ;
26577 int val2 ;
26578 int ecode2 = 0 ;
26579 PyObject * obj0 = 0 ;
26580 PyObject * obj1 = 0 ;
26581 char * kwnames[] = {
26582 (char *) "type",(char *) "winid", NULL
26583 };
26584
26585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26586 if (obj0) {
26587 ecode1 = SWIG_AsVal_int(obj0, &val1);
26588 if (!SWIG_IsOK(ecode1)) {
26589 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26590 }
26591 arg1 = static_cast< wxEventType >(val1);
26592 }
26593 if (obj1) {
26594 ecode2 = SWIG_AsVal_int(obj1, &val2);
26595 if (!SWIG_IsOK(ecode2)) {
26596 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26597 }
26598 arg2 = static_cast< int >(val2);
26599 }
26600 {
26601 PyThreadState* __tstate = wxPyBeginAllowThreads();
26602 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26603 wxPyEndAllowThreads(__tstate);
26604 if (PyErr_Occurred()) SWIG_fail;
26605 }
26606 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26607 return resultobj;
26608 fail:
26609 return NULL;
26610 }
26611
26612
26613 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26614 PyObject *resultobj = 0;
26615 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26616 wxWindow *result = 0 ;
26617 void *argp1 = 0 ;
26618 int res1 = 0 ;
26619 PyObject *swig_obj[1] ;
26620
26621 if (!args) SWIG_fail;
26622 swig_obj[0] = args;
26623 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26624 if (!SWIG_IsOK(res1)) {
26625 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26626 }
26627 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26628 {
26629 PyThreadState* __tstate = wxPyBeginAllowThreads();
26630 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26631 wxPyEndAllowThreads(__tstate);
26632 if (PyErr_Occurred()) SWIG_fail;
26633 }
26634 {
26635 resultobj = wxPyMake_wxObject(result, (bool)0);
26636 }
26637 return resultobj;
26638 fail:
26639 return NULL;
26640 }
26641
26642
26643 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26644 PyObject *resultobj = 0;
26645 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26646 wxWindow *arg2 = (wxWindow *) 0 ;
26647 void *argp1 = 0 ;
26648 int res1 = 0 ;
26649 void *argp2 = 0 ;
26650 int res2 = 0 ;
26651 PyObject * obj0 = 0 ;
26652 PyObject * obj1 = 0 ;
26653 char * kwnames[] = {
26654 (char *) "self",(char *) "win", NULL
26655 };
26656
26657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26658 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26659 if (!SWIG_IsOK(res1)) {
26660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26661 }
26662 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26663 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26664 if (!SWIG_IsOK(res2)) {
26665 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26666 }
26667 arg2 = reinterpret_cast< wxWindow * >(argp2);
26668 {
26669 PyThreadState* __tstate = wxPyBeginAllowThreads();
26670 (arg1)->SetWindow(arg2);
26671 wxPyEndAllowThreads(__tstate);
26672 if (PyErr_Occurred()) SWIG_fail;
26673 }
26674 resultobj = SWIG_Py_Void();
26675 return resultobj;
26676 fail:
26677 return NULL;
26678 }
26679
26680
26681 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26682 PyObject *obj;
26683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26684 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26685 return SWIG_Py_Void();
26686 }
26687
26688 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26689 return SWIG_Python_InitShadowInstance(args);
26690 }
26691
26692 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26693 PyObject *resultobj = 0;
26694 wxWindow *arg1 = (wxWindow *) NULL ;
26695 wxChildFocusEvent *result = 0 ;
26696 void *argp1 = 0 ;
26697 int res1 = 0 ;
26698 PyObject * obj0 = 0 ;
26699 char * kwnames[] = {
26700 (char *) "win", NULL
26701 };
26702
26703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26704 if (obj0) {
26705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26706 if (!SWIG_IsOK(res1)) {
26707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26708 }
26709 arg1 = reinterpret_cast< wxWindow * >(argp1);
26710 }
26711 {
26712 PyThreadState* __tstate = wxPyBeginAllowThreads();
26713 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26714 wxPyEndAllowThreads(__tstate);
26715 if (PyErr_Occurred()) SWIG_fail;
26716 }
26717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26718 return resultobj;
26719 fail:
26720 return NULL;
26721 }
26722
26723
26724 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26725 PyObject *resultobj = 0;
26726 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26727 wxWindow *result = 0 ;
26728 void *argp1 = 0 ;
26729 int res1 = 0 ;
26730 PyObject *swig_obj[1] ;
26731
26732 if (!args) SWIG_fail;
26733 swig_obj[0] = args;
26734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26735 if (!SWIG_IsOK(res1)) {
26736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26737 }
26738 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26739 {
26740 PyThreadState* __tstate = wxPyBeginAllowThreads();
26741 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26742 wxPyEndAllowThreads(__tstate);
26743 if (PyErr_Occurred()) SWIG_fail;
26744 }
26745 {
26746 resultobj = wxPyMake_wxObject(result, (bool)0);
26747 }
26748 return resultobj;
26749 fail:
26750 return NULL;
26751 }
26752
26753
26754 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26755 PyObject *obj;
26756 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26757 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26758 return SWIG_Py_Void();
26759 }
26760
26761 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26762 return SWIG_Python_InitShadowInstance(args);
26763 }
26764
26765 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26766 PyObject *resultobj = 0;
26767 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26768 bool arg2 = (bool) true ;
26769 int arg3 = (int) 0 ;
26770 wxActivateEvent *result = 0 ;
26771 int val1 ;
26772 int ecode1 = 0 ;
26773 bool val2 ;
26774 int ecode2 = 0 ;
26775 int val3 ;
26776 int ecode3 = 0 ;
26777 PyObject * obj0 = 0 ;
26778 PyObject * obj1 = 0 ;
26779 PyObject * obj2 = 0 ;
26780 char * kwnames[] = {
26781 (char *) "type",(char *) "active",(char *) "Id", NULL
26782 };
26783
26784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26785 if (obj0) {
26786 ecode1 = SWIG_AsVal_int(obj0, &val1);
26787 if (!SWIG_IsOK(ecode1)) {
26788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26789 }
26790 arg1 = static_cast< wxEventType >(val1);
26791 }
26792 if (obj1) {
26793 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26794 if (!SWIG_IsOK(ecode2)) {
26795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26796 }
26797 arg2 = static_cast< bool >(val2);
26798 }
26799 if (obj2) {
26800 ecode3 = SWIG_AsVal_int(obj2, &val3);
26801 if (!SWIG_IsOK(ecode3)) {
26802 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26803 }
26804 arg3 = static_cast< int >(val3);
26805 }
26806 {
26807 PyThreadState* __tstate = wxPyBeginAllowThreads();
26808 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26809 wxPyEndAllowThreads(__tstate);
26810 if (PyErr_Occurred()) SWIG_fail;
26811 }
26812 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26813 return resultobj;
26814 fail:
26815 return NULL;
26816 }
26817
26818
26819 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26820 PyObject *resultobj = 0;
26821 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26822 bool result;
26823 void *argp1 = 0 ;
26824 int res1 = 0 ;
26825 PyObject *swig_obj[1] ;
26826
26827 if (!args) SWIG_fail;
26828 swig_obj[0] = args;
26829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26830 if (!SWIG_IsOK(res1)) {
26831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26832 }
26833 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26834 {
26835 PyThreadState* __tstate = wxPyBeginAllowThreads();
26836 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26837 wxPyEndAllowThreads(__tstate);
26838 if (PyErr_Occurred()) SWIG_fail;
26839 }
26840 {
26841 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26842 }
26843 return resultobj;
26844 fail:
26845 return NULL;
26846 }
26847
26848
26849 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26850 PyObject *obj;
26851 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26852 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26853 return SWIG_Py_Void();
26854 }
26855
26856 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26857 return SWIG_Python_InitShadowInstance(args);
26858 }
26859
26860 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26861 PyObject *resultobj = 0;
26862 int arg1 = (int) 0 ;
26863 wxInitDialogEvent *result = 0 ;
26864 int val1 ;
26865 int ecode1 = 0 ;
26866 PyObject * obj0 = 0 ;
26867 char * kwnames[] = {
26868 (char *) "Id", NULL
26869 };
26870
26871 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26872 if (obj0) {
26873 ecode1 = SWIG_AsVal_int(obj0, &val1);
26874 if (!SWIG_IsOK(ecode1)) {
26875 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26876 }
26877 arg1 = static_cast< int >(val1);
26878 }
26879 {
26880 PyThreadState* __tstate = wxPyBeginAllowThreads();
26881 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26882 wxPyEndAllowThreads(__tstate);
26883 if (PyErr_Occurred()) SWIG_fail;
26884 }
26885 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26886 return resultobj;
26887 fail:
26888 return NULL;
26889 }
26890
26891
26892 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26893 PyObject *obj;
26894 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26895 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26896 return SWIG_Py_Void();
26897 }
26898
26899 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26900 return SWIG_Python_InitShadowInstance(args);
26901 }
26902
26903 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26904 PyObject *resultobj = 0;
26905 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26906 int arg2 = (int) 0 ;
26907 wxMenu *arg3 = (wxMenu *) NULL ;
26908 wxMenuEvent *result = 0 ;
26909 int val1 ;
26910 int ecode1 = 0 ;
26911 int val2 ;
26912 int ecode2 = 0 ;
26913 void *argp3 = 0 ;
26914 int res3 = 0 ;
26915 PyObject * obj0 = 0 ;
26916 PyObject * obj1 = 0 ;
26917 PyObject * obj2 = 0 ;
26918 char * kwnames[] = {
26919 (char *) "type",(char *) "winid",(char *) "menu", NULL
26920 };
26921
26922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26923 if (obj0) {
26924 ecode1 = SWIG_AsVal_int(obj0, &val1);
26925 if (!SWIG_IsOK(ecode1)) {
26926 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26927 }
26928 arg1 = static_cast< wxEventType >(val1);
26929 }
26930 if (obj1) {
26931 ecode2 = SWIG_AsVal_int(obj1, &val2);
26932 if (!SWIG_IsOK(ecode2)) {
26933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26934 }
26935 arg2 = static_cast< int >(val2);
26936 }
26937 if (obj2) {
26938 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26939 if (!SWIG_IsOK(res3)) {
26940 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26941 }
26942 arg3 = reinterpret_cast< wxMenu * >(argp3);
26943 }
26944 {
26945 PyThreadState* __tstate = wxPyBeginAllowThreads();
26946 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26947 wxPyEndAllowThreads(__tstate);
26948 if (PyErr_Occurred()) SWIG_fail;
26949 }
26950 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26951 return resultobj;
26952 fail:
26953 return NULL;
26954 }
26955
26956
26957 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26958 PyObject *resultobj = 0;
26959 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26960 int result;
26961 void *argp1 = 0 ;
26962 int res1 = 0 ;
26963 PyObject *swig_obj[1] ;
26964
26965 if (!args) SWIG_fail;
26966 swig_obj[0] = args;
26967 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26968 if (!SWIG_IsOK(res1)) {
26969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26970 }
26971 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26972 {
26973 PyThreadState* __tstate = wxPyBeginAllowThreads();
26974 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26975 wxPyEndAllowThreads(__tstate);
26976 if (PyErr_Occurred()) SWIG_fail;
26977 }
26978 resultobj = SWIG_From_int(static_cast< int >(result));
26979 return resultobj;
26980 fail:
26981 return NULL;
26982 }
26983
26984
26985 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26986 PyObject *resultobj = 0;
26987 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26988 bool result;
26989 void *argp1 = 0 ;
26990 int res1 = 0 ;
26991 PyObject *swig_obj[1] ;
26992
26993 if (!args) SWIG_fail;
26994 swig_obj[0] = args;
26995 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26996 if (!SWIG_IsOK(res1)) {
26997 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26998 }
26999 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27000 {
27001 PyThreadState* __tstate = wxPyBeginAllowThreads();
27002 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27003 wxPyEndAllowThreads(__tstate);
27004 if (PyErr_Occurred()) SWIG_fail;
27005 }
27006 {
27007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27008 }
27009 return resultobj;
27010 fail:
27011 return NULL;
27012 }
27013
27014
27015 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27016 PyObject *resultobj = 0;
27017 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27018 wxMenu *result = 0 ;
27019 void *argp1 = 0 ;
27020 int res1 = 0 ;
27021 PyObject *swig_obj[1] ;
27022
27023 if (!args) SWIG_fail;
27024 swig_obj[0] = args;
27025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27026 if (!SWIG_IsOK(res1)) {
27027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27028 }
27029 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27030 {
27031 PyThreadState* __tstate = wxPyBeginAllowThreads();
27032 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27033 wxPyEndAllowThreads(__tstate);
27034 if (PyErr_Occurred()) SWIG_fail;
27035 }
27036 {
27037 resultobj = wxPyMake_wxObject(result, (bool)0);
27038 }
27039 return resultobj;
27040 fail:
27041 return NULL;
27042 }
27043
27044
27045 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 PyObject *obj;
27047 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27048 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27049 return SWIG_Py_Void();
27050 }
27051
27052 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27053 return SWIG_Python_InitShadowInstance(args);
27054 }
27055
27056 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27057 PyObject *resultobj = 0;
27058 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27059 int arg2 = (int) 0 ;
27060 wxCloseEvent *result = 0 ;
27061 int val1 ;
27062 int ecode1 = 0 ;
27063 int val2 ;
27064 int ecode2 = 0 ;
27065 PyObject * obj0 = 0 ;
27066 PyObject * obj1 = 0 ;
27067 char * kwnames[] = {
27068 (char *) "type",(char *) "winid", NULL
27069 };
27070
27071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27072 if (obj0) {
27073 ecode1 = SWIG_AsVal_int(obj0, &val1);
27074 if (!SWIG_IsOK(ecode1)) {
27075 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27076 }
27077 arg1 = static_cast< wxEventType >(val1);
27078 }
27079 if (obj1) {
27080 ecode2 = SWIG_AsVal_int(obj1, &val2);
27081 if (!SWIG_IsOK(ecode2)) {
27082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27083 }
27084 arg2 = static_cast< int >(val2);
27085 }
27086 {
27087 PyThreadState* __tstate = wxPyBeginAllowThreads();
27088 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27089 wxPyEndAllowThreads(__tstate);
27090 if (PyErr_Occurred()) SWIG_fail;
27091 }
27092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27093 return resultobj;
27094 fail:
27095 return NULL;
27096 }
27097
27098
27099 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27100 PyObject *resultobj = 0;
27101 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27102 bool arg2 ;
27103 void *argp1 = 0 ;
27104 int res1 = 0 ;
27105 bool val2 ;
27106 int ecode2 = 0 ;
27107 PyObject * obj0 = 0 ;
27108 PyObject * obj1 = 0 ;
27109 char * kwnames[] = {
27110 (char *) "self",(char *) "logOff", NULL
27111 };
27112
27113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27115 if (!SWIG_IsOK(res1)) {
27116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27117 }
27118 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27119 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27120 if (!SWIG_IsOK(ecode2)) {
27121 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27122 }
27123 arg2 = static_cast< bool >(val2);
27124 {
27125 PyThreadState* __tstate = wxPyBeginAllowThreads();
27126 (arg1)->SetLoggingOff(arg2);
27127 wxPyEndAllowThreads(__tstate);
27128 if (PyErr_Occurred()) SWIG_fail;
27129 }
27130 resultobj = SWIG_Py_Void();
27131 return resultobj;
27132 fail:
27133 return NULL;
27134 }
27135
27136
27137 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27138 PyObject *resultobj = 0;
27139 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27140 bool result;
27141 void *argp1 = 0 ;
27142 int res1 = 0 ;
27143 PyObject *swig_obj[1] ;
27144
27145 if (!args) SWIG_fail;
27146 swig_obj[0] = args;
27147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27148 if (!SWIG_IsOK(res1)) {
27149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27150 }
27151 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27152 {
27153 PyThreadState* __tstate = wxPyBeginAllowThreads();
27154 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27155 wxPyEndAllowThreads(__tstate);
27156 if (PyErr_Occurred()) SWIG_fail;
27157 }
27158 {
27159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27160 }
27161 return resultobj;
27162 fail:
27163 return NULL;
27164 }
27165
27166
27167 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27168 PyObject *resultobj = 0;
27169 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27170 bool arg2 = (bool) true ;
27171 void *argp1 = 0 ;
27172 int res1 = 0 ;
27173 bool val2 ;
27174 int ecode2 = 0 ;
27175 PyObject * obj0 = 0 ;
27176 PyObject * obj1 = 0 ;
27177 char * kwnames[] = {
27178 (char *) "self",(char *) "veto", NULL
27179 };
27180
27181 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27182 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27183 if (!SWIG_IsOK(res1)) {
27184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27185 }
27186 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27187 if (obj1) {
27188 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27189 if (!SWIG_IsOK(ecode2)) {
27190 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27191 }
27192 arg2 = static_cast< bool >(val2);
27193 }
27194 {
27195 PyThreadState* __tstate = wxPyBeginAllowThreads();
27196 (arg1)->Veto(arg2);
27197 wxPyEndAllowThreads(__tstate);
27198 if (PyErr_Occurred()) SWIG_fail;
27199 }
27200 resultobj = SWIG_Py_Void();
27201 return resultobj;
27202 fail:
27203 return NULL;
27204 }
27205
27206
27207 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27208 PyObject *resultobj = 0;
27209 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27210 bool result;
27211 void *argp1 = 0 ;
27212 int res1 = 0 ;
27213 PyObject *swig_obj[1] ;
27214
27215 if (!args) SWIG_fail;
27216 swig_obj[0] = args;
27217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27218 if (!SWIG_IsOK(res1)) {
27219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27220 }
27221 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27222 {
27223 PyThreadState* __tstate = wxPyBeginAllowThreads();
27224 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27225 wxPyEndAllowThreads(__tstate);
27226 if (PyErr_Occurred()) SWIG_fail;
27227 }
27228 {
27229 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27230 }
27231 return resultobj;
27232 fail:
27233 return NULL;
27234 }
27235
27236
27237 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27238 PyObject *resultobj = 0;
27239 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27240 bool arg2 ;
27241 void *argp1 = 0 ;
27242 int res1 = 0 ;
27243 bool val2 ;
27244 int ecode2 = 0 ;
27245 PyObject * obj0 = 0 ;
27246 PyObject * obj1 = 0 ;
27247 char * kwnames[] = {
27248 (char *) "self",(char *) "canVeto", NULL
27249 };
27250
27251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27252 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27253 if (!SWIG_IsOK(res1)) {
27254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27255 }
27256 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27257 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27258 if (!SWIG_IsOK(ecode2)) {
27259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27260 }
27261 arg2 = static_cast< bool >(val2);
27262 {
27263 PyThreadState* __tstate = wxPyBeginAllowThreads();
27264 (arg1)->SetCanVeto(arg2);
27265 wxPyEndAllowThreads(__tstate);
27266 if (PyErr_Occurred()) SWIG_fail;
27267 }
27268 resultobj = SWIG_Py_Void();
27269 return resultobj;
27270 fail:
27271 return NULL;
27272 }
27273
27274
27275 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27276 PyObject *resultobj = 0;
27277 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27278 bool result;
27279 void *argp1 = 0 ;
27280 int res1 = 0 ;
27281 PyObject *swig_obj[1] ;
27282
27283 if (!args) SWIG_fail;
27284 swig_obj[0] = args;
27285 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27286 if (!SWIG_IsOK(res1)) {
27287 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27288 }
27289 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27290 {
27291 PyThreadState* __tstate = wxPyBeginAllowThreads();
27292 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27293 wxPyEndAllowThreads(__tstate);
27294 if (PyErr_Occurred()) SWIG_fail;
27295 }
27296 {
27297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27298 }
27299 return resultobj;
27300 fail:
27301 return NULL;
27302 }
27303
27304
27305 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27306 PyObject *obj;
27307 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27308 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27309 return SWIG_Py_Void();
27310 }
27311
27312 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27313 return SWIG_Python_InitShadowInstance(args);
27314 }
27315
27316 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27317 PyObject *resultobj = 0;
27318 int arg1 = (int) 0 ;
27319 bool arg2 = (bool) false ;
27320 wxShowEvent *result = 0 ;
27321 int val1 ;
27322 int ecode1 = 0 ;
27323 bool val2 ;
27324 int ecode2 = 0 ;
27325 PyObject * obj0 = 0 ;
27326 PyObject * obj1 = 0 ;
27327 char * kwnames[] = {
27328 (char *) "winid",(char *) "show", NULL
27329 };
27330
27331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27332 if (obj0) {
27333 ecode1 = SWIG_AsVal_int(obj0, &val1);
27334 if (!SWIG_IsOK(ecode1)) {
27335 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27336 }
27337 arg1 = static_cast< int >(val1);
27338 }
27339 if (obj1) {
27340 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27341 if (!SWIG_IsOK(ecode2)) {
27342 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27343 }
27344 arg2 = static_cast< bool >(val2);
27345 }
27346 {
27347 PyThreadState* __tstate = wxPyBeginAllowThreads();
27348 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27349 wxPyEndAllowThreads(__tstate);
27350 if (PyErr_Occurred()) SWIG_fail;
27351 }
27352 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27353 return resultobj;
27354 fail:
27355 return NULL;
27356 }
27357
27358
27359 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27360 PyObject *resultobj = 0;
27361 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27362 bool arg2 ;
27363 void *argp1 = 0 ;
27364 int res1 = 0 ;
27365 bool val2 ;
27366 int ecode2 = 0 ;
27367 PyObject * obj0 = 0 ;
27368 PyObject * obj1 = 0 ;
27369 char * kwnames[] = {
27370 (char *) "self",(char *) "show", NULL
27371 };
27372
27373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27375 if (!SWIG_IsOK(res1)) {
27376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27377 }
27378 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27379 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27380 if (!SWIG_IsOK(ecode2)) {
27381 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27382 }
27383 arg2 = static_cast< bool >(val2);
27384 {
27385 PyThreadState* __tstate = wxPyBeginAllowThreads();
27386 (arg1)->SetShow(arg2);
27387 wxPyEndAllowThreads(__tstate);
27388 if (PyErr_Occurred()) SWIG_fail;
27389 }
27390 resultobj = SWIG_Py_Void();
27391 return resultobj;
27392 fail:
27393 return NULL;
27394 }
27395
27396
27397 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27398 PyObject *resultobj = 0;
27399 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27400 bool result;
27401 void *argp1 = 0 ;
27402 int res1 = 0 ;
27403 PyObject *swig_obj[1] ;
27404
27405 if (!args) SWIG_fail;
27406 swig_obj[0] = args;
27407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27408 if (!SWIG_IsOK(res1)) {
27409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27410 }
27411 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27412 {
27413 PyThreadState* __tstate = wxPyBeginAllowThreads();
27414 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27415 wxPyEndAllowThreads(__tstate);
27416 if (PyErr_Occurred()) SWIG_fail;
27417 }
27418 {
27419 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27420 }
27421 return resultobj;
27422 fail:
27423 return NULL;
27424 }
27425
27426
27427 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27428 PyObject *obj;
27429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27430 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27431 return SWIG_Py_Void();
27432 }
27433
27434 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27435 return SWIG_Python_InitShadowInstance(args);
27436 }
27437
27438 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27439 PyObject *resultobj = 0;
27440 int arg1 = (int) 0 ;
27441 bool arg2 = (bool) true ;
27442 wxIconizeEvent *result = 0 ;
27443 int val1 ;
27444 int ecode1 = 0 ;
27445 bool val2 ;
27446 int ecode2 = 0 ;
27447 PyObject * obj0 = 0 ;
27448 PyObject * obj1 = 0 ;
27449 char * kwnames[] = {
27450 (char *) "id",(char *) "iconized", NULL
27451 };
27452
27453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27454 if (obj0) {
27455 ecode1 = SWIG_AsVal_int(obj0, &val1);
27456 if (!SWIG_IsOK(ecode1)) {
27457 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27458 }
27459 arg1 = static_cast< int >(val1);
27460 }
27461 if (obj1) {
27462 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27463 if (!SWIG_IsOK(ecode2)) {
27464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27465 }
27466 arg2 = static_cast< bool >(val2);
27467 }
27468 {
27469 PyThreadState* __tstate = wxPyBeginAllowThreads();
27470 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27471 wxPyEndAllowThreads(__tstate);
27472 if (PyErr_Occurred()) SWIG_fail;
27473 }
27474 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27475 return resultobj;
27476 fail:
27477 return NULL;
27478 }
27479
27480
27481 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27482 PyObject *resultobj = 0;
27483 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27484 bool result;
27485 void *argp1 = 0 ;
27486 int res1 = 0 ;
27487 PyObject *swig_obj[1] ;
27488
27489 if (!args) SWIG_fail;
27490 swig_obj[0] = args;
27491 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27492 if (!SWIG_IsOK(res1)) {
27493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27494 }
27495 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27496 {
27497 PyThreadState* __tstate = wxPyBeginAllowThreads();
27498 result = (bool)(arg1)->Iconized();
27499 wxPyEndAllowThreads(__tstate);
27500 if (PyErr_Occurred()) SWIG_fail;
27501 }
27502 {
27503 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27504 }
27505 return resultobj;
27506 fail:
27507 return NULL;
27508 }
27509
27510
27511 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27512 PyObject *obj;
27513 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27514 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27515 return SWIG_Py_Void();
27516 }
27517
27518 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27519 return SWIG_Python_InitShadowInstance(args);
27520 }
27521
27522 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27523 PyObject *resultobj = 0;
27524 int arg1 = (int) 0 ;
27525 wxMaximizeEvent *result = 0 ;
27526 int val1 ;
27527 int ecode1 = 0 ;
27528 PyObject * obj0 = 0 ;
27529 char * kwnames[] = {
27530 (char *) "id", NULL
27531 };
27532
27533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27534 if (obj0) {
27535 ecode1 = SWIG_AsVal_int(obj0, &val1);
27536 if (!SWIG_IsOK(ecode1)) {
27537 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27538 }
27539 arg1 = static_cast< int >(val1);
27540 }
27541 {
27542 PyThreadState* __tstate = wxPyBeginAllowThreads();
27543 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27544 wxPyEndAllowThreads(__tstate);
27545 if (PyErr_Occurred()) SWIG_fail;
27546 }
27547 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27548 return resultobj;
27549 fail:
27550 return NULL;
27551 }
27552
27553
27554 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27555 PyObject *obj;
27556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27557 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27558 return SWIG_Py_Void();
27559 }
27560
27561 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27562 return SWIG_Python_InitShadowInstance(args);
27563 }
27564
27565 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27566 PyObject *resultobj = 0;
27567 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27568 wxPoint result;
27569 void *argp1 = 0 ;
27570 int res1 = 0 ;
27571 PyObject *swig_obj[1] ;
27572
27573 if (!args) SWIG_fail;
27574 swig_obj[0] = args;
27575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27576 if (!SWIG_IsOK(res1)) {
27577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27578 }
27579 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27580 {
27581 PyThreadState* __tstate = wxPyBeginAllowThreads();
27582 result = (arg1)->GetPosition();
27583 wxPyEndAllowThreads(__tstate);
27584 if (PyErr_Occurred()) SWIG_fail;
27585 }
27586 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27587 return resultobj;
27588 fail:
27589 return NULL;
27590 }
27591
27592
27593 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27594 PyObject *resultobj = 0;
27595 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27596 int result;
27597 void *argp1 = 0 ;
27598 int res1 = 0 ;
27599 PyObject *swig_obj[1] ;
27600
27601 if (!args) SWIG_fail;
27602 swig_obj[0] = args;
27603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27604 if (!SWIG_IsOK(res1)) {
27605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27606 }
27607 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27608 {
27609 PyThreadState* __tstate = wxPyBeginAllowThreads();
27610 result = (int)(arg1)->GetNumberOfFiles();
27611 wxPyEndAllowThreads(__tstate);
27612 if (PyErr_Occurred()) SWIG_fail;
27613 }
27614 resultobj = SWIG_From_int(static_cast< int >(result));
27615 return resultobj;
27616 fail:
27617 return NULL;
27618 }
27619
27620
27621 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27622 PyObject *resultobj = 0;
27623 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27624 PyObject *result = 0 ;
27625 void *argp1 = 0 ;
27626 int res1 = 0 ;
27627 PyObject *swig_obj[1] ;
27628
27629 if (!args) SWIG_fail;
27630 swig_obj[0] = args;
27631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27632 if (!SWIG_IsOK(res1)) {
27633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27634 }
27635 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27636 {
27637 PyThreadState* __tstate = wxPyBeginAllowThreads();
27638 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27639 wxPyEndAllowThreads(__tstate);
27640 if (PyErr_Occurred()) SWIG_fail;
27641 }
27642 resultobj = result;
27643 return resultobj;
27644 fail:
27645 return NULL;
27646 }
27647
27648
27649 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27650 PyObject *obj;
27651 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27652 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27653 return SWIG_Py_Void();
27654 }
27655
27656 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27657 PyObject *resultobj = 0;
27658 int arg1 = (int) 0 ;
27659 wxUpdateUIEvent *result = 0 ;
27660 int val1 ;
27661 int ecode1 = 0 ;
27662 PyObject * obj0 = 0 ;
27663 char * kwnames[] = {
27664 (char *) "commandId", NULL
27665 };
27666
27667 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27668 if (obj0) {
27669 ecode1 = SWIG_AsVal_int(obj0, &val1);
27670 if (!SWIG_IsOK(ecode1)) {
27671 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27672 }
27673 arg1 = static_cast< int >(val1);
27674 }
27675 {
27676 PyThreadState* __tstate = wxPyBeginAllowThreads();
27677 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27678 wxPyEndAllowThreads(__tstate);
27679 if (PyErr_Occurred()) SWIG_fail;
27680 }
27681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27682 return resultobj;
27683 fail:
27684 return NULL;
27685 }
27686
27687
27688 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27689 PyObject *resultobj = 0;
27690 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 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_wxUpdateUIEvent, 0 | 0 );
27699 if (!SWIG_IsOK(res1)) {
27700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27701 }
27702 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27703 {
27704 PyThreadState* __tstate = wxPyBeginAllowThreads();
27705 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
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_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27719 PyObject *resultobj = 0;
27720 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27721 bool result;
27722 void *argp1 = 0 ;
27723 int res1 = 0 ;
27724 PyObject *swig_obj[1] ;
27725
27726 if (!args) SWIG_fail;
27727 swig_obj[0] = args;
27728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27729 if (!SWIG_IsOK(res1)) {
27730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27731 }
27732 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27733 {
27734 PyThreadState* __tstate = wxPyBeginAllowThreads();
27735 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27736 wxPyEndAllowThreads(__tstate);
27737 if (PyErr_Occurred()) SWIG_fail;
27738 }
27739 {
27740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27741 }
27742 return resultobj;
27743 fail:
27744 return NULL;
27745 }
27746
27747
27748 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27749 PyObject *resultobj = 0;
27750 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27751 bool result;
27752 void *argp1 = 0 ;
27753 int res1 = 0 ;
27754 PyObject *swig_obj[1] ;
27755
27756 if (!args) SWIG_fail;
27757 swig_obj[0] = args;
27758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27759 if (!SWIG_IsOK(res1)) {
27760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27761 }
27762 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27763 {
27764 PyThreadState* __tstate = wxPyBeginAllowThreads();
27765 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27766 wxPyEndAllowThreads(__tstate);
27767 if (PyErr_Occurred()) SWIG_fail;
27768 }
27769 {
27770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27771 }
27772 return resultobj;
27773 fail:
27774 return NULL;
27775 }
27776
27777
27778 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27779 PyObject *resultobj = 0;
27780 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27781 wxString result;
27782 void *argp1 = 0 ;
27783 int res1 = 0 ;
27784 PyObject *swig_obj[1] ;
27785
27786 if (!args) SWIG_fail;
27787 swig_obj[0] = args;
27788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27789 if (!SWIG_IsOK(res1)) {
27790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27791 }
27792 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27793 {
27794 PyThreadState* __tstate = wxPyBeginAllowThreads();
27795 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27796 wxPyEndAllowThreads(__tstate);
27797 if (PyErr_Occurred()) SWIG_fail;
27798 }
27799 {
27800 #if wxUSE_UNICODE
27801 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27802 #else
27803 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27804 #endif
27805 }
27806 return resultobj;
27807 fail:
27808 return NULL;
27809 }
27810
27811
27812 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27813 PyObject *resultobj = 0;
27814 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27815 bool result;
27816 void *argp1 = 0 ;
27817 int res1 = 0 ;
27818 PyObject *swig_obj[1] ;
27819
27820 if (!args) SWIG_fail;
27821 swig_obj[0] = args;
27822 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27823 if (!SWIG_IsOK(res1)) {
27824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27825 }
27826 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27827 {
27828 PyThreadState* __tstate = wxPyBeginAllowThreads();
27829 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27830 wxPyEndAllowThreads(__tstate);
27831 if (PyErr_Occurred()) SWIG_fail;
27832 }
27833 {
27834 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27835 }
27836 return resultobj;
27837 fail:
27838 return NULL;
27839 }
27840
27841
27842 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27843 PyObject *resultobj = 0;
27844 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27845 bool result;
27846 void *argp1 = 0 ;
27847 int res1 = 0 ;
27848 PyObject *swig_obj[1] ;
27849
27850 if (!args) SWIG_fail;
27851 swig_obj[0] = args;
27852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27853 if (!SWIG_IsOK(res1)) {
27854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27855 }
27856 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27857 {
27858 PyThreadState* __tstate = wxPyBeginAllowThreads();
27859 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27860 wxPyEndAllowThreads(__tstate);
27861 if (PyErr_Occurred()) SWIG_fail;
27862 }
27863 {
27864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27865 }
27866 return resultobj;
27867 fail:
27868 return NULL;
27869 }
27870
27871
27872 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27873 PyObject *resultobj = 0;
27874 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27875 bool result;
27876 void *argp1 = 0 ;
27877 int res1 = 0 ;
27878 PyObject *swig_obj[1] ;
27879
27880 if (!args) SWIG_fail;
27881 swig_obj[0] = args;
27882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27883 if (!SWIG_IsOK(res1)) {
27884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27885 }
27886 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27887 {
27888 PyThreadState* __tstate = wxPyBeginAllowThreads();
27889 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27890 wxPyEndAllowThreads(__tstate);
27891 if (PyErr_Occurred()) SWIG_fail;
27892 }
27893 {
27894 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27895 }
27896 return resultobj;
27897 fail:
27898 return NULL;
27899 }
27900
27901
27902 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27903 PyObject *resultobj = 0;
27904 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27905 bool result;
27906 void *argp1 = 0 ;
27907 int res1 = 0 ;
27908 PyObject *swig_obj[1] ;
27909
27910 if (!args) SWIG_fail;
27911 swig_obj[0] = args;
27912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27913 if (!SWIG_IsOK(res1)) {
27914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27915 }
27916 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27917 {
27918 PyThreadState* __tstate = wxPyBeginAllowThreads();
27919 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27920 wxPyEndAllowThreads(__tstate);
27921 if (PyErr_Occurred()) SWIG_fail;
27922 }
27923 {
27924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27925 }
27926 return resultobj;
27927 fail:
27928 return NULL;
27929 }
27930
27931
27932 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27933 PyObject *resultobj = 0;
27934 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27935 bool arg2 ;
27936 void *argp1 = 0 ;
27937 int res1 = 0 ;
27938 bool val2 ;
27939 int ecode2 = 0 ;
27940 PyObject * obj0 = 0 ;
27941 PyObject * obj1 = 0 ;
27942 char * kwnames[] = {
27943 (char *) "self",(char *) "check", NULL
27944 };
27945
27946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27948 if (!SWIG_IsOK(res1)) {
27949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27950 }
27951 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27952 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27953 if (!SWIG_IsOK(ecode2)) {
27954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27955 }
27956 arg2 = static_cast< bool >(val2);
27957 {
27958 PyThreadState* __tstate = wxPyBeginAllowThreads();
27959 (arg1)->Check(arg2);
27960 wxPyEndAllowThreads(__tstate);
27961 if (PyErr_Occurred()) SWIG_fail;
27962 }
27963 resultobj = SWIG_Py_Void();
27964 return resultobj;
27965 fail:
27966 return NULL;
27967 }
27968
27969
27970 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27971 PyObject *resultobj = 0;
27972 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27973 bool arg2 ;
27974 void *argp1 = 0 ;
27975 int res1 = 0 ;
27976 bool val2 ;
27977 int ecode2 = 0 ;
27978 PyObject * obj0 = 0 ;
27979 PyObject * obj1 = 0 ;
27980 char * kwnames[] = {
27981 (char *) "self",(char *) "enable", NULL
27982 };
27983
27984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
27985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27986 if (!SWIG_IsOK(res1)) {
27987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27988 }
27989 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27990 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27991 if (!SWIG_IsOK(ecode2)) {
27992 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
27993 }
27994 arg2 = static_cast< bool >(val2);
27995 {
27996 PyThreadState* __tstate = wxPyBeginAllowThreads();
27997 (arg1)->Enable(arg2);
27998 wxPyEndAllowThreads(__tstate);
27999 if (PyErr_Occurred()) SWIG_fail;
28000 }
28001 resultobj = SWIG_Py_Void();
28002 return resultobj;
28003 fail:
28004 return NULL;
28005 }
28006
28007
28008 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28009 PyObject *resultobj = 0;
28010 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28011 bool arg2 ;
28012 void *argp1 = 0 ;
28013 int res1 = 0 ;
28014 bool val2 ;
28015 int ecode2 = 0 ;
28016 PyObject * obj0 = 0 ;
28017 PyObject * obj1 = 0 ;
28018 char * kwnames[] = {
28019 (char *) "self",(char *) "show", NULL
28020 };
28021
28022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28024 if (!SWIG_IsOK(res1)) {
28025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28026 }
28027 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28028 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28029 if (!SWIG_IsOK(ecode2)) {
28030 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28031 }
28032 arg2 = static_cast< bool >(val2);
28033 {
28034 PyThreadState* __tstate = wxPyBeginAllowThreads();
28035 (arg1)->Show(arg2);
28036 wxPyEndAllowThreads(__tstate);
28037 if (PyErr_Occurred()) SWIG_fail;
28038 }
28039 resultobj = SWIG_Py_Void();
28040 return resultobj;
28041 fail:
28042 return NULL;
28043 }
28044
28045
28046 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28047 PyObject *resultobj = 0;
28048 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28049 wxString *arg2 = 0 ;
28050 void *argp1 = 0 ;
28051 int res1 = 0 ;
28052 bool temp2 = false ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char * kwnames[] = {
28056 (char *) "self",(char *) "text", NULL
28057 };
28058
28059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28061 if (!SWIG_IsOK(res1)) {
28062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28063 }
28064 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28065 {
28066 arg2 = wxString_in_helper(obj1);
28067 if (arg2 == NULL) SWIG_fail;
28068 temp2 = true;
28069 }
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 (arg1)->SetText((wxString const &)*arg2);
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 resultobj = SWIG_Py_Void();
28077 {
28078 if (temp2)
28079 delete arg2;
28080 }
28081 return resultobj;
28082 fail:
28083 {
28084 if (temp2)
28085 delete arg2;
28086 }
28087 return NULL;
28088 }
28089
28090
28091 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28092 PyObject *resultobj = 0;
28093 long arg1 ;
28094 long val1 ;
28095 int ecode1 = 0 ;
28096 PyObject * obj0 = 0 ;
28097 char * kwnames[] = {
28098 (char *) "updateInterval", NULL
28099 };
28100
28101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28102 ecode1 = SWIG_AsVal_long(obj0, &val1);
28103 if (!SWIG_IsOK(ecode1)) {
28104 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28105 }
28106 arg1 = static_cast< long >(val1);
28107 {
28108 PyThreadState* __tstate = wxPyBeginAllowThreads();
28109 wxUpdateUIEvent::SetUpdateInterval(arg1);
28110 wxPyEndAllowThreads(__tstate);
28111 if (PyErr_Occurred()) SWIG_fail;
28112 }
28113 resultobj = SWIG_Py_Void();
28114 return resultobj;
28115 fail:
28116 return NULL;
28117 }
28118
28119
28120 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28121 PyObject *resultobj = 0;
28122 long result;
28123
28124 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28125 {
28126 PyThreadState* __tstate = wxPyBeginAllowThreads();
28127 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28128 wxPyEndAllowThreads(__tstate);
28129 if (PyErr_Occurred()) SWIG_fail;
28130 }
28131 resultobj = SWIG_From_long(static_cast< long >(result));
28132 return resultobj;
28133 fail:
28134 return NULL;
28135 }
28136
28137
28138 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28139 PyObject *resultobj = 0;
28140 wxWindow *arg1 = (wxWindow *) 0 ;
28141 bool result;
28142 void *argp1 = 0 ;
28143 int res1 = 0 ;
28144 PyObject * obj0 = 0 ;
28145 char * kwnames[] = {
28146 (char *) "win", NULL
28147 };
28148
28149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28151 if (!SWIG_IsOK(res1)) {
28152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28153 }
28154 arg1 = reinterpret_cast< wxWindow * >(argp1);
28155 {
28156 PyThreadState* __tstate = wxPyBeginAllowThreads();
28157 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28158 wxPyEndAllowThreads(__tstate);
28159 if (PyErr_Occurred()) SWIG_fail;
28160 }
28161 {
28162 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28163 }
28164 return resultobj;
28165 fail:
28166 return NULL;
28167 }
28168
28169
28170 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28171 PyObject *resultobj = 0;
28172
28173 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28174 {
28175 PyThreadState* __tstate = wxPyBeginAllowThreads();
28176 wxUpdateUIEvent::ResetUpdateTime();
28177 wxPyEndAllowThreads(__tstate);
28178 if (PyErr_Occurred()) SWIG_fail;
28179 }
28180 resultobj = SWIG_Py_Void();
28181 return resultobj;
28182 fail:
28183 return NULL;
28184 }
28185
28186
28187 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28188 PyObject *resultobj = 0;
28189 wxUpdateUIMode arg1 ;
28190 int val1 ;
28191 int ecode1 = 0 ;
28192 PyObject * obj0 = 0 ;
28193 char * kwnames[] = {
28194 (char *) "mode", NULL
28195 };
28196
28197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28198 ecode1 = SWIG_AsVal_int(obj0, &val1);
28199 if (!SWIG_IsOK(ecode1)) {
28200 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28201 }
28202 arg1 = static_cast< wxUpdateUIMode >(val1);
28203 {
28204 PyThreadState* __tstate = wxPyBeginAllowThreads();
28205 wxUpdateUIEvent::SetMode(arg1);
28206 wxPyEndAllowThreads(__tstate);
28207 if (PyErr_Occurred()) SWIG_fail;
28208 }
28209 resultobj = SWIG_Py_Void();
28210 return resultobj;
28211 fail:
28212 return NULL;
28213 }
28214
28215
28216 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28217 PyObject *resultobj = 0;
28218 wxUpdateUIMode result;
28219
28220 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28221 {
28222 PyThreadState* __tstate = wxPyBeginAllowThreads();
28223 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28224 wxPyEndAllowThreads(__tstate);
28225 if (PyErr_Occurred()) SWIG_fail;
28226 }
28227 resultobj = SWIG_From_int(static_cast< int >(result));
28228 return resultobj;
28229 fail:
28230 return NULL;
28231 }
28232
28233
28234 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28235 PyObject *obj;
28236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28237 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28238 return SWIG_Py_Void();
28239 }
28240
28241 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28242 return SWIG_Python_InitShadowInstance(args);
28243 }
28244
28245 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28246 PyObject *resultobj = 0;
28247 wxSysColourChangedEvent *result = 0 ;
28248
28249 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28250 {
28251 PyThreadState* __tstate = wxPyBeginAllowThreads();
28252 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28253 wxPyEndAllowThreads(__tstate);
28254 if (PyErr_Occurred()) SWIG_fail;
28255 }
28256 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28257 return resultobj;
28258 fail:
28259 return NULL;
28260 }
28261
28262
28263 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28264 PyObject *obj;
28265 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28266 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28267 return SWIG_Py_Void();
28268 }
28269
28270 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28271 return SWIG_Python_InitShadowInstance(args);
28272 }
28273
28274 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28275 PyObject *resultobj = 0;
28276 int arg1 = (int) 0 ;
28277 wxWindow *arg2 = (wxWindow *) NULL ;
28278 wxMouseCaptureChangedEvent *result = 0 ;
28279 int val1 ;
28280 int ecode1 = 0 ;
28281 void *argp2 = 0 ;
28282 int res2 = 0 ;
28283 PyObject * obj0 = 0 ;
28284 PyObject * obj1 = 0 ;
28285 char * kwnames[] = {
28286 (char *) "winid",(char *) "gainedCapture", NULL
28287 };
28288
28289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28290 if (obj0) {
28291 ecode1 = SWIG_AsVal_int(obj0, &val1);
28292 if (!SWIG_IsOK(ecode1)) {
28293 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28294 }
28295 arg1 = static_cast< int >(val1);
28296 }
28297 if (obj1) {
28298 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28299 if (!SWIG_IsOK(res2)) {
28300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28301 }
28302 arg2 = reinterpret_cast< wxWindow * >(argp2);
28303 }
28304 {
28305 PyThreadState* __tstate = wxPyBeginAllowThreads();
28306 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28307 wxPyEndAllowThreads(__tstate);
28308 if (PyErr_Occurred()) SWIG_fail;
28309 }
28310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28311 return resultobj;
28312 fail:
28313 return NULL;
28314 }
28315
28316
28317 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28318 PyObject *resultobj = 0;
28319 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28320 wxWindow *result = 0 ;
28321 void *argp1 = 0 ;
28322 int res1 = 0 ;
28323 PyObject *swig_obj[1] ;
28324
28325 if (!args) SWIG_fail;
28326 swig_obj[0] = args;
28327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28328 if (!SWIG_IsOK(res1)) {
28329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28330 }
28331 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28332 {
28333 PyThreadState* __tstate = wxPyBeginAllowThreads();
28334 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28335 wxPyEndAllowThreads(__tstate);
28336 if (PyErr_Occurred()) SWIG_fail;
28337 }
28338 {
28339 resultobj = wxPyMake_wxObject(result, (bool)0);
28340 }
28341 return resultobj;
28342 fail:
28343 return NULL;
28344 }
28345
28346
28347 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28348 PyObject *obj;
28349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28350 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28351 return SWIG_Py_Void();
28352 }
28353
28354 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28355 return SWIG_Python_InitShadowInstance(args);
28356 }
28357
28358 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28359 PyObject *resultobj = 0;
28360 int arg1 = (int) 0 ;
28361 wxMouseCaptureLostEvent *result = 0 ;
28362 int val1 ;
28363 int ecode1 = 0 ;
28364 PyObject * obj0 = 0 ;
28365 char * kwnames[] = {
28366 (char *) "winid", NULL
28367 };
28368
28369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28370 if (obj0) {
28371 ecode1 = SWIG_AsVal_int(obj0, &val1);
28372 if (!SWIG_IsOK(ecode1)) {
28373 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28374 }
28375 arg1 = static_cast< int >(val1);
28376 }
28377 {
28378 PyThreadState* __tstate = wxPyBeginAllowThreads();
28379 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28380 wxPyEndAllowThreads(__tstate);
28381 if (PyErr_Occurred()) SWIG_fail;
28382 }
28383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28384 return resultobj;
28385 fail:
28386 return NULL;
28387 }
28388
28389
28390 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28391 PyObject *obj;
28392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28393 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28394 return SWIG_Py_Void();
28395 }
28396
28397 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28398 return SWIG_Python_InitShadowInstance(args);
28399 }
28400
28401 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28402 PyObject *resultobj = 0;
28403 wxDisplayChangedEvent *result = 0 ;
28404
28405 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28406 {
28407 PyThreadState* __tstate = wxPyBeginAllowThreads();
28408 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28409 wxPyEndAllowThreads(__tstate);
28410 if (PyErr_Occurred()) SWIG_fail;
28411 }
28412 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28413 return resultobj;
28414 fail:
28415 return NULL;
28416 }
28417
28418
28419 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28420 PyObject *obj;
28421 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28422 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28423 return SWIG_Py_Void();
28424 }
28425
28426 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28427 return SWIG_Python_InitShadowInstance(args);
28428 }
28429
28430 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28431 PyObject *resultobj = 0;
28432 int arg1 = (int) 0 ;
28433 wxPaletteChangedEvent *result = 0 ;
28434 int val1 ;
28435 int ecode1 = 0 ;
28436 PyObject * obj0 = 0 ;
28437 char * kwnames[] = {
28438 (char *) "id", NULL
28439 };
28440
28441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28442 if (obj0) {
28443 ecode1 = SWIG_AsVal_int(obj0, &val1);
28444 if (!SWIG_IsOK(ecode1)) {
28445 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28446 }
28447 arg1 = static_cast< int >(val1);
28448 }
28449 {
28450 PyThreadState* __tstate = wxPyBeginAllowThreads();
28451 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28452 wxPyEndAllowThreads(__tstate);
28453 if (PyErr_Occurred()) SWIG_fail;
28454 }
28455 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28456 return resultobj;
28457 fail:
28458 return NULL;
28459 }
28460
28461
28462 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28463 PyObject *resultobj = 0;
28464 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28465 wxWindow *arg2 = (wxWindow *) 0 ;
28466 void *argp1 = 0 ;
28467 int res1 = 0 ;
28468 void *argp2 = 0 ;
28469 int res2 = 0 ;
28470 PyObject * obj0 = 0 ;
28471 PyObject * obj1 = 0 ;
28472 char * kwnames[] = {
28473 (char *) "self",(char *) "win", NULL
28474 };
28475
28476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28477 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28478 if (!SWIG_IsOK(res1)) {
28479 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28480 }
28481 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28482 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28483 if (!SWIG_IsOK(res2)) {
28484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28485 }
28486 arg2 = reinterpret_cast< wxWindow * >(argp2);
28487 {
28488 PyThreadState* __tstate = wxPyBeginAllowThreads();
28489 (arg1)->SetChangedWindow(arg2);
28490 wxPyEndAllowThreads(__tstate);
28491 if (PyErr_Occurred()) SWIG_fail;
28492 }
28493 resultobj = SWIG_Py_Void();
28494 return resultobj;
28495 fail:
28496 return NULL;
28497 }
28498
28499
28500 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28501 PyObject *resultobj = 0;
28502 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28503 wxWindow *result = 0 ;
28504 void *argp1 = 0 ;
28505 int res1 = 0 ;
28506 PyObject *swig_obj[1] ;
28507
28508 if (!args) SWIG_fail;
28509 swig_obj[0] = args;
28510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28511 if (!SWIG_IsOK(res1)) {
28512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28513 }
28514 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28515 {
28516 PyThreadState* __tstate = wxPyBeginAllowThreads();
28517 result = (wxWindow *)(arg1)->GetChangedWindow();
28518 wxPyEndAllowThreads(__tstate);
28519 if (PyErr_Occurred()) SWIG_fail;
28520 }
28521 {
28522 resultobj = wxPyMake_wxObject(result, (bool)0);
28523 }
28524 return resultobj;
28525 fail:
28526 return NULL;
28527 }
28528
28529
28530 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28531 PyObject *obj;
28532 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28533 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28534 return SWIG_Py_Void();
28535 }
28536
28537 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28538 return SWIG_Python_InitShadowInstance(args);
28539 }
28540
28541 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28542 PyObject *resultobj = 0;
28543 int arg1 = (int) 0 ;
28544 wxQueryNewPaletteEvent *result = 0 ;
28545 int val1 ;
28546 int ecode1 = 0 ;
28547 PyObject * obj0 = 0 ;
28548 char * kwnames[] = {
28549 (char *) "winid", NULL
28550 };
28551
28552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28553 if (obj0) {
28554 ecode1 = SWIG_AsVal_int(obj0, &val1);
28555 if (!SWIG_IsOK(ecode1)) {
28556 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28557 }
28558 arg1 = static_cast< int >(val1);
28559 }
28560 {
28561 PyThreadState* __tstate = wxPyBeginAllowThreads();
28562 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28563 wxPyEndAllowThreads(__tstate);
28564 if (PyErr_Occurred()) SWIG_fail;
28565 }
28566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28567 return resultobj;
28568 fail:
28569 return NULL;
28570 }
28571
28572
28573 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28574 PyObject *resultobj = 0;
28575 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28576 bool arg2 ;
28577 void *argp1 = 0 ;
28578 int res1 = 0 ;
28579 bool val2 ;
28580 int ecode2 = 0 ;
28581 PyObject * obj0 = 0 ;
28582 PyObject * obj1 = 0 ;
28583 char * kwnames[] = {
28584 (char *) "self",(char *) "realized", NULL
28585 };
28586
28587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28589 if (!SWIG_IsOK(res1)) {
28590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28591 }
28592 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28593 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28594 if (!SWIG_IsOK(ecode2)) {
28595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28596 }
28597 arg2 = static_cast< bool >(val2);
28598 {
28599 PyThreadState* __tstate = wxPyBeginAllowThreads();
28600 (arg1)->SetPaletteRealized(arg2);
28601 wxPyEndAllowThreads(__tstate);
28602 if (PyErr_Occurred()) SWIG_fail;
28603 }
28604 resultobj = SWIG_Py_Void();
28605 return resultobj;
28606 fail:
28607 return NULL;
28608 }
28609
28610
28611 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28612 PyObject *resultobj = 0;
28613 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28614 bool result;
28615 void *argp1 = 0 ;
28616 int res1 = 0 ;
28617 PyObject *swig_obj[1] ;
28618
28619 if (!args) SWIG_fail;
28620 swig_obj[0] = args;
28621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28622 if (!SWIG_IsOK(res1)) {
28623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28624 }
28625 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28626 {
28627 PyThreadState* __tstate = wxPyBeginAllowThreads();
28628 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28629 wxPyEndAllowThreads(__tstate);
28630 if (PyErr_Occurred()) SWIG_fail;
28631 }
28632 {
28633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28634 }
28635 return resultobj;
28636 fail:
28637 return NULL;
28638 }
28639
28640
28641 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28642 PyObject *obj;
28643 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28644 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28645 return SWIG_Py_Void();
28646 }
28647
28648 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28649 return SWIG_Python_InitShadowInstance(args);
28650 }
28651
28652 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28653 PyObject *resultobj = 0;
28654 wxNavigationKeyEvent *result = 0 ;
28655
28656 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28657 {
28658 PyThreadState* __tstate = wxPyBeginAllowThreads();
28659 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28660 wxPyEndAllowThreads(__tstate);
28661 if (PyErr_Occurred()) SWIG_fail;
28662 }
28663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28664 return resultobj;
28665 fail:
28666 return NULL;
28667 }
28668
28669
28670 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28671 PyObject *resultobj = 0;
28672 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28673 bool result;
28674 void *argp1 = 0 ;
28675 int res1 = 0 ;
28676 PyObject *swig_obj[1] ;
28677
28678 if (!args) SWIG_fail;
28679 swig_obj[0] = args;
28680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28681 if (!SWIG_IsOK(res1)) {
28682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28683 }
28684 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28685 {
28686 PyThreadState* __tstate = wxPyBeginAllowThreads();
28687 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28688 wxPyEndAllowThreads(__tstate);
28689 if (PyErr_Occurred()) SWIG_fail;
28690 }
28691 {
28692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28693 }
28694 return resultobj;
28695 fail:
28696 return NULL;
28697 }
28698
28699
28700 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28701 PyObject *resultobj = 0;
28702 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28703 bool arg2 ;
28704 void *argp1 = 0 ;
28705 int res1 = 0 ;
28706 bool val2 ;
28707 int ecode2 = 0 ;
28708 PyObject * obj0 = 0 ;
28709 PyObject * obj1 = 0 ;
28710 char * kwnames[] = {
28711 (char *) "self",(char *) "forward", NULL
28712 };
28713
28714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28716 if (!SWIG_IsOK(res1)) {
28717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28718 }
28719 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28720 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28721 if (!SWIG_IsOK(ecode2)) {
28722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28723 }
28724 arg2 = static_cast< bool >(val2);
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 (arg1)->SetDirection(arg2);
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 resultobj = SWIG_Py_Void();
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28739 PyObject *resultobj = 0;
28740 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28741 bool result;
28742 void *argp1 = 0 ;
28743 int res1 = 0 ;
28744 PyObject *swig_obj[1] ;
28745
28746 if (!args) SWIG_fail;
28747 swig_obj[0] = args;
28748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28749 if (!SWIG_IsOK(res1)) {
28750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28751 }
28752 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28753 {
28754 PyThreadState* __tstate = wxPyBeginAllowThreads();
28755 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28756 wxPyEndAllowThreads(__tstate);
28757 if (PyErr_Occurred()) SWIG_fail;
28758 }
28759 {
28760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28761 }
28762 return resultobj;
28763 fail:
28764 return NULL;
28765 }
28766
28767
28768 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28769 PyObject *resultobj = 0;
28770 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28771 bool arg2 ;
28772 void *argp1 = 0 ;
28773 int res1 = 0 ;
28774 bool val2 ;
28775 int ecode2 = 0 ;
28776 PyObject * obj0 = 0 ;
28777 PyObject * obj1 = 0 ;
28778 char * kwnames[] = {
28779 (char *) "self",(char *) "ischange", NULL
28780 };
28781
28782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28784 if (!SWIG_IsOK(res1)) {
28785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28786 }
28787 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28788 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28789 if (!SWIG_IsOK(ecode2)) {
28790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28791 }
28792 arg2 = static_cast< bool >(val2);
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 (arg1)->SetWindowChange(arg2);
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 resultobj = SWIG_Py_Void();
28800 return resultobj;
28801 fail:
28802 return NULL;
28803 }
28804
28805
28806 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28807 PyObject *resultobj = 0;
28808 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28809 bool result;
28810 void *argp1 = 0 ;
28811 int res1 = 0 ;
28812 PyObject *swig_obj[1] ;
28813
28814 if (!args) SWIG_fail;
28815 swig_obj[0] = args;
28816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28817 if (!SWIG_IsOK(res1)) {
28818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28819 }
28820 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28821 {
28822 PyThreadState* __tstate = wxPyBeginAllowThreads();
28823 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28824 wxPyEndAllowThreads(__tstate);
28825 if (PyErr_Occurred()) SWIG_fail;
28826 }
28827 {
28828 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28829 }
28830 return resultobj;
28831 fail:
28832 return NULL;
28833 }
28834
28835
28836 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28837 PyObject *resultobj = 0;
28838 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28839 bool arg2 ;
28840 void *argp1 = 0 ;
28841 int res1 = 0 ;
28842 bool val2 ;
28843 int ecode2 = 0 ;
28844 PyObject * obj0 = 0 ;
28845 PyObject * obj1 = 0 ;
28846 char * kwnames[] = {
28847 (char *) "self",(char *) "bIs", NULL
28848 };
28849
28850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28852 if (!SWIG_IsOK(res1)) {
28853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28854 }
28855 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28856 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28857 if (!SWIG_IsOK(ecode2)) {
28858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28859 }
28860 arg2 = static_cast< bool >(val2);
28861 {
28862 PyThreadState* __tstate = wxPyBeginAllowThreads();
28863 (arg1)->SetFromTab(arg2);
28864 wxPyEndAllowThreads(__tstate);
28865 if (PyErr_Occurred()) SWIG_fail;
28866 }
28867 resultobj = SWIG_Py_Void();
28868 return resultobj;
28869 fail:
28870 return NULL;
28871 }
28872
28873
28874 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28875 PyObject *resultobj = 0;
28876 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28877 long arg2 ;
28878 void *argp1 = 0 ;
28879 int res1 = 0 ;
28880 long val2 ;
28881 int ecode2 = 0 ;
28882 PyObject * obj0 = 0 ;
28883 PyObject * obj1 = 0 ;
28884 char * kwnames[] = {
28885 (char *) "self",(char *) "flags", NULL
28886 };
28887
28888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28890 if (!SWIG_IsOK(res1)) {
28891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28892 }
28893 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28894 ecode2 = SWIG_AsVal_long(obj1, &val2);
28895 if (!SWIG_IsOK(ecode2)) {
28896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28897 }
28898 arg2 = static_cast< long >(val2);
28899 {
28900 PyThreadState* __tstate = wxPyBeginAllowThreads();
28901 (arg1)->SetFlags(arg2);
28902 wxPyEndAllowThreads(__tstate);
28903 if (PyErr_Occurred()) SWIG_fail;
28904 }
28905 resultobj = SWIG_Py_Void();
28906 return resultobj;
28907 fail:
28908 return NULL;
28909 }
28910
28911
28912 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28913 PyObject *resultobj = 0;
28914 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28915 wxWindow *result = 0 ;
28916 void *argp1 = 0 ;
28917 int res1 = 0 ;
28918 PyObject *swig_obj[1] ;
28919
28920 if (!args) SWIG_fail;
28921 swig_obj[0] = args;
28922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28923 if (!SWIG_IsOK(res1)) {
28924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28925 }
28926 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28927 {
28928 PyThreadState* __tstate = wxPyBeginAllowThreads();
28929 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28930 wxPyEndAllowThreads(__tstate);
28931 if (PyErr_Occurred()) SWIG_fail;
28932 }
28933 {
28934 resultobj = wxPyMake_wxObject(result, (bool)0);
28935 }
28936 return resultobj;
28937 fail:
28938 return NULL;
28939 }
28940
28941
28942 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28943 PyObject *resultobj = 0;
28944 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28945 wxWindow *arg2 = (wxWindow *) 0 ;
28946 void *argp1 = 0 ;
28947 int res1 = 0 ;
28948 void *argp2 = 0 ;
28949 int res2 = 0 ;
28950 PyObject * obj0 = 0 ;
28951 PyObject * obj1 = 0 ;
28952 char * kwnames[] = {
28953 (char *) "self",(char *) "win", NULL
28954 };
28955
28956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28958 if (!SWIG_IsOK(res1)) {
28959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28960 }
28961 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28962 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28963 if (!SWIG_IsOK(res2)) {
28964 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28965 }
28966 arg2 = reinterpret_cast< wxWindow * >(argp2);
28967 {
28968 PyThreadState* __tstate = wxPyBeginAllowThreads();
28969 (arg1)->SetCurrentFocus(arg2);
28970 wxPyEndAllowThreads(__tstate);
28971 if (PyErr_Occurred()) SWIG_fail;
28972 }
28973 resultobj = SWIG_Py_Void();
28974 return resultobj;
28975 fail:
28976 return NULL;
28977 }
28978
28979
28980 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28981 PyObject *obj;
28982 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28983 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28984 return SWIG_Py_Void();
28985 }
28986
28987 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28988 return SWIG_Python_InitShadowInstance(args);
28989 }
28990
28991 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28992 PyObject *resultobj = 0;
28993 wxWindow *arg1 = (wxWindow *) NULL ;
28994 wxWindowCreateEvent *result = 0 ;
28995 void *argp1 = 0 ;
28996 int res1 = 0 ;
28997 PyObject * obj0 = 0 ;
28998 char * kwnames[] = {
28999 (char *) "win", NULL
29000 };
29001
29002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29003 if (obj0) {
29004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29005 if (!SWIG_IsOK(res1)) {
29006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29007 }
29008 arg1 = reinterpret_cast< wxWindow * >(argp1);
29009 }
29010 {
29011 PyThreadState* __tstate = wxPyBeginAllowThreads();
29012 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29013 wxPyEndAllowThreads(__tstate);
29014 if (PyErr_Occurred()) SWIG_fail;
29015 }
29016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29017 return resultobj;
29018 fail:
29019 return NULL;
29020 }
29021
29022
29023 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29024 PyObject *resultobj = 0;
29025 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29026 wxWindow *result = 0 ;
29027 void *argp1 = 0 ;
29028 int res1 = 0 ;
29029 PyObject *swig_obj[1] ;
29030
29031 if (!args) SWIG_fail;
29032 swig_obj[0] = args;
29033 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29034 if (!SWIG_IsOK(res1)) {
29035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29036 }
29037 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29038 {
29039 PyThreadState* __tstate = wxPyBeginAllowThreads();
29040 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29041 wxPyEndAllowThreads(__tstate);
29042 if (PyErr_Occurred()) SWIG_fail;
29043 }
29044 {
29045 resultobj = wxPyMake_wxObject(result, (bool)0);
29046 }
29047 return resultobj;
29048 fail:
29049 return NULL;
29050 }
29051
29052
29053 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29054 PyObject *obj;
29055 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29056 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29057 return SWIG_Py_Void();
29058 }
29059
29060 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29061 return SWIG_Python_InitShadowInstance(args);
29062 }
29063
29064 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29065 PyObject *resultobj = 0;
29066 wxWindow *arg1 = (wxWindow *) NULL ;
29067 wxWindowDestroyEvent *result = 0 ;
29068 void *argp1 = 0 ;
29069 int res1 = 0 ;
29070 PyObject * obj0 = 0 ;
29071 char * kwnames[] = {
29072 (char *) "win", NULL
29073 };
29074
29075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29076 if (obj0) {
29077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29078 if (!SWIG_IsOK(res1)) {
29079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29080 }
29081 arg1 = reinterpret_cast< wxWindow * >(argp1);
29082 }
29083 {
29084 PyThreadState* __tstate = wxPyBeginAllowThreads();
29085 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29086 wxPyEndAllowThreads(__tstate);
29087 if (PyErr_Occurred()) SWIG_fail;
29088 }
29089 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29090 return resultobj;
29091 fail:
29092 return NULL;
29093 }
29094
29095
29096 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29097 PyObject *resultobj = 0;
29098 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29099 wxWindow *result = 0 ;
29100 void *argp1 = 0 ;
29101 int res1 = 0 ;
29102 PyObject *swig_obj[1] ;
29103
29104 if (!args) SWIG_fail;
29105 swig_obj[0] = args;
29106 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29107 if (!SWIG_IsOK(res1)) {
29108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29109 }
29110 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29111 {
29112 PyThreadState* __tstate = wxPyBeginAllowThreads();
29113 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29114 wxPyEndAllowThreads(__tstate);
29115 if (PyErr_Occurred()) SWIG_fail;
29116 }
29117 {
29118 resultobj = wxPyMake_wxObject(result, (bool)0);
29119 }
29120 return resultobj;
29121 fail:
29122 return NULL;
29123 }
29124
29125
29126 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29127 PyObject *obj;
29128 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29129 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29130 return SWIG_Py_Void();
29131 }
29132
29133 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 return SWIG_Python_InitShadowInstance(args);
29135 }
29136
29137 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29138 PyObject *resultobj = 0;
29139 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29140 int arg2 = (int) 0 ;
29141 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29142 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29143 wxContextMenuEvent *result = 0 ;
29144 int val1 ;
29145 int ecode1 = 0 ;
29146 int val2 ;
29147 int ecode2 = 0 ;
29148 wxPoint temp3 ;
29149 PyObject * obj0 = 0 ;
29150 PyObject * obj1 = 0 ;
29151 PyObject * obj2 = 0 ;
29152 char * kwnames[] = {
29153 (char *) "type",(char *) "winid",(char *) "pt", NULL
29154 };
29155
29156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29157 if (obj0) {
29158 ecode1 = SWIG_AsVal_int(obj0, &val1);
29159 if (!SWIG_IsOK(ecode1)) {
29160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29161 }
29162 arg1 = static_cast< wxEventType >(val1);
29163 }
29164 if (obj1) {
29165 ecode2 = SWIG_AsVal_int(obj1, &val2);
29166 if (!SWIG_IsOK(ecode2)) {
29167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29168 }
29169 arg2 = static_cast< int >(val2);
29170 }
29171 if (obj2) {
29172 {
29173 arg3 = &temp3;
29174 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29175 }
29176 }
29177 {
29178 PyThreadState* __tstate = wxPyBeginAllowThreads();
29179 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29180 wxPyEndAllowThreads(__tstate);
29181 if (PyErr_Occurred()) SWIG_fail;
29182 }
29183 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29184 return resultobj;
29185 fail:
29186 return NULL;
29187 }
29188
29189
29190 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29191 PyObject *resultobj = 0;
29192 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29193 wxPoint *result = 0 ;
29194 void *argp1 = 0 ;
29195 int res1 = 0 ;
29196 PyObject *swig_obj[1] ;
29197
29198 if (!args) SWIG_fail;
29199 swig_obj[0] = args;
29200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29201 if (!SWIG_IsOK(res1)) {
29202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29203 }
29204 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29205 {
29206 PyThreadState* __tstate = wxPyBeginAllowThreads();
29207 {
29208 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29209 result = (wxPoint *) &_result_ref;
29210 }
29211 wxPyEndAllowThreads(__tstate);
29212 if (PyErr_Occurred()) SWIG_fail;
29213 }
29214 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29215 return resultobj;
29216 fail:
29217 return NULL;
29218 }
29219
29220
29221 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29222 PyObject *resultobj = 0;
29223 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29224 wxPoint *arg2 = 0 ;
29225 void *argp1 = 0 ;
29226 int res1 = 0 ;
29227 wxPoint temp2 ;
29228 PyObject * obj0 = 0 ;
29229 PyObject * obj1 = 0 ;
29230 char * kwnames[] = {
29231 (char *) "self",(char *) "pos", NULL
29232 };
29233
29234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29236 if (!SWIG_IsOK(res1)) {
29237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29238 }
29239 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29240 {
29241 arg2 = &temp2;
29242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29243 }
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 (arg1)->SetPosition((wxPoint const &)*arg2);
29247 wxPyEndAllowThreads(__tstate);
29248 if (PyErr_Occurred()) SWIG_fail;
29249 }
29250 resultobj = SWIG_Py_Void();
29251 return resultobj;
29252 fail:
29253 return NULL;
29254 }
29255
29256
29257 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29258 PyObject *obj;
29259 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29260 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29261 return SWIG_Py_Void();
29262 }
29263
29264 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29265 return SWIG_Python_InitShadowInstance(args);
29266 }
29267
29268 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29269 PyObject *resultobj = 0;
29270 wxIdleEvent *result = 0 ;
29271
29272 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29273 {
29274 PyThreadState* __tstate = wxPyBeginAllowThreads();
29275 result = (wxIdleEvent *)new wxIdleEvent();
29276 wxPyEndAllowThreads(__tstate);
29277 if (PyErr_Occurred()) SWIG_fail;
29278 }
29279 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29280 return resultobj;
29281 fail:
29282 return NULL;
29283 }
29284
29285
29286 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29287 PyObject *resultobj = 0;
29288 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29289 bool arg2 = (bool) true ;
29290 void *argp1 = 0 ;
29291 int res1 = 0 ;
29292 bool val2 ;
29293 int ecode2 = 0 ;
29294 PyObject * obj0 = 0 ;
29295 PyObject * obj1 = 0 ;
29296 char * kwnames[] = {
29297 (char *) "self",(char *) "needMore", NULL
29298 };
29299
29300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29302 if (!SWIG_IsOK(res1)) {
29303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29304 }
29305 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29306 if (obj1) {
29307 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29308 if (!SWIG_IsOK(ecode2)) {
29309 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29310 }
29311 arg2 = static_cast< bool >(val2);
29312 }
29313 {
29314 PyThreadState* __tstate = wxPyBeginAllowThreads();
29315 (arg1)->RequestMore(arg2);
29316 wxPyEndAllowThreads(__tstate);
29317 if (PyErr_Occurred()) SWIG_fail;
29318 }
29319 resultobj = SWIG_Py_Void();
29320 return resultobj;
29321 fail:
29322 return NULL;
29323 }
29324
29325
29326 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29327 PyObject *resultobj = 0;
29328 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29329 bool result;
29330 void *argp1 = 0 ;
29331 int res1 = 0 ;
29332 PyObject *swig_obj[1] ;
29333
29334 if (!args) SWIG_fail;
29335 swig_obj[0] = args;
29336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29337 if (!SWIG_IsOK(res1)) {
29338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29339 }
29340 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29341 {
29342 PyThreadState* __tstate = wxPyBeginAllowThreads();
29343 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29344 wxPyEndAllowThreads(__tstate);
29345 if (PyErr_Occurred()) SWIG_fail;
29346 }
29347 {
29348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29349 }
29350 return resultobj;
29351 fail:
29352 return NULL;
29353 }
29354
29355
29356 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29357 PyObject *resultobj = 0;
29358 wxIdleMode arg1 ;
29359 int val1 ;
29360 int ecode1 = 0 ;
29361 PyObject * obj0 = 0 ;
29362 char * kwnames[] = {
29363 (char *) "mode", NULL
29364 };
29365
29366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29367 ecode1 = SWIG_AsVal_int(obj0, &val1);
29368 if (!SWIG_IsOK(ecode1)) {
29369 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29370 }
29371 arg1 = static_cast< wxIdleMode >(val1);
29372 {
29373 PyThreadState* __tstate = wxPyBeginAllowThreads();
29374 wxIdleEvent::SetMode(arg1);
29375 wxPyEndAllowThreads(__tstate);
29376 if (PyErr_Occurred()) SWIG_fail;
29377 }
29378 resultobj = SWIG_Py_Void();
29379 return resultobj;
29380 fail:
29381 return NULL;
29382 }
29383
29384
29385 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29386 PyObject *resultobj = 0;
29387 wxIdleMode result;
29388
29389 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29390 {
29391 PyThreadState* __tstate = wxPyBeginAllowThreads();
29392 result = (wxIdleMode)wxIdleEvent::GetMode();
29393 wxPyEndAllowThreads(__tstate);
29394 if (PyErr_Occurred()) SWIG_fail;
29395 }
29396 resultobj = SWIG_From_int(static_cast< int >(result));
29397 return resultobj;
29398 fail:
29399 return NULL;
29400 }
29401
29402
29403 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29404 PyObject *resultobj = 0;
29405 wxWindow *arg1 = (wxWindow *) 0 ;
29406 bool result;
29407 void *argp1 = 0 ;
29408 int res1 = 0 ;
29409 PyObject * obj0 = 0 ;
29410 char * kwnames[] = {
29411 (char *) "win", NULL
29412 };
29413
29414 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29415 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29416 if (!SWIG_IsOK(res1)) {
29417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29418 }
29419 arg1 = reinterpret_cast< wxWindow * >(argp1);
29420 {
29421 PyThreadState* __tstate = wxPyBeginAllowThreads();
29422 result = (bool)wxIdleEvent::CanSend(arg1);
29423 wxPyEndAllowThreads(__tstate);
29424 if (PyErr_Occurred()) SWIG_fail;
29425 }
29426 {
29427 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29428 }
29429 return resultobj;
29430 fail:
29431 return NULL;
29432 }
29433
29434
29435 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29436 PyObject *obj;
29437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29438 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29439 return SWIG_Py_Void();
29440 }
29441
29442 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29443 return SWIG_Python_InitShadowInstance(args);
29444 }
29445
29446 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29447 PyObject *resultobj = 0;
29448 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29449 int arg2 = (int) 0 ;
29450 wxClipboardTextEvent *result = 0 ;
29451 int val1 ;
29452 int ecode1 = 0 ;
29453 int val2 ;
29454 int ecode2 = 0 ;
29455 PyObject * obj0 = 0 ;
29456 PyObject * obj1 = 0 ;
29457 char * kwnames[] = {
29458 (char *) "type",(char *) "winid", NULL
29459 };
29460
29461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29462 if (obj0) {
29463 ecode1 = SWIG_AsVal_int(obj0, &val1);
29464 if (!SWIG_IsOK(ecode1)) {
29465 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29466 }
29467 arg1 = static_cast< wxEventType >(val1);
29468 }
29469 if (obj1) {
29470 ecode2 = SWIG_AsVal_int(obj1, &val2);
29471 if (!SWIG_IsOK(ecode2)) {
29472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29473 }
29474 arg2 = static_cast< int >(val2);
29475 }
29476 {
29477 PyThreadState* __tstate = wxPyBeginAllowThreads();
29478 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29479 wxPyEndAllowThreads(__tstate);
29480 if (PyErr_Occurred()) SWIG_fail;
29481 }
29482 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29483 return resultobj;
29484 fail:
29485 return NULL;
29486 }
29487
29488
29489 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29490 PyObject *obj;
29491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29492 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29493 return SWIG_Py_Void();
29494 }
29495
29496 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29497 return SWIG_Python_InitShadowInstance(args);
29498 }
29499
29500 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29501 PyObject *resultobj = 0;
29502 int arg1 = (int) 0 ;
29503 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29504 wxPyEvent *result = 0 ;
29505 int val1 ;
29506 int ecode1 = 0 ;
29507 int val2 ;
29508 int ecode2 = 0 ;
29509 PyObject * obj0 = 0 ;
29510 PyObject * obj1 = 0 ;
29511 char * kwnames[] = {
29512 (char *) "winid",(char *) "eventType", NULL
29513 };
29514
29515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29516 if (obj0) {
29517 ecode1 = SWIG_AsVal_int(obj0, &val1);
29518 if (!SWIG_IsOK(ecode1)) {
29519 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29520 }
29521 arg1 = static_cast< int >(val1);
29522 }
29523 if (obj1) {
29524 ecode2 = SWIG_AsVal_int(obj1, &val2);
29525 if (!SWIG_IsOK(ecode2)) {
29526 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29527 }
29528 arg2 = static_cast< wxEventType >(val2);
29529 }
29530 {
29531 PyThreadState* __tstate = wxPyBeginAllowThreads();
29532 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29533 wxPyEndAllowThreads(__tstate);
29534 if (PyErr_Occurred()) SWIG_fail;
29535 }
29536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29537 return resultobj;
29538 fail:
29539 return NULL;
29540 }
29541
29542
29543 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29544 PyObject *resultobj = 0;
29545 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29546 void *argp1 = 0 ;
29547 int res1 = 0 ;
29548 PyObject *swig_obj[1] ;
29549
29550 if (!args) SWIG_fail;
29551 swig_obj[0] = args;
29552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29553 if (!SWIG_IsOK(res1)) {
29554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29555 }
29556 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29557 {
29558 PyThreadState* __tstate = wxPyBeginAllowThreads();
29559 delete arg1;
29560
29561 wxPyEndAllowThreads(__tstate);
29562 if (PyErr_Occurred()) SWIG_fail;
29563 }
29564 resultobj = SWIG_Py_Void();
29565 return resultobj;
29566 fail:
29567 return NULL;
29568 }
29569
29570
29571 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29572 PyObject *resultobj = 0;
29573 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29574 PyObject *arg2 = (PyObject *) 0 ;
29575 void *argp1 = 0 ;
29576 int res1 = 0 ;
29577 PyObject * obj0 = 0 ;
29578 PyObject * obj1 = 0 ;
29579 char * kwnames[] = {
29580 (char *) "self",(char *) "self", NULL
29581 };
29582
29583 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29584 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29585 if (!SWIG_IsOK(res1)) {
29586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29587 }
29588 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29589 arg2 = obj1;
29590 {
29591 PyThreadState* __tstate = wxPyBeginAllowThreads();
29592 (arg1)->SetSelf(arg2);
29593 wxPyEndAllowThreads(__tstate);
29594 if (PyErr_Occurred()) SWIG_fail;
29595 }
29596 resultobj = SWIG_Py_Void();
29597 return resultobj;
29598 fail:
29599 return NULL;
29600 }
29601
29602
29603 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29604 PyObject *resultobj = 0;
29605 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29606 PyObject *result = 0 ;
29607 void *argp1 = 0 ;
29608 int res1 = 0 ;
29609 PyObject *swig_obj[1] ;
29610
29611 if (!args) SWIG_fail;
29612 swig_obj[0] = args;
29613 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29614 if (!SWIG_IsOK(res1)) {
29615 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29616 }
29617 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29618 {
29619 PyThreadState* __tstate = wxPyBeginAllowThreads();
29620 result = (PyObject *)(arg1)->GetSelf();
29621 wxPyEndAllowThreads(__tstate);
29622 if (PyErr_Occurred()) SWIG_fail;
29623 }
29624 resultobj = result;
29625 return resultobj;
29626 fail:
29627 return NULL;
29628 }
29629
29630
29631 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29632 PyObject *obj;
29633 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29634 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29635 return SWIG_Py_Void();
29636 }
29637
29638 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29639 return SWIG_Python_InitShadowInstance(args);
29640 }
29641
29642 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29643 PyObject *resultobj = 0;
29644 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29645 int arg2 = (int) 0 ;
29646 wxPyCommandEvent *result = 0 ;
29647 int val1 ;
29648 int ecode1 = 0 ;
29649 int val2 ;
29650 int ecode2 = 0 ;
29651 PyObject * obj0 = 0 ;
29652 PyObject * obj1 = 0 ;
29653 char * kwnames[] = {
29654 (char *) "eventType",(char *) "id", NULL
29655 };
29656
29657 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29658 if (obj0) {
29659 ecode1 = SWIG_AsVal_int(obj0, &val1);
29660 if (!SWIG_IsOK(ecode1)) {
29661 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29662 }
29663 arg1 = static_cast< wxEventType >(val1);
29664 }
29665 if (obj1) {
29666 ecode2 = SWIG_AsVal_int(obj1, &val2);
29667 if (!SWIG_IsOK(ecode2)) {
29668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29669 }
29670 arg2 = static_cast< int >(val2);
29671 }
29672 {
29673 PyThreadState* __tstate = wxPyBeginAllowThreads();
29674 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29675 wxPyEndAllowThreads(__tstate);
29676 if (PyErr_Occurred()) SWIG_fail;
29677 }
29678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29679 return resultobj;
29680 fail:
29681 return NULL;
29682 }
29683
29684
29685 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29686 PyObject *resultobj = 0;
29687 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29688 void *argp1 = 0 ;
29689 int res1 = 0 ;
29690 PyObject *swig_obj[1] ;
29691
29692 if (!args) SWIG_fail;
29693 swig_obj[0] = args;
29694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29695 if (!SWIG_IsOK(res1)) {
29696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29697 }
29698 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29699 {
29700 PyThreadState* __tstate = wxPyBeginAllowThreads();
29701 delete arg1;
29702
29703 wxPyEndAllowThreads(__tstate);
29704 if (PyErr_Occurred()) SWIG_fail;
29705 }
29706 resultobj = SWIG_Py_Void();
29707 return resultobj;
29708 fail:
29709 return NULL;
29710 }
29711
29712
29713 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29714 PyObject *resultobj = 0;
29715 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29716 PyObject *arg2 = (PyObject *) 0 ;
29717 void *argp1 = 0 ;
29718 int res1 = 0 ;
29719 PyObject * obj0 = 0 ;
29720 PyObject * obj1 = 0 ;
29721 char * kwnames[] = {
29722 (char *) "self",(char *) "self", NULL
29723 };
29724
29725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29727 if (!SWIG_IsOK(res1)) {
29728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29729 }
29730 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29731 arg2 = obj1;
29732 {
29733 PyThreadState* __tstate = wxPyBeginAllowThreads();
29734 (arg1)->SetSelf(arg2);
29735 wxPyEndAllowThreads(__tstate);
29736 if (PyErr_Occurred()) SWIG_fail;
29737 }
29738 resultobj = SWIG_Py_Void();
29739 return resultobj;
29740 fail:
29741 return NULL;
29742 }
29743
29744
29745 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29746 PyObject *resultobj = 0;
29747 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29748 PyObject *result = 0 ;
29749 void *argp1 = 0 ;
29750 int res1 = 0 ;
29751 PyObject *swig_obj[1] ;
29752
29753 if (!args) SWIG_fail;
29754 swig_obj[0] = args;
29755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29756 if (!SWIG_IsOK(res1)) {
29757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29758 }
29759 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29760 {
29761 PyThreadState* __tstate = wxPyBeginAllowThreads();
29762 result = (PyObject *)(arg1)->GetSelf();
29763 wxPyEndAllowThreads(__tstate);
29764 if (PyErr_Occurred()) SWIG_fail;
29765 }
29766 resultobj = result;
29767 return resultobj;
29768 fail:
29769 return NULL;
29770 }
29771
29772
29773 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29774 PyObject *obj;
29775 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29776 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29777 return SWIG_Py_Void();
29778 }
29779
29780 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29781 return SWIG_Python_InitShadowInstance(args);
29782 }
29783
29784 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29785 PyObject *resultobj = 0;
29786 wxWindow *arg1 = (wxWindow *) 0 ;
29787 wxDateTime *arg2 = 0 ;
29788 wxEventType arg3 ;
29789 wxDateEvent *result = 0 ;
29790 void *argp1 = 0 ;
29791 int res1 = 0 ;
29792 void *argp2 = 0 ;
29793 int res2 = 0 ;
29794 int val3 ;
29795 int ecode3 = 0 ;
29796 PyObject * obj0 = 0 ;
29797 PyObject * obj1 = 0 ;
29798 PyObject * obj2 = 0 ;
29799 char * kwnames[] = {
29800 (char *) "win",(char *) "dt",(char *) "type", NULL
29801 };
29802
29803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29805 if (!SWIG_IsOK(res1)) {
29806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29807 }
29808 arg1 = reinterpret_cast< wxWindow * >(argp1);
29809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29810 if (!SWIG_IsOK(res2)) {
29811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29812 }
29813 if (!argp2) {
29814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29815 }
29816 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29817 ecode3 = SWIG_AsVal_int(obj2, &val3);
29818 if (!SWIG_IsOK(ecode3)) {
29819 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29820 }
29821 arg3 = static_cast< wxEventType >(val3);
29822 {
29823 PyThreadState* __tstate = wxPyBeginAllowThreads();
29824 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29825 wxPyEndAllowThreads(__tstate);
29826 if (PyErr_Occurred()) SWIG_fail;
29827 }
29828 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29829 return resultobj;
29830 fail:
29831 return NULL;
29832 }
29833
29834
29835 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29836 PyObject *resultobj = 0;
29837 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29838 wxDateTime *result = 0 ;
29839 void *argp1 = 0 ;
29840 int res1 = 0 ;
29841 PyObject *swig_obj[1] ;
29842
29843 if (!args) SWIG_fail;
29844 swig_obj[0] = args;
29845 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29846 if (!SWIG_IsOK(res1)) {
29847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29848 }
29849 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29850 {
29851 PyThreadState* __tstate = wxPyBeginAllowThreads();
29852 {
29853 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29854 result = (wxDateTime *) &_result_ref;
29855 }
29856 wxPyEndAllowThreads(__tstate);
29857 if (PyErr_Occurred()) SWIG_fail;
29858 }
29859 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29860 return resultobj;
29861 fail:
29862 return NULL;
29863 }
29864
29865
29866 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29867 PyObject *resultobj = 0;
29868 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29869 wxDateTime *arg2 = 0 ;
29870 void *argp1 = 0 ;
29871 int res1 = 0 ;
29872 void *argp2 = 0 ;
29873 int res2 = 0 ;
29874 PyObject * obj0 = 0 ;
29875 PyObject * obj1 = 0 ;
29876 char * kwnames[] = {
29877 (char *) "self",(char *) "date", NULL
29878 };
29879
29880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29882 if (!SWIG_IsOK(res1)) {
29883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29884 }
29885 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29886 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29887 if (!SWIG_IsOK(res2)) {
29888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29889 }
29890 if (!argp2) {
29891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29892 }
29893 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29894 {
29895 PyThreadState* __tstate = wxPyBeginAllowThreads();
29896 (arg1)->SetDate((wxDateTime const &)*arg2);
29897 wxPyEndAllowThreads(__tstate);
29898 if (PyErr_Occurred()) SWIG_fail;
29899 }
29900 resultobj = SWIG_Py_Void();
29901 return resultobj;
29902 fail:
29903 return NULL;
29904 }
29905
29906
29907 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29908 PyObject *obj;
29909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29910 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29911 return SWIG_Py_Void();
29912 }
29913
29914 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29915 return SWIG_Python_InitShadowInstance(args);
29916 }
29917
29918 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29919 PyObject *resultobj = 0;
29920 wxWindow *arg1 = (wxWindow *) 0 ;
29921 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
29922 wxEventBlocker *result = 0 ;
29923 void *argp1 = 0 ;
29924 int res1 = 0 ;
29925 int val2 ;
29926 int ecode2 = 0 ;
29927 PyObject * obj0 = 0 ;
29928 PyObject * obj1 = 0 ;
29929 char * kwnames[] = {
29930 (char *) "win",(char *) "type", NULL
29931 };
29932
29933 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
29934 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29935 if (!SWIG_IsOK(res1)) {
29936 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
29937 }
29938 arg1 = reinterpret_cast< wxWindow * >(argp1);
29939 if (obj1) {
29940 ecode2 = SWIG_AsVal_int(obj1, &val2);
29941 if (!SWIG_IsOK(ecode2)) {
29942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
29943 }
29944 arg2 = static_cast< wxEventType >(val2);
29945 }
29946 {
29947 PyThreadState* __tstate = wxPyBeginAllowThreads();
29948 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
29949 wxPyEndAllowThreads(__tstate);
29950 if (PyErr_Occurred()) SWIG_fail;
29951 }
29952 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29960 PyObject *resultobj = 0;
29961 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
29962 void *argp1 = 0 ;
29963 int res1 = 0 ;
29964 PyObject *swig_obj[1] ;
29965
29966 if (!args) SWIG_fail;
29967 swig_obj[0] = args;
29968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
29969 if (!SWIG_IsOK(res1)) {
29970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
29971 }
29972 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
29973 {
29974 PyThreadState* __tstate = wxPyBeginAllowThreads();
29975 delete arg1;
29976
29977 wxPyEndAllowThreads(__tstate);
29978 if (PyErr_Occurred()) SWIG_fail;
29979 }
29980 resultobj = SWIG_Py_Void();
29981 return resultobj;
29982 fail:
29983 return NULL;
29984 }
29985
29986
29987 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29988 PyObject *resultobj = 0;
29989 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
29990 wxEventType arg2 ;
29991 void *argp1 = 0 ;
29992 int res1 = 0 ;
29993 int val2 ;
29994 int ecode2 = 0 ;
29995 PyObject * obj0 = 0 ;
29996 PyObject * obj1 = 0 ;
29997 char * kwnames[] = {
29998 (char *) "self",(char *) "type", NULL
29999 };
30000
30001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30003 if (!SWIG_IsOK(res1)) {
30004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30005 }
30006 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30007 ecode2 = SWIG_AsVal_int(obj1, &val2);
30008 if (!SWIG_IsOK(ecode2)) {
30009 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30010 }
30011 arg2 = static_cast< wxEventType >(val2);
30012 {
30013 PyThreadState* __tstate = wxPyBeginAllowThreads();
30014 (arg1)->Block(arg2);
30015 wxPyEndAllowThreads(__tstate);
30016 if (PyErr_Occurred()) SWIG_fail;
30017 }
30018 resultobj = SWIG_Py_Void();
30019 return resultobj;
30020 fail:
30021 return NULL;
30022 }
30023
30024
30025 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30026 PyObject *obj;
30027 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30028 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30029 return SWIG_Py_Void();
30030 }
30031
30032 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30033 return SWIG_Python_InitShadowInstance(args);
30034 }
30035
30036 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30037 PyObject *resultobj = 0;
30038 wxPyApp *result = 0 ;
30039
30040 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30041 {
30042 PyThreadState* __tstate = wxPyBeginAllowThreads();
30043 result = (wxPyApp *)new_wxPyApp();
30044 wxPyEndAllowThreads(__tstate);
30045 if (PyErr_Occurred()) SWIG_fail;
30046 }
30047 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30048 return resultobj;
30049 fail:
30050 return NULL;
30051 }
30052
30053
30054 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30055 PyObject *resultobj = 0;
30056 wxPyApp *arg1 = (wxPyApp *) 0 ;
30057 void *argp1 = 0 ;
30058 int res1 = 0 ;
30059 PyObject *swig_obj[1] ;
30060
30061 if (!args) SWIG_fail;
30062 swig_obj[0] = args;
30063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30064 if (!SWIG_IsOK(res1)) {
30065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30066 }
30067 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30068 {
30069 PyThreadState* __tstate = wxPyBeginAllowThreads();
30070 delete arg1;
30071
30072 wxPyEndAllowThreads(__tstate);
30073 if (PyErr_Occurred()) SWIG_fail;
30074 }
30075 resultobj = SWIG_Py_Void();
30076 return resultobj;
30077 fail:
30078 return NULL;
30079 }
30080
30081
30082 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30083 PyObject *resultobj = 0;
30084 wxPyApp *arg1 = (wxPyApp *) 0 ;
30085 PyObject *arg2 = (PyObject *) 0 ;
30086 PyObject *arg3 = (PyObject *) 0 ;
30087 bool arg4 = (bool) false ;
30088 void *argp1 = 0 ;
30089 int res1 = 0 ;
30090 bool val4 ;
30091 int ecode4 = 0 ;
30092 PyObject * obj0 = 0 ;
30093 PyObject * obj1 = 0 ;
30094 PyObject * obj2 = 0 ;
30095 PyObject * obj3 = 0 ;
30096 char * kwnames[] = {
30097 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30098 };
30099
30100 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30101 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30102 if (!SWIG_IsOK(res1)) {
30103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30104 }
30105 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30106 arg2 = obj1;
30107 arg3 = obj2;
30108 if (obj3) {
30109 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30110 if (!SWIG_IsOK(ecode4)) {
30111 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30112 }
30113 arg4 = static_cast< bool >(val4);
30114 }
30115 {
30116 PyThreadState* __tstate = wxPyBeginAllowThreads();
30117 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30118 wxPyEndAllowThreads(__tstate);
30119 if (PyErr_Occurred()) SWIG_fail;
30120 }
30121 resultobj = SWIG_Py_Void();
30122 return resultobj;
30123 fail:
30124 return NULL;
30125 }
30126
30127
30128 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30129 PyObject *resultobj = 0;
30130 wxPyApp *arg1 = (wxPyApp *) 0 ;
30131 wxString result;
30132 void *argp1 = 0 ;
30133 int res1 = 0 ;
30134 PyObject *swig_obj[1] ;
30135
30136 if (!args) SWIG_fail;
30137 swig_obj[0] = args;
30138 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30139 if (!SWIG_IsOK(res1)) {
30140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30141 }
30142 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30143 {
30144 PyThreadState* __tstate = wxPyBeginAllowThreads();
30145 result = ((wxPyApp const *)arg1)->GetAppName();
30146 wxPyEndAllowThreads(__tstate);
30147 if (PyErr_Occurred()) SWIG_fail;
30148 }
30149 {
30150 #if wxUSE_UNICODE
30151 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30152 #else
30153 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30154 #endif
30155 }
30156 return resultobj;
30157 fail:
30158 return NULL;
30159 }
30160
30161
30162 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30163 PyObject *resultobj = 0;
30164 wxPyApp *arg1 = (wxPyApp *) 0 ;
30165 wxString *arg2 = 0 ;
30166 void *argp1 = 0 ;
30167 int res1 = 0 ;
30168 bool temp2 = false ;
30169 PyObject * obj0 = 0 ;
30170 PyObject * obj1 = 0 ;
30171 char * kwnames[] = {
30172 (char *) "self",(char *) "name", NULL
30173 };
30174
30175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30177 if (!SWIG_IsOK(res1)) {
30178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30179 }
30180 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30181 {
30182 arg2 = wxString_in_helper(obj1);
30183 if (arg2 == NULL) SWIG_fail;
30184 temp2 = true;
30185 }
30186 {
30187 PyThreadState* __tstate = wxPyBeginAllowThreads();
30188 (arg1)->SetAppName((wxString const &)*arg2);
30189 wxPyEndAllowThreads(__tstate);
30190 if (PyErr_Occurred()) SWIG_fail;
30191 }
30192 resultobj = SWIG_Py_Void();
30193 {
30194 if (temp2)
30195 delete arg2;
30196 }
30197 return resultobj;
30198 fail:
30199 {
30200 if (temp2)
30201 delete arg2;
30202 }
30203 return NULL;
30204 }
30205
30206
30207 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30208 PyObject *resultobj = 0;
30209 wxPyApp *arg1 = (wxPyApp *) 0 ;
30210 wxString result;
30211 void *argp1 = 0 ;
30212 int res1 = 0 ;
30213 PyObject *swig_obj[1] ;
30214
30215 if (!args) SWIG_fail;
30216 swig_obj[0] = args;
30217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30218 if (!SWIG_IsOK(res1)) {
30219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30220 }
30221 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30222 {
30223 PyThreadState* __tstate = wxPyBeginAllowThreads();
30224 result = ((wxPyApp const *)arg1)->GetClassName();
30225 wxPyEndAllowThreads(__tstate);
30226 if (PyErr_Occurred()) SWIG_fail;
30227 }
30228 {
30229 #if wxUSE_UNICODE
30230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30231 #else
30232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30233 #endif
30234 }
30235 return resultobj;
30236 fail:
30237 return NULL;
30238 }
30239
30240
30241 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30242 PyObject *resultobj = 0;
30243 wxPyApp *arg1 = (wxPyApp *) 0 ;
30244 wxString *arg2 = 0 ;
30245 void *argp1 = 0 ;
30246 int res1 = 0 ;
30247 bool temp2 = false ;
30248 PyObject * obj0 = 0 ;
30249 PyObject * obj1 = 0 ;
30250 char * kwnames[] = {
30251 (char *) "self",(char *) "name", NULL
30252 };
30253
30254 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30255 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30256 if (!SWIG_IsOK(res1)) {
30257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30258 }
30259 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30260 {
30261 arg2 = wxString_in_helper(obj1);
30262 if (arg2 == NULL) SWIG_fail;
30263 temp2 = true;
30264 }
30265 {
30266 PyThreadState* __tstate = wxPyBeginAllowThreads();
30267 (arg1)->SetClassName((wxString const &)*arg2);
30268 wxPyEndAllowThreads(__tstate);
30269 if (PyErr_Occurred()) SWIG_fail;
30270 }
30271 resultobj = SWIG_Py_Void();
30272 {
30273 if (temp2)
30274 delete arg2;
30275 }
30276 return resultobj;
30277 fail:
30278 {
30279 if (temp2)
30280 delete arg2;
30281 }
30282 return NULL;
30283 }
30284
30285
30286 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30287 PyObject *resultobj = 0;
30288 wxPyApp *arg1 = (wxPyApp *) 0 ;
30289 wxString *result = 0 ;
30290 void *argp1 = 0 ;
30291 int res1 = 0 ;
30292 PyObject *swig_obj[1] ;
30293
30294 if (!args) SWIG_fail;
30295 swig_obj[0] = args;
30296 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30297 if (!SWIG_IsOK(res1)) {
30298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30299 }
30300 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30301 {
30302 PyThreadState* __tstate = wxPyBeginAllowThreads();
30303 {
30304 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30305 result = (wxString *) &_result_ref;
30306 }
30307 wxPyEndAllowThreads(__tstate);
30308 if (PyErr_Occurred()) SWIG_fail;
30309 }
30310 {
30311 #if wxUSE_UNICODE
30312 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30313 #else
30314 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30315 #endif
30316 }
30317 return resultobj;
30318 fail:
30319 return NULL;
30320 }
30321
30322
30323 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30324 PyObject *resultobj = 0;
30325 wxPyApp *arg1 = (wxPyApp *) 0 ;
30326 wxString *arg2 = 0 ;
30327 void *argp1 = 0 ;
30328 int res1 = 0 ;
30329 bool temp2 = false ;
30330 PyObject * obj0 = 0 ;
30331 PyObject * obj1 = 0 ;
30332 char * kwnames[] = {
30333 (char *) "self",(char *) "name", NULL
30334 };
30335
30336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30338 if (!SWIG_IsOK(res1)) {
30339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30340 }
30341 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30342 {
30343 arg2 = wxString_in_helper(obj1);
30344 if (arg2 == NULL) SWIG_fail;
30345 temp2 = true;
30346 }
30347 {
30348 PyThreadState* __tstate = wxPyBeginAllowThreads();
30349 (arg1)->SetVendorName((wxString const &)*arg2);
30350 wxPyEndAllowThreads(__tstate);
30351 if (PyErr_Occurred()) SWIG_fail;
30352 }
30353 resultobj = SWIG_Py_Void();
30354 {
30355 if (temp2)
30356 delete arg2;
30357 }
30358 return resultobj;
30359 fail:
30360 {
30361 if (temp2)
30362 delete arg2;
30363 }
30364 return NULL;
30365 }
30366
30367
30368 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30369 PyObject *resultobj = 0;
30370 wxPyApp *arg1 = (wxPyApp *) 0 ;
30371 wxAppTraits *result = 0 ;
30372 void *argp1 = 0 ;
30373 int res1 = 0 ;
30374 PyObject *swig_obj[1] ;
30375
30376 if (!args) SWIG_fail;
30377 swig_obj[0] = args;
30378 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30379 if (!SWIG_IsOK(res1)) {
30380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30381 }
30382 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30383 {
30384 PyThreadState* __tstate = wxPyBeginAllowThreads();
30385 result = (wxAppTraits *)(arg1)->GetTraits();
30386 wxPyEndAllowThreads(__tstate);
30387 if (PyErr_Occurred()) SWIG_fail;
30388 }
30389 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30390 return resultobj;
30391 fail:
30392 return NULL;
30393 }
30394
30395
30396 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30397 PyObject *resultobj = 0;
30398 wxPyApp *arg1 = (wxPyApp *) 0 ;
30399 void *argp1 = 0 ;
30400 int res1 = 0 ;
30401 PyObject *swig_obj[1] ;
30402
30403 if (!args) SWIG_fail;
30404 swig_obj[0] = args;
30405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30406 if (!SWIG_IsOK(res1)) {
30407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30408 }
30409 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30410 {
30411 PyThreadState* __tstate = wxPyBeginAllowThreads();
30412 (arg1)->ProcessPendingEvents();
30413 wxPyEndAllowThreads(__tstate);
30414 if (PyErr_Occurred()) SWIG_fail;
30415 }
30416 resultobj = SWIG_Py_Void();
30417 return resultobj;
30418 fail:
30419 return NULL;
30420 }
30421
30422
30423 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30424 PyObject *resultobj = 0;
30425 wxPyApp *arg1 = (wxPyApp *) 0 ;
30426 bool arg2 = (bool) false ;
30427 bool result;
30428 void *argp1 = 0 ;
30429 int res1 = 0 ;
30430 bool val2 ;
30431 int ecode2 = 0 ;
30432 PyObject * obj0 = 0 ;
30433 PyObject * obj1 = 0 ;
30434 char * kwnames[] = {
30435 (char *) "self",(char *) "onlyIfNeeded", NULL
30436 };
30437
30438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30440 if (!SWIG_IsOK(res1)) {
30441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30442 }
30443 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30444 if (obj1) {
30445 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30446 if (!SWIG_IsOK(ecode2)) {
30447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30448 }
30449 arg2 = static_cast< bool >(val2);
30450 }
30451 {
30452 PyThreadState* __tstate = wxPyBeginAllowThreads();
30453 result = (bool)(arg1)->Yield(arg2);
30454 wxPyEndAllowThreads(__tstate);
30455 if (PyErr_Occurred()) SWIG_fail;
30456 }
30457 {
30458 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30459 }
30460 return resultobj;
30461 fail:
30462 return NULL;
30463 }
30464
30465
30466 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30467 PyObject *resultobj = 0;
30468 wxPyApp *arg1 = (wxPyApp *) 0 ;
30469 void *argp1 = 0 ;
30470 int res1 = 0 ;
30471 PyObject *swig_obj[1] ;
30472
30473 if (!args) SWIG_fail;
30474 swig_obj[0] = args;
30475 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30476 if (!SWIG_IsOK(res1)) {
30477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30478 }
30479 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30480 {
30481 PyThreadState* __tstate = wxPyBeginAllowThreads();
30482 (arg1)->WakeUpIdle();
30483 wxPyEndAllowThreads(__tstate);
30484 if (PyErr_Occurred()) SWIG_fail;
30485 }
30486 resultobj = SWIG_Py_Void();
30487 return resultobj;
30488 fail:
30489 return NULL;
30490 }
30491
30492
30493 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30494 PyObject *resultobj = 0;
30495 bool result;
30496
30497 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30498 {
30499 PyThreadState* __tstate = wxPyBeginAllowThreads();
30500 result = (bool)wxPyApp::IsMainLoopRunning();
30501 wxPyEndAllowThreads(__tstate);
30502 if (PyErr_Occurred()) SWIG_fail;
30503 }
30504 {
30505 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30506 }
30507 return resultobj;
30508 fail:
30509 return NULL;
30510 }
30511
30512
30513 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30514 PyObject *resultobj = 0;
30515 wxPyApp *arg1 = (wxPyApp *) 0 ;
30516 int result;
30517 void *argp1 = 0 ;
30518 int res1 = 0 ;
30519 PyObject *swig_obj[1] ;
30520
30521 if (!args) SWIG_fail;
30522 swig_obj[0] = args;
30523 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30524 if (!SWIG_IsOK(res1)) {
30525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30526 }
30527 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30528 {
30529 PyThreadState* __tstate = wxPyBeginAllowThreads();
30530 result = (int)(arg1)->MainLoop();
30531 wxPyEndAllowThreads(__tstate);
30532 if (PyErr_Occurred()) SWIG_fail;
30533 }
30534 resultobj = SWIG_From_int(static_cast< int >(result));
30535 return resultobj;
30536 fail:
30537 return NULL;
30538 }
30539
30540
30541 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30542 PyObject *resultobj = 0;
30543 wxPyApp *arg1 = (wxPyApp *) 0 ;
30544 void *argp1 = 0 ;
30545 int res1 = 0 ;
30546 PyObject *swig_obj[1] ;
30547
30548 if (!args) SWIG_fail;
30549 swig_obj[0] = args;
30550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30551 if (!SWIG_IsOK(res1)) {
30552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30553 }
30554 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30555 {
30556 PyThreadState* __tstate = wxPyBeginAllowThreads();
30557 (arg1)->Exit();
30558 wxPyEndAllowThreads(__tstate);
30559 if (PyErr_Occurred()) SWIG_fail;
30560 }
30561 resultobj = SWIG_Py_Void();
30562 return resultobj;
30563 fail:
30564 return NULL;
30565 }
30566
30567
30568 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30569 PyObject *resultobj = 0;
30570 wxPyApp *arg1 = (wxPyApp *) 0 ;
30571 wxLayoutDirection result;
30572 void *argp1 = 0 ;
30573 int res1 = 0 ;
30574 PyObject *swig_obj[1] ;
30575
30576 if (!args) SWIG_fail;
30577 swig_obj[0] = args;
30578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30579 if (!SWIG_IsOK(res1)) {
30580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30581 }
30582 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30583 {
30584 PyThreadState* __tstate = wxPyBeginAllowThreads();
30585 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30586 wxPyEndAllowThreads(__tstate);
30587 if (PyErr_Occurred()) SWIG_fail;
30588 }
30589 resultobj = SWIG_From_int(static_cast< int >(result));
30590 return resultobj;
30591 fail:
30592 return NULL;
30593 }
30594
30595
30596 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30597 PyObject *resultobj = 0;
30598 wxPyApp *arg1 = (wxPyApp *) 0 ;
30599 void *argp1 = 0 ;
30600 int res1 = 0 ;
30601 PyObject *swig_obj[1] ;
30602
30603 if (!args) SWIG_fail;
30604 swig_obj[0] = args;
30605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30606 if (!SWIG_IsOK(res1)) {
30607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30608 }
30609 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30610 {
30611 PyThreadState* __tstate = wxPyBeginAllowThreads();
30612 (arg1)->ExitMainLoop();
30613 wxPyEndAllowThreads(__tstate);
30614 if (PyErr_Occurred()) SWIG_fail;
30615 }
30616 resultobj = SWIG_Py_Void();
30617 return resultobj;
30618 fail:
30619 return NULL;
30620 }
30621
30622
30623 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30624 PyObject *resultobj = 0;
30625 wxPyApp *arg1 = (wxPyApp *) 0 ;
30626 bool result;
30627 void *argp1 = 0 ;
30628 int res1 = 0 ;
30629 PyObject *swig_obj[1] ;
30630
30631 if (!args) SWIG_fail;
30632 swig_obj[0] = args;
30633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30634 if (!SWIG_IsOK(res1)) {
30635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30636 }
30637 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30638 {
30639 PyThreadState* __tstate = wxPyBeginAllowThreads();
30640 result = (bool)(arg1)->Pending();
30641 wxPyEndAllowThreads(__tstate);
30642 if (PyErr_Occurred()) SWIG_fail;
30643 }
30644 {
30645 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30646 }
30647 return resultobj;
30648 fail:
30649 return NULL;
30650 }
30651
30652
30653 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30654 PyObject *resultobj = 0;
30655 wxPyApp *arg1 = (wxPyApp *) 0 ;
30656 bool result;
30657 void *argp1 = 0 ;
30658 int res1 = 0 ;
30659 PyObject *swig_obj[1] ;
30660
30661 if (!args) SWIG_fail;
30662 swig_obj[0] = args;
30663 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30664 if (!SWIG_IsOK(res1)) {
30665 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30666 }
30667 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30668 {
30669 PyThreadState* __tstate = wxPyBeginAllowThreads();
30670 result = (bool)(arg1)->Dispatch();
30671 wxPyEndAllowThreads(__tstate);
30672 if (PyErr_Occurred()) SWIG_fail;
30673 }
30674 {
30675 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30676 }
30677 return resultobj;
30678 fail:
30679 return NULL;
30680 }
30681
30682
30683 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30684 PyObject *resultobj = 0;
30685 wxPyApp *arg1 = (wxPyApp *) 0 ;
30686 bool result;
30687 void *argp1 = 0 ;
30688 int res1 = 0 ;
30689 PyObject *swig_obj[1] ;
30690
30691 if (!args) SWIG_fail;
30692 swig_obj[0] = args;
30693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30694 if (!SWIG_IsOK(res1)) {
30695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30696 }
30697 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30698 {
30699 PyThreadState* __tstate = wxPyBeginAllowThreads();
30700 result = (bool)(arg1)->ProcessIdle();
30701 wxPyEndAllowThreads(__tstate);
30702 if (PyErr_Occurred()) SWIG_fail;
30703 }
30704 {
30705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30706 }
30707 return resultobj;
30708 fail:
30709 return NULL;
30710 }
30711
30712
30713 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30714 PyObject *resultobj = 0;
30715 wxPyApp *arg1 = (wxPyApp *) 0 ;
30716 wxWindow *arg2 = (wxWindow *) 0 ;
30717 wxIdleEvent *arg3 = 0 ;
30718 bool result;
30719 void *argp1 = 0 ;
30720 int res1 = 0 ;
30721 void *argp2 = 0 ;
30722 int res2 = 0 ;
30723 void *argp3 = 0 ;
30724 int res3 = 0 ;
30725 PyObject * obj0 = 0 ;
30726 PyObject * obj1 = 0 ;
30727 PyObject * obj2 = 0 ;
30728 char * kwnames[] = {
30729 (char *) "self",(char *) "win",(char *) "event", NULL
30730 };
30731
30732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30734 if (!SWIG_IsOK(res1)) {
30735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30736 }
30737 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30738 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30739 if (!SWIG_IsOK(res2)) {
30740 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30741 }
30742 arg2 = reinterpret_cast< wxWindow * >(argp2);
30743 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30744 if (!SWIG_IsOK(res3)) {
30745 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30746 }
30747 if (!argp3) {
30748 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30749 }
30750 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30751 {
30752 PyThreadState* __tstate = wxPyBeginAllowThreads();
30753 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30754 wxPyEndAllowThreads(__tstate);
30755 if (PyErr_Occurred()) SWIG_fail;
30756 }
30757 {
30758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30759 }
30760 return resultobj;
30761 fail:
30762 return NULL;
30763 }
30764
30765
30766 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30767 PyObject *resultobj = 0;
30768 wxPyApp *arg1 = (wxPyApp *) 0 ;
30769 bool result;
30770 void *argp1 = 0 ;
30771 int res1 = 0 ;
30772 PyObject *swig_obj[1] ;
30773
30774 if (!args) SWIG_fail;
30775 swig_obj[0] = args;
30776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30777 if (!SWIG_IsOK(res1)) {
30778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30779 }
30780 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30781 {
30782 PyThreadState* __tstate = wxPyBeginAllowThreads();
30783 result = (bool)((wxPyApp const *)arg1)->IsActive();
30784 wxPyEndAllowThreads(__tstate);
30785 if (PyErr_Occurred()) SWIG_fail;
30786 }
30787 {
30788 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30789 }
30790 return resultobj;
30791 fail:
30792 return NULL;
30793 }
30794
30795
30796 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30797 PyObject *resultobj = 0;
30798 wxPyApp *arg1 = (wxPyApp *) 0 ;
30799 wxWindow *arg2 = (wxWindow *) 0 ;
30800 void *argp1 = 0 ;
30801 int res1 = 0 ;
30802 void *argp2 = 0 ;
30803 int res2 = 0 ;
30804 PyObject * obj0 = 0 ;
30805 PyObject * obj1 = 0 ;
30806 char * kwnames[] = {
30807 (char *) "self",(char *) "win", NULL
30808 };
30809
30810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30812 if (!SWIG_IsOK(res1)) {
30813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30814 }
30815 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30816 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30817 if (!SWIG_IsOK(res2)) {
30818 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30819 }
30820 arg2 = reinterpret_cast< wxWindow * >(argp2);
30821 {
30822 PyThreadState* __tstate = wxPyBeginAllowThreads();
30823 (arg1)->SetTopWindow(arg2);
30824 wxPyEndAllowThreads(__tstate);
30825 if (PyErr_Occurred()) SWIG_fail;
30826 }
30827 resultobj = SWIG_Py_Void();
30828 return resultobj;
30829 fail:
30830 return NULL;
30831 }
30832
30833
30834 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30835 PyObject *resultobj = 0;
30836 wxPyApp *arg1 = (wxPyApp *) 0 ;
30837 wxWindow *result = 0 ;
30838 void *argp1 = 0 ;
30839 int res1 = 0 ;
30840 PyObject *swig_obj[1] ;
30841
30842 if (!args) SWIG_fail;
30843 swig_obj[0] = args;
30844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30845 if (!SWIG_IsOK(res1)) {
30846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30847 }
30848 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30849 {
30850 PyThreadState* __tstate = wxPyBeginAllowThreads();
30851 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30852 wxPyEndAllowThreads(__tstate);
30853 if (PyErr_Occurred()) SWIG_fail;
30854 }
30855 {
30856 resultobj = wxPyMake_wxObject(result, (bool)0);
30857 }
30858 return resultobj;
30859 fail:
30860 return NULL;
30861 }
30862
30863
30864 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30865 PyObject *resultobj = 0;
30866 wxPyApp *arg1 = (wxPyApp *) 0 ;
30867 bool arg2 ;
30868 void *argp1 = 0 ;
30869 int res1 = 0 ;
30870 bool val2 ;
30871 int ecode2 = 0 ;
30872 PyObject * obj0 = 0 ;
30873 PyObject * obj1 = 0 ;
30874 char * kwnames[] = {
30875 (char *) "self",(char *) "flag", NULL
30876 };
30877
30878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30880 if (!SWIG_IsOK(res1)) {
30881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30882 }
30883 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30884 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30885 if (!SWIG_IsOK(ecode2)) {
30886 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30887 }
30888 arg2 = static_cast< bool >(val2);
30889 {
30890 PyThreadState* __tstate = wxPyBeginAllowThreads();
30891 (arg1)->SetExitOnFrameDelete(arg2);
30892 wxPyEndAllowThreads(__tstate);
30893 if (PyErr_Occurred()) SWIG_fail;
30894 }
30895 resultobj = SWIG_Py_Void();
30896 return resultobj;
30897 fail:
30898 return NULL;
30899 }
30900
30901
30902 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30903 PyObject *resultobj = 0;
30904 wxPyApp *arg1 = (wxPyApp *) 0 ;
30905 bool result;
30906 void *argp1 = 0 ;
30907 int res1 = 0 ;
30908 PyObject *swig_obj[1] ;
30909
30910 if (!args) SWIG_fail;
30911 swig_obj[0] = args;
30912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30913 if (!SWIG_IsOK(res1)) {
30914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30915 }
30916 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30917 {
30918 PyThreadState* __tstate = wxPyBeginAllowThreads();
30919 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30920 wxPyEndAllowThreads(__tstate);
30921 if (PyErr_Occurred()) SWIG_fail;
30922 }
30923 {
30924 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30925 }
30926 return resultobj;
30927 fail:
30928 return NULL;
30929 }
30930
30931
30932 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30933 PyObject *resultobj = 0;
30934 wxPyApp *arg1 = (wxPyApp *) 0 ;
30935 bool arg2 ;
30936 bool arg3 = (bool) false ;
30937 void *argp1 = 0 ;
30938 int res1 = 0 ;
30939 bool val2 ;
30940 int ecode2 = 0 ;
30941 bool val3 ;
30942 int ecode3 = 0 ;
30943 PyObject * obj0 = 0 ;
30944 PyObject * obj1 = 0 ;
30945 PyObject * obj2 = 0 ;
30946 char * kwnames[] = {
30947 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
30948 };
30949
30950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30952 if (!SWIG_IsOK(res1)) {
30953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30954 }
30955 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30956 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30957 if (!SWIG_IsOK(ecode2)) {
30958 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30959 }
30960 arg2 = static_cast< bool >(val2);
30961 if (obj2) {
30962 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30963 if (!SWIG_IsOK(ecode3)) {
30964 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30965 }
30966 arg3 = static_cast< bool >(val3);
30967 }
30968 {
30969 PyThreadState* __tstate = wxPyBeginAllowThreads();
30970 (arg1)->SetUseBestVisual(arg2,arg3);
30971 wxPyEndAllowThreads(__tstate);
30972 if (PyErr_Occurred()) SWIG_fail;
30973 }
30974 resultobj = SWIG_Py_Void();
30975 return resultobj;
30976 fail:
30977 return NULL;
30978 }
30979
30980
30981 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30982 PyObject *resultobj = 0;
30983 wxPyApp *arg1 = (wxPyApp *) 0 ;
30984 bool result;
30985 void *argp1 = 0 ;
30986 int res1 = 0 ;
30987 PyObject *swig_obj[1] ;
30988
30989 if (!args) SWIG_fail;
30990 swig_obj[0] = args;
30991 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30992 if (!SWIG_IsOK(res1)) {
30993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30994 }
30995 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30996 {
30997 PyThreadState* __tstate = wxPyBeginAllowThreads();
30998 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
30999 wxPyEndAllowThreads(__tstate);
31000 if (PyErr_Occurred()) SWIG_fail;
31001 }
31002 {
31003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31004 }
31005 return resultobj;
31006 fail:
31007 return NULL;
31008 }
31009
31010
31011 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31012 PyObject *resultobj = 0;
31013 wxPyApp *arg1 = (wxPyApp *) 0 ;
31014 int arg2 ;
31015 void *argp1 = 0 ;
31016 int res1 = 0 ;
31017 int val2 ;
31018 int ecode2 = 0 ;
31019 PyObject * obj0 = 0 ;
31020 PyObject * obj1 = 0 ;
31021 char * kwnames[] = {
31022 (char *) "self",(char *) "mode", NULL
31023 };
31024
31025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31027 if (!SWIG_IsOK(res1)) {
31028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31029 }
31030 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31031 ecode2 = SWIG_AsVal_int(obj1, &val2);
31032 if (!SWIG_IsOK(ecode2)) {
31033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31034 }
31035 arg2 = static_cast< int >(val2);
31036 {
31037 PyThreadState* __tstate = wxPyBeginAllowThreads();
31038 (arg1)->SetPrintMode(arg2);
31039 wxPyEndAllowThreads(__tstate);
31040 if (PyErr_Occurred()) SWIG_fail;
31041 }
31042 resultobj = SWIG_Py_Void();
31043 return resultobj;
31044 fail:
31045 return NULL;
31046 }
31047
31048
31049 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31050 PyObject *resultobj = 0;
31051 wxPyApp *arg1 = (wxPyApp *) 0 ;
31052 int result;
31053 void *argp1 = 0 ;
31054 int res1 = 0 ;
31055 PyObject *swig_obj[1] ;
31056
31057 if (!args) SWIG_fail;
31058 swig_obj[0] = args;
31059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31060 if (!SWIG_IsOK(res1)) {
31061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31062 }
31063 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31064 {
31065 PyThreadState* __tstate = wxPyBeginAllowThreads();
31066 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31067 wxPyEndAllowThreads(__tstate);
31068 if (PyErr_Occurred()) SWIG_fail;
31069 }
31070 resultobj = SWIG_From_int(static_cast< int >(result));
31071 return resultobj;
31072 fail:
31073 return NULL;
31074 }
31075
31076
31077 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31078 PyObject *resultobj = 0;
31079 wxPyApp *arg1 = (wxPyApp *) 0 ;
31080 int arg2 ;
31081 void *argp1 = 0 ;
31082 int res1 = 0 ;
31083 int val2 ;
31084 int ecode2 = 0 ;
31085 PyObject * obj0 = 0 ;
31086 PyObject * obj1 = 0 ;
31087 char * kwnames[] = {
31088 (char *) "self",(char *) "mode", NULL
31089 };
31090
31091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31093 if (!SWIG_IsOK(res1)) {
31094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31095 }
31096 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31097 ecode2 = SWIG_AsVal_int(obj1, &val2);
31098 if (!SWIG_IsOK(ecode2)) {
31099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31100 }
31101 arg2 = static_cast< int >(val2);
31102 {
31103 PyThreadState* __tstate = wxPyBeginAllowThreads();
31104 (arg1)->SetAssertMode(arg2);
31105 wxPyEndAllowThreads(__tstate);
31106 if (PyErr_Occurred()) SWIG_fail;
31107 }
31108 resultobj = SWIG_Py_Void();
31109 return resultobj;
31110 fail:
31111 return NULL;
31112 }
31113
31114
31115 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31116 PyObject *resultobj = 0;
31117 wxPyApp *arg1 = (wxPyApp *) 0 ;
31118 int result;
31119 void *argp1 = 0 ;
31120 int res1 = 0 ;
31121 PyObject *swig_obj[1] ;
31122
31123 if (!args) SWIG_fail;
31124 swig_obj[0] = args;
31125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31126 if (!SWIG_IsOK(res1)) {
31127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31128 }
31129 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31130 {
31131 PyThreadState* __tstate = wxPyBeginAllowThreads();
31132 result = (int)(arg1)->GetAssertMode();
31133 wxPyEndAllowThreads(__tstate);
31134 if (PyErr_Occurred()) SWIG_fail;
31135 }
31136 resultobj = SWIG_From_int(static_cast< int >(result));
31137 return resultobj;
31138 fail:
31139 return NULL;
31140 }
31141
31142
31143 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31144 PyObject *resultobj = 0;
31145 bool result;
31146
31147 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31148 {
31149 PyThreadState* __tstate = wxPyBeginAllowThreads();
31150 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31151 wxPyEndAllowThreads(__tstate);
31152 if (PyErr_Occurred()) SWIG_fail;
31153 }
31154 {
31155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31156 }
31157 return resultobj;
31158 fail:
31159 return NULL;
31160 }
31161
31162
31163 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31164 PyObject *resultobj = 0;
31165 long result;
31166
31167 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31168 {
31169 PyThreadState* __tstate = wxPyBeginAllowThreads();
31170 result = (long)wxPyApp::GetMacAboutMenuItemId();
31171 wxPyEndAllowThreads(__tstate);
31172 if (PyErr_Occurred()) SWIG_fail;
31173 }
31174 resultobj = SWIG_From_long(static_cast< long >(result));
31175 return resultobj;
31176 fail:
31177 return NULL;
31178 }
31179
31180
31181 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31182 PyObject *resultobj = 0;
31183 long result;
31184
31185 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31186 {
31187 PyThreadState* __tstate = wxPyBeginAllowThreads();
31188 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31189 wxPyEndAllowThreads(__tstate);
31190 if (PyErr_Occurred()) SWIG_fail;
31191 }
31192 resultobj = SWIG_From_long(static_cast< long >(result));
31193 return resultobj;
31194 fail:
31195 return NULL;
31196 }
31197
31198
31199 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31200 PyObject *resultobj = 0;
31201 long result;
31202
31203 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31204 {
31205 PyThreadState* __tstate = wxPyBeginAllowThreads();
31206 result = (long)wxPyApp::GetMacExitMenuItemId();
31207 wxPyEndAllowThreads(__tstate);
31208 if (PyErr_Occurred()) SWIG_fail;
31209 }
31210 resultobj = SWIG_From_long(static_cast< long >(result));
31211 return resultobj;
31212 fail:
31213 return NULL;
31214 }
31215
31216
31217 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31218 PyObject *resultobj = 0;
31219 wxString result;
31220
31221 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31222 {
31223 PyThreadState* __tstate = wxPyBeginAllowThreads();
31224 result = wxPyApp::GetMacHelpMenuTitleName();
31225 wxPyEndAllowThreads(__tstate);
31226 if (PyErr_Occurred()) SWIG_fail;
31227 }
31228 {
31229 #if wxUSE_UNICODE
31230 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31231 #else
31232 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31233 #endif
31234 }
31235 return resultobj;
31236 fail:
31237 return NULL;
31238 }
31239
31240
31241 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31242 PyObject *resultobj = 0;
31243 bool arg1 ;
31244 bool val1 ;
31245 int ecode1 = 0 ;
31246 PyObject * obj0 = 0 ;
31247 char * kwnames[] = {
31248 (char *) "val", NULL
31249 };
31250
31251 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31252 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31253 if (!SWIG_IsOK(ecode1)) {
31254 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31255 }
31256 arg1 = static_cast< bool >(val1);
31257 {
31258 PyThreadState* __tstate = wxPyBeginAllowThreads();
31259 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31260 wxPyEndAllowThreads(__tstate);
31261 if (PyErr_Occurred()) SWIG_fail;
31262 }
31263 resultobj = SWIG_Py_Void();
31264 return resultobj;
31265 fail:
31266 return NULL;
31267 }
31268
31269
31270 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31271 PyObject *resultobj = 0;
31272 long arg1 ;
31273 long val1 ;
31274 int ecode1 = 0 ;
31275 PyObject * obj0 = 0 ;
31276 char * kwnames[] = {
31277 (char *) "val", NULL
31278 };
31279
31280 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31281 ecode1 = SWIG_AsVal_long(obj0, &val1);
31282 if (!SWIG_IsOK(ecode1)) {
31283 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31284 }
31285 arg1 = static_cast< long >(val1);
31286 {
31287 PyThreadState* __tstate = wxPyBeginAllowThreads();
31288 wxPyApp::SetMacAboutMenuItemId(arg1);
31289 wxPyEndAllowThreads(__tstate);
31290 if (PyErr_Occurred()) SWIG_fail;
31291 }
31292 resultobj = SWIG_Py_Void();
31293 return resultobj;
31294 fail:
31295 return NULL;
31296 }
31297
31298
31299 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31300 PyObject *resultobj = 0;
31301 long arg1 ;
31302 long val1 ;
31303 int ecode1 = 0 ;
31304 PyObject * obj0 = 0 ;
31305 char * kwnames[] = {
31306 (char *) "val", NULL
31307 };
31308
31309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31310 ecode1 = SWIG_AsVal_long(obj0, &val1);
31311 if (!SWIG_IsOK(ecode1)) {
31312 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31313 }
31314 arg1 = static_cast< long >(val1);
31315 {
31316 PyThreadState* __tstate = wxPyBeginAllowThreads();
31317 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31318 wxPyEndAllowThreads(__tstate);
31319 if (PyErr_Occurred()) SWIG_fail;
31320 }
31321 resultobj = SWIG_Py_Void();
31322 return resultobj;
31323 fail:
31324 return NULL;
31325 }
31326
31327
31328 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31329 PyObject *resultobj = 0;
31330 long arg1 ;
31331 long val1 ;
31332 int ecode1 = 0 ;
31333 PyObject * obj0 = 0 ;
31334 char * kwnames[] = {
31335 (char *) "val", NULL
31336 };
31337
31338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31339 ecode1 = SWIG_AsVal_long(obj0, &val1);
31340 if (!SWIG_IsOK(ecode1)) {
31341 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31342 }
31343 arg1 = static_cast< long >(val1);
31344 {
31345 PyThreadState* __tstate = wxPyBeginAllowThreads();
31346 wxPyApp::SetMacExitMenuItemId(arg1);
31347 wxPyEndAllowThreads(__tstate);
31348 if (PyErr_Occurred()) SWIG_fail;
31349 }
31350 resultobj = SWIG_Py_Void();
31351 return resultobj;
31352 fail:
31353 return NULL;
31354 }
31355
31356
31357 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31358 PyObject *resultobj = 0;
31359 wxString *arg1 = 0 ;
31360 bool temp1 = false ;
31361 PyObject * obj0 = 0 ;
31362 char * kwnames[] = {
31363 (char *) "val", NULL
31364 };
31365
31366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31367 {
31368 arg1 = wxString_in_helper(obj0);
31369 if (arg1 == NULL) SWIG_fail;
31370 temp1 = true;
31371 }
31372 {
31373 PyThreadState* __tstate = wxPyBeginAllowThreads();
31374 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31375 wxPyEndAllowThreads(__tstate);
31376 if (PyErr_Occurred()) SWIG_fail;
31377 }
31378 resultobj = SWIG_Py_Void();
31379 {
31380 if (temp1)
31381 delete arg1;
31382 }
31383 return resultobj;
31384 fail:
31385 {
31386 if (temp1)
31387 delete arg1;
31388 }
31389 return NULL;
31390 }
31391
31392
31393 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31394 PyObject *resultobj = 0;
31395 wxPyApp *arg1 = (wxPyApp *) 0 ;
31396 void *argp1 = 0 ;
31397 int res1 = 0 ;
31398 PyObject *swig_obj[1] ;
31399
31400 if (!args) SWIG_fail;
31401 swig_obj[0] = args;
31402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31403 if (!SWIG_IsOK(res1)) {
31404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31405 }
31406 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31407 {
31408 PyThreadState* __tstate = wxPyBeginAllowThreads();
31409 (arg1)->_BootstrapApp();
31410 wxPyEndAllowThreads(__tstate);
31411 if (PyErr_Occurred()) SWIG_fail;
31412 }
31413 resultobj = SWIG_Py_Void();
31414 return resultobj;
31415 fail:
31416 return NULL;
31417 }
31418
31419
31420 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31421 PyObject *resultobj = 0;
31422 int result;
31423
31424 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31425 {
31426 PyThreadState* __tstate = wxPyBeginAllowThreads();
31427 result = (int)wxPyApp::GetComCtl32Version();
31428 wxPyEndAllowThreads(__tstate);
31429 if (PyErr_Occurred()) SWIG_fail;
31430 }
31431 resultobj = SWIG_From_int(static_cast< int >(result));
31432 return resultobj;
31433 fail:
31434 return NULL;
31435 }
31436
31437
31438 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31439 PyObject *resultobj = 0;
31440 bool result;
31441
31442 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = (bool)wxPyApp_IsDisplayAvailable();
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 {
31450 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31451 }
31452 return resultobj;
31453 fail:
31454 return NULL;
31455 }
31456
31457
31458 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31459 PyObject *obj;
31460 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31461 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31462 return SWIG_Py_Void();
31463 }
31464
31465 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31466 return SWIG_Python_InitShadowInstance(args);
31467 }
31468
31469 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31470 PyObject *resultobj = 0;
31471
31472 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31473 {
31474 PyThreadState* __tstate = wxPyBeginAllowThreads();
31475 wxExit();
31476 wxPyEndAllowThreads(__tstate);
31477 if (PyErr_Occurred()) SWIG_fail;
31478 }
31479 resultobj = SWIG_Py_Void();
31480 return resultobj;
31481 fail:
31482 return NULL;
31483 }
31484
31485
31486 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31487 PyObject *resultobj = 0;
31488 bool result;
31489
31490 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31491 {
31492 PyThreadState* __tstate = wxPyBeginAllowThreads();
31493 result = (bool)wxYield();
31494 wxPyEndAllowThreads(__tstate);
31495 if (PyErr_Occurred()) SWIG_fail;
31496 }
31497 {
31498 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31499 }
31500 return resultobj;
31501 fail:
31502 return NULL;
31503 }
31504
31505
31506 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31507 PyObject *resultobj = 0;
31508 bool result;
31509
31510 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31511 {
31512 PyThreadState* __tstate = wxPyBeginAllowThreads();
31513 result = (bool)wxYieldIfNeeded();
31514 wxPyEndAllowThreads(__tstate);
31515 if (PyErr_Occurred()) SWIG_fail;
31516 }
31517 {
31518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31519 }
31520 return resultobj;
31521 fail:
31522 return NULL;
31523 }
31524
31525
31526 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31527 PyObject *resultobj = 0;
31528 wxWindow *arg1 = (wxWindow *) NULL ;
31529 bool arg2 = (bool) false ;
31530 bool result;
31531 void *argp1 = 0 ;
31532 int res1 = 0 ;
31533 bool val2 ;
31534 int ecode2 = 0 ;
31535 PyObject * obj0 = 0 ;
31536 PyObject * obj1 = 0 ;
31537 char * kwnames[] = {
31538 (char *) "win",(char *) "onlyIfNeeded", NULL
31539 };
31540
31541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31542 if (obj0) {
31543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31544 if (!SWIG_IsOK(res1)) {
31545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31546 }
31547 arg1 = reinterpret_cast< wxWindow * >(argp1);
31548 }
31549 if (obj1) {
31550 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31551 if (!SWIG_IsOK(ecode2)) {
31552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31553 }
31554 arg2 = static_cast< bool >(val2);
31555 }
31556 {
31557 PyThreadState* __tstate = wxPyBeginAllowThreads();
31558 result = (bool)wxSafeYield(arg1,arg2);
31559 wxPyEndAllowThreads(__tstate);
31560 if (PyErr_Occurred()) SWIG_fail;
31561 }
31562 {
31563 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31564 }
31565 return resultobj;
31566 fail:
31567 return NULL;
31568 }
31569
31570
31571 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31572 PyObject *resultobj = 0;
31573
31574 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31575 {
31576 PyThreadState* __tstate = wxPyBeginAllowThreads();
31577 wxWakeUpIdle();
31578 wxPyEndAllowThreads(__tstate);
31579 if (PyErr_Occurred()) SWIG_fail;
31580 }
31581 resultobj = SWIG_Py_Void();
31582 return resultobj;
31583 fail:
31584 return NULL;
31585 }
31586
31587
31588 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31589 PyObject *resultobj = 0;
31590 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31591 wxEvent *arg2 = 0 ;
31592 void *argp1 = 0 ;
31593 int res1 = 0 ;
31594 void *argp2 = 0 ;
31595 int res2 = 0 ;
31596 PyObject * obj0 = 0 ;
31597 PyObject * obj1 = 0 ;
31598 char * kwnames[] = {
31599 (char *) "dest",(char *) "event", NULL
31600 };
31601
31602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31604 if (!SWIG_IsOK(res1)) {
31605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31606 }
31607 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31608 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31609 if (!SWIG_IsOK(res2)) {
31610 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31611 }
31612 if (!argp2) {
31613 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31614 }
31615 arg2 = reinterpret_cast< wxEvent * >(argp2);
31616 {
31617 PyThreadState* __tstate = wxPyBeginAllowThreads();
31618 wxPostEvent(arg1,*arg2);
31619 wxPyEndAllowThreads(__tstate);
31620 if (PyErr_Occurred()) SWIG_fail;
31621 }
31622 resultobj = SWIG_Py_Void();
31623 return resultobj;
31624 fail:
31625 return NULL;
31626 }
31627
31628
31629 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31630 PyObject *resultobj = 0;
31631
31632 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31633 {
31634 PyThreadState* __tstate = wxPyBeginAllowThreads();
31635 wxApp_CleanUp();
31636 wxPyEndAllowThreads(__tstate);
31637 if (PyErr_Occurred()) SWIG_fail;
31638 }
31639 resultobj = SWIG_Py_Void();
31640 return resultobj;
31641 fail:
31642 return NULL;
31643 }
31644
31645
31646 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31647 PyObject *resultobj = 0;
31648 wxPyApp *result = 0 ;
31649
31650 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31651 {
31652 PyThreadState* __tstate = wxPyBeginAllowThreads();
31653 result = (wxPyApp *)wxPyGetApp();
31654 wxPyEndAllowThreads(__tstate);
31655 if (PyErr_Occurred()) SWIG_fail;
31656 }
31657 {
31658 resultobj = wxPyMake_wxObject(result, 0);
31659 }
31660 return resultobj;
31661 fail:
31662 return NULL;
31663 }
31664
31665
31666 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31667 PyObject *resultobj = 0;
31668 char *arg1 = (char *) 0 ;
31669 int res1 ;
31670 char *buf1 = 0 ;
31671 int alloc1 = 0 ;
31672 PyObject * obj0 = 0 ;
31673 char * kwnames[] = {
31674 (char *) "encoding", NULL
31675 };
31676
31677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31678 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31679 if (!SWIG_IsOK(res1)) {
31680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31681 }
31682 arg1 = buf1;
31683 {
31684 PyThreadState* __tstate = wxPyBeginAllowThreads();
31685 wxSetDefaultPyEncoding((char const *)arg1);
31686 wxPyEndAllowThreads(__tstate);
31687 if (PyErr_Occurred()) SWIG_fail;
31688 }
31689 resultobj = SWIG_Py_Void();
31690 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31691 return resultobj;
31692 fail:
31693 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31694 return NULL;
31695 }
31696
31697
31698 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31699 PyObject *resultobj = 0;
31700 char *result = 0 ;
31701
31702 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31703 {
31704 PyThreadState* __tstate = wxPyBeginAllowThreads();
31705 result = (char *)wxGetDefaultPyEncoding();
31706 wxPyEndAllowThreads(__tstate);
31707 if (PyErr_Occurred()) SWIG_fail;
31708 }
31709 resultobj = SWIG_FromCharPtr(result);
31710 return resultobj;
31711 fail:
31712 return NULL;
31713 }
31714
31715
31716 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31717 PyObject *resultobj = 0;
31718 wxEventLoop *result = 0 ;
31719
31720 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31721 {
31722 PyThreadState* __tstate = wxPyBeginAllowThreads();
31723 result = (wxEventLoop *)new wxEventLoop();
31724 wxPyEndAllowThreads(__tstate);
31725 if (PyErr_Occurred()) SWIG_fail;
31726 }
31727 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31728 return resultobj;
31729 fail:
31730 return NULL;
31731 }
31732
31733
31734 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31735 PyObject *resultobj = 0;
31736 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31737 void *argp1 = 0 ;
31738 int res1 = 0 ;
31739 PyObject *swig_obj[1] ;
31740
31741 if (!args) SWIG_fail;
31742 swig_obj[0] = args;
31743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31744 if (!SWIG_IsOK(res1)) {
31745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31746 }
31747 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31748 {
31749 PyThreadState* __tstate = wxPyBeginAllowThreads();
31750 delete arg1;
31751
31752 wxPyEndAllowThreads(__tstate);
31753 if (PyErr_Occurred()) SWIG_fail;
31754 }
31755 resultobj = SWIG_Py_Void();
31756 return resultobj;
31757 fail:
31758 return NULL;
31759 }
31760
31761
31762 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31763 PyObject *resultobj = 0;
31764 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31765 int result;
31766 void *argp1 = 0 ;
31767 int res1 = 0 ;
31768 PyObject *swig_obj[1] ;
31769
31770 if (!args) SWIG_fail;
31771 swig_obj[0] = args;
31772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31773 if (!SWIG_IsOK(res1)) {
31774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31775 }
31776 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31777 {
31778 PyThreadState* __tstate = wxPyBeginAllowThreads();
31779 result = (int)(arg1)->Run();
31780 wxPyEndAllowThreads(__tstate);
31781 if (PyErr_Occurred()) SWIG_fail;
31782 }
31783 resultobj = SWIG_From_int(static_cast< int >(result));
31784 return resultobj;
31785 fail:
31786 return NULL;
31787 }
31788
31789
31790 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31791 PyObject *resultobj = 0;
31792 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31793 int arg2 = (int) 0 ;
31794 void *argp1 = 0 ;
31795 int res1 = 0 ;
31796 int val2 ;
31797 int ecode2 = 0 ;
31798 PyObject * obj0 = 0 ;
31799 PyObject * obj1 = 0 ;
31800 char * kwnames[] = {
31801 (char *) "self",(char *) "rc", NULL
31802 };
31803
31804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31806 if (!SWIG_IsOK(res1)) {
31807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31808 }
31809 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31810 if (obj1) {
31811 ecode2 = SWIG_AsVal_int(obj1, &val2);
31812 if (!SWIG_IsOK(ecode2)) {
31813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31814 }
31815 arg2 = static_cast< int >(val2);
31816 }
31817 {
31818 PyThreadState* __tstate = wxPyBeginAllowThreads();
31819 (arg1)->Exit(arg2);
31820 wxPyEndAllowThreads(__tstate);
31821 if (PyErr_Occurred()) SWIG_fail;
31822 }
31823 resultobj = SWIG_Py_Void();
31824 return resultobj;
31825 fail:
31826 return NULL;
31827 }
31828
31829
31830 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31831 PyObject *resultobj = 0;
31832 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31833 bool result;
31834 void *argp1 = 0 ;
31835 int res1 = 0 ;
31836 PyObject *swig_obj[1] ;
31837
31838 if (!args) SWIG_fail;
31839 swig_obj[0] = args;
31840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31841 if (!SWIG_IsOK(res1)) {
31842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31843 }
31844 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31845 {
31846 PyThreadState* __tstate = wxPyBeginAllowThreads();
31847 result = (bool)((wxEventLoop const *)arg1)->Pending();
31848 wxPyEndAllowThreads(__tstate);
31849 if (PyErr_Occurred()) SWIG_fail;
31850 }
31851 {
31852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31853 }
31854 return resultobj;
31855 fail:
31856 return NULL;
31857 }
31858
31859
31860 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31861 PyObject *resultobj = 0;
31862 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31863 bool result;
31864 void *argp1 = 0 ;
31865 int res1 = 0 ;
31866 PyObject *swig_obj[1] ;
31867
31868 if (!args) SWIG_fail;
31869 swig_obj[0] = args;
31870 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31871 if (!SWIG_IsOK(res1)) {
31872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31873 }
31874 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31875 {
31876 PyThreadState* __tstate = wxPyBeginAllowThreads();
31877 result = (bool)(arg1)->Dispatch();
31878 wxPyEndAllowThreads(__tstate);
31879 if (PyErr_Occurred()) SWIG_fail;
31880 }
31881 {
31882 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31883 }
31884 return resultobj;
31885 fail:
31886 return NULL;
31887 }
31888
31889
31890 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31891 PyObject *resultobj = 0;
31892 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31893 bool result;
31894 void *argp1 = 0 ;
31895 int res1 = 0 ;
31896 PyObject *swig_obj[1] ;
31897
31898 if (!args) SWIG_fail;
31899 swig_obj[0] = args;
31900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31901 if (!SWIG_IsOK(res1)) {
31902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31903 }
31904 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31905 {
31906 PyThreadState* __tstate = wxPyBeginAllowThreads();
31907 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31908 wxPyEndAllowThreads(__tstate);
31909 if (PyErr_Occurred()) SWIG_fail;
31910 }
31911 {
31912 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31913 }
31914 return resultobj;
31915 fail:
31916 return NULL;
31917 }
31918
31919
31920 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31921 PyObject *resultobj = 0;
31922 wxEventLoop *result = 0 ;
31923
31924 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31925 {
31926 PyThreadState* __tstate = wxPyBeginAllowThreads();
31927 result = (wxEventLoop *)wxEventLoop::GetActive();
31928 wxPyEndAllowThreads(__tstate);
31929 if (PyErr_Occurred()) SWIG_fail;
31930 }
31931 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31932 return resultobj;
31933 fail:
31934 return NULL;
31935 }
31936
31937
31938 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31939 PyObject *resultobj = 0;
31940 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31941 void *argp1 = 0 ;
31942 int res1 = 0 ;
31943 PyObject * obj0 = 0 ;
31944 char * kwnames[] = {
31945 (char *) "loop", NULL
31946 };
31947
31948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31950 if (!SWIG_IsOK(res1)) {
31951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31952 }
31953 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31954 {
31955 PyThreadState* __tstate = wxPyBeginAllowThreads();
31956 wxEventLoop::SetActive(arg1);
31957 wxPyEndAllowThreads(__tstate);
31958 if (PyErr_Occurred()) SWIG_fail;
31959 }
31960 resultobj = SWIG_Py_Void();
31961 return resultobj;
31962 fail:
31963 return NULL;
31964 }
31965
31966
31967 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31968 PyObject *obj;
31969 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31970 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31971 return SWIG_Py_Void();
31972 }
31973
31974 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31975 return SWIG_Python_InitShadowInstance(args);
31976 }
31977
31978 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31979 PyObject *resultobj = 0;
31980 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31981 wxEventLoopActivator *result = 0 ;
31982 void *argp1 = 0 ;
31983 int res1 = 0 ;
31984 PyObject * obj0 = 0 ;
31985 char * kwnames[] = {
31986 (char *) "evtLoop", NULL
31987 };
31988
31989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
31990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31991 if (!SWIG_IsOK(res1)) {
31992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31993 }
31994 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31995 {
31996 PyThreadState* __tstate = wxPyBeginAllowThreads();
31997 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32002 return resultobj;
32003 fail:
32004 return NULL;
32005 }
32006
32007
32008 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32009 PyObject *resultobj = 0;
32010 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32011 void *argp1 = 0 ;
32012 int res1 = 0 ;
32013 PyObject *swig_obj[1] ;
32014
32015 if (!args) SWIG_fail;
32016 swig_obj[0] = args;
32017 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32018 if (!SWIG_IsOK(res1)) {
32019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32020 }
32021 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32022 {
32023 PyThreadState* __tstate = wxPyBeginAllowThreads();
32024 delete arg1;
32025
32026 wxPyEndAllowThreads(__tstate);
32027 if (PyErr_Occurred()) SWIG_fail;
32028 }
32029 resultobj = SWIG_Py_Void();
32030 return resultobj;
32031 fail:
32032 return NULL;
32033 }
32034
32035
32036 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32037 PyObject *obj;
32038 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32039 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32040 return SWIG_Py_Void();
32041 }
32042
32043 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32044 return SWIG_Python_InitShadowInstance(args);
32045 }
32046
32047 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32048 PyObject *resultobj = 0;
32049 int arg1 = (int) 0 ;
32050 int arg2 = (int) 0 ;
32051 int arg3 = (int) 0 ;
32052 wxAcceleratorEntry *result = 0 ;
32053 int val1 ;
32054 int ecode1 = 0 ;
32055 int val2 ;
32056 int ecode2 = 0 ;
32057 int val3 ;
32058 int ecode3 = 0 ;
32059 PyObject * obj0 = 0 ;
32060 PyObject * obj1 = 0 ;
32061 PyObject * obj2 = 0 ;
32062 char * kwnames[] = {
32063 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32064 };
32065
32066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32067 if (obj0) {
32068 ecode1 = SWIG_AsVal_int(obj0, &val1);
32069 if (!SWIG_IsOK(ecode1)) {
32070 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32071 }
32072 arg1 = static_cast< int >(val1);
32073 }
32074 if (obj1) {
32075 ecode2 = SWIG_AsVal_int(obj1, &val2);
32076 if (!SWIG_IsOK(ecode2)) {
32077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32078 }
32079 arg2 = static_cast< int >(val2);
32080 }
32081 if (obj2) {
32082 ecode3 = SWIG_AsVal_int(obj2, &val3);
32083 if (!SWIG_IsOK(ecode3)) {
32084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32085 }
32086 arg3 = static_cast< int >(val3);
32087 }
32088 {
32089 PyThreadState* __tstate = wxPyBeginAllowThreads();
32090 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32091 wxPyEndAllowThreads(__tstate);
32092 if (PyErr_Occurred()) SWIG_fail;
32093 }
32094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32095 return resultobj;
32096 fail:
32097 return NULL;
32098 }
32099
32100
32101 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32102 PyObject *resultobj = 0;
32103 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32104 void *argp1 = 0 ;
32105 int res1 = 0 ;
32106 PyObject *swig_obj[1] ;
32107
32108 if (!args) SWIG_fail;
32109 swig_obj[0] = args;
32110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32111 if (!SWIG_IsOK(res1)) {
32112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32113 }
32114 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 delete arg1;
32118
32119 wxPyEndAllowThreads(__tstate);
32120 if (PyErr_Occurred()) SWIG_fail;
32121 }
32122 resultobj = SWIG_Py_Void();
32123 return resultobj;
32124 fail:
32125 return NULL;
32126 }
32127
32128
32129 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32130 PyObject *resultobj = 0;
32131 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32132 int arg2 ;
32133 int arg3 ;
32134 int arg4 ;
32135 void *argp1 = 0 ;
32136 int res1 = 0 ;
32137 int val2 ;
32138 int ecode2 = 0 ;
32139 int val3 ;
32140 int ecode3 = 0 ;
32141 int val4 ;
32142 int ecode4 = 0 ;
32143 PyObject * obj0 = 0 ;
32144 PyObject * obj1 = 0 ;
32145 PyObject * obj2 = 0 ;
32146 PyObject * obj3 = 0 ;
32147 char * kwnames[] = {
32148 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32149 };
32150
32151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32153 if (!SWIG_IsOK(res1)) {
32154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32155 }
32156 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32157 ecode2 = SWIG_AsVal_int(obj1, &val2);
32158 if (!SWIG_IsOK(ecode2)) {
32159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32160 }
32161 arg2 = static_cast< int >(val2);
32162 ecode3 = SWIG_AsVal_int(obj2, &val3);
32163 if (!SWIG_IsOK(ecode3)) {
32164 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32165 }
32166 arg3 = static_cast< int >(val3);
32167 ecode4 = SWIG_AsVal_int(obj3, &val4);
32168 if (!SWIG_IsOK(ecode4)) {
32169 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32170 }
32171 arg4 = static_cast< int >(val4);
32172 {
32173 PyThreadState* __tstate = wxPyBeginAllowThreads();
32174 (arg1)->Set(arg2,arg3,arg4);
32175 wxPyEndAllowThreads(__tstate);
32176 if (PyErr_Occurred()) SWIG_fail;
32177 }
32178 resultobj = SWIG_Py_Void();
32179 return resultobj;
32180 fail:
32181 return NULL;
32182 }
32183
32184
32185 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32186 PyObject *resultobj = 0;
32187 wxString *arg1 = 0 ;
32188 wxAcceleratorEntry *result = 0 ;
32189 bool temp1 = false ;
32190 PyObject * obj0 = 0 ;
32191 char * kwnames[] = {
32192 (char *) "str", NULL
32193 };
32194
32195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32196 {
32197 arg1 = wxString_in_helper(obj0);
32198 if (arg1 == NULL) SWIG_fail;
32199 temp1 = true;
32200 }
32201 {
32202 PyThreadState* __tstate = wxPyBeginAllowThreads();
32203 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32204 wxPyEndAllowThreads(__tstate);
32205 if (PyErr_Occurred()) SWIG_fail;
32206 }
32207 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32208 {
32209 if (temp1)
32210 delete arg1;
32211 }
32212 return resultobj;
32213 fail:
32214 {
32215 if (temp1)
32216 delete arg1;
32217 }
32218 return NULL;
32219 }
32220
32221
32222 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32223 PyObject *resultobj = 0;
32224 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32225 int result;
32226 void *argp1 = 0 ;
32227 int res1 = 0 ;
32228 PyObject *swig_obj[1] ;
32229
32230 if (!args) SWIG_fail;
32231 swig_obj[0] = args;
32232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32233 if (!SWIG_IsOK(res1)) {
32234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32235 }
32236 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32237 {
32238 PyThreadState* __tstate = wxPyBeginAllowThreads();
32239 result = (int)(arg1)->GetFlags();
32240 wxPyEndAllowThreads(__tstate);
32241 if (PyErr_Occurred()) SWIG_fail;
32242 }
32243 resultobj = SWIG_From_int(static_cast< int >(result));
32244 return resultobj;
32245 fail:
32246 return NULL;
32247 }
32248
32249
32250 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32251 PyObject *resultobj = 0;
32252 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32253 int result;
32254 void *argp1 = 0 ;
32255 int res1 = 0 ;
32256 PyObject *swig_obj[1] ;
32257
32258 if (!args) SWIG_fail;
32259 swig_obj[0] = args;
32260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32261 if (!SWIG_IsOK(res1)) {
32262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32263 }
32264 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 result = (int)(arg1)->GetKeyCode();
32268 wxPyEndAllowThreads(__tstate);
32269 if (PyErr_Occurred()) SWIG_fail;
32270 }
32271 resultobj = SWIG_From_int(static_cast< int >(result));
32272 return resultobj;
32273 fail:
32274 return NULL;
32275 }
32276
32277
32278 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32279 PyObject *resultobj = 0;
32280 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32281 int result;
32282 void *argp1 = 0 ;
32283 int res1 = 0 ;
32284 PyObject *swig_obj[1] ;
32285
32286 if (!args) SWIG_fail;
32287 swig_obj[0] = args;
32288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32289 if (!SWIG_IsOK(res1)) {
32290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32291 }
32292 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32293 {
32294 PyThreadState* __tstate = wxPyBeginAllowThreads();
32295 result = (int)(arg1)->GetCommand();
32296 wxPyEndAllowThreads(__tstate);
32297 if (PyErr_Occurred()) SWIG_fail;
32298 }
32299 resultobj = SWIG_From_int(static_cast< int >(result));
32300 return resultobj;
32301 fail:
32302 return NULL;
32303 }
32304
32305
32306 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32307 PyObject *resultobj = 0;
32308 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32309 bool result;
32310 void *argp1 = 0 ;
32311 int res1 = 0 ;
32312 PyObject *swig_obj[1] ;
32313
32314 if (!args) SWIG_fail;
32315 swig_obj[0] = args;
32316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32317 if (!SWIG_IsOK(res1)) {
32318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32319 }
32320 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32321 {
32322 PyThreadState* __tstate = wxPyBeginAllowThreads();
32323 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32324 wxPyEndAllowThreads(__tstate);
32325 if (PyErr_Occurred()) SWIG_fail;
32326 }
32327 {
32328 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32329 }
32330 return resultobj;
32331 fail:
32332 return NULL;
32333 }
32334
32335
32336 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32337 PyObject *resultobj = 0;
32338 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32339 wxString result;
32340 void *argp1 = 0 ;
32341 int res1 = 0 ;
32342 PyObject *swig_obj[1] ;
32343
32344 if (!args) SWIG_fail;
32345 swig_obj[0] = args;
32346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32347 if (!SWIG_IsOK(res1)) {
32348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32349 }
32350 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32351 {
32352 PyThreadState* __tstate = wxPyBeginAllowThreads();
32353 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32354 wxPyEndAllowThreads(__tstate);
32355 if (PyErr_Occurred()) SWIG_fail;
32356 }
32357 {
32358 #if wxUSE_UNICODE
32359 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32360 #else
32361 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32362 #endif
32363 }
32364 return resultobj;
32365 fail:
32366 return NULL;
32367 }
32368
32369
32370 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32371 PyObject *resultobj = 0;
32372 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32373 wxString *arg2 = 0 ;
32374 bool result;
32375 void *argp1 = 0 ;
32376 int res1 = 0 ;
32377 bool temp2 = false ;
32378 PyObject * obj0 = 0 ;
32379 PyObject * obj1 = 0 ;
32380 char * kwnames[] = {
32381 (char *) "self",(char *) "str", NULL
32382 };
32383
32384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32386 if (!SWIG_IsOK(res1)) {
32387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32388 }
32389 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32390 {
32391 arg2 = wxString_in_helper(obj1);
32392 if (arg2 == NULL) SWIG_fail;
32393 temp2 = true;
32394 }
32395 {
32396 PyThreadState* __tstate = wxPyBeginAllowThreads();
32397 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32398 wxPyEndAllowThreads(__tstate);
32399 if (PyErr_Occurred()) SWIG_fail;
32400 }
32401 {
32402 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32403 }
32404 {
32405 if (temp2)
32406 delete arg2;
32407 }
32408 return resultobj;
32409 fail:
32410 {
32411 if (temp2)
32412 delete arg2;
32413 }
32414 return NULL;
32415 }
32416
32417
32418 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32419 PyObject *obj;
32420 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32421 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32422 return SWIG_Py_Void();
32423 }
32424
32425 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32426 return SWIG_Python_InitShadowInstance(args);
32427 }
32428
32429 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32430 PyObject *resultobj = 0;
32431 int arg1 ;
32432 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32433 wxAcceleratorTable *result = 0 ;
32434 PyObject * obj0 = 0 ;
32435 char * kwnames[] = {
32436 (char *) "n", NULL
32437 };
32438
32439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32440 {
32441 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32442 if (arg2) arg1 = PyList_Size(obj0);
32443 else arg1 = 0;
32444 }
32445 {
32446 PyThreadState* __tstate = wxPyBeginAllowThreads();
32447 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32448 wxPyEndAllowThreads(__tstate);
32449 if (PyErr_Occurred()) SWIG_fail;
32450 }
32451 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32452 return resultobj;
32453 fail:
32454 return NULL;
32455 }
32456
32457
32458 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32459 PyObject *resultobj = 0;
32460 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32461 void *argp1 = 0 ;
32462 int res1 = 0 ;
32463 PyObject *swig_obj[1] ;
32464
32465 if (!args) SWIG_fail;
32466 swig_obj[0] = args;
32467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32468 if (!SWIG_IsOK(res1)) {
32469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32470 }
32471 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32472 {
32473 PyThreadState* __tstate = wxPyBeginAllowThreads();
32474 delete arg1;
32475
32476 wxPyEndAllowThreads(__tstate);
32477 if (PyErr_Occurred()) SWIG_fail;
32478 }
32479 resultobj = SWIG_Py_Void();
32480 return resultobj;
32481 fail:
32482 return NULL;
32483 }
32484
32485
32486 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32487 PyObject *resultobj = 0;
32488 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32489 bool result;
32490 void *argp1 = 0 ;
32491 int res1 = 0 ;
32492 PyObject *swig_obj[1] ;
32493
32494 if (!args) SWIG_fail;
32495 swig_obj[0] = args;
32496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32497 if (!SWIG_IsOK(res1)) {
32498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32499 }
32500 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32501 {
32502 PyThreadState* __tstate = wxPyBeginAllowThreads();
32503 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32504 wxPyEndAllowThreads(__tstate);
32505 if (PyErr_Occurred()) SWIG_fail;
32506 }
32507 {
32508 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32509 }
32510 return resultobj;
32511 fail:
32512 return NULL;
32513 }
32514
32515
32516 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32517 PyObject *obj;
32518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32519 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32520 return SWIG_Py_Void();
32521 }
32522
32523 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32524 return SWIG_Python_InitShadowInstance(args);
32525 }
32526
32527 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32528 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32529 return 1;
32530 }
32531
32532
32533 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32534 PyObject *pyobj = 0;
32535
32536 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32537 return pyobj;
32538 }
32539
32540
32541 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32542 PyObject *resultobj = 0;
32543 wxString *arg1 = 0 ;
32544 wxAcceleratorEntry *result = 0 ;
32545 bool temp1 = false ;
32546 PyObject * obj0 = 0 ;
32547 char * kwnames[] = {
32548 (char *) "label", NULL
32549 };
32550
32551 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32552 {
32553 arg1 = wxString_in_helper(obj0);
32554 if (arg1 == NULL) SWIG_fail;
32555 temp1 = true;
32556 }
32557 {
32558 PyThreadState* __tstate = wxPyBeginAllowThreads();
32559 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32560 wxPyEndAllowThreads(__tstate);
32561 if (PyErr_Occurred()) SWIG_fail;
32562 }
32563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32564 {
32565 if (temp1)
32566 delete arg1;
32567 }
32568 return resultobj;
32569 fail:
32570 {
32571 if (temp1)
32572 delete arg1;
32573 }
32574 return NULL;
32575 }
32576
32577
32578 SWIGINTERN int PanelNameStr_set(PyObject *) {
32579 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32580 return 1;
32581 }
32582
32583
32584 SWIGINTERN PyObject *PanelNameStr_get(void) {
32585 PyObject *pyobj = 0;
32586
32587 {
32588 #if wxUSE_UNICODE
32589 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32590 #else
32591 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32592 #endif
32593 }
32594 return pyobj;
32595 }
32596
32597
32598 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32599 PyObject *resultobj = 0;
32600 wxVisualAttributes *result = 0 ;
32601
32602 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32603 {
32604 PyThreadState* __tstate = wxPyBeginAllowThreads();
32605 result = (wxVisualAttributes *)new_wxVisualAttributes();
32606 wxPyEndAllowThreads(__tstate);
32607 if (PyErr_Occurred()) SWIG_fail;
32608 }
32609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32610 return resultobj;
32611 fail:
32612 return NULL;
32613 }
32614
32615
32616 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32617 PyObject *resultobj = 0;
32618 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32619 void *argp1 = 0 ;
32620 int res1 = 0 ;
32621 PyObject *swig_obj[1] ;
32622
32623 if (!args) SWIG_fail;
32624 swig_obj[0] = args;
32625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32626 if (!SWIG_IsOK(res1)) {
32627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32628 }
32629 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32630 {
32631 PyThreadState* __tstate = wxPyBeginAllowThreads();
32632 delete_wxVisualAttributes(arg1);
32633
32634 wxPyEndAllowThreads(__tstate);
32635 if (PyErr_Occurred()) SWIG_fail;
32636 }
32637 resultobj = SWIG_Py_Void();
32638 return resultobj;
32639 fail:
32640 return NULL;
32641 }
32642
32643
32644 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32645 PyObject *resultobj = 0;
32646 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32647 wxFont *arg2 = (wxFont *) 0 ;
32648 void *argp1 = 0 ;
32649 int res1 = 0 ;
32650 void *argp2 = 0 ;
32651 int res2 = 0 ;
32652 PyObject *swig_obj[2] ;
32653
32654 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32656 if (!SWIG_IsOK(res1)) {
32657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32658 }
32659 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32660 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32661 if (!SWIG_IsOK(res2)) {
32662 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32663 }
32664 arg2 = reinterpret_cast< wxFont * >(argp2);
32665 if (arg1) (arg1)->font = *arg2;
32666
32667 resultobj = SWIG_Py_Void();
32668 return resultobj;
32669 fail:
32670 return NULL;
32671 }
32672
32673
32674 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32675 PyObject *resultobj = 0;
32676 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32677 wxFont *result = 0 ;
32678 void *argp1 = 0 ;
32679 int res1 = 0 ;
32680 PyObject *swig_obj[1] ;
32681
32682 if (!args) SWIG_fail;
32683 swig_obj[0] = args;
32684 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32685 if (!SWIG_IsOK(res1)) {
32686 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32687 }
32688 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32689 result = (wxFont *)& ((arg1)->font);
32690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32691 return resultobj;
32692 fail:
32693 return NULL;
32694 }
32695
32696
32697 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32698 PyObject *resultobj = 0;
32699 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32700 wxColour *arg2 = (wxColour *) 0 ;
32701 void *argp1 = 0 ;
32702 int res1 = 0 ;
32703 void *argp2 = 0 ;
32704 int res2 = 0 ;
32705 PyObject *swig_obj[2] ;
32706
32707 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32709 if (!SWIG_IsOK(res1)) {
32710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32711 }
32712 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32713 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32714 if (!SWIG_IsOK(res2)) {
32715 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32716 }
32717 arg2 = reinterpret_cast< wxColour * >(argp2);
32718 if (arg1) (arg1)->colFg = *arg2;
32719
32720 resultobj = SWIG_Py_Void();
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32728 PyObject *resultobj = 0;
32729 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32730 wxColour *result = 0 ;
32731 void *argp1 = 0 ;
32732 int res1 = 0 ;
32733 PyObject *swig_obj[1] ;
32734
32735 if (!args) SWIG_fail;
32736 swig_obj[0] = args;
32737 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32738 if (!SWIG_IsOK(res1)) {
32739 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32740 }
32741 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32742 result = (wxColour *)& ((arg1)->colFg);
32743 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32744 return resultobj;
32745 fail:
32746 return NULL;
32747 }
32748
32749
32750 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32751 PyObject *resultobj = 0;
32752 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32753 wxColour *arg2 = (wxColour *) 0 ;
32754 void *argp1 = 0 ;
32755 int res1 = 0 ;
32756 void *argp2 = 0 ;
32757 int res2 = 0 ;
32758 PyObject *swig_obj[2] ;
32759
32760 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32762 if (!SWIG_IsOK(res1)) {
32763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32764 }
32765 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32766 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32767 if (!SWIG_IsOK(res2)) {
32768 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32769 }
32770 arg2 = reinterpret_cast< wxColour * >(argp2);
32771 if (arg1) (arg1)->colBg = *arg2;
32772
32773 resultobj = SWIG_Py_Void();
32774 return resultobj;
32775 fail:
32776 return NULL;
32777 }
32778
32779
32780 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32781 PyObject *resultobj = 0;
32782 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32783 wxColour *result = 0 ;
32784 void *argp1 = 0 ;
32785 int res1 = 0 ;
32786 PyObject *swig_obj[1] ;
32787
32788 if (!args) SWIG_fail;
32789 swig_obj[0] = args;
32790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32791 if (!SWIG_IsOK(res1)) {
32792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32793 }
32794 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32795 result = (wxColour *)& ((arg1)->colBg);
32796 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32797 return resultobj;
32798 fail:
32799 return NULL;
32800 }
32801
32802
32803 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32804 PyObject *obj;
32805 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32806 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32807 return SWIG_Py_Void();
32808 }
32809
32810 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32811 return SWIG_Python_InitShadowInstance(args);
32812 }
32813
32814 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32815 PyObject *resultobj = 0;
32816 wxWindow *arg1 = (wxWindow *) 0 ;
32817 int arg2 = (int) (int)-1 ;
32818 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32819 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32820 wxSize const &arg4_defvalue = wxDefaultSize ;
32821 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32822 long arg5 = (long) 0 ;
32823 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32824 wxString *arg6 = (wxString *) &arg6_defvalue ;
32825 wxWindow *result = 0 ;
32826 void *argp1 = 0 ;
32827 int res1 = 0 ;
32828 int val2 ;
32829 int ecode2 = 0 ;
32830 wxPoint temp3 ;
32831 wxSize temp4 ;
32832 long val5 ;
32833 int ecode5 = 0 ;
32834 bool temp6 = false ;
32835 PyObject * obj0 = 0 ;
32836 PyObject * obj1 = 0 ;
32837 PyObject * obj2 = 0 ;
32838 PyObject * obj3 = 0 ;
32839 PyObject * obj4 = 0 ;
32840 PyObject * obj5 = 0 ;
32841 char * kwnames[] = {
32842 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32843 };
32844
32845 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32846 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32847 if (!SWIG_IsOK(res1)) {
32848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32849 }
32850 arg1 = reinterpret_cast< wxWindow * >(argp1);
32851 if (obj1) {
32852 ecode2 = SWIG_AsVal_int(obj1, &val2);
32853 if (!SWIG_IsOK(ecode2)) {
32854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32855 }
32856 arg2 = static_cast< int >(val2);
32857 }
32858 if (obj2) {
32859 {
32860 arg3 = &temp3;
32861 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32862 }
32863 }
32864 if (obj3) {
32865 {
32866 arg4 = &temp4;
32867 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32868 }
32869 }
32870 if (obj4) {
32871 ecode5 = SWIG_AsVal_long(obj4, &val5);
32872 if (!SWIG_IsOK(ecode5)) {
32873 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32874 }
32875 arg5 = static_cast< long >(val5);
32876 }
32877 if (obj5) {
32878 {
32879 arg6 = wxString_in_helper(obj5);
32880 if (arg6 == NULL) SWIG_fail;
32881 temp6 = true;
32882 }
32883 }
32884 {
32885 if (!wxPyCheckForApp()) SWIG_fail;
32886 PyThreadState* __tstate = wxPyBeginAllowThreads();
32887 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32888 wxPyEndAllowThreads(__tstate);
32889 if (PyErr_Occurred()) SWIG_fail;
32890 }
32891 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32892 {
32893 if (temp6)
32894 delete arg6;
32895 }
32896 return resultobj;
32897 fail:
32898 {
32899 if (temp6)
32900 delete arg6;
32901 }
32902 return NULL;
32903 }
32904
32905
32906 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32907 PyObject *resultobj = 0;
32908 wxWindow *result = 0 ;
32909
32910 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32911 {
32912 if (!wxPyCheckForApp()) SWIG_fail;
32913 PyThreadState* __tstate = wxPyBeginAllowThreads();
32914 result = (wxWindow *)new wxWindow();
32915 wxPyEndAllowThreads(__tstate);
32916 if (PyErr_Occurred()) SWIG_fail;
32917 }
32918 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32919 return resultobj;
32920 fail:
32921 return NULL;
32922 }
32923
32924
32925 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32926 PyObject *resultobj = 0;
32927 wxWindow *arg1 = (wxWindow *) 0 ;
32928 wxWindow *arg2 = (wxWindow *) 0 ;
32929 int arg3 = (int) (int)-1 ;
32930 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32931 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32932 wxSize const &arg5_defvalue = wxDefaultSize ;
32933 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32934 long arg6 = (long) 0 ;
32935 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32936 wxString *arg7 = (wxString *) &arg7_defvalue ;
32937 bool result;
32938 void *argp1 = 0 ;
32939 int res1 = 0 ;
32940 void *argp2 = 0 ;
32941 int res2 = 0 ;
32942 int val3 ;
32943 int ecode3 = 0 ;
32944 wxPoint temp4 ;
32945 wxSize temp5 ;
32946 long val6 ;
32947 int ecode6 = 0 ;
32948 bool temp7 = false ;
32949 PyObject * obj0 = 0 ;
32950 PyObject * obj1 = 0 ;
32951 PyObject * obj2 = 0 ;
32952 PyObject * obj3 = 0 ;
32953 PyObject * obj4 = 0 ;
32954 PyObject * obj5 = 0 ;
32955 PyObject * obj6 = 0 ;
32956 char * kwnames[] = {
32957 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32958 };
32959
32960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32962 if (!SWIG_IsOK(res1)) {
32963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32964 }
32965 arg1 = reinterpret_cast< wxWindow * >(argp1);
32966 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32967 if (!SWIG_IsOK(res2)) {
32968 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32969 }
32970 arg2 = reinterpret_cast< wxWindow * >(argp2);
32971 if (obj2) {
32972 ecode3 = SWIG_AsVal_int(obj2, &val3);
32973 if (!SWIG_IsOK(ecode3)) {
32974 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32975 }
32976 arg3 = static_cast< int >(val3);
32977 }
32978 if (obj3) {
32979 {
32980 arg4 = &temp4;
32981 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32982 }
32983 }
32984 if (obj4) {
32985 {
32986 arg5 = &temp5;
32987 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
32988 }
32989 }
32990 if (obj5) {
32991 ecode6 = SWIG_AsVal_long(obj5, &val6);
32992 if (!SWIG_IsOK(ecode6)) {
32993 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
32994 }
32995 arg6 = static_cast< long >(val6);
32996 }
32997 if (obj6) {
32998 {
32999 arg7 = wxString_in_helper(obj6);
33000 if (arg7 == NULL) SWIG_fail;
33001 temp7 = true;
33002 }
33003 }
33004 {
33005 PyThreadState* __tstate = wxPyBeginAllowThreads();
33006 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33007 wxPyEndAllowThreads(__tstate);
33008 if (PyErr_Occurred()) SWIG_fail;
33009 }
33010 {
33011 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33012 }
33013 {
33014 if (temp7)
33015 delete arg7;
33016 }
33017 return resultobj;
33018 fail:
33019 {
33020 if (temp7)
33021 delete arg7;
33022 }
33023 return NULL;
33024 }
33025
33026
33027 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33028 PyObject *resultobj = 0;
33029 wxWindow *arg1 = (wxWindow *) 0 ;
33030 bool arg2 = (bool) false ;
33031 bool result;
33032 void *argp1 = 0 ;
33033 int res1 = 0 ;
33034 bool val2 ;
33035 int ecode2 = 0 ;
33036 PyObject * obj0 = 0 ;
33037 PyObject * obj1 = 0 ;
33038 char * kwnames[] = {
33039 (char *) "self",(char *) "force", NULL
33040 };
33041
33042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33044 if (!SWIG_IsOK(res1)) {
33045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33046 }
33047 arg1 = reinterpret_cast< wxWindow * >(argp1);
33048 if (obj1) {
33049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33050 if (!SWIG_IsOK(ecode2)) {
33051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33052 }
33053 arg2 = static_cast< bool >(val2);
33054 }
33055 {
33056 PyThreadState* __tstate = wxPyBeginAllowThreads();
33057 result = (bool)(arg1)->Close(arg2);
33058 wxPyEndAllowThreads(__tstate);
33059 if (PyErr_Occurred()) SWIG_fail;
33060 }
33061 {
33062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33063 }
33064 return resultobj;
33065 fail:
33066 return NULL;
33067 }
33068
33069
33070 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33071 PyObject *resultobj = 0;
33072 wxWindow *arg1 = (wxWindow *) 0 ;
33073 bool result;
33074 void *argp1 = 0 ;
33075 int res1 = 0 ;
33076 PyObject *swig_obj[1] ;
33077
33078 if (!args) SWIG_fail;
33079 swig_obj[0] = args;
33080 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33081 if (!SWIG_IsOK(res1)) {
33082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33083 }
33084 arg1 = reinterpret_cast< wxWindow * >(argp1);
33085 {
33086 PyThreadState* __tstate = wxPyBeginAllowThreads();
33087 result = (bool)(arg1)->Destroy();
33088 wxPyEndAllowThreads(__tstate);
33089 if (PyErr_Occurred()) SWIG_fail;
33090 }
33091 {
33092 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33093 }
33094 return resultobj;
33095 fail:
33096 return NULL;
33097 }
33098
33099
33100 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33101 PyObject *resultobj = 0;
33102 wxWindow *arg1 = (wxWindow *) 0 ;
33103 bool result;
33104 void *argp1 = 0 ;
33105 int res1 = 0 ;
33106 PyObject *swig_obj[1] ;
33107
33108 if (!args) SWIG_fail;
33109 swig_obj[0] = args;
33110 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33111 if (!SWIG_IsOK(res1)) {
33112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33113 }
33114 arg1 = reinterpret_cast< wxWindow * >(argp1);
33115 {
33116 PyThreadState* __tstate = wxPyBeginAllowThreads();
33117 result = (bool)(arg1)->DestroyChildren();
33118 wxPyEndAllowThreads(__tstate);
33119 if (PyErr_Occurred()) SWIG_fail;
33120 }
33121 {
33122 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33123 }
33124 return resultobj;
33125 fail:
33126 return NULL;
33127 }
33128
33129
33130 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33131 PyObject *resultobj = 0;
33132 wxWindow *arg1 = (wxWindow *) 0 ;
33133 bool result;
33134 void *argp1 = 0 ;
33135 int res1 = 0 ;
33136 PyObject *swig_obj[1] ;
33137
33138 if (!args) SWIG_fail;
33139 swig_obj[0] = args;
33140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33141 if (!SWIG_IsOK(res1)) {
33142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33143 }
33144 arg1 = reinterpret_cast< wxWindow * >(argp1);
33145 {
33146 PyThreadState* __tstate = wxPyBeginAllowThreads();
33147 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33148 wxPyEndAllowThreads(__tstate);
33149 if (PyErr_Occurred()) SWIG_fail;
33150 }
33151 {
33152 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33153 }
33154 return resultobj;
33155 fail:
33156 return NULL;
33157 }
33158
33159
33160 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33161 PyObject *resultobj = 0;
33162 wxWindow *arg1 = (wxWindow *) 0 ;
33163 wxString *arg2 = 0 ;
33164 void *argp1 = 0 ;
33165 int res1 = 0 ;
33166 bool temp2 = false ;
33167 PyObject * obj0 = 0 ;
33168 PyObject * obj1 = 0 ;
33169 char * kwnames[] = {
33170 (char *) "self",(char *) "label", NULL
33171 };
33172
33173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33175 if (!SWIG_IsOK(res1)) {
33176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33177 }
33178 arg1 = reinterpret_cast< wxWindow * >(argp1);
33179 {
33180 arg2 = wxString_in_helper(obj1);
33181 if (arg2 == NULL) SWIG_fail;
33182 temp2 = true;
33183 }
33184 {
33185 PyThreadState* __tstate = wxPyBeginAllowThreads();
33186 (arg1)->SetLabel((wxString const &)*arg2);
33187 wxPyEndAllowThreads(__tstate);
33188 if (PyErr_Occurred()) SWIG_fail;
33189 }
33190 resultobj = SWIG_Py_Void();
33191 {
33192 if (temp2)
33193 delete arg2;
33194 }
33195 return resultobj;
33196 fail:
33197 {
33198 if (temp2)
33199 delete arg2;
33200 }
33201 return NULL;
33202 }
33203
33204
33205 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33206 PyObject *resultobj = 0;
33207 wxWindow *arg1 = (wxWindow *) 0 ;
33208 wxString result;
33209 void *argp1 = 0 ;
33210 int res1 = 0 ;
33211 PyObject *swig_obj[1] ;
33212
33213 if (!args) SWIG_fail;
33214 swig_obj[0] = args;
33215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33216 if (!SWIG_IsOK(res1)) {
33217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33218 }
33219 arg1 = reinterpret_cast< wxWindow * >(argp1);
33220 {
33221 PyThreadState* __tstate = wxPyBeginAllowThreads();
33222 result = ((wxWindow const *)arg1)->GetLabel();
33223 wxPyEndAllowThreads(__tstate);
33224 if (PyErr_Occurred()) SWIG_fail;
33225 }
33226 {
33227 #if wxUSE_UNICODE
33228 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33229 #else
33230 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33231 #endif
33232 }
33233 return resultobj;
33234 fail:
33235 return NULL;
33236 }
33237
33238
33239 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33240 PyObject *resultobj = 0;
33241 wxWindow *arg1 = (wxWindow *) 0 ;
33242 wxString *arg2 = 0 ;
33243 void *argp1 = 0 ;
33244 int res1 = 0 ;
33245 bool temp2 = false ;
33246 PyObject * obj0 = 0 ;
33247 PyObject * obj1 = 0 ;
33248 char * kwnames[] = {
33249 (char *) "self",(char *) "name", NULL
33250 };
33251
33252 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33253 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33254 if (!SWIG_IsOK(res1)) {
33255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33256 }
33257 arg1 = reinterpret_cast< wxWindow * >(argp1);
33258 {
33259 arg2 = wxString_in_helper(obj1);
33260 if (arg2 == NULL) SWIG_fail;
33261 temp2 = true;
33262 }
33263 {
33264 PyThreadState* __tstate = wxPyBeginAllowThreads();
33265 (arg1)->SetName((wxString const &)*arg2);
33266 wxPyEndAllowThreads(__tstate);
33267 if (PyErr_Occurred()) SWIG_fail;
33268 }
33269 resultobj = SWIG_Py_Void();
33270 {
33271 if (temp2)
33272 delete arg2;
33273 }
33274 return resultobj;
33275 fail:
33276 {
33277 if (temp2)
33278 delete arg2;
33279 }
33280 return NULL;
33281 }
33282
33283
33284 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33285 PyObject *resultobj = 0;
33286 wxWindow *arg1 = (wxWindow *) 0 ;
33287 wxString result;
33288 void *argp1 = 0 ;
33289 int res1 = 0 ;
33290 PyObject *swig_obj[1] ;
33291
33292 if (!args) SWIG_fail;
33293 swig_obj[0] = args;
33294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33295 if (!SWIG_IsOK(res1)) {
33296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33297 }
33298 arg1 = reinterpret_cast< wxWindow * >(argp1);
33299 {
33300 PyThreadState* __tstate = wxPyBeginAllowThreads();
33301 result = ((wxWindow const *)arg1)->GetName();
33302 wxPyEndAllowThreads(__tstate);
33303 if (PyErr_Occurred()) SWIG_fail;
33304 }
33305 {
33306 #if wxUSE_UNICODE
33307 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33308 #else
33309 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33310 #endif
33311 }
33312 return resultobj;
33313 fail:
33314 return NULL;
33315 }
33316
33317
33318 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33319 PyObject *resultobj = 0;
33320 wxWindow *arg1 = (wxWindow *) 0 ;
33321 wxWindowVariant arg2 ;
33322 void *argp1 = 0 ;
33323 int res1 = 0 ;
33324 int val2 ;
33325 int ecode2 = 0 ;
33326 PyObject * obj0 = 0 ;
33327 PyObject * obj1 = 0 ;
33328 char * kwnames[] = {
33329 (char *) "self",(char *) "variant", NULL
33330 };
33331
33332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33334 if (!SWIG_IsOK(res1)) {
33335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33336 }
33337 arg1 = reinterpret_cast< wxWindow * >(argp1);
33338 ecode2 = SWIG_AsVal_int(obj1, &val2);
33339 if (!SWIG_IsOK(ecode2)) {
33340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33341 }
33342 arg2 = static_cast< wxWindowVariant >(val2);
33343 {
33344 PyThreadState* __tstate = wxPyBeginAllowThreads();
33345 (arg1)->SetWindowVariant(arg2);
33346 wxPyEndAllowThreads(__tstate);
33347 if (PyErr_Occurred()) SWIG_fail;
33348 }
33349 resultobj = SWIG_Py_Void();
33350 return resultobj;
33351 fail:
33352 return NULL;
33353 }
33354
33355
33356 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33357 PyObject *resultobj = 0;
33358 wxWindow *arg1 = (wxWindow *) 0 ;
33359 wxWindowVariant result;
33360 void *argp1 = 0 ;
33361 int res1 = 0 ;
33362 PyObject *swig_obj[1] ;
33363
33364 if (!args) SWIG_fail;
33365 swig_obj[0] = args;
33366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33367 if (!SWIG_IsOK(res1)) {
33368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33369 }
33370 arg1 = reinterpret_cast< wxWindow * >(argp1);
33371 {
33372 PyThreadState* __tstate = wxPyBeginAllowThreads();
33373 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33374 wxPyEndAllowThreads(__tstate);
33375 if (PyErr_Occurred()) SWIG_fail;
33376 }
33377 resultobj = SWIG_From_int(static_cast< int >(result));
33378 return resultobj;
33379 fail:
33380 return NULL;
33381 }
33382
33383
33384 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33385 PyObject *resultobj = 0;
33386 wxWindow *arg1 = (wxWindow *) 0 ;
33387 int arg2 ;
33388 void *argp1 = 0 ;
33389 int res1 = 0 ;
33390 int val2 ;
33391 int ecode2 = 0 ;
33392 PyObject * obj0 = 0 ;
33393 PyObject * obj1 = 0 ;
33394 char * kwnames[] = {
33395 (char *) "self",(char *) "winid", NULL
33396 };
33397
33398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33400 if (!SWIG_IsOK(res1)) {
33401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33402 }
33403 arg1 = reinterpret_cast< wxWindow * >(argp1);
33404 ecode2 = SWIG_AsVal_int(obj1, &val2);
33405 if (!SWIG_IsOK(ecode2)) {
33406 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33407 }
33408 arg2 = static_cast< int >(val2);
33409 {
33410 PyThreadState* __tstate = wxPyBeginAllowThreads();
33411 (arg1)->SetId(arg2);
33412 wxPyEndAllowThreads(__tstate);
33413 if (PyErr_Occurred()) SWIG_fail;
33414 }
33415 resultobj = SWIG_Py_Void();
33416 return resultobj;
33417 fail:
33418 return NULL;
33419 }
33420
33421
33422 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33423 PyObject *resultobj = 0;
33424 wxWindow *arg1 = (wxWindow *) 0 ;
33425 int result;
33426 void *argp1 = 0 ;
33427 int res1 = 0 ;
33428 PyObject *swig_obj[1] ;
33429
33430 if (!args) SWIG_fail;
33431 swig_obj[0] = args;
33432 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33433 if (!SWIG_IsOK(res1)) {
33434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33435 }
33436 arg1 = reinterpret_cast< wxWindow * >(argp1);
33437 {
33438 PyThreadState* __tstate = wxPyBeginAllowThreads();
33439 result = (int)((wxWindow const *)arg1)->GetId();
33440 wxPyEndAllowThreads(__tstate);
33441 if (PyErr_Occurred()) SWIG_fail;
33442 }
33443 resultobj = SWIG_From_int(static_cast< int >(result));
33444 return resultobj;
33445 fail:
33446 return NULL;
33447 }
33448
33449
33450 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33451 PyObject *resultobj = 0;
33452 int result;
33453
33454 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33455 {
33456 PyThreadState* __tstate = wxPyBeginAllowThreads();
33457 result = (int)wxWindow::NewControlId();
33458 wxPyEndAllowThreads(__tstate);
33459 if (PyErr_Occurred()) SWIG_fail;
33460 }
33461 resultobj = SWIG_From_int(static_cast< int >(result));
33462 return resultobj;
33463 fail:
33464 return NULL;
33465 }
33466
33467
33468 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33469 PyObject *resultobj = 0;
33470 int arg1 ;
33471 int result;
33472 int val1 ;
33473 int ecode1 = 0 ;
33474 PyObject * obj0 = 0 ;
33475 char * kwnames[] = {
33476 (char *) "winid", NULL
33477 };
33478
33479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33480 ecode1 = SWIG_AsVal_int(obj0, &val1);
33481 if (!SWIG_IsOK(ecode1)) {
33482 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33483 }
33484 arg1 = static_cast< int >(val1);
33485 {
33486 PyThreadState* __tstate = wxPyBeginAllowThreads();
33487 result = (int)wxWindow::NextControlId(arg1);
33488 wxPyEndAllowThreads(__tstate);
33489 if (PyErr_Occurred()) SWIG_fail;
33490 }
33491 resultobj = SWIG_From_int(static_cast< int >(result));
33492 return resultobj;
33493 fail:
33494 return NULL;
33495 }
33496
33497
33498 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33499 PyObject *resultobj = 0;
33500 int arg1 ;
33501 int result;
33502 int val1 ;
33503 int ecode1 = 0 ;
33504 PyObject * obj0 = 0 ;
33505 char * kwnames[] = {
33506 (char *) "winid", NULL
33507 };
33508
33509 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33510 ecode1 = SWIG_AsVal_int(obj0, &val1);
33511 if (!SWIG_IsOK(ecode1)) {
33512 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33513 }
33514 arg1 = static_cast< int >(val1);
33515 {
33516 PyThreadState* __tstate = wxPyBeginAllowThreads();
33517 result = (int)wxWindow::PrevControlId(arg1);
33518 wxPyEndAllowThreads(__tstate);
33519 if (PyErr_Occurred()) SWIG_fail;
33520 }
33521 resultobj = SWIG_From_int(static_cast< int >(result));
33522 return resultobj;
33523 fail:
33524 return NULL;
33525 }
33526
33527
33528 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33529 PyObject *resultobj = 0;
33530 wxWindow *arg1 = (wxWindow *) 0 ;
33531 wxLayoutDirection result;
33532 void *argp1 = 0 ;
33533 int res1 = 0 ;
33534 PyObject *swig_obj[1] ;
33535
33536 if (!args) SWIG_fail;
33537 swig_obj[0] = args;
33538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33539 if (!SWIG_IsOK(res1)) {
33540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33541 }
33542 arg1 = reinterpret_cast< wxWindow * >(argp1);
33543 {
33544 PyThreadState* __tstate = wxPyBeginAllowThreads();
33545 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33546 wxPyEndAllowThreads(__tstate);
33547 if (PyErr_Occurred()) SWIG_fail;
33548 }
33549 resultobj = SWIG_From_int(static_cast< int >(result));
33550 return resultobj;
33551 fail:
33552 return NULL;
33553 }
33554
33555
33556 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33557 PyObject *resultobj = 0;
33558 wxWindow *arg1 = (wxWindow *) 0 ;
33559 wxLayoutDirection arg2 ;
33560 void *argp1 = 0 ;
33561 int res1 = 0 ;
33562 int val2 ;
33563 int ecode2 = 0 ;
33564 PyObject * obj0 = 0 ;
33565 PyObject * obj1 = 0 ;
33566 char * kwnames[] = {
33567 (char *) "self",(char *) "dir", NULL
33568 };
33569
33570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33572 if (!SWIG_IsOK(res1)) {
33573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33574 }
33575 arg1 = reinterpret_cast< wxWindow * >(argp1);
33576 ecode2 = SWIG_AsVal_int(obj1, &val2);
33577 if (!SWIG_IsOK(ecode2)) {
33578 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33579 }
33580 arg2 = static_cast< wxLayoutDirection >(val2);
33581 {
33582 PyThreadState* __tstate = wxPyBeginAllowThreads();
33583 (arg1)->SetLayoutDirection(arg2);
33584 wxPyEndAllowThreads(__tstate);
33585 if (PyErr_Occurred()) SWIG_fail;
33586 }
33587 resultobj = SWIG_Py_Void();
33588 return resultobj;
33589 fail:
33590 return NULL;
33591 }
33592
33593
33594 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33595 PyObject *resultobj = 0;
33596 wxWindow *arg1 = (wxWindow *) 0 ;
33597 int arg2 ;
33598 int arg3 ;
33599 int arg4 ;
33600 int result;
33601 void *argp1 = 0 ;
33602 int res1 = 0 ;
33603 int val2 ;
33604 int ecode2 = 0 ;
33605 int val3 ;
33606 int ecode3 = 0 ;
33607 int val4 ;
33608 int ecode4 = 0 ;
33609 PyObject * obj0 = 0 ;
33610 PyObject * obj1 = 0 ;
33611 PyObject * obj2 = 0 ;
33612 PyObject * obj3 = 0 ;
33613 char * kwnames[] = {
33614 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33615 };
33616
33617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33619 if (!SWIG_IsOK(res1)) {
33620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33621 }
33622 arg1 = reinterpret_cast< wxWindow * >(argp1);
33623 ecode2 = SWIG_AsVal_int(obj1, &val2);
33624 if (!SWIG_IsOK(ecode2)) {
33625 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33626 }
33627 arg2 = static_cast< int >(val2);
33628 ecode3 = SWIG_AsVal_int(obj2, &val3);
33629 if (!SWIG_IsOK(ecode3)) {
33630 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33631 }
33632 arg3 = static_cast< int >(val3);
33633 ecode4 = SWIG_AsVal_int(obj3, &val4);
33634 if (!SWIG_IsOK(ecode4)) {
33635 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33636 }
33637 arg4 = static_cast< int >(val4);
33638 {
33639 PyThreadState* __tstate = wxPyBeginAllowThreads();
33640 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33641 wxPyEndAllowThreads(__tstate);
33642 if (PyErr_Occurred()) SWIG_fail;
33643 }
33644 resultobj = SWIG_From_int(static_cast< int >(result));
33645 return resultobj;
33646 fail:
33647 return NULL;
33648 }
33649
33650
33651 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33652 PyObject *resultobj = 0;
33653 wxWindow *arg1 = (wxWindow *) 0 ;
33654 wxSize *arg2 = 0 ;
33655 void *argp1 = 0 ;
33656 int res1 = 0 ;
33657 wxSize temp2 ;
33658 PyObject * obj0 = 0 ;
33659 PyObject * obj1 = 0 ;
33660 char * kwnames[] = {
33661 (char *) "self",(char *) "size", NULL
33662 };
33663
33664 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33665 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33666 if (!SWIG_IsOK(res1)) {
33667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33668 }
33669 arg1 = reinterpret_cast< wxWindow * >(argp1);
33670 {
33671 arg2 = &temp2;
33672 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33673 }
33674 {
33675 PyThreadState* __tstate = wxPyBeginAllowThreads();
33676 (arg1)->SetSize((wxSize const &)*arg2);
33677 wxPyEndAllowThreads(__tstate);
33678 if (PyErr_Occurred()) SWIG_fail;
33679 }
33680 resultobj = SWIG_Py_Void();
33681 return resultobj;
33682 fail:
33683 return NULL;
33684 }
33685
33686
33687 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33688 PyObject *resultobj = 0;
33689 wxWindow *arg1 = (wxWindow *) 0 ;
33690 int arg2 ;
33691 int arg3 ;
33692 int arg4 ;
33693 int arg5 ;
33694 int arg6 = (int) wxSIZE_AUTO ;
33695 void *argp1 = 0 ;
33696 int res1 = 0 ;
33697 int val2 ;
33698 int ecode2 = 0 ;
33699 int val3 ;
33700 int ecode3 = 0 ;
33701 int val4 ;
33702 int ecode4 = 0 ;
33703 int val5 ;
33704 int ecode5 = 0 ;
33705 int val6 ;
33706 int ecode6 = 0 ;
33707 PyObject * obj0 = 0 ;
33708 PyObject * obj1 = 0 ;
33709 PyObject * obj2 = 0 ;
33710 PyObject * obj3 = 0 ;
33711 PyObject * obj4 = 0 ;
33712 PyObject * obj5 = 0 ;
33713 char * kwnames[] = {
33714 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33715 };
33716
33717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33719 if (!SWIG_IsOK(res1)) {
33720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33721 }
33722 arg1 = reinterpret_cast< wxWindow * >(argp1);
33723 ecode2 = SWIG_AsVal_int(obj1, &val2);
33724 if (!SWIG_IsOK(ecode2)) {
33725 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33726 }
33727 arg2 = static_cast< int >(val2);
33728 ecode3 = SWIG_AsVal_int(obj2, &val3);
33729 if (!SWIG_IsOK(ecode3)) {
33730 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33731 }
33732 arg3 = static_cast< int >(val3);
33733 ecode4 = SWIG_AsVal_int(obj3, &val4);
33734 if (!SWIG_IsOK(ecode4)) {
33735 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33736 }
33737 arg4 = static_cast< int >(val4);
33738 ecode5 = SWIG_AsVal_int(obj4, &val5);
33739 if (!SWIG_IsOK(ecode5)) {
33740 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33741 }
33742 arg5 = static_cast< int >(val5);
33743 if (obj5) {
33744 ecode6 = SWIG_AsVal_int(obj5, &val6);
33745 if (!SWIG_IsOK(ecode6)) {
33746 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33747 }
33748 arg6 = static_cast< int >(val6);
33749 }
33750 {
33751 PyThreadState* __tstate = wxPyBeginAllowThreads();
33752 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33753 wxPyEndAllowThreads(__tstate);
33754 if (PyErr_Occurred()) SWIG_fail;
33755 }
33756 resultobj = SWIG_Py_Void();
33757 return resultobj;
33758 fail:
33759 return NULL;
33760 }
33761
33762
33763 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33764 PyObject *resultobj = 0;
33765 wxWindow *arg1 = (wxWindow *) 0 ;
33766 wxRect *arg2 = 0 ;
33767 int arg3 = (int) wxSIZE_AUTO ;
33768 void *argp1 = 0 ;
33769 int res1 = 0 ;
33770 wxRect temp2 ;
33771 int val3 ;
33772 int ecode3 = 0 ;
33773 PyObject * obj0 = 0 ;
33774 PyObject * obj1 = 0 ;
33775 PyObject * obj2 = 0 ;
33776 char * kwnames[] = {
33777 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33778 };
33779
33780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33782 if (!SWIG_IsOK(res1)) {
33783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33784 }
33785 arg1 = reinterpret_cast< wxWindow * >(argp1);
33786 {
33787 arg2 = &temp2;
33788 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33789 }
33790 if (obj2) {
33791 ecode3 = SWIG_AsVal_int(obj2, &val3);
33792 if (!SWIG_IsOK(ecode3)) {
33793 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33794 }
33795 arg3 = static_cast< int >(val3);
33796 }
33797 {
33798 PyThreadState* __tstate = wxPyBeginAllowThreads();
33799 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33800 wxPyEndAllowThreads(__tstate);
33801 if (PyErr_Occurred()) SWIG_fail;
33802 }
33803 resultobj = SWIG_Py_Void();
33804 return resultobj;
33805 fail:
33806 return NULL;
33807 }
33808
33809
33810 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33811 PyObject *resultobj = 0;
33812 wxWindow *arg1 = (wxWindow *) 0 ;
33813 int arg2 ;
33814 int arg3 ;
33815 void *argp1 = 0 ;
33816 int res1 = 0 ;
33817 int val2 ;
33818 int ecode2 = 0 ;
33819 int val3 ;
33820 int ecode3 = 0 ;
33821 PyObject * obj0 = 0 ;
33822 PyObject * obj1 = 0 ;
33823 PyObject * obj2 = 0 ;
33824 char * kwnames[] = {
33825 (char *) "self",(char *) "width",(char *) "height", NULL
33826 };
33827
33828 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33829 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33830 if (!SWIG_IsOK(res1)) {
33831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33832 }
33833 arg1 = reinterpret_cast< wxWindow * >(argp1);
33834 ecode2 = SWIG_AsVal_int(obj1, &val2);
33835 if (!SWIG_IsOK(ecode2)) {
33836 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33837 }
33838 arg2 = static_cast< int >(val2);
33839 ecode3 = SWIG_AsVal_int(obj2, &val3);
33840 if (!SWIG_IsOK(ecode3)) {
33841 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33842 }
33843 arg3 = static_cast< int >(val3);
33844 {
33845 PyThreadState* __tstate = wxPyBeginAllowThreads();
33846 (arg1)->SetSize(arg2,arg3);
33847 wxPyEndAllowThreads(__tstate);
33848 if (PyErr_Occurred()) SWIG_fail;
33849 }
33850 resultobj = SWIG_Py_Void();
33851 return resultobj;
33852 fail:
33853 return NULL;
33854 }
33855
33856
33857 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33858 PyObject *resultobj = 0;
33859 wxWindow *arg1 = (wxWindow *) 0 ;
33860 wxPoint *arg2 = 0 ;
33861 int arg3 = (int) wxSIZE_USE_EXISTING ;
33862 void *argp1 = 0 ;
33863 int res1 = 0 ;
33864 wxPoint temp2 ;
33865 int val3 ;
33866 int ecode3 = 0 ;
33867 PyObject * obj0 = 0 ;
33868 PyObject * obj1 = 0 ;
33869 PyObject * obj2 = 0 ;
33870 char * kwnames[] = {
33871 (char *) "self",(char *) "pt",(char *) "flags", NULL
33872 };
33873
33874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33876 if (!SWIG_IsOK(res1)) {
33877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33878 }
33879 arg1 = reinterpret_cast< wxWindow * >(argp1);
33880 {
33881 arg2 = &temp2;
33882 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33883 }
33884 if (obj2) {
33885 ecode3 = SWIG_AsVal_int(obj2, &val3);
33886 if (!SWIG_IsOK(ecode3)) {
33887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33888 }
33889 arg3 = static_cast< int >(val3);
33890 }
33891 {
33892 PyThreadState* __tstate = wxPyBeginAllowThreads();
33893 (arg1)->Move((wxPoint const &)*arg2,arg3);
33894 wxPyEndAllowThreads(__tstate);
33895 if (PyErr_Occurred()) SWIG_fail;
33896 }
33897 resultobj = SWIG_Py_Void();
33898 return resultobj;
33899 fail:
33900 return NULL;
33901 }
33902
33903
33904 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33905 PyObject *resultobj = 0;
33906 wxWindow *arg1 = (wxWindow *) 0 ;
33907 int arg2 ;
33908 int arg3 ;
33909 int arg4 = (int) wxSIZE_USE_EXISTING ;
33910 void *argp1 = 0 ;
33911 int res1 = 0 ;
33912 int val2 ;
33913 int ecode2 = 0 ;
33914 int val3 ;
33915 int ecode3 = 0 ;
33916 int val4 ;
33917 int ecode4 = 0 ;
33918 PyObject * obj0 = 0 ;
33919 PyObject * obj1 = 0 ;
33920 PyObject * obj2 = 0 ;
33921 PyObject * obj3 = 0 ;
33922 char * kwnames[] = {
33923 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33924 };
33925
33926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33928 if (!SWIG_IsOK(res1)) {
33929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33930 }
33931 arg1 = reinterpret_cast< wxWindow * >(argp1);
33932 ecode2 = SWIG_AsVal_int(obj1, &val2);
33933 if (!SWIG_IsOK(ecode2)) {
33934 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33935 }
33936 arg2 = static_cast< int >(val2);
33937 ecode3 = SWIG_AsVal_int(obj2, &val3);
33938 if (!SWIG_IsOK(ecode3)) {
33939 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33940 }
33941 arg3 = static_cast< int >(val3);
33942 if (obj3) {
33943 ecode4 = SWIG_AsVal_int(obj3, &val4);
33944 if (!SWIG_IsOK(ecode4)) {
33945 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33946 }
33947 arg4 = static_cast< int >(val4);
33948 }
33949 {
33950 PyThreadState* __tstate = wxPyBeginAllowThreads();
33951 (arg1)->Move(arg2,arg3,arg4);
33952 wxPyEndAllowThreads(__tstate);
33953 if (PyErr_Occurred()) SWIG_fail;
33954 }
33955 resultobj = SWIG_Py_Void();
33956 return resultobj;
33957 fail:
33958 return NULL;
33959 }
33960
33961
33962 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33963 PyObject *resultobj = 0;
33964 wxWindow *arg1 = (wxWindow *) 0 ;
33965 wxSize const &arg2_defvalue = wxDefaultSize ;
33966 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33967 void *argp1 = 0 ;
33968 int res1 = 0 ;
33969 wxSize temp2 ;
33970 PyObject * obj0 = 0 ;
33971 PyObject * obj1 = 0 ;
33972 char * kwnames[] = {
33973 (char *) "self",(char *) "size", NULL
33974 };
33975
33976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33978 if (!SWIG_IsOK(res1)) {
33979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33980 }
33981 arg1 = reinterpret_cast< wxWindow * >(argp1);
33982 if (obj1) {
33983 {
33984 arg2 = &temp2;
33985 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33986 }
33987 }
33988 {
33989 PyThreadState* __tstate = wxPyBeginAllowThreads();
33990 (arg1)->SetInitialSize((wxSize const &)*arg2);
33991 wxPyEndAllowThreads(__tstate);
33992 if (PyErr_Occurred()) SWIG_fail;
33993 }
33994 resultobj = SWIG_Py_Void();
33995 return resultobj;
33996 fail:
33997 return NULL;
33998 }
33999
34000
34001 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34002 PyObject *resultobj = 0;
34003 wxWindow *arg1 = (wxWindow *) 0 ;
34004 void *argp1 = 0 ;
34005 int res1 = 0 ;
34006 PyObject *swig_obj[1] ;
34007
34008 if (!args) SWIG_fail;
34009 swig_obj[0] = args;
34010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34011 if (!SWIG_IsOK(res1)) {
34012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34013 }
34014 arg1 = reinterpret_cast< wxWindow * >(argp1);
34015 {
34016 PyThreadState* __tstate = wxPyBeginAllowThreads();
34017 (arg1)->Raise();
34018 wxPyEndAllowThreads(__tstate);
34019 if (PyErr_Occurred()) SWIG_fail;
34020 }
34021 resultobj = SWIG_Py_Void();
34022 return resultobj;
34023 fail:
34024 return NULL;
34025 }
34026
34027
34028 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34029 PyObject *resultobj = 0;
34030 wxWindow *arg1 = (wxWindow *) 0 ;
34031 void *argp1 = 0 ;
34032 int res1 = 0 ;
34033 PyObject *swig_obj[1] ;
34034
34035 if (!args) SWIG_fail;
34036 swig_obj[0] = args;
34037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34038 if (!SWIG_IsOK(res1)) {
34039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34040 }
34041 arg1 = reinterpret_cast< wxWindow * >(argp1);
34042 {
34043 PyThreadState* __tstate = wxPyBeginAllowThreads();
34044 (arg1)->Lower();
34045 wxPyEndAllowThreads(__tstate);
34046 if (PyErr_Occurred()) SWIG_fail;
34047 }
34048 resultobj = SWIG_Py_Void();
34049 return resultobj;
34050 fail:
34051 return NULL;
34052 }
34053
34054
34055 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34056 PyObject *resultobj = 0;
34057 wxWindow *arg1 = (wxWindow *) 0 ;
34058 wxSize *arg2 = 0 ;
34059 void *argp1 = 0 ;
34060 int res1 = 0 ;
34061 wxSize temp2 ;
34062 PyObject * obj0 = 0 ;
34063 PyObject * obj1 = 0 ;
34064 char * kwnames[] = {
34065 (char *) "self",(char *) "size", NULL
34066 };
34067
34068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34070 if (!SWIG_IsOK(res1)) {
34071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34072 }
34073 arg1 = reinterpret_cast< wxWindow * >(argp1);
34074 {
34075 arg2 = &temp2;
34076 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34077 }
34078 {
34079 PyThreadState* __tstate = wxPyBeginAllowThreads();
34080 (arg1)->SetClientSize((wxSize const &)*arg2);
34081 wxPyEndAllowThreads(__tstate);
34082 if (PyErr_Occurred()) SWIG_fail;
34083 }
34084 resultobj = SWIG_Py_Void();
34085 return resultobj;
34086 fail:
34087 return NULL;
34088 }
34089
34090
34091 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34092 PyObject *resultobj = 0;
34093 wxWindow *arg1 = (wxWindow *) 0 ;
34094 int arg2 ;
34095 int arg3 ;
34096 void *argp1 = 0 ;
34097 int res1 = 0 ;
34098 int val2 ;
34099 int ecode2 = 0 ;
34100 int val3 ;
34101 int ecode3 = 0 ;
34102 PyObject * obj0 = 0 ;
34103 PyObject * obj1 = 0 ;
34104 PyObject * obj2 = 0 ;
34105 char * kwnames[] = {
34106 (char *) "self",(char *) "width",(char *) "height", NULL
34107 };
34108
34109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34111 if (!SWIG_IsOK(res1)) {
34112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34113 }
34114 arg1 = reinterpret_cast< wxWindow * >(argp1);
34115 ecode2 = SWIG_AsVal_int(obj1, &val2);
34116 if (!SWIG_IsOK(ecode2)) {
34117 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34118 }
34119 arg2 = static_cast< int >(val2);
34120 ecode3 = SWIG_AsVal_int(obj2, &val3);
34121 if (!SWIG_IsOK(ecode3)) {
34122 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34123 }
34124 arg3 = static_cast< int >(val3);
34125 {
34126 PyThreadState* __tstate = wxPyBeginAllowThreads();
34127 (arg1)->SetClientSize(arg2,arg3);
34128 wxPyEndAllowThreads(__tstate);
34129 if (PyErr_Occurred()) SWIG_fail;
34130 }
34131 resultobj = SWIG_Py_Void();
34132 return resultobj;
34133 fail:
34134 return NULL;
34135 }
34136
34137
34138 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34139 PyObject *resultobj = 0;
34140 wxWindow *arg1 = (wxWindow *) 0 ;
34141 wxRect *arg2 = 0 ;
34142 void *argp1 = 0 ;
34143 int res1 = 0 ;
34144 wxRect temp2 ;
34145 PyObject * obj0 = 0 ;
34146 PyObject * obj1 = 0 ;
34147 char * kwnames[] = {
34148 (char *) "self",(char *) "rect", NULL
34149 };
34150
34151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34153 if (!SWIG_IsOK(res1)) {
34154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34155 }
34156 arg1 = reinterpret_cast< wxWindow * >(argp1);
34157 {
34158 arg2 = &temp2;
34159 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34160 }
34161 {
34162 PyThreadState* __tstate = wxPyBeginAllowThreads();
34163 (arg1)->SetClientSize((wxRect const &)*arg2);
34164 wxPyEndAllowThreads(__tstate);
34165 if (PyErr_Occurred()) SWIG_fail;
34166 }
34167 resultobj = SWIG_Py_Void();
34168 return resultobj;
34169 fail:
34170 return NULL;
34171 }
34172
34173
34174 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34175 PyObject *resultobj = 0;
34176 wxWindow *arg1 = (wxWindow *) 0 ;
34177 wxPoint result;
34178 void *argp1 = 0 ;
34179 int res1 = 0 ;
34180 PyObject *swig_obj[1] ;
34181
34182 if (!args) SWIG_fail;
34183 swig_obj[0] = args;
34184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34185 if (!SWIG_IsOK(res1)) {
34186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34187 }
34188 arg1 = reinterpret_cast< wxWindow * >(argp1);
34189 {
34190 PyThreadState* __tstate = wxPyBeginAllowThreads();
34191 result = ((wxWindow const *)arg1)->GetPosition();
34192 wxPyEndAllowThreads(__tstate);
34193 if (PyErr_Occurred()) SWIG_fail;
34194 }
34195 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34196 return resultobj;
34197 fail:
34198 return NULL;
34199 }
34200
34201
34202 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34203 PyObject *resultobj = 0;
34204 wxWindow *arg1 = (wxWindow *) 0 ;
34205 int *arg2 = (int *) 0 ;
34206 int *arg3 = (int *) 0 ;
34207 void *argp1 = 0 ;
34208 int res1 = 0 ;
34209 int temp2 ;
34210 int res2 = SWIG_TMPOBJ ;
34211 int temp3 ;
34212 int res3 = SWIG_TMPOBJ ;
34213 PyObject *swig_obj[1] ;
34214
34215 arg2 = &temp2;
34216 arg3 = &temp3;
34217 if (!args) SWIG_fail;
34218 swig_obj[0] = args;
34219 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34220 if (!SWIG_IsOK(res1)) {
34221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34222 }
34223 arg1 = reinterpret_cast< wxWindow * >(argp1);
34224 {
34225 PyThreadState* __tstate = wxPyBeginAllowThreads();
34226 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34227 wxPyEndAllowThreads(__tstate);
34228 if (PyErr_Occurred()) SWIG_fail;
34229 }
34230 resultobj = SWIG_Py_Void();
34231 if (SWIG_IsTmpObj(res2)) {
34232 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34233 } else {
34234 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34235 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34236 }
34237 if (SWIG_IsTmpObj(res3)) {
34238 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34239 } else {
34240 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34241 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34242 }
34243 return resultobj;
34244 fail:
34245 return NULL;
34246 }
34247
34248
34249 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34250 PyObject *resultobj = 0;
34251 wxWindow *arg1 = (wxWindow *) 0 ;
34252 wxPoint result;
34253 void *argp1 = 0 ;
34254 int res1 = 0 ;
34255 PyObject *swig_obj[1] ;
34256
34257 if (!args) SWIG_fail;
34258 swig_obj[0] = args;
34259 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34260 if (!SWIG_IsOK(res1)) {
34261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34262 }
34263 arg1 = reinterpret_cast< wxWindow * >(argp1);
34264 {
34265 PyThreadState* __tstate = wxPyBeginAllowThreads();
34266 result = ((wxWindow const *)arg1)->GetScreenPosition();
34267 wxPyEndAllowThreads(__tstate);
34268 if (PyErr_Occurred()) SWIG_fail;
34269 }
34270 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34271 return resultobj;
34272 fail:
34273 return NULL;
34274 }
34275
34276
34277 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34278 PyObject *resultobj = 0;
34279 wxWindow *arg1 = (wxWindow *) 0 ;
34280 int *arg2 = (int *) 0 ;
34281 int *arg3 = (int *) 0 ;
34282 void *argp1 = 0 ;
34283 int res1 = 0 ;
34284 int temp2 ;
34285 int res2 = SWIG_TMPOBJ ;
34286 int temp3 ;
34287 int res3 = SWIG_TMPOBJ ;
34288 PyObject *swig_obj[1] ;
34289
34290 arg2 = &temp2;
34291 arg3 = &temp3;
34292 if (!args) SWIG_fail;
34293 swig_obj[0] = args;
34294 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34295 if (!SWIG_IsOK(res1)) {
34296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34297 }
34298 arg1 = reinterpret_cast< wxWindow * >(argp1);
34299 {
34300 PyThreadState* __tstate = wxPyBeginAllowThreads();
34301 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34302 wxPyEndAllowThreads(__tstate);
34303 if (PyErr_Occurred()) SWIG_fail;
34304 }
34305 resultobj = SWIG_Py_Void();
34306 if (SWIG_IsTmpObj(res2)) {
34307 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34308 } else {
34309 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34310 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34311 }
34312 if (SWIG_IsTmpObj(res3)) {
34313 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34314 } else {
34315 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34316 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34317 }
34318 return resultobj;
34319 fail:
34320 return NULL;
34321 }
34322
34323
34324 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34325 PyObject *resultobj = 0;
34326 wxWindow *arg1 = (wxWindow *) 0 ;
34327 wxRect result;
34328 void *argp1 = 0 ;
34329 int res1 = 0 ;
34330 PyObject *swig_obj[1] ;
34331
34332 if (!args) SWIG_fail;
34333 swig_obj[0] = args;
34334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34335 if (!SWIG_IsOK(res1)) {
34336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34337 }
34338 arg1 = reinterpret_cast< wxWindow * >(argp1);
34339 {
34340 PyThreadState* __tstate = wxPyBeginAllowThreads();
34341 result = ((wxWindow const *)arg1)->GetScreenRect();
34342 wxPyEndAllowThreads(__tstate);
34343 if (PyErr_Occurred()) SWIG_fail;
34344 }
34345 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34346 return resultobj;
34347 fail:
34348 return NULL;
34349 }
34350
34351
34352 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34353 PyObject *resultobj = 0;
34354 wxWindow *arg1 = (wxWindow *) 0 ;
34355 wxSize result;
34356 void *argp1 = 0 ;
34357 int res1 = 0 ;
34358 PyObject *swig_obj[1] ;
34359
34360 if (!args) SWIG_fail;
34361 swig_obj[0] = args;
34362 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34363 if (!SWIG_IsOK(res1)) {
34364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34365 }
34366 arg1 = reinterpret_cast< wxWindow * >(argp1);
34367 {
34368 PyThreadState* __tstate = wxPyBeginAllowThreads();
34369 result = ((wxWindow const *)arg1)->GetSize();
34370 wxPyEndAllowThreads(__tstate);
34371 if (PyErr_Occurred()) SWIG_fail;
34372 }
34373 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34374 return resultobj;
34375 fail:
34376 return NULL;
34377 }
34378
34379
34380 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34381 PyObject *resultobj = 0;
34382 wxWindow *arg1 = (wxWindow *) 0 ;
34383 int *arg2 = (int *) 0 ;
34384 int *arg3 = (int *) 0 ;
34385 void *argp1 = 0 ;
34386 int res1 = 0 ;
34387 int temp2 ;
34388 int res2 = SWIG_TMPOBJ ;
34389 int temp3 ;
34390 int res3 = SWIG_TMPOBJ ;
34391 PyObject *swig_obj[1] ;
34392
34393 arg2 = &temp2;
34394 arg3 = &temp3;
34395 if (!args) SWIG_fail;
34396 swig_obj[0] = args;
34397 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34398 if (!SWIG_IsOK(res1)) {
34399 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34400 }
34401 arg1 = reinterpret_cast< wxWindow * >(argp1);
34402 {
34403 PyThreadState* __tstate = wxPyBeginAllowThreads();
34404 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34405 wxPyEndAllowThreads(__tstate);
34406 if (PyErr_Occurred()) SWIG_fail;
34407 }
34408 resultobj = SWIG_Py_Void();
34409 if (SWIG_IsTmpObj(res2)) {
34410 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34411 } else {
34412 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34413 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34414 }
34415 if (SWIG_IsTmpObj(res3)) {
34416 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34417 } else {
34418 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34419 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34420 }
34421 return resultobj;
34422 fail:
34423 return NULL;
34424 }
34425
34426
34427 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34428 PyObject *resultobj = 0;
34429 wxWindow *arg1 = (wxWindow *) 0 ;
34430 wxRect result;
34431 void *argp1 = 0 ;
34432 int res1 = 0 ;
34433 PyObject *swig_obj[1] ;
34434
34435 if (!args) SWIG_fail;
34436 swig_obj[0] = args;
34437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34438 if (!SWIG_IsOK(res1)) {
34439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34440 }
34441 arg1 = reinterpret_cast< wxWindow * >(argp1);
34442 {
34443 PyThreadState* __tstate = wxPyBeginAllowThreads();
34444 result = ((wxWindow const *)arg1)->GetRect();
34445 wxPyEndAllowThreads(__tstate);
34446 if (PyErr_Occurred()) SWIG_fail;
34447 }
34448 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34449 return resultobj;
34450 fail:
34451 return NULL;
34452 }
34453
34454
34455 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34456 PyObject *resultobj = 0;
34457 wxWindow *arg1 = (wxWindow *) 0 ;
34458 wxSize result;
34459 void *argp1 = 0 ;
34460 int res1 = 0 ;
34461 PyObject *swig_obj[1] ;
34462
34463 if (!args) SWIG_fail;
34464 swig_obj[0] = args;
34465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34466 if (!SWIG_IsOK(res1)) {
34467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34468 }
34469 arg1 = reinterpret_cast< wxWindow * >(argp1);
34470 {
34471 PyThreadState* __tstate = wxPyBeginAllowThreads();
34472 result = ((wxWindow const *)arg1)->GetClientSize();
34473 wxPyEndAllowThreads(__tstate);
34474 if (PyErr_Occurred()) SWIG_fail;
34475 }
34476 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34477 return resultobj;
34478 fail:
34479 return NULL;
34480 }
34481
34482
34483 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34484 PyObject *resultobj = 0;
34485 wxWindow *arg1 = (wxWindow *) 0 ;
34486 int *arg2 = (int *) 0 ;
34487 int *arg3 = (int *) 0 ;
34488 void *argp1 = 0 ;
34489 int res1 = 0 ;
34490 int temp2 ;
34491 int res2 = SWIG_TMPOBJ ;
34492 int temp3 ;
34493 int res3 = SWIG_TMPOBJ ;
34494 PyObject *swig_obj[1] ;
34495
34496 arg2 = &temp2;
34497 arg3 = &temp3;
34498 if (!args) SWIG_fail;
34499 swig_obj[0] = args;
34500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34501 if (!SWIG_IsOK(res1)) {
34502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34503 }
34504 arg1 = reinterpret_cast< wxWindow * >(argp1);
34505 {
34506 PyThreadState* __tstate = wxPyBeginAllowThreads();
34507 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34508 wxPyEndAllowThreads(__tstate);
34509 if (PyErr_Occurred()) SWIG_fail;
34510 }
34511 resultobj = SWIG_Py_Void();
34512 if (SWIG_IsTmpObj(res2)) {
34513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34514 } else {
34515 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34517 }
34518 if (SWIG_IsTmpObj(res3)) {
34519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34520 } else {
34521 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34523 }
34524 return resultobj;
34525 fail:
34526 return NULL;
34527 }
34528
34529
34530 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34531 PyObject *resultobj = 0;
34532 wxWindow *arg1 = (wxWindow *) 0 ;
34533 wxPoint result;
34534 void *argp1 = 0 ;
34535 int res1 = 0 ;
34536 PyObject *swig_obj[1] ;
34537
34538 if (!args) SWIG_fail;
34539 swig_obj[0] = args;
34540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34541 if (!SWIG_IsOK(res1)) {
34542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34543 }
34544 arg1 = reinterpret_cast< wxWindow * >(argp1);
34545 {
34546 PyThreadState* __tstate = wxPyBeginAllowThreads();
34547 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34548 wxPyEndAllowThreads(__tstate);
34549 if (PyErr_Occurred()) SWIG_fail;
34550 }
34551 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34552 return resultobj;
34553 fail:
34554 return NULL;
34555 }
34556
34557
34558 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34559 PyObject *resultobj = 0;
34560 wxWindow *arg1 = (wxWindow *) 0 ;
34561 wxRect result;
34562 void *argp1 = 0 ;
34563 int res1 = 0 ;
34564 PyObject *swig_obj[1] ;
34565
34566 if (!args) SWIG_fail;
34567 swig_obj[0] = args;
34568 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34569 if (!SWIG_IsOK(res1)) {
34570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34571 }
34572 arg1 = reinterpret_cast< wxWindow * >(argp1);
34573 {
34574 PyThreadState* __tstate = wxPyBeginAllowThreads();
34575 result = ((wxWindow const *)arg1)->GetClientRect();
34576 wxPyEndAllowThreads(__tstate);
34577 if (PyErr_Occurred()) SWIG_fail;
34578 }
34579 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34580 return resultobj;
34581 fail:
34582 return NULL;
34583 }
34584
34585
34586 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34587 PyObject *resultobj = 0;
34588 wxWindow *arg1 = (wxWindow *) 0 ;
34589 wxSize result;
34590 void *argp1 = 0 ;
34591 int res1 = 0 ;
34592 PyObject *swig_obj[1] ;
34593
34594 if (!args) SWIG_fail;
34595 swig_obj[0] = args;
34596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34597 if (!SWIG_IsOK(res1)) {
34598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34599 }
34600 arg1 = reinterpret_cast< wxWindow * >(argp1);
34601 {
34602 PyThreadState* __tstate = wxPyBeginAllowThreads();
34603 result = ((wxWindow const *)arg1)->GetBestSize();
34604 wxPyEndAllowThreads(__tstate);
34605 if (PyErr_Occurred()) SWIG_fail;
34606 }
34607 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34608 return resultobj;
34609 fail:
34610 return NULL;
34611 }
34612
34613
34614 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34615 PyObject *resultobj = 0;
34616 wxWindow *arg1 = (wxWindow *) 0 ;
34617 int *arg2 = (int *) 0 ;
34618 int *arg3 = (int *) 0 ;
34619 void *argp1 = 0 ;
34620 int res1 = 0 ;
34621 int temp2 ;
34622 int res2 = SWIG_TMPOBJ ;
34623 int temp3 ;
34624 int res3 = SWIG_TMPOBJ ;
34625 PyObject *swig_obj[1] ;
34626
34627 arg2 = &temp2;
34628 arg3 = &temp3;
34629 if (!args) SWIG_fail;
34630 swig_obj[0] = args;
34631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34632 if (!SWIG_IsOK(res1)) {
34633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34634 }
34635 arg1 = reinterpret_cast< wxWindow * >(argp1);
34636 {
34637 PyThreadState* __tstate = wxPyBeginAllowThreads();
34638 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34639 wxPyEndAllowThreads(__tstate);
34640 if (PyErr_Occurred()) SWIG_fail;
34641 }
34642 resultobj = SWIG_Py_Void();
34643 if (SWIG_IsTmpObj(res2)) {
34644 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34645 } else {
34646 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34647 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34648 }
34649 if (SWIG_IsTmpObj(res3)) {
34650 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34651 } else {
34652 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34653 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34654 }
34655 return resultobj;
34656 fail:
34657 return NULL;
34658 }
34659
34660
34661 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34662 PyObject *resultobj = 0;
34663 wxWindow *arg1 = (wxWindow *) 0 ;
34664 void *argp1 = 0 ;
34665 int res1 = 0 ;
34666 PyObject *swig_obj[1] ;
34667
34668 if (!args) SWIG_fail;
34669 swig_obj[0] = args;
34670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34671 if (!SWIG_IsOK(res1)) {
34672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34673 }
34674 arg1 = reinterpret_cast< wxWindow * >(argp1);
34675 {
34676 PyThreadState* __tstate = wxPyBeginAllowThreads();
34677 (arg1)->InvalidateBestSize();
34678 wxPyEndAllowThreads(__tstate);
34679 if (PyErr_Occurred()) SWIG_fail;
34680 }
34681 resultobj = SWIG_Py_Void();
34682 return resultobj;
34683 fail:
34684 return NULL;
34685 }
34686
34687
34688 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34689 PyObject *resultobj = 0;
34690 wxWindow *arg1 = (wxWindow *) 0 ;
34691 wxSize *arg2 = 0 ;
34692 void *argp1 = 0 ;
34693 int res1 = 0 ;
34694 wxSize temp2 ;
34695 PyObject * obj0 = 0 ;
34696 PyObject * obj1 = 0 ;
34697 char * kwnames[] = {
34698 (char *) "self",(char *) "size", NULL
34699 };
34700
34701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34703 if (!SWIG_IsOK(res1)) {
34704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34705 }
34706 arg1 = reinterpret_cast< wxWindow * >(argp1);
34707 {
34708 arg2 = &temp2;
34709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34710 }
34711 {
34712 PyThreadState* __tstate = wxPyBeginAllowThreads();
34713 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34714 wxPyEndAllowThreads(__tstate);
34715 if (PyErr_Occurred()) SWIG_fail;
34716 }
34717 resultobj = SWIG_Py_Void();
34718 return resultobj;
34719 fail:
34720 return NULL;
34721 }
34722
34723
34724 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34725 PyObject *resultobj = 0;
34726 wxWindow *arg1 = (wxWindow *) 0 ;
34727 wxSize result;
34728 void *argp1 = 0 ;
34729 int res1 = 0 ;
34730 PyObject *swig_obj[1] ;
34731
34732 if (!args) SWIG_fail;
34733 swig_obj[0] = args;
34734 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34735 if (!SWIG_IsOK(res1)) {
34736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34737 }
34738 arg1 = reinterpret_cast< wxWindow * >(argp1);
34739 {
34740 PyThreadState* __tstate = wxPyBeginAllowThreads();
34741 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34742 wxPyEndAllowThreads(__tstate);
34743 if (PyErr_Occurred()) SWIG_fail;
34744 }
34745 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34746 return resultobj;
34747 fail:
34748 return NULL;
34749 }
34750
34751
34752 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34753 PyObject *resultobj = 0;
34754 wxWindow *arg1 = (wxWindow *) 0 ;
34755 int arg2 = (int) wxBOTH ;
34756 void *argp1 = 0 ;
34757 int res1 = 0 ;
34758 int val2 ;
34759 int ecode2 = 0 ;
34760 PyObject * obj0 = 0 ;
34761 PyObject * obj1 = 0 ;
34762 char * kwnames[] = {
34763 (char *) "self",(char *) "direction", NULL
34764 };
34765
34766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34768 if (!SWIG_IsOK(res1)) {
34769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34770 }
34771 arg1 = reinterpret_cast< wxWindow * >(argp1);
34772 if (obj1) {
34773 ecode2 = SWIG_AsVal_int(obj1, &val2);
34774 if (!SWIG_IsOK(ecode2)) {
34775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34776 }
34777 arg2 = static_cast< int >(val2);
34778 }
34779 {
34780 PyThreadState* __tstate = wxPyBeginAllowThreads();
34781 (arg1)->Center(arg2);
34782 wxPyEndAllowThreads(__tstate);
34783 if (PyErr_Occurred()) SWIG_fail;
34784 }
34785 resultobj = SWIG_Py_Void();
34786 return resultobj;
34787 fail:
34788 return NULL;
34789 }
34790
34791
34792 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34793 PyObject *resultobj = 0;
34794 wxWindow *arg1 = (wxWindow *) 0 ;
34795 int arg2 = (int) wxBOTH ;
34796 void *argp1 = 0 ;
34797 int res1 = 0 ;
34798 int val2 ;
34799 int ecode2 = 0 ;
34800 PyObject * obj0 = 0 ;
34801 PyObject * obj1 = 0 ;
34802 char * kwnames[] = {
34803 (char *) "self",(char *) "dir", NULL
34804 };
34805
34806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34807 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34808 if (!SWIG_IsOK(res1)) {
34809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34810 }
34811 arg1 = reinterpret_cast< wxWindow * >(argp1);
34812 if (obj1) {
34813 ecode2 = SWIG_AsVal_int(obj1, &val2);
34814 if (!SWIG_IsOK(ecode2)) {
34815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34816 }
34817 arg2 = static_cast< int >(val2);
34818 }
34819 {
34820 PyThreadState* __tstate = wxPyBeginAllowThreads();
34821 (arg1)->CenterOnParent(arg2);
34822 wxPyEndAllowThreads(__tstate);
34823 if (PyErr_Occurred()) SWIG_fail;
34824 }
34825 resultobj = SWIG_Py_Void();
34826 return resultobj;
34827 fail:
34828 return NULL;
34829 }
34830
34831
34832 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34833 PyObject *resultobj = 0;
34834 wxWindow *arg1 = (wxWindow *) 0 ;
34835 void *argp1 = 0 ;
34836 int res1 = 0 ;
34837 PyObject *swig_obj[1] ;
34838
34839 if (!args) SWIG_fail;
34840 swig_obj[0] = args;
34841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34842 if (!SWIG_IsOK(res1)) {
34843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34844 }
34845 arg1 = reinterpret_cast< wxWindow * >(argp1);
34846 {
34847 PyThreadState* __tstate = wxPyBeginAllowThreads();
34848 (arg1)->Fit();
34849 wxPyEndAllowThreads(__tstate);
34850 if (PyErr_Occurred()) SWIG_fail;
34851 }
34852 resultobj = SWIG_Py_Void();
34853 return resultobj;
34854 fail:
34855 return NULL;
34856 }
34857
34858
34859 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34860 PyObject *resultobj = 0;
34861 wxWindow *arg1 = (wxWindow *) 0 ;
34862 void *argp1 = 0 ;
34863 int res1 = 0 ;
34864 PyObject *swig_obj[1] ;
34865
34866 if (!args) SWIG_fail;
34867 swig_obj[0] = args;
34868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34869 if (!SWIG_IsOK(res1)) {
34870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34871 }
34872 arg1 = reinterpret_cast< wxWindow * >(argp1);
34873 {
34874 PyThreadState* __tstate = wxPyBeginAllowThreads();
34875 (arg1)->FitInside();
34876 wxPyEndAllowThreads(__tstate);
34877 if (PyErr_Occurred()) SWIG_fail;
34878 }
34879 resultobj = SWIG_Py_Void();
34880 return resultobj;
34881 fail:
34882 return NULL;
34883 }
34884
34885
34886 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34887 PyObject *resultobj = 0;
34888 wxWindow *arg1 = (wxWindow *) 0 ;
34889 int arg2 ;
34890 int arg3 ;
34891 int arg4 = (int) -1 ;
34892 int arg5 = (int) -1 ;
34893 int arg6 = (int) -1 ;
34894 int arg7 = (int) -1 ;
34895 void *argp1 = 0 ;
34896 int res1 = 0 ;
34897 int val2 ;
34898 int ecode2 = 0 ;
34899 int val3 ;
34900 int ecode3 = 0 ;
34901 int val4 ;
34902 int ecode4 = 0 ;
34903 int val5 ;
34904 int ecode5 = 0 ;
34905 int val6 ;
34906 int ecode6 = 0 ;
34907 int val7 ;
34908 int ecode7 = 0 ;
34909 PyObject * obj0 = 0 ;
34910 PyObject * obj1 = 0 ;
34911 PyObject * obj2 = 0 ;
34912 PyObject * obj3 = 0 ;
34913 PyObject * obj4 = 0 ;
34914 PyObject * obj5 = 0 ;
34915 PyObject * obj6 = 0 ;
34916 char * kwnames[] = {
34917 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34918 };
34919
34920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34922 if (!SWIG_IsOK(res1)) {
34923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34924 }
34925 arg1 = reinterpret_cast< wxWindow * >(argp1);
34926 ecode2 = SWIG_AsVal_int(obj1, &val2);
34927 if (!SWIG_IsOK(ecode2)) {
34928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34929 }
34930 arg2 = static_cast< int >(val2);
34931 ecode3 = SWIG_AsVal_int(obj2, &val3);
34932 if (!SWIG_IsOK(ecode3)) {
34933 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34934 }
34935 arg3 = static_cast< int >(val3);
34936 if (obj3) {
34937 ecode4 = SWIG_AsVal_int(obj3, &val4);
34938 if (!SWIG_IsOK(ecode4)) {
34939 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34940 }
34941 arg4 = static_cast< int >(val4);
34942 }
34943 if (obj4) {
34944 ecode5 = SWIG_AsVal_int(obj4, &val5);
34945 if (!SWIG_IsOK(ecode5)) {
34946 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34947 }
34948 arg5 = static_cast< int >(val5);
34949 }
34950 if (obj5) {
34951 ecode6 = SWIG_AsVal_int(obj5, &val6);
34952 if (!SWIG_IsOK(ecode6)) {
34953 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34954 }
34955 arg6 = static_cast< int >(val6);
34956 }
34957 if (obj6) {
34958 ecode7 = SWIG_AsVal_int(obj6, &val7);
34959 if (!SWIG_IsOK(ecode7)) {
34960 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34961 }
34962 arg7 = static_cast< int >(val7);
34963 }
34964 {
34965 PyThreadState* __tstate = wxPyBeginAllowThreads();
34966 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34967 wxPyEndAllowThreads(__tstate);
34968 if (PyErr_Occurred()) SWIG_fail;
34969 }
34970 resultobj = SWIG_Py_Void();
34971 return resultobj;
34972 fail:
34973 return NULL;
34974 }
34975
34976
34977 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34978 PyObject *resultobj = 0;
34979 wxWindow *arg1 = (wxWindow *) 0 ;
34980 wxSize *arg2 = 0 ;
34981 wxSize const &arg3_defvalue = wxDefaultSize ;
34982 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34983 wxSize const &arg4_defvalue = wxDefaultSize ;
34984 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
34985 void *argp1 = 0 ;
34986 int res1 = 0 ;
34987 wxSize temp2 ;
34988 wxSize temp3 ;
34989 wxSize temp4 ;
34990 PyObject * obj0 = 0 ;
34991 PyObject * obj1 = 0 ;
34992 PyObject * obj2 = 0 ;
34993 PyObject * obj3 = 0 ;
34994 char * kwnames[] = {
34995 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
34996 };
34997
34998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
34999 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35000 if (!SWIG_IsOK(res1)) {
35001 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35002 }
35003 arg1 = reinterpret_cast< wxWindow * >(argp1);
35004 {
35005 arg2 = &temp2;
35006 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35007 }
35008 if (obj2) {
35009 {
35010 arg3 = &temp3;
35011 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35012 }
35013 }
35014 if (obj3) {
35015 {
35016 arg4 = &temp4;
35017 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35018 }
35019 }
35020 {
35021 PyThreadState* __tstate = wxPyBeginAllowThreads();
35022 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35023 wxPyEndAllowThreads(__tstate);
35024 if (PyErr_Occurred()) SWIG_fail;
35025 }
35026 resultobj = SWIG_Py_Void();
35027 return resultobj;
35028 fail:
35029 return NULL;
35030 }
35031
35032
35033 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35034 PyObject *resultobj = 0;
35035 wxWindow *arg1 = (wxWindow *) 0 ;
35036 int arg2 ;
35037 int arg3 ;
35038 int arg4 = (int) -1 ;
35039 int arg5 = (int) -1 ;
35040 void *argp1 = 0 ;
35041 int res1 = 0 ;
35042 int val2 ;
35043 int ecode2 = 0 ;
35044 int val3 ;
35045 int ecode3 = 0 ;
35046 int val4 ;
35047 int ecode4 = 0 ;
35048 int val5 ;
35049 int ecode5 = 0 ;
35050 PyObject * obj0 = 0 ;
35051 PyObject * obj1 = 0 ;
35052 PyObject * obj2 = 0 ;
35053 PyObject * obj3 = 0 ;
35054 PyObject * obj4 = 0 ;
35055 char * kwnames[] = {
35056 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35057 };
35058
35059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35061 if (!SWIG_IsOK(res1)) {
35062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35063 }
35064 arg1 = reinterpret_cast< wxWindow * >(argp1);
35065 ecode2 = SWIG_AsVal_int(obj1, &val2);
35066 if (!SWIG_IsOK(ecode2)) {
35067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35068 }
35069 arg2 = static_cast< int >(val2);
35070 ecode3 = SWIG_AsVal_int(obj2, &val3);
35071 if (!SWIG_IsOK(ecode3)) {
35072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35073 }
35074 arg3 = static_cast< int >(val3);
35075 if (obj3) {
35076 ecode4 = SWIG_AsVal_int(obj3, &val4);
35077 if (!SWIG_IsOK(ecode4)) {
35078 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35079 }
35080 arg4 = static_cast< int >(val4);
35081 }
35082 if (obj4) {
35083 ecode5 = SWIG_AsVal_int(obj4, &val5);
35084 if (!SWIG_IsOK(ecode5)) {
35085 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35086 }
35087 arg5 = static_cast< int >(val5);
35088 }
35089 {
35090 PyThreadState* __tstate = wxPyBeginAllowThreads();
35091 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35092 wxPyEndAllowThreads(__tstate);
35093 if (PyErr_Occurred()) SWIG_fail;
35094 }
35095 resultobj = SWIG_Py_Void();
35096 return resultobj;
35097 fail:
35098 return NULL;
35099 }
35100
35101
35102 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35103 PyObject *resultobj = 0;
35104 wxWindow *arg1 = (wxWindow *) 0 ;
35105 wxSize *arg2 = 0 ;
35106 wxSize const &arg3_defvalue = wxDefaultSize ;
35107 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35108 void *argp1 = 0 ;
35109 int res1 = 0 ;
35110 wxSize temp2 ;
35111 wxSize temp3 ;
35112 PyObject * obj0 = 0 ;
35113 PyObject * obj1 = 0 ;
35114 PyObject * obj2 = 0 ;
35115 char * kwnames[] = {
35116 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35117 };
35118
35119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35121 if (!SWIG_IsOK(res1)) {
35122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35123 }
35124 arg1 = reinterpret_cast< wxWindow * >(argp1);
35125 {
35126 arg2 = &temp2;
35127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35128 }
35129 if (obj2) {
35130 {
35131 arg3 = &temp3;
35132 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35133 }
35134 }
35135 {
35136 PyThreadState* __tstate = wxPyBeginAllowThreads();
35137 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35138 wxPyEndAllowThreads(__tstate);
35139 if (PyErr_Occurred()) SWIG_fail;
35140 }
35141 resultobj = SWIG_Py_Void();
35142 return resultobj;
35143 fail:
35144 return NULL;
35145 }
35146
35147
35148 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35149 PyObject *resultobj = 0;
35150 wxWindow *arg1 = (wxWindow *) 0 ;
35151 wxSize result;
35152 void *argp1 = 0 ;
35153 int res1 = 0 ;
35154 PyObject *swig_obj[1] ;
35155
35156 if (!args) SWIG_fail;
35157 swig_obj[0] = args;
35158 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35159 if (!SWIG_IsOK(res1)) {
35160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35161 }
35162 arg1 = reinterpret_cast< wxWindow * >(argp1);
35163 {
35164 PyThreadState* __tstate = wxPyBeginAllowThreads();
35165 result = ((wxWindow const *)arg1)->GetMaxSize();
35166 wxPyEndAllowThreads(__tstate);
35167 if (PyErr_Occurred()) SWIG_fail;
35168 }
35169 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35170 return resultobj;
35171 fail:
35172 return NULL;
35173 }
35174
35175
35176 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35177 PyObject *resultobj = 0;
35178 wxWindow *arg1 = (wxWindow *) 0 ;
35179 wxSize result;
35180 void *argp1 = 0 ;
35181 int res1 = 0 ;
35182 PyObject *swig_obj[1] ;
35183
35184 if (!args) SWIG_fail;
35185 swig_obj[0] = args;
35186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35187 if (!SWIG_IsOK(res1)) {
35188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35189 }
35190 arg1 = reinterpret_cast< wxWindow * >(argp1);
35191 {
35192 PyThreadState* __tstate = wxPyBeginAllowThreads();
35193 result = ((wxWindow const *)arg1)->GetMinSize();
35194 wxPyEndAllowThreads(__tstate);
35195 if (PyErr_Occurred()) SWIG_fail;
35196 }
35197 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35198 return resultobj;
35199 fail:
35200 return NULL;
35201 }
35202
35203
35204 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35205 PyObject *resultobj = 0;
35206 wxWindow *arg1 = (wxWindow *) 0 ;
35207 wxSize *arg2 = 0 ;
35208 void *argp1 = 0 ;
35209 int res1 = 0 ;
35210 wxSize temp2 ;
35211 PyObject * obj0 = 0 ;
35212 PyObject * obj1 = 0 ;
35213 char * kwnames[] = {
35214 (char *) "self",(char *) "minSize", NULL
35215 };
35216
35217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",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_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35221 }
35222 arg1 = reinterpret_cast< wxWindow * >(argp1);
35223 {
35224 arg2 = &temp2;
35225 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35226 }
35227 {
35228 PyThreadState* __tstate = wxPyBeginAllowThreads();
35229 (arg1)->SetMinSize((wxSize const &)*arg2);
35230 wxPyEndAllowThreads(__tstate);
35231 if (PyErr_Occurred()) SWIG_fail;
35232 }
35233 resultobj = SWIG_Py_Void();
35234 return resultobj;
35235 fail:
35236 return NULL;
35237 }
35238
35239
35240 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35241 PyObject *resultobj = 0;
35242 wxWindow *arg1 = (wxWindow *) 0 ;
35243 wxSize *arg2 = 0 ;
35244 void *argp1 = 0 ;
35245 int res1 = 0 ;
35246 wxSize temp2 ;
35247 PyObject * obj0 = 0 ;
35248 PyObject * obj1 = 0 ;
35249 char * kwnames[] = {
35250 (char *) "self",(char *) "maxSize", NULL
35251 };
35252
35253 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35254 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35255 if (!SWIG_IsOK(res1)) {
35256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35257 }
35258 arg1 = reinterpret_cast< wxWindow * >(argp1);
35259 {
35260 arg2 = &temp2;
35261 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35262 }
35263 {
35264 PyThreadState* __tstate = wxPyBeginAllowThreads();
35265 (arg1)->SetMaxSize((wxSize const &)*arg2);
35266 wxPyEndAllowThreads(__tstate);
35267 if (PyErr_Occurred()) SWIG_fail;
35268 }
35269 resultobj = SWIG_Py_Void();
35270 return resultobj;
35271 fail:
35272 return NULL;
35273 }
35274
35275
35276 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35277 PyObject *resultobj = 0;
35278 wxWindow *arg1 = (wxWindow *) 0 ;
35279 int result;
35280 void *argp1 = 0 ;
35281 int res1 = 0 ;
35282 PyObject *swig_obj[1] ;
35283
35284 if (!args) SWIG_fail;
35285 swig_obj[0] = args;
35286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35287 if (!SWIG_IsOK(res1)) {
35288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35289 }
35290 arg1 = reinterpret_cast< wxWindow * >(argp1);
35291 {
35292 PyThreadState* __tstate = wxPyBeginAllowThreads();
35293 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35294 wxPyEndAllowThreads(__tstate);
35295 if (PyErr_Occurred()) SWIG_fail;
35296 }
35297 resultobj = SWIG_From_int(static_cast< int >(result));
35298 return resultobj;
35299 fail:
35300 return NULL;
35301 }
35302
35303
35304 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35305 PyObject *resultobj = 0;
35306 wxWindow *arg1 = (wxWindow *) 0 ;
35307 int result;
35308 void *argp1 = 0 ;
35309 int res1 = 0 ;
35310 PyObject *swig_obj[1] ;
35311
35312 if (!args) SWIG_fail;
35313 swig_obj[0] = args;
35314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35315 if (!SWIG_IsOK(res1)) {
35316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35317 }
35318 arg1 = reinterpret_cast< wxWindow * >(argp1);
35319 {
35320 PyThreadState* __tstate = wxPyBeginAllowThreads();
35321 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35322 wxPyEndAllowThreads(__tstate);
35323 if (PyErr_Occurred()) SWIG_fail;
35324 }
35325 resultobj = SWIG_From_int(static_cast< int >(result));
35326 return resultobj;
35327 fail:
35328 return NULL;
35329 }
35330
35331
35332 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35333 PyObject *resultobj = 0;
35334 wxWindow *arg1 = (wxWindow *) 0 ;
35335 int result;
35336 void *argp1 = 0 ;
35337 int res1 = 0 ;
35338 PyObject *swig_obj[1] ;
35339
35340 if (!args) SWIG_fail;
35341 swig_obj[0] = args;
35342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35343 if (!SWIG_IsOK(res1)) {
35344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35345 }
35346 arg1 = reinterpret_cast< wxWindow * >(argp1);
35347 {
35348 PyThreadState* __tstate = wxPyBeginAllowThreads();
35349 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35350 wxPyEndAllowThreads(__tstate);
35351 if (PyErr_Occurred()) SWIG_fail;
35352 }
35353 resultobj = SWIG_From_int(static_cast< int >(result));
35354 return resultobj;
35355 fail:
35356 return NULL;
35357 }
35358
35359
35360 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35361 PyObject *resultobj = 0;
35362 wxWindow *arg1 = (wxWindow *) 0 ;
35363 int result;
35364 void *argp1 = 0 ;
35365 int res1 = 0 ;
35366 PyObject *swig_obj[1] ;
35367
35368 if (!args) SWIG_fail;
35369 swig_obj[0] = args;
35370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35371 if (!SWIG_IsOK(res1)) {
35372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35373 }
35374 arg1 = reinterpret_cast< wxWindow * >(argp1);
35375 {
35376 PyThreadState* __tstate = wxPyBeginAllowThreads();
35377 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35378 wxPyEndAllowThreads(__tstate);
35379 if (PyErr_Occurred()) SWIG_fail;
35380 }
35381 resultobj = SWIG_From_int(static_cast< int >(result));
35382 return resultobj;
35383 fail:
35384 return NULL;
35385 }
35386
35387
35388 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35389 PyObject *resultobj = 0;
35390 wxWindow *arg1 = (wxWindow *) 0 ;
35391 wxSize *arg2 = 0 ;
35392 void *argp1 = 0 ;
35393 int res1 = 0 ;
35394 wxSize temp2 ;
35395 PyObject * obj0 = 0 ;
35396 PyObject * obj1 = 0 ;
35397 char * kwnames[] = {
35398 (char *) "self",(char *) "size", NULL
35399 };
35400
35401 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35402 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35403 if (!SWIG_IsOK(res1)) {
35404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35405 }
35406 arg1 = reinterpret_cast< wxWindow * >(argp1);
35407 {
35408 arg2 = &temp2;
35409 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35410 }
35411 {
35412 PyThreadState* __tstate = wxPyBeginAllowThreads();
35413 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35414 wxPyEndAllowThreads(__tstate);
35415 if (PyErr_Occurred()) SWIG_fail;
35416 }
35417 resultobj = SWIG_Py_Void();
35418 return resultobj;
35419 fail:
35420 return NULL;
35421 }
35422
35423
35424 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35425 PyObject *resultobj = 0;
35426 wxWindow *arg1 = (wxWindow *) 0 ;
35427 int arg2 ;
35428 int arg3 ;
35429 void *argp1 = 0 ;
35430 int res1 = 0 ;
35431 int val2 ;
35432 int ecode2 = 0 ;
35433 int val3 ;
35434 int ecode3 = 0 ;
35435 PyObject * obj0 = 0 ;
35436 PyObject * obj1 = 0 ;
35437 PyObject * obj2 = 0 ;
35438 char * kwnames[] = {
35439 (char *) "self",(char *) "w",(char *) "h", NULL
35440 };
35441
35442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35444 if (!SWIG_IsOK(res1)) {
35445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35446 }
35447 arg1 = reinterpret_cast< wxWindow * >(argp1);
35448 ecode2 = SWIG_AsVal_int(obj1, &val2);
35449 if (!SWIG_IsOK(ecode2)) {
35450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35451 }
35452 arg2 = static_cast< int >(val2);
35453 ecode3 = SWIG_AsVal_int(obj2, &val3);
35454 if (!SWIG_IsOK(ecode3)) {
35455 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35456 }
35457 arg3 = static_cast< int >(val3);
35458 {
35459 PyThreadState* __tstate = wxPyBeginAllowThreads();
35460 (arg1)->SetVirtualSize(arg2,arg3);
35461 wxPyEndAllowThreads(__tstate);
35462 if (PyErr_Occurred()) SWIG_fail;
35463 }
35464 resultobj = SWIG_Py_Void();
35465 return resultobj;
35466 fail:
35467 return NULL;
35468 }
35469
35470
35471 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35472 PyObject *resultobj = 0;
35473 wxWindow *arg1 = (wxWindow *) 0 ;
35474 wxSize result;
35475 void *argp1 = 0 ;
35476 int res1 = 0 ;
35477 PyObject *swig_obj[1] ;
35478
35479 if (!args) SWIG_fail;
35480 swig_obj[0] = args;
35481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35482 if (!SWIG_IsOK(res1)) {
35483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35484 }
35485 arg1 = reinterpret_cast< wxWindow * >(argp1);
35486 {
35487 PyThreadState* __tstate = wxPyBeginAllowThreads();
35488 result = ((wxWindow const *)arg1)->GetVirtualSize();
35489 wxPyEndAllowThreads(__tstate);
35490 if (PyErr_Occurred()) SWIG_fail;
35491 }
35492 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35493 return resultobj;
35494 fail:
35495 return NULL;
35496 }
35497
35498
35499 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35500 PyObject *resultobj = 0;
35501 wxWindow *arg1 = (wxWindow *) 0 ;
35502 int *arg2 = (int *) 0 ;
35503 int *arg3 = (int *) 0 ;
35504 void *argp1 = 0 ;
35505 int res1 = 0 ;
35506 int temp2 ;
35507 int res2 = SWIG_TMPOBJ ;
35508 int temp3 ;
35509 int res3 = SWIG_TMPOBJ ;
35510 PyObject *swig_obj[1] ;
35511
35512 arg2 = &temp2;
35513 arg3 = &temp3;
35514 if (!args) SWIG_fail;
35515 swig_obj[0] = args;
35516 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35517 if (!SWIG_IsOK(res1)) {
35518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35519 }
35520 arg1 = reinterpret_cast< wxWindow * >(argp1);
35521 {
35522 PyThreadState* __tstate = wxPyBeginAllowThreads();
35523 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35524 wxPyEndAllowThreads(__tstate);
35525 if (PyErr_Occurred()) SWIG_fail;
35526 }
35527 resultobj = SWIG_Py_Void();
35528 if (SWIG_IsTmpObj(res2)) {
35529 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35530 } else {
35531 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35532 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35533 }
35534 if (SWIG_IsTmpObj(res3)) {
35535 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35536 } else {
35537 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35538 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35539 }
35540 return resultobj;
35541 fail:
35542 return NULL;
35543 }
35544
35545
35546 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35547 PyObject *resultobj = 0;
35548 wxWindow *arg1 = (wxWindow *) 0 ;
35549 wxSize result;
35550 void *argp1 = 0 ;
35551 int res1 = 0 ;
35552 PyObject *swig_obj[1] ;
35553
35554 if (!args) SWIG_fail;
35555 swig_obj[0] = args;
35556 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35557 if (!SWIG_IsOK(res1)) {
35558 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35559 }
35560 arg1 = reinterpret_cast< wxWindow * >(argp1);
35561 {
35562 PyThreadState* __tstate = wxPyBeginAllowThreads();
35563 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35564 wxPyEndAllowThreads(__tstate);
35565 if (PyErr_Occurred()) SWIG_fail;
35566 }
35567 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35568 return resultobj;
35569 fail:
35570 return NULL;
35571 }
35572
35573
35574 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35575 PyObject *resultobj = 0;
35576 wxWindow *arg1 = (wxWindow *) 0 ;
35577 wxSize result;
35578 void *argp1 = 0 ;
35579 int res1 = 0 ;
35580 PyObject *swig_obj[1] ;
35581
35582 if (!args) SWIG_fail;
35583 swig_obj[0] = args;
35584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35585 if (!SWIG_IsOK(res1)) {
35586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35587 }
35588 arg1 = reinterpret_cast< wxWindow * >(argp1);
35589 {
35590 PyThreadState* __tstate = wxPyBeginAllowThreads();
35591 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35592 wxPyEndAllowThreads(__tstate);
35593 if (PyErr_Occurred()) SWIG_fail;
35594 }
35595 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35596 return resultobj;
35597 fail:
35598 return NULL;
35599 }
35600
35601
35602 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35603 PyObject *resultobj = 0;
35604 wxWindow *arg1 = (wxWindow *) 0 ;
35605 bool arg2 = (bool) true ;
35606 bool result;
35607 void *argp1 = 0 ;
35608 int res1 = 0 ;
35609 bool val2 ;
35610 int ecode2 = 0 ;
35611 PyObject * obj0 = 0 ;
35612 PyObject * obj1 = 0 ;
35613 char * kwnames[] = {
35614 (char *) "self",(char *) "show", NULL
35615 };
35616
35617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35619 if (!SWIG_IsOK(res1)) {
35620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35621 }
35622 arg1 = reinterpret_cast< wxWindow * >(argp1);
35623 if (obj1) {
35624 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35625 if (!SWIG_IsOK(ecode2)) {
35626 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35627 }
35628 arg2 = static_cast< bool >(val2);
35629 }
35630 {
35631 PyThreadState* __tstate = wxPyBeginAllowThreads();
35632 result = (bool)(arg1)->Show(arg2);
35633 wxPyEndAllowThreads(__tstate);
35634 if (PyErr_Occurred()) SWIG_fail;
35635 }
35636 {
35637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35638 }
35639 return resultobj;
35640 fail:
35641 return NULL;
35642 }
35643
35644
35645 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35646 PyObject *resultobj = 0;
35647 wxWindow *arg1 = (wxWindow *) 0 ;
35648 bool result;
35649 void *argp1 = 0 ;
35650 int res1 = 0 ;
35651 PyObject *swig_obj[1] ;
35652
35653 if (!args) SWIG_fail;
35654 swig_obj[0] = args;
35655 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35656 if (!SWIG_IsOK(res1)) {
35657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35658 }
35659 arg1 = reinterpret_cast< wxWindow * >(argp1);
35660 {
35661 PyThreadState* __tstate = wxPyBeginAllowThreads();
35662 result = (bool)(arg1)->Hide();
35663 wxPyEndAllowThreads(__tstate);
35664 if (PyErr_Occurred()) SWIG_fail;
35665 }
35666 {
35667 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35668 }
35669 return resultobj;
35670 fail:
35671 return NULL;
35672 }
35673
35674
35675 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35676 PyObject *resultobj = 0;
35677 wxWindow *arg1 = (wxWindow *) 0 ;
35678 bool arg2 = (bool) true ;
35679 bool result;
35680 void *argp1 = 0 ;
35681 int res1 = 0 ;
35682 bool val2 ;
35683 int ecode2 = 0 ;
35684 PyObject * obj0 = 0 ;
35685 PyObject * obj1 = 0 ;
35686 char * kwnames[] = {
35687 (char *) "self",(char *) "enable", NULL
35688 };
35689
35690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35692 if (!SWIG_IsOK(res1)) {
35693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35694 }
35695 arg1 = reinterpret_cast< wxWindow * >(argp1);
35696 if (obj1) {
35697 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35698 if (!SWIG_IsOK(ecode2)) {
35699 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35700 }
35701 arg2 = static_cast< bool >(val2);
35702 }
35703 {
35704 PyThreadState* __tstate = wxPyBeginAllowThreads();
35705 result = (bool)(arg1)->Enable(arg2);
35706 wxPyEndAllowThreads(__tstate);
35707 if (PyErr_Occurred()) SWIG_fail;
35708 }
35709 {
35710 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35711 }
35712 return resultobj;
35713 fail:
35714 return NULL;
35715 }
35716
35717
35718 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35719 PyObject *resultobj = 0;
35720 wxWindow *arg1 = (wxWindow *) 0 ;
35721 bool result;
35722 void *argp1 = 0 ;
35723 int res1 = 0 ;
35724 PyObject *swig_obj[1] ;
35725
35726 if (!args) SWIG_fail;
35727 swig_obj[0] = args;
35728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35729 if (!SWIG_IsOK(res1)) {
35730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35731 }
35732 arg1 = reinterpret_cast< wxWindow * >(argp1);
35733 {
35734 PyThreadState* __tstate = wxPyBeginAllowThreads();
35735 result = (bool)(arg1)->Disable();
35736 wxPyEndAllowThreads(__tstate);
35737 if (PyErr_Occurred()) SWIG_fail;
35738 }
35739 {
35740 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35741 }
35742 return resultobj;
35743 fail:
35744 return NULL;
35745 }
35746
35747
35748 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35749 PyObject *resultobj = 0;
35750 wxWindow *arg1 = (wxWindow *) 0 ;
35751 bool result;
35752 void *argp1 = 0 ;
35753 int res1 = 0 ;
35754 PyObject *swig_obj[1] ;
35755
35756 if (!args) SWIG_fail;
35757 swig_obj[0] = args;
35758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35759 if (!SWIG_IsOK(res1)) {
35760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35761 }
35762 arg1 = reinterpret_cast< wxWindow * >(argp1);
35763 {
35764 PyThreadState* __tstate = wxPyBeginAllowThreads();
35765 result = (bool)((wxWindow const *)arg1)->IsShown();
35766 wxPyEndAllowThreads(__tstate);
35767 if (PyErr_Occurred()) SWIG_fail;
35768 }
35769 {
35770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35771 }
35772 return resultobj;
35773 fail:
35774 return NULL;
35775 }
35776
35777
35778 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35779 PyObject *resultobj = 0;
35780 wxWindow *arg1 = (wxWindow *) 0 ;
35781 bool result;
35782 void *argp1 = 0 ;
35783 int res1 = 0 ;
35784 PyObject *swig_obj[1] ;
35785
35786 if (!args) SWIG_fail;
35787 swig_obj[0] = args;
35788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35789 if (!SWIG_IsOK(res1)) {
35790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35791 }
35792 arg1 = reinterpret_cast< wxWindow * >(argp1);
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 {
35800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35801 }
35802 return resultobj;
35803 fail:
35804 return NULL;
35805 }
35806
35807
35808 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35809 PyObject *resultobj = 0;
35810 wxWindow *arg1 = (wxWindow *) 0 ;
35811 bool result;
35812 void *argp1 = 0 ;
35813 int res1 = 0 ;
35814 PyObject *swig_obj[1] ;
35815
35816 if (!args) SWIG_fail;
35817 swig_obj[0] = args;
35818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35819 if (!SWIG_IsOK(res1)) {
35820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35821 }
35822 arg1 = reinterpret_cast< wxWindow * >(argp1);
35823 {
35824 PyThreadState* __tstate = wxPyBeginAllowThreads();
35825 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35826 wxPyEndAllowThreads(__tstate);
35827 if (PyErr_Occurred()) SWIG_fail;
35828 }
35829 {
35830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35831 }
35832 return resultobj;
35833 fail:
35834 return NULL;
35835 }
35836
35837
35838 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35839 PyObject *resultobj = 0;
35840 wxWindow *arg1 = (wxWindow *) 0 ;
35841 long arg2 ;
35842 void *argp1 = 0 ;
35843 int res1 = 0 ;
35844 long val2 ;
35845 int ecode2 = 0 ;
35846 PyObject * obj0 = 0 ;
35847 PyObject * obj1 = 0 ;
35848 char * kwnames[] = {
35849 (char *) "self",(char *) "style", NULL
35850 };
35851
35852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35854 if (!SWIG_IsOK(res1)) {
35855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35856 }
35857 arg1 = reinterpret_cast< wxWindow * >(argp1);
35858 ecode2 = SWIG_AsVal_long(obj1, &val2);
35859 if (!SWIG_IsOK(ecode2)) {
35860 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35861 }
35862 arg2 = static_cast< long >(val2);
35863 {
35864 PyThreadState* __tstate = wxPyBeginAllowThreads();
35865 (arg1)->SetWindowStyleFlag(arg2);
35866 wxPyEndAllowThreads(__tstate);
35867 if (PyErr_Occurred()) SWIG_fail;
35868 }
35869 resultobj = SWIG_Py_Void();
35870 return resultobj;
35871 fail:
35872 return NULL;
35873 }
35874
35875
35876 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35877 PyObject *resultobj = 0;
35878 wxWindow *arg1 = (wxWindow *) 0 ;
35879 long result;
35880 void *argp1 = 0 ;
35881 int res1 = 0 ;
35882 PyObject *swig_obj[1] ;
35883
35884 if (!args) SWIG_fail;
35885 swig_obj[0] = args;
35886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35887 if (!SWIG_IsOK(res1)) {
35888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35889 }
35890 arg1 = reinterpret_cast< wxWindow * >(argp1);
35891 {
35892 PyThreadState* __tstate = wxPyBeginAllowThreads();
35893 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35894 wxPyEndAllowThreads(__tstate);
35895 if (PyErr_Occurred()) SWIG_fail;
35896 }
35897 resultobj = SWIG_From_long(static_cast< long >(result));
35898 return resultobj;
35899 fail:
35900 return NULL;
35901 }
35902
35903
35904 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35905 PyObject *resultobj = 0;
35906 wxWindow *arg1 = (wxWindow *) 0 ;
35907 int arg2 ;
35908 bool result;
35909 void *argp1 = 0 ;
35910 int res1 = 0 ;
35911 int val2 ;
35912 int ecode2 = 0 ;
35913 PyObject * obj0 = 0 ;
35914 PyObject * obj1 = 0 ;
35915 char * kwnames[] = {
35916 (char *) "self",(char *) "flag", NULL
35917 };
35918
35919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35920 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35921 if (!SWIG_IsOK(res1)) {
35922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35923 }
35924 arg1 = reinterpret_cast< wxWindow * >(argp1);
35925 ecode2 = SWIG_AsVal_int(obj1, &val2);
35926 if (!SWIG_IsOK(ecode2)) {
35927 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35928 }
35929 arg2 = static_cast< int >(val2);
35930 {
35931 PyThreadState* __tstate = wxPyBeginAllowThreads();
35932 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35933 wxPyEndAllowThreads(__tstate);
35934 if (PyErr_Occurred()) SWIG_fail;
35935 }
35936 {
35937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35938 }
35939 return resultobj;
35940 fail:
35941 return NULL;
35942 }
35943
35944
35945 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35946 PyObject *resultobj = 0;
35947 wxWindow *arg1 = (wxWindow *) 0 ;
35948 bool result;
35949 void *argp1 = 0 ;
35950 int res1 = 0 ;
35951 PyObject *swig_obj[1] ;
35952
35953 if (!args) SWIG_fail;
35954 swig_obj[0] = args;
35955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35956 if (!SWIG_IsOK(res1)) {
35957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35958 }
35959 arg1 = reinterpret_cast< wxWindow * >(argp1);
35960 {
35961 PyThreadState* __tstate = wxPyBeginAllowThreads();
35962 result = (bool)((wxWindow const *)arg1)->IsRetained();
35963 wxPyEndAllowThreads(__tstate);
35964 if (PyErr_Occurred()) SWIG_fail;
35965 }
35966 {
35967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35968 }
35969 return resultobj;
35970 fail:
35971 return NULL;
35972 }
35973
35974
35975 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35976 PyObject *resultobj = 0;
35977 wxWindow *arg1 = (wxWindow *) 0 ;
35978 int arg2 ;
35979 bool result;
35980 void *argp1 = 0 ;
35981 int res1 = 0 ;
35982 int val2 ;
35983 int ecode2 = 0 ;
35984 PyObject * obj0 = 0 ;
35985 PyObject * obj1 = 0 ;
35986 char * kwnames[] = {
35987 (char *) "self",(char *) "flag", NULL
35988 };
35989
35990 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35991 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35992 if (!SWIG_IsOK(res1)) {
35993 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35994 }
35995 arg1 = reinterpret_cast< wxWindow * >(argp1);
35996 ecode2 = SWIG_AsVal_int(obj1, &val2);
35997 if (!SWIG_IsOK(ecode2)) {
35998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
35999 }
36000 arg2 = static_cast< int >(val2);
36001 {
36002 PyThreadState* __tstate = wxPyBeginAllowThreads();
36003 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36004 wxPyEndAllowThreads(__tstate);
36005 if (PyErr_Occurred()) SWIG_fail;
36006 }
36007 {
36008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36009 }
36010 return resultobj;
36011 fail:
36012 return NULL;
36013 }
36014
36015
36016 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36017 PyObject *resultobj = 0;
36018 wxWindow *arg1 = (wxWindow *) 0 ;
36019 long arg2 ;
36020 void *argp1 = 0 ;
36021 int res1 = 0 ;
36022 long val2 ;
36023 int ecode2 = 0 ;
36024 PyObject * obj0 = 0 ;
36025 PyObject * obj1 = 0 ;
36026 char * kwnames[] = {
36027 (char *) "self",(char *) "exStyle", NULL
36028 };
36029
36030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36032 if (!SWIG_IsOK(res1)) {
36033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36034 }
36035 arg1 = reinterpret_cast< wxWindow * >(argp1);
36036 ecode2 = SWIG_AsVal_long(obj1, &val2);
36037 if (!SWIG_IsOK(ecode2)) {
36038 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36039 }
36040 arg2 = static_cast< long >(val2);
36041 {
36042 PyThreadState* __tstate = wxPyBeginAllowThreads();
36043 (arg1)->SetExtraStyle(arg2);
36044 wxPyEndAllowThreads(__tstate);
36045 if (PyErr_Occurred()) SWIG_fail;
36046 }
36047 resultobj = SWIG_Py_Void();
36048 return resultobj;
36049 fail:
36050 return NULL;
36051 }
36052
36053
36054 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36055 PyObject *resultobj = 0;
36056 wxWindow *arg1 = (wxWindow *) 0 ;
36057 long result;
36058 void *argp1 = 0 ;
36059 int res1 = 0 ;
36060 PyObject *swig_obj[1] ;
36061
36062 if (!args) SWIG_fail;
36063 swig_obj[0] = args;
36064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36065 if (!SWIG_IsOK(res1)) {
36066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36067 }
36068 arg1 = reinterpret_cast< wxWindow * >(argp1);
36069 {
36070 PyThreadState* __tstate = wxPyBeginAllowThreads();
36071 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36072 wxPyEndAllowThreads(__tstate);
36073 if (PyErr_Occurred()) SWIG_fail;
36074 }
36075 resultobj = SWIG_From_long(static_cast< long >(result));
36076 return resultobj;
36077 fail:
36078 return NULL;
36079 }
36080
36081
36082 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36083 PyObject *resultobj = 0;
36084 wxWindow *arg1 = (wxWindow *) 0 ;
36085 bool arg2 = (bool) true ;
36086 void *argp1 = 0 ;
36087 int res1 = 0 ;
36088 bool val2 ;
36089 int ecode2 = 0 ;
36090 PyObject * obj0 = 0 ;
36091 PyObject * obj1 = 0 ;
36092 char * kwnames[] = {
36093 (char *) "self",(char *) "modal", NULL
36094 };
36095
36096 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36097 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36098 if (!SWIG_IsOK(res1)) {
36099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36100 }
36101 arg1 = reinterpret_cast< wxWindow * >(argp1);
36102 if (obj1) {
36103 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36104 if (!SWIG_IsOK(ecode2)) {
36105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36106 }
36107 arg2 = static_cast< bool >(val2);
36108 }
36109 {
36110 PyThreadState* __tstate = wxPyBeginAllowThreads();
36111 (arg1)->MakeModal(arg2);
36112 wxPyEndAllowThreads(__tstate);
36113 if (PyErr_Occurred()) SWIG_fail;
36114 }
36115 resultobj = SWIG_Py_Void();
36116 return resultobj;
36117 fail:
36118 return NULL;
36119 }
36120
36121
36122 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36123 PyObject *resultobj = 0;
36124 wxWindow *arg1 = (wxWindow *) 0 ;
36125 bool arg2 ;
36126 void *argp1 = 0 ;
36127 int res1 = 0 ;
36128 bool val2 ;
36129 int ecode2 = 0 ;
36130 PyObject * obj0 = 0 ;
36131 PyObject * obj1 = 0 ;
36132 char * kwnames[] = {
36133 (char *) "self",(char *) "enableTheme", NULL
36134 };
36135
36136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36138 if (!SWIG_IsOK(res1)) {
36139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36140 }
36141 arg1 = reinterpret_cast< wxWindow * >(argp1);
36142 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36143 if (!SWIG_IsOK(ecode2)) {
36144 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36145 }
36146 arg2 = static_cast< bool >(val2);
36147 {
36148 PyThreadState* __tstate = wxPyBeginAllowThreads();
36149 (arg1)->SetThemeEnabled(arg2);
36150 wxPyEndAllowThreads(__tstate);
36151 if (PyErr_Occurred()) SWIG_fail;
36152 }
36153 resultobj = SWIG_Py_Void();
36154 return resultobj;
36155 fail:
36156 return NULL;
36157 }
36158
36159
36160 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36161 PyObject *resultobj = 0;
36162 wxWindow *arg1 = (wxWindow *) 0 ;
36163 bool result;
36164 void *argp1 = 0 ;
36165 int res1 = 0 ;
36166 PyObject *swig_obj[1] ;
36167
36168 if (!args) SWIG_fail;
36169 swig_obj[0] = args;
36170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36171 if (!SWIG_IsOK(res1)) {
36172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36173 }
36174 arg1 = reinterpret_cast< wxWindow * >(argp1);
36175 {
36176 PyThreadState* __tstate = wxPyBeginAllowThreads();
36177 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36178 wxPyEndAllowThreads(__tstate);
36179 if (PyErr_Occurred()) SWIG_fail;
36180 }
36181 {
36182 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36183 }
36184 return resultobj;
36185 fail:
36186 return NULL;
36187 }
36188
36189
36190 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36191 PyObject *resultobj = 0;
36192 wxWindow *arg1 = (wxWindow *) 0 ;
36193 void *argp1 = 0 ;
36194 int res1 = 0 ;
36195 PyObject *swig_obj[1] ;
36196
36197 if (!args) SWIG_fail;
36198 swig_obj[0] = args;
36199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36200 if (!SWIG_IsOK(res1)) {
36201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36202 }
36203 arg1 = reinterpret_cast< wxWindow * >(argp1);
36204 {
36205 PyThreadState* __tstate = wxPyBeginAllowThreads();
36206 (arg1)->SetFocus();
36207 wxPyEndAllowThreads(__tstate);
36208 if (PyErr_Occurred()) SWIG_fail;
36209 }
36210 resultobj = SWIG_Py_Void();
36211 return resultobj;
36212 fail:
36213 return NULL;
36214 }
36215
36216
36217 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36218 PyObject *resultobj = 0;
36219 wxWindow *arg1 = (wxWindow *) 0 ;
36220 void *argp1 = 0 ;
36221 int res1 = 0 ;
36222 PyObject *swig_obj[1] ;
36223
36224 if (!args) SWIG_fail;
36225 swig_obj[0] = args;
36226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36227 if (!SWIG_IsOK(res1)) {
36228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36229 }
36230 arg1 = reinterpret_cast< wxWindow * >(argp1);
36231 {
36232 PyThreadState* __tstate = wxPyBeginAllowThreads();
36233 (arg1)->SetFocusFromKbd();
36234 wxPyEndAllowThreads(__tstate);
36235 if (PyErr_Occurred()) SWIG_fail;
36236 }
36237 resultobj = SWIG_Py_Void();
36238 return resultobj;
36239 fail:
36240 return NULL;
36241 }
36242
36243
36244 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36245 PyObject *resultobj = 0;
36246 wxWindow *result = 0 ;
36247
36248 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36249 {
36250 if (!wxPyCheckForApp()) SWIG_fail;
36251 PyThreadState* __tstate = wxPyBeginAllowThreads();
36252 result = (wxWindow *)wxWindow::FindFocus();
36253 wxPyEndAllowThreads(__tstate);
36254 if (PyErr_Occurred()) SWIG_fail;
36255 }
36256 {
36257 resultobj = wxPyMake_wxObject(result, 0);
36258 }
36259 return resultobj;
36260 fail:
36261 return NULL;
36262 }
36263
36264
36265 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36266 PyObject *resultobj = 0;
36267 wxWindow *arg1 = (wxWindow *) 0 ;
36268 bool result;
36269 void *argp1 = 0 ;
36270 int res1 = 0 ;
36271 PyObject *swig_obj[1] ;
36272
36273 if (!args) SWIG_fail;
36274 swig_obj[0] = args;
36275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36276 if (!SWIG_IsOK(res1)) {
36277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36278 }
36279 arg1 = reinterpret_cast< wxWindow * >(argp1);
36280 {
36281 PyThreadState* __tstate = wxPyBeginAllowThreads();
36282 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36283 wxPyEndAllowThreads(__tstate);
36284 if (PyErr_Occurred()) SWIG_fail;
36285 }
36286 {
36287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36288 }
36289 return resultobj;
36290 fail:
36291 return NULL;
36292 }
36293
36294
36295 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36296 PyObject *resultobj = 0;
36297 wxWindow *arg1 = (wxWindow *) 0 ;
36298 bool result;
36299 void *argp1 = 0 ;
36300 int res1 = 0 ;
36301 PyObject *swig_obj[1] ;
36302
36303 if (!args) SWIG_fail;
36304 swig_obj[0] = args;
36305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36306 if (!SWIG_IsOK(res1)) {
36307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36308 }
36309 arg1 = reinterpret_cast< wxWindow * >(argp1);
36310 {
36311 PyThreadState* __tstate = wxPyBeginAllowThreads();
36312 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36313 wxPyEndAllowThreads(__tstate);
36314 if (PyErr_Occurred()) SWIG_fail;
36315 }
36316 {
36317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36318 }
36319 return resultobj;
36320 fail:
36321 return NULL;
36322 }
36323
36324
36325 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36326 PyObject *resultobj = 0;
36327 wxWindow *arg1 = (wxWindow *) 0 ;
36328 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36329 bool result;
36330 void *argp1 = 0 ;
36331 int res1 = 0 ;
36332 int val2 ;
36333 int ecode2 = 0 ;
36334 PyObject * obj0 = 0 ;
36335 PyObject * obj1 = 0 ;
36336 char * kwnames[] = {
36337 (char *) "self",(char *) "flags", NULL
36338 };
36339
36340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36342 if (!SWIG_IsOK(res1)) {
36343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36344 }
36345 arg1 = reinterpret_cast< wxWindow * >(argp1);
36346 if (obj1) {
36347 ecode2 = SWIG_AsVal_int(obj1, &val2);
36348 if (!SWIG_IsOK(ecode2)) {
36349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36350 }
36351 arg2 = static_cast< int >(val2);
36352 }
36353 {
36354 PyThreadState* __tstate = wxPyBeginAllowThreads();
36355 result = (bool)(arg1)->Navigate(arg2);
36356 wxPyEndAllowThreads(__tstate);
36357 if (PyErr_Occurred()) SWIG_fail;
36358 }
36359 {
36360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36361 }
36362 return resultobj;
36363 fail:
36364 return NULL;
36365 }
36366
36367
36368 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36369 PyObject *resultobj = 0;
36370 wxWindow *arg1 = (wxWindow *) 0 ;
36371 wxWindow *arg2 = (wxWindow *) 0 ;
36372 void *argp1 = 0 ;
36373 int res1 = 0 ;
36374 void *argp2 = 0 ;
36375 int res2 = 0 ;
36376 PyObject * obj0 = 0 ;
36377 PyObject * obj1 = 0 ;
36378 char * kwnames[] = {
36379 (char *) "self",(char *) "win", NULL
36380 };
36381
36382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36384 if (!SWIG_IsOK(res1)) {
36385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36386 }
36387 arg1 = reinterpret_cast< wxWindow * >(argp1);
36388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36389 if (!SWIG_IsOK(res2)) {
36390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36391 }
36392 arg2 = reinterpret_cast< wxWindow * >(argp2);
36393 {
36394 PyThreadState* __tstate = wxPyBeginAllowThreads();
36395 (arg1)->MoveAfterInTabOrder(arg2);
36396 wxPyEndAllowThreads(__tstate);
36397 if (PyErr_Occurred()) SWIG_fail;
36398 }
36399 resultobj = SWIG_Py_Void();
36400 return resultobj;
36401 fail:
36402 return NULL;
36403 }
36404
36405
36406 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36407 PyObject *resultobj = 0;
36408 wxWindow *arg1 = (wxWindow *) 0 ;
36409 wxWindow *arg2 = (wxWindow *) 0 ;
36410 void *argp1 = 0 ;
36411 int res1 = 0 ;
36412 void *argp2 = 0 ;
36413 int res2 = 0 ;
36414 PyObject * obj0 = 0 ;
36415 PyObject * obj1 = 0 ;
36416 char * kwnames[] = {
36417 (char *) "self",(char *) "win", NULL
36418 };
36419
36420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36422 if (!SWIG_IsOK(res1)) {
36423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36424 }
36425 arg1 = reinterpret_cast< wxWindow * >(argp1);
36426 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36427 if (!SWIG_IsOK(res2)) {
36428 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36429 }
36430 arg2 = reinterpret_cast< wxWindow * >(argp2);
36431 {
36432 PyThreadState* __tstate = wxPyBeginAllowThreads();
36433 (arg1)->MoveBeforeInTabOrder(arg2);
36434 wxPyEndAllowThreads(__tstate);
36435 if (PyErr_Occurred()) SWIG_fail;
36436 }
36437 resultobj = SWIG_Py_Void();
36438 return resultobj;
36439 fail:
36440 return NULL;
36441 }
36442
36443
36444 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36445 PyObject *resultobj = 0;
36446 wxWindow *arg1 = (wxWindow *) 0 ;
36447 PyObject *result = 0 ;
36448 void *argp1 = 0 ;
36449 int res1 = 0 ;
36450 PyObject *swig_obj[1] ;
36451
36452 if (!args) SWIG_fail;
36453 swig_obj[0] = args;
36454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36455 if (!SWIG_IsOK(res1)) {
36456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36457 }
36458 arg1 = reinterpret_cast< wxWindow * >(argp1);
36459 {
36460 PyThreadState* __tstate = wxPyBeginAllowThreads();
36461 result = (PyObject *)wxWindow_GetChildren(arg1);
36462 wxPyEndAllowThreads(__tstate);
36463 if (PyErr_Occurred()) SWIG_fail;
36464 }
36465 resultobj = result;
36466 return resultobj;
36467 fail:
36468 return NULL;
36469 }
36470
36471
36472 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36473 PyObject *resultobj = 0;
36474 wxWindow *arg1 = (wxWindow *) 0 ;
36475 wxWindow *result = 0 ;
36476 void *argp1 = 0 ;
36477 int res1 = 0 ;
36478 PyObject *swig_obj[1] ;
36479
36480 if (!args) SWIG_fail;
36481 swig_obj[0] = args;
36482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36483 if (!SWIG_IsOK(res1)) {
36484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36485 }
36486 arg1 = reinterpret_cast< wxWindow * >(argp1);
36487 {
36488 PyThreadState* __tstate = wxPyBeginAllowThreads();
36489 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36490 wxPyEndAllowThreads(__tstate);
36491 if (PyErr_Occurred()) SWIG_fail;
36492 }
36493 {
36494 resultobj = wxPyMake_wxObject(result, 0);
36495 }
36496 return resultobj;
36497 fail:
36498 return NULL;
36499 }
36500
36501
36502 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36503 PyObject *resultobj = 0;
36504 wxWindow *arg1 = (wxWindow *) 0 ;
36505 wxWindow *result = 0 ;
36506 void *argp1 = 0 ;
36507 int res1 = 0 ;
36508 PyObject *swig_obj[1] ;
36509
36510 if (!args) SWIG_fail;
36511 swig_obj[0] = args;
36512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36513 if (!SWIG_IsOK(res1)) {
36514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36515 }
36516 arg1 = reinterpret_cast< wxWindow * >(argp1);
36517 {
36518 PyThreadState* __tstate = wxPyBeginAllowThreads();
36519 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36520 wxPyEndAllowThreads(__tstate);
36521 if (PyErr_Occurred()) SWIG_fail;
36522 }
36523 {
36524 resultobj = wxPyMake_wxObject(result, 0);
36525 }
36526 return resultobj;
36527 fail:
36528 return NULL;
36529 }
36530
36531
36532 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36533 PyObject *resultobj = 0;
36534 wxWindow *arg1 = (wxWindow *) 0 ;
36535 bool result;
36536 void *argp1 = 0 ;
36537 int res1 = 0 ;
36538 PyObject *swig_obj[1] ;
36539
36540 if (!args) SWIG_fail;
36541 swig_obj[0] = args;
36542 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36543 if (!SWIG_IsOK(res1)) {
36544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36545 }
36546 arg1 = reinterpret_cast< wxWindow * >(argp1);
36547 {
36548 PyThreadState* __tstate = wxPyBeginAllowThreads();
36549 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36550 wxPyEndAllowThreads(__tstate);
36551 if (PyErr_Occurred()) SWIG_fail;
36552 }
36553 {
36554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36555 }
36556 return resultobj;
36557 fail:
36558 return NULL;
36559 }
36560
36561
36562 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36563 PyObject *resultobj = 0;
36564 wxWindow *arg1 = (wxWindow *) 0 ;
36565 wxWindow *arg2 = (wxWindow *) 0 ;
36566 bool result;
36567 void *argp1 = 0 ;
36568 int res1 = 0 ;
36569 void *argp2 = 0 ;
36570 int res2 = 0 ;
36571 PyObject * obj0 = 0 ;
36572 PyObject * obj1 = 0 ;
36573 char * kwnames[] = {
36574 (char *) "self",(char *) "newParent", NULL
36575 };
36576
36577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36579 if (!SWIG_IsOK(res1)) {
36580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36581 }
36582 arg1 = reinterpret_cast< wxWindow * >(argp1);
36583 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36584 if (!SWIG_IsOK(res2)) {
36585 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36586 }
36587 arg2 = reinterpret_cast< wxWindow * >(argp2);
36588 {
36589 PyThreadState* __tstate = wxPyBeginAllowThreads();
36590 result = (bool)(arg1)->Reparent(arg2);
36591 wxPyEndAllowThreads(__tstate);
36592 if (PyErr_Occurred()) SWIG_fail;
36593 }
36594 {
36595 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36596 }
36597 return resultobj;
36598 fail:
36599 return NULL;
36600 }
36601
36602
36603 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36604 PyObject *resultobj = 0;
36605 wxWindow *arg1 = (wxWindow *) 0 ;
36606 wxWindow *arg2 = (wxWindow *) 0 ;
36607 void *argp1 = 0 ;
36608 int res1 = 0 ;
36609 void *argp2 = 0 ;
36610 int res2 = 0 ;
36611 PyObject * obj0 = 0 ;
36612 PyObject * obj1 = 0 ;
36613 char * kwnames[] = {
36614 (char *) "self",(char *) "child", NULL
36615 };
36616
36617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36619 if (!SWIG_IsOK(res1)) {
36620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36621 }
36622 arg1 = reinterpret_cast< wxWindow * >(argp1);
36623 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36624 if (!SWIG_IsOK(res2)) {
36625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36626 }
36627 arg2 = reinterpret_cast< wxWindow * >(argp2);
36628 {
36629 PyThreadState* __tstate = wxPyBeginAllowThreads();
36630 (arg1)->AddChild(arg2);
36631 wxPyEndAllowThreads(__tstate);
36632 if (PyErr_Occurred()) SWIG_fail;
36633 }
36634 resultobj = SWIG_Py_Void();
36635 return resultobj;
36636 fail:
36637 return NULL;
36638 }
36639
36640
36641 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36642 PyObject *resultobj = 0;
36643 wxWindow *arg1 = (wxWindow *) 0 ;
36644 wxWindow *arg2 = (wxWindow *) 0 ;
36645 void *argp1 = 0 ;
36646 int res1 = 0 ;
36647 void *argp2 = 0 ;
36648 int res2 = 0 ;
36649 PyObject * obj0 = 0 ;
36650 PyObject * obj1 = 0 ;
36651 char * kwnames[] = {
36652 (char *) "self",(char *) "child", NULL
36653 };
36654
36655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36656 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36657 if (!SWIG_IsOK(res1)) {
36658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36659 }
36660 arg1 = reinterpret_cast< wxWindow * >(argp1);
36661 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36662 if (!SWIG_IsOK(res2)) {
36663 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36664 }
36665 arg2 = reinterpret_cast< wxWindow * >(argp2);
36666 {
36667 PyThreadState* __tstate = wxPyBeginAllowThreads();
36668 (arg1)->RemoveChild(arg2);
36669 wxPyEndAllowThreads(__tstate);
36670 if (PyErr_Occurred()) SWIG_fail;
36671 }
36672 resultobj = SWIG_Py_Void();
36673 return resultobj;
36674 fail:
36675 return NULL;
36676 }
36677
36678
36679 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36680 PyObject *resultobj = 0;
36681 wxWindow *arg1 = (wxWindow *) 0 ;
36682 bool arg2 ;
36683 void *argp1 = 0 ;
36684 int res1 = 0 ;
36685 bool val2 ;
36686 int ecode2 = 0 ;
36687 PyObject * obj0 = 0 ;
36688 PyObject * obj1 = 0 ;
36689 char * kwnames[] = {
36690 (char *) "self",(char *) "on", NULL
36691 };
36692
36693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36695 if (!SWIG_IsOK(res1)) {
36696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36697 }
36698 arg1 = reinterpret_cast< wxWindow * >(argp1);
36699 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36700 if (!SWIG_IsOK(ecode2)) {
36701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36702 }
36703 arg2 = static_cast< bool >(val2);
36704 {
36705 PyThreadState* __tstate = wxPyBeginAllowThreads();
36706 wxWindow_SetDoubleBuffered(arg1,arg2);
36707 wxPyEndAllowThreads(__tstate);
36708 if (PyErr_Occurred()) SWIG_fail;
36709 }
36710 resultobj = SWIG_Py_Void();
36711 return resultobj;
36712 fail:
36713 return NULL;
36714 }
36715
36716
36717 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36718 PyObject *resultobj = 0;
36719 wxWindow *arg1 = (wxWindow *) 0 ;
36720 long arg2 ;
36721 wxWindow *result = 0 ;
36722 void *argp1 = 0 ;
36723 int res1 = 0 ;
36724 long val2 ;
36725 int ecode2 = 0 ;
36726 PyObject * obj0 = 0 ;
36727 PyObject * obj1 = 0 ;
36728 char * kwnames[] = {
36729 (char *) "self",(char *) "winid", NULL
36730 };
36731
36732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36734 if (!SWIG_IsOK(res1)) {
36735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36736 }
36737 arg1 = reinterpret_cast< wxWindow * >(argp1);
36738 ecode2 = SWIG_AsVal_long(obj1, &val2);
36739 if (!SWIG_IsOK(ecode2)) {
36740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36741 }
36742 arg2 = static_cast< long >(val2);
36743 {
36744 PyThreadState* __tstate = wxPyBeginAllowThreads();
36745 result = (wxWindow *)(arg1)->FindWindow(arg2);
36746 wxPyEndAllowThreads(__tstate);
36747 if (PyErr_Occurred()) SWIG_fail;
36748 }
36749 {
36750 resultobj = wxPyMake_wxObject(result, 0);
36751 }
36752 return resultobj;
36753 fail:
36754 return NULL;
36755 }
36756
36757
36758 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36759 PyObject *resultobj = 0;
36760 wxWindow *arg1 = (wxWindow *) 0 ;
36761 wxString *arg2 = 0 ;
36762 wxWindow *result = 0 ;
36763 void *argp1 = 0 ;
36764 int res1 = 0 ;
36765 bool temp2 = false ;
36766 PyObject * obj0 = 0 ;
36767 PyObject * obj1 = 0 ;
36768 char * kwnames[] = {
36769 (char *) "self",(char *) "name", NULL
36770 };
36771
36772 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36773 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36774 if (!SWIG_IsOK(res1)) {
36775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36776 }
36777 arg1 = reinterpret_cast< wxWindow * >(argp1);
36778 {
36779 arg2 = wxString_in_helper(obj1);
36780 if (arg2 == NULL) SWIG_fail;
36781 temp2 = true;
36782 }
36783 {
36784 PyThreadState* __tstate = wxPyBeginAllowThreads();
36785 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36786 wxPyEndAllowThreads(__tstate);
36787 if (PyErr_Occurred()) SWIG_fail;
36788 }
36789 {
36790 resultobj = wxPyMake_wxObject(result, 0);
36791 }
36792 {
36793 if (temp2)
36794 delete arg2;
36795 }
36796 return resultobj;
36797 fail:
36798 {
36799 if (temp2)
36800 delete arg2;
36801 }
36802 return NULL;
36803 }
36804
36805
36806 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36807 PyObject *resultobj = 0;
36808 wxWindow *arg1 = (wxWindow *) 0 ;
36809 wxEvtHandler *result = 0 ;
36810 void *argp1 = 0 ;
36811 int res1 = 0 ;
36812 PyObject *swig_obj[1] ;
36813
36814 if (!args) SWIG_fail;
36815 swig_obj[0] = args;
36816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36817 if (!SWIG_IsOK(res1)) {
36818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36819 }
36820 arg1 = reinterpret_cast< wxWindow * >(argp1);
36821 {
36822 PyThreadState* __tstate = wxPyBeginAllowThreads();
36823 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36824 wxPyEndAllowThreads(__tstate);
36825 if (PyErr_Occurred()) SWIG_fail;
36826 }
36827 {
36828 resultobj = wxPyMake_wxObject(result, 0);
36829 }
36830 return resultobj;
36831 fail:
36832 return NULL;
36833 }
36834
36835
36836 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36837 PyObject *resultobj = 0;
36838 wxWindow *arg1 = (wxWindow *) 0 ;
36839 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36840 void *argp1 = 0 ;
36841 int res1 = 0 ;
36842 void *argp2 = 0 ;
36843 int res2 = 0 ;
36844 PyObject * obj0 = 0 ;
36845 PyObject * obj1 = 0 ;
36846 char * kwnames[] = {
36847 (char *) "self",(char *) "handler", NULL
36848 };
36849
36850 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36851 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36852 if (!SWIG_IsOK(res1)) {
36853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36854 }
36855 arg1 = reinterpret_cast< wxWindow * >(argp1);
36856 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36857 if (!SWIG_IsOK(res2)) {
36858 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36859 }
36860 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36861 {
36862 PyThreadState* __tstate = wxPyBeginAllowThreads();
36863 (arg1)->SetEventHandler(arg2);
36864 wxPyEndAllowThreads(__tstate);
36865 if (PyErr_Occurred()) SWIG_fail;
36866 }
36867 resultobj = SWIG_Py_Void();
36868 return resultobj;
36869 fail:
36870 return NULL;
36871 }
36872
36873
36874 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36875 PyObject *resultobj = 0;
36876 wxWindow *arg1 = (wxWindow *) 0 ;
36877 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36878 void *argp1 = 0 ;
36879 int res1 = 0 ;
36880 void *argp2 = 0 ;
36881 int res2 = 0 ;
36882 PyObject * obj0 = 0 ;
36883 PyObject * obj1 = 0 ;
36884 char * kwnames[] = {
36885 (char *) "self",(char *) "handler", NULL
36886 };
36887
36888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36890 if (!SWIG_IsOK(res1)) {
36891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36892 }
36893 arg1 = reinterpret_cast< wxWindow * >(argp1);
36894 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36895 if (!SWIG_IsOK(res2)) {
36896 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36897 }
36898 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36899 {
36900 PyThreadState* __tstate = wxPyBeginAllowThreads();
36901 (arg1)->PushEventHandler(arg2);
36902 wxPyEndAllowThreads(__tstate);
36903 if (PyErr_Occurred()) SWIG_fail;
36904 }
36905 resultobj = SWIG_Py_Void();
36906 return resultobj;
36907 fail:
36908 return NULL;
36909 }
36910
36911
36912 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36913 PyObject *resultobj = 0;
36914 wxWindow *arg1 = (wxWindow *) 0 ;
36915 bool arg2 = (bool) false ;
36916 wxEvtHandler *result = 0 ;
36917 void *argp1 = 0 ;
36918 int res1 = 0 ;
36919 bool val2 ;
36920 int ecode2 = 0 ;
36921 PyObject * obj0 = 0 ;
36922 PyObject * obj1 = 0 ;
36923 char * kwnames[] = {
36924 (char *) "self",(char *) "deleteHandler", NULL
36925 };
36926
36927 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36928 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36929 if (!SWIG_IsOK(res1)) {
36930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36931 }
36932 arg1 = reinterpret_cast< wxWindow * >(argp1);
36933 if (obj1) {
36934 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36935 if (!SWIG_IsOK(ecode2)) {
36936 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36937 }
36938 arg2 = static_cast< bool >(val2);
36939 }
36940 {
36941 PyThreadState* __tstate = wxPyBeginAllowThreads();
36942 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36943 wxPyEndAllowThreads(__tstate);
36944 if (PyErr_Occurred()) SWIG_fail;
36945 }
36946 {
36947 resultobj = wxPyMake_wxObject(result, 0);
36948 }
36949 return resultobj;
36950 fail:
36951 return NULL;
36952 }
36953
36954
36955 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36956 PyObject *resultobj = 0;
36957 wxWindow *arg1 = (wxWindow *) 0 ;
36958 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36959 bool result;
36960 void *argp1 = 0 ;
36961 int res1 = 0 ;
36962 void *argp2 = 0 ;
36963 int res2 = 0 ;
36964 PyObject * obj0 = 0 ;
36965 PyObject * obj1 = 0 ;
36966 char * kwnames[] = {
36967 (char *) "self",(char *) "handler", NULL
36968 };
36969
36970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36972 if (!SWIG_IsOK(res1)) {
36973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36974 }
36975 arg1 = reinterpret_cast< wxWindow * >(argp1);
36976 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36977 if (!SWIG_IsOK(res2)) {
36978 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36979 }
36980 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36981 {
36982 PyThreadState* __tstate = wxPyBeginAllowThreads();
36983 result = (bool)(arg1)->RemoveEventHandler(arg2);
36984 wxPyEndAllowThreads(__tstate);
36985 if (PyErr_Occurred()) SWIG_fail;
36986 }
36987 {
36988 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36989 }
36990 return resultobj;
36991 fail:
36992 return NULL;
36993 }
36994
36995
36996 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36997 PyObject *resultobj = 0;
36998 wxWindow *arg1 = (wxWindow *) 0 ;
36999 wxValidator *arg2 = 0 ;
37000 void *argp1 = 0 ;
37001 int res1 = 0 ;
37002 void *argp2 = 0 ;
37003 int res2 = 0 ;
37004 PyObject * obj0 = 0 ;
37005 PyObject * obj1 = 0 ;
37006 char * kwnames[] = {
37007 (char *) "self",(char *) "validator", NULL
37008 };
37009
37010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37012 if (!SWIG_IsOK(res1)) {
37013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37014 }
37015 arg1 = reinterpret_cast< wxWindow * >(argp1);
37016 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37017 if (!SWIG_IsOK(res2)) {
37018 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37019 }
37020 if (!argp2) {
37021 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37022 }
37023 arg2 = reinterpret_cast< wxValidator * >(argp2);
37024 {
37025 PyThreadState* __tstate = wxPyBeginAllowThreads();
37026 (arg1)->SetValidator((wxValidator const &)*arg2);
37027 wxPyEndAllowThreads(__tstate);
37028 if (PyErr_Occurred()) SWIG_fail;
37029 }
37030 resultobj = SWIG_Py_Void();
37031 return resultobj;
37032 fail:
37033 return NULL;
37034 }
37035
37036
37037 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37038 PyObject *resultobj = 0;
37039 wxWindow *arg1 = (wxWindow *) 0 ;
37040 wxValidator *result = 0 ;
37041 void *argp1 = 0 ;
37042 int res1 = 0 ;
37043 PyObject *swig_obj[1] ;
37044
37045 if (!args) SWIG_fail;
37046 swig_obj[0] = args;
37047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37048 if (!SWIG_IsOK(res1)) {
37049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37050 }
37051 arg1 = reinterpret_cast< wxWindow * >(argp1);
37052 {
37053 PyThreadState* __tstate = wxPyBeginAllowThreads();
37054 result = (wxValidator *)(arg1)->GetValidator();
37055 wxPyEndAllowThreads(__tstate);
37056 if (PyErr_Occurred()) SWIG_fail;
37057 }
37058 {
37059 resultobj = wxPyMake_wxObject(result, (bool)0);
37060 }
37061 return resultobj;
37062 fail:
37063 return NULL;
37064 }
37065
37066
37067 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37068 PyObject *resultobj = 0;
37069 wxWindow *arg1 = (wxWindow *) 0 ;
37070 bool result;
37071 void *argp1 = 0 ;
37072 int res1 = 0 ;
37073 PyObject *swig_obj[1] ;
37074
37075 if (!args) SWIG_fail;
37076 swig_obj[0] = args;
37077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37078 if (!SWIG_IsOK(res1)) {
37079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37080 }
37081 arg1 = reinterpret_cast< wxWindow * >(argp1);
37082 {
37083 PyThreadState* __tstate = wxPyBeginAllowThreads();
37084 result = (bool)(arg1)->Validate();
37085 wxPyEndAllowThreads(__tstate);
37086 if (PyErr_Occurred()) SWIG_fail;
37087 }
37088 {
37089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37090 }
37091 return resultobj;
37092 fail:
37093 return NULL;
37094 }
37095
37096
37097 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37098 PyObject *resultobj = 0;
37099 wxWindow *arg1 = (wxWindow *) 0 ;
37100 bool result;
37101 void *argp1 = 0 ;
37102 int res1 = 0 ;
37103 PyObject *swig_obj[1] ;
37104
37105 if (!args) SWIG_fail;
37106 swig_obj[0] = args;
37107 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37108 if (!SWIG_IsOK(res1)) {
37109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37110 }
37111 arg1 = reinterpret_cast< wxWindow * >(argp1);
37112 {
37113 PyThreadState* __tstate = wxPyBeginAllowThreads();
37114 result = (bool)(arg1)->TransferDataToWindow();
37115 wxPyEndAllowThreads(__tstate);
37116 if (PyErr_Occurred()) SWIG_fail;
37117 }
37118 {
37119 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37120 }
37121 return resultobj;
37122 fail:
37123 return NULL;
37124 }
37125
37126
37127 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37128 PyObject *resultobj = 0;
37129 wxWindow *arg1 = (wxWindow *) 0 ;
37130 bool result;
37131 void *argp1 = 0 ;
37132 int res1 = 0 ;
37133 PyObject *swig_obj[1] ;
37134
37135 if (!args) SWIG_fail;
37136 swig_obj[0] = args;
37137 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37138 if (!SWIG_IsOK(res1)) {
37139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37140 }
37141 arg1 = reinterpret_cast< wxWindow * >(argp1);
37142 {
37143 PyThreadState* __tstate = wxPyBeginAllowThreads();
37144 result = (bool)(arg1)->TransferDataFromWindow();
37145 wxPyEndAllowThreads(__tstate);
37146 if (PyErr_Occurred()) SWIG_fail;
37147 }
37148 {
37149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37150 }
37151 return resultobj;
37152 fail:
37153 return NULL;
37154 }
37155
37156
37157 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37158 PyObject *resultobj = 0;
37159 wxWindow *arg1 = (wxWindow *) 0 ;
37160 void *argp1 = 0 ;
37161 int res1 = 0 ;
37162 PyObject *swig_obj[1] ;
37163
37164 if (!args) SWIG_fail;
37165 swig_obj[0] = args;
37166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37167 if (!SWIG_IsOK(res1)) {
37168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37169 }
37170 arg1 = reinterpret_cast< wxWindow * >(argp1);
37171 {
37172 PyThreadState* __tstate = wxPyBeginAllowThreads();
37173 (arg1)->InitDialog();
37174 wxPyEndAllowThreads(__tstate);
37175 if (PyErr_Occurred()) SWIG_fail;
37176 }
37177 resultobj = SWIG_Py_Void();
37178 return resultobj;
37179 fail:
37180 return NULL;
37181 }
37182
37183
37184 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37185 PyObject *resultobj = 0;
37186 wxWindow *arg1 = (wxWindow *) 0 ;
37187 wxAcceleratorTable *arg2 = 0 ;
37188 void *argp1 = 0 ;
37189 int res1 = 0 ;
37190 void *argp2 = 0 ;
37191 int res2 = 0 ;
37192 PyObject * obj0 = 0 ;
37193 PyObject * obj1 = 0 ;
37194 char * kwnames[] = {
37195 (char *) "self",(char *) "accel", NULL
37196 };
37197
37198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37200 if (!SWIG_IsOK(res1)) {
37201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37202 }
37203 arg1 = reinterpret_cast< wxWindow * >(argp1);
37204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37205 if (!SWIG_IsOK(res2)) {
37206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37207 }
37208 if (!argp2) {
37209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37210 }
37211 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37212 {
37213 PyThreadState* __tstate = wxPyBeginAllowThreads();
37214 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37215 wxPyEndAllowThreads(__tstate);
37216 if (PyErr_Occurred()) SWIG_fail;
37217 }
37218 resultobj = SWIG_Py_Void();
37219 return resultobj;
37220 fail:
37221 return NULL;
37222 }
37223
37224
37225 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37226 PyObject *resultobj = 0;
37227 wxWindow *arg1 = (wxWindow *) 0 ;
37228 wxAcceleratorTable *result = 0 ;
37229 void *argp1 = 0 ;
37230 int res1 = 0 ;
37231 PyObject *swig_obj[1] ;
37232
37233 if (!args) SWIG_fail;
37234 swig_obj[0] = args;
37235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37236 if (!SWIG_IsOK(res1)) {
37237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37238 }
37239 arg1 = reinterpret_cast< wxWindow * >(argp1);
37240 {
37241 PyThreadState* __tstate = wxPyBeginAllowThreads();
37242 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37243 wxPyEndAllowThreads(__tstate);
37244 if (PyErr_Occurred()) SWIG_fail;
37245 }
37246 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37247 return resultobj;
37248 fail:
37249 return NULL;
37250 }
37251
37252
37253 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37254 PyObject *resultobj = 0;
37255 wxWindow *arg1 = (wxWindow *) 0 ;
37256 int arg2 ;
37257 int arg3 ;
37258 int arg4 ;
37259 bool result;
37260 void *argp1 = 0 ;
37261 int res1 = 0 ;
37262 int val2 ;
37263 int ecode2 = 0 ;
37264 int val3 ;
37265 int ecode3 = 0 ;
37266 int val4 ;
37267 int ecode4 = 0 ;
37268 PyObject * obj0 = 0 ;
37269 PyObject * obj1 = 0 ;
37270 PyObject * obj2 = 0 ;
37271 PyObject * obj3 = 0 ;
37272 char * kwnames[] = {
37273 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37274 };
37275
37276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37278 if (!SWIG_IsOK(res1)) {
37279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37280 }
37281 arg1 = reinterpret_cast< wxWindow * >(argp1);
37282 ecode2 = SWIG_AsVal_int(obj1, &val2);
37283 if (!SWIG_IsOK(ecode2)) {
37284 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37285 }
37286 arg2 = static_cast< int >(val2);
37287 ecode3 = SWIG_AsVal_int(obj2, &val3);
37288 if (!SWIG_IsOK(ecode3)) {
37289 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37290 }
37291 arg3 = static_cast< int >(val3);
37292 ecode4 = SWIG_AsVal_int(obj3, &val4);
37293 if (!SWIG_IsOK(ecode4)) {
37294 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37295 }
37296 arg4 = static_cast< int >(val4);
37297 {
37298 PyThreadState* __tstate = wxPyBeginAllowThreads();
37299 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37300 wxPyEndAllowThreads(__tstate);
37301 if (PyErr_Occurred()) SWIG_fail;
37302 }
37303 {
37304 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37305 }
37306 return resultobj;
37307 fail:
37308 return NULL;
37309 }
37310
37311
37312 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37313 PyObject *resultobj = 0;
37314 wxWindow *arg1 = (wxWindow *) 0 ;
37315 int arg2 ;
37316 bool result;
37317 void *argp1 = 0 ;
37318 int res1 = 0 ;
37319 int val2 ;
37320 int ecode2 = 0 ;
37321 PyObject * obj0 = 0 ;
37322 PyObject * obj1 = 0 ;
37323 char * kwnames[] = {
37324 (char *) "self",(char *) "hotkeyId", NULL
37325 };
37326
37327 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37328 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37329 if (!SWIG_IsOK(res1)) {
37330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37331 }
37332 arg1 = reinterpret_cast< wxWindow * >(argp1);
37333 ecode2 = SWIG_AsVal_int(obj1, &val2);
37334 if (!SWIG_IsOK(ecode2)) {
37335 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37336 }
37337 arg2 = static_cast< int >(val2);
37338 {
37339 PyThreadState* __tstate = wxPyBeginAllowThreads();
37340 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37341 wxPyEndAllowThreads(__tstate);
37342 if (PyErr_Occurred()) SWIG_fail;
37343 }
37344 {
37345 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37346 }
37347 return resultobj;
37348 fail:
37349 return NULL;
37350 }
37351
37352
37353 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37354 PyObject *resultobj = 0;
37355 wxWindow *arg1 = (wxWindow *) 0 ;
37356 wxPoint *arg2 = 0 ;
37357 wxPoint result;
37358 void *argp1 = 0 ;
37359 int res1 = 0 ;
37360 wxPoint temp2 ;
37361 PyObject * obj0 = 0 ;
37362 PyObject * obj1 = 0 ;
37363 char * kwnames[] = {
37364 (char *) "self",(char *) "pt", NULL
37365 };
37366
37367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37369 if (!SWIG_IsOK(res1)) {
37370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37371 }
37372 arg1 = reinterpret_cast< wxWindow * >(argp1);
37373 {
37374 arg2 = &temp2;
37375 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37376 }
37377 {
37378 PyThreadState* __tstate = wxPyBeginAllowThreads();
37379 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37380 wxPyEndAllowThreads(__tstate);
37381 if (PyErr_Occurred()) SWIG_fail;
37382 }
37383 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37384 return resultobj;
37385 fail:
37386 return NULL;
37387 }
37388
37389
37390 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37391 PyObject *resultobj = 0;
37392 wxWindow *arg1 = (wxWindow *) 0 ;
37393 wxSize *arg2 = 0 ;
37394 wxSize result;
37395 void *argp1 = 0 ;
37396 int res1 = 0 ;
37397 wxSize temp2 ;
37398 PyObject * obj0 = 0 ;
37399 PyObject * obj1 = 0 ;
37400 char * kwnames[] = {
37401 (char *) "self",(char *) "sz", NULL
37402 };
37403
37404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37406 if (!SWIG_IsOK(res1)) {
37407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37408 }
37409 arg1 = reinterpret_cast< wxWindow * >(argp1);
37410 {
37411 arg2 = &temp2;
37412 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37413 }
37414 {
37415 PyThreadState* __tstate = wxPyBeginAllowThreads();
37416 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37417 wxPyEndAllowThreads(__tstate);
37418 if (PyErr_Occurred()) SWIG_fail;
37419 }
37420 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37421 return resultobj;
37422 fail:
37423 return NULL;
37424 }
37425
37426
37427 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37428 PyObject *resultobj = 0;
37429 wxWindow *arg1 = (wxWindow *) 0 ;
37430 wxPoint *arg2 = 0 ;
37431 wxPoint result;
37432 void *argp1 = 0 ;
37433 int res1 = 0 ;
37434 wxPoint temp2 ;
37435 PyObject * obj0 = 0 ;
37436 PyObject * obj1 = 0 ;
37437 char * kwnames[] = {
37438 (char *) "self",(char *) "pt", NULL
37439 };
37440
37441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37443 if (!SWIG_IsOK(res1)) {
37444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37445 }
37446 arg1 = reinterpret_cast< wxWindow * >(argp1);
37447 {
37448 arg2 = &temp2;
37449 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37450 }
37451 {
37452 PyThreadState* __tstate = wxPyBeginAllowThreads();
37453 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37454 wxPyEndAllowThreads(__tstate);
37455 if (PyErr_Occurred()) SWIG_fail;
37456 }
37457 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37458 return resultobj;
37459 fail:
37460 return NULL;
37461 }
37462
37463
37464 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37465 PyObject *resultobj = 0;
37466 wxWindow *arg1 = (wxWindow *) 0 ;
37467 wxSize *arg2 = 0 ;
37468 wxSize result;
37469 void *argp1 = 0 ;
37470 int res1 = 0 ;
37471 wxSize temp2 ;
37472 PyObject * obj0 = 0 ;
37473 PyObject * obj1 = 0 ;
37474 char * kwnames[] = {
37475 (char *) "self",(char *) "sz", NULL
37476 };
37477
37478 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37479 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37480 if (!SWIG_IsOK(res1)) {
37481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37482 }
37483 arg1 = reinterpret_cast< wxWindow * >(argp1);
37484 {
37485 arg2 = &temp2;
37486 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37487 }
37488 {
37489 PyThreadState* __tstate = wxPyBeginAllowThreads();
37490 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37491 wxPyEndAllowThreads(__tstate);
37492 if (PyErr_Occurred()) SWIG_fail;
37493 }
37494 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37495 return resultobj;
37496 fail:
37497 return NULL;
37498 }
37499
37500
37501 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37502 PyObject *resultobj = 0;
37503 wxWindow *arg1 = (wxWindow *) 0 ;
37504 wxPoint *arg2 = 0 ;
37505 wxPoint result;
37506 void *argp1 = 0 ;
37507 int res1 = 0 ;
37508 wxPoint temp2 ;
37509 PyObject * obj0 = 0 ;
37510 PyObject * obj1 = 0 ;
37511 char * kwnames[] = {
37512 (char *) "self",(char *) "pt", NULL
37513 };
37514
37515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37517 if (!SWIG_IsOK(res1)) {
37518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37519 }
37520 arg1 = reinterpret_cast< wxWindow * >(argp1);
37521 {
37522 arg2 = &temp2;
37523 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37524 }
37525 {
37526 PyThreadState* __tstate = wxPyBeginAllowThreads();
37527 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37528 wxPyEndAllowThreads(__tstate);
37529 if (PyErr_Occurred()) SWIG_fail;
37530 }
37531 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37532 return resultobj;
37533 fail:
37534 return NULL;
37535 }
37536
37537
37538 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37539 PyObject *resultobj = 0;
37540 wxWindow *arg1 = (wxWindow *) 0 ;
37541 wxSize *arg2 = 0 ;
37542 wxSize result;
37543 void *argp1 = 0 ;
37544 int res1 = 0 ;
37545 wxSize temp2 ;
37546 PyObject * obj0 = 0 ;
37547 PyObject * obj1 = 0 ;
37548 char * kwnames[] = {
37549 (char *) "self",(char *) "sz", NULL
37550 };
37551
37552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37554 if (!SWIG_IsOK(res1)) {
37555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37556 }
37557 arg1 = reinterpret_cast< wxWindow * >(argp1);
37558 {
37559 arg2 = &temp2;
37560 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37561 }
37562 {
37563 PyThreadState* __tstate = wxPyBeginAllowThreads();
37564 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37565 wxPyEndAllowThreads(__tstate);
37566 if (PyErr_Occurred()) SWIG_fail;
37567 }
37568 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37569 return resultobj;
37570 fail:
37571 return NULL;
37572 }
37573
37574
37575 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37576 PyObject *resultobj = 0;
37577 wxWindow *arg1 = (wxWindow *) 0 ;
37578 int arg2 ;
37579 int arg3 ;
37580 void *argp1 = 0 ;
37581 int res1 = 0 ;
37582 int val2 ;
37583 int ecode2 = 0 ;
37584 int val3 ;
37585 int ecode3 = 0 ;
37586 PyObject * obj0 = 0 ;
37587 PyObject * obj1 = 0 ;
37588 PyObject * obj2 = 0 ;
37589 char * kwnames[] = {
37590 (char *) "self",(char *) "x",(char *) "y", NULL
37591 };
37592
37593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37595 if (!SWIG_IsOK(res1)) {
37596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37597 }
37598 arg1 = reinterpret_cast< wxWindow * >(argp1);
37599 ecode2 = SWIG_AsVal_int(obj1, &val2);
37600 if (!SWIG_IsOK(ecode2)) {
37601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37602 }
37603 arg2 = static_cast< int >(val2);
37604 ecode3 = SWIG_AsVal_int(obj2, &val3);
37605 if (!SWIG_IsOK(ecode3)) {
37606 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37607 }
37608 arg3 = static_cast< int >(val3);
37609 {
37610 PyThreadState* __tstate = wxPyBeginAllowThreads();
37611 (arg1)->WarpPointer(arg2,arg3);
37612 wxPyEndAllowThreads(__tstate);
37613 if (PyErr_Occurred()) SWIG_fail;
37614 }
37615 resultobj = SWIG_Py_Void();
37616 return resultobj;
37617 fail:
37618 return NULL;
37619 }
37620
37621
37622 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37623 PyObject *resultobj = 0;
37624 wxWindow *arg1 = (wxWindow *) 0 ;
37625 void *argp1 = 0 ;
37626 int res1 = 0 ;
37627 PyObject *swig_obj[1] ;
37628
37629 if (!args) SWIG_fail;
37630 swig_obj[0] = args;
37631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37632 if (!SWIG_IsOK(res1)) {
37633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37634 }
37635 arg1 = reinterpret_cast< wxWindow * >(argp1);
37636 {
37637 PyThreadState* __tstate = wxPyBeginAllowThreads();
37638 (arg1)->CaptureMouse();
37639 wxPyEndAllowThreads(__tstate);
37640 if (PyErr_Occurred()) SWIG_fail;
37641 }
37642 resultobj = SWIG_Py_Void();
37643 return resultobj;
37644 fail:
37645 return NULL;
37646 }
37647
37648
37649 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37650 PyObject *resultobj = 0;
37651 wxWindow *arg1 = (wxWindow *) 0 ;
37652 void *argp1 = 0 ;
37653 int res1 = 0 ;
37654 PyObject *swig_obj[1] ;
37655
37656 if (!args) SWIG_fail;
37657 swig_obj[0] = args;
37658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37659 if (!SWIG_IsOK(res1)) {
37660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37661 }
37662 arg1 = reinterpret_cast< wxWindow * >(argp1);
37663 {
37664 PyThreadState* __tstate = wxPyBeginAllowThreads();
37665 (arg1)->ReleaseMouse();
37666 wxPyEndAllowThreads(__tstate);
37667 if (PyErr_Occurred()) SWIG_fail;
37668 }
37669 resultobj = SWIG_Py_Void();
37670 return resultobj;
37671 fail:
37672 return NULL;
37673 }
37674
37675
37676 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37677 PyObject *resultobj = 0;
37678 wxWindow *result = 0 ;
37679
37680 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37681 {
37682 if (!wxPyCheckForApp()) SWIG_fail;
37683 PyThreadState* __tstate = wxPyBeginAllowThreads();
37684 result = (wxWindow *)wxWindow::GetCapture();
37685 wxPyEndAllowThreads(__tstate);
37686 if (PyErr_Occurred()) SWIG_fail;
37687 }
37688 {
37689 resultobj = wxPyMake_wxObject(result, 0);
37690 }
37691 return resultobj;
37692 fail:
37693 return NULL;
37694 }
37695
37696
37697 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37698 PyObject *resultobj = 0;
37699 wxWindow *arg1 = (wxWindow *) 0 ;
37700 bool result;
37701 void *argp1 = 0 ;
37702 int res1 = 0 ;
37703 PyObject *swig_obj[1] ;
37704
37705 if (!args) SWIG_fail;
37706 swig_obj[0] = args;
37707 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37708 if (!SWIG_IsOK(res1)) {
37709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37710 }
37711 arg1 = reinterpret_cast< wxWindow * >(argp1);
37712 {
37713 PyThreadState* __tstate = wxPyBeginAllowThreads();
37714 result = (bool)((wxWindow const *)arg1)->HasCapture();
37715 wxPyEndAllowThreads(__tstate);
37716 if (PyErr_Occurred()) SWIG_fail;
37717 }
37718 {
37719 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37720 }
37721 return resultobj;
37722 fail:
37723 return NULL;
37724 }
37725
37726
37727 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37728 PyObject *resultobj = 0;
37729 wxWindow *arg1 = (wxWindow *) 0 ;
37730 bool arg2 = (bool) true ;
37731 wxRect *arg3 = (wxRect *) NULL ;
37732 void *argp1 = 0 ;
37733 int res1 = 0 ;
37734 bool val2 ;
37735 int ecode2 = 0 ;
37736 void *argp3 = 0 ;
37737 int res3 = 0 ;
37738 PyObject * obj0 = 0 ;
37739 PyObject * obj1 = 0 ;
37740 PyObject * obj2 = 0 ;
37741 char * kwnames[] = {
37742 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37743 };
37744
37745 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37746 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37747 if (!SWIG_IsOK(res1)) {
37748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37749 }
37750 arg1 = reinterpret_cast< wxWindow * >(argp1);
37751 if (obj1) {
37752 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37753 if (!SWIG_IsOK(ecode2)) {
37754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37755 }
37756 arg2 = static_cast< bool >(val2);
37757 }
37758 if (obj2) {
37759 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37760 if (!SWIG_IsOK(res3)) {
37761 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37762 }
37763 arg3 = reinterpret_cast< wxRect * >(argp3);
37764 }
37765 {
37766 PyThreadState* __tstate = wxPyBeginAllowThreads();
37767 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37768 wxPyEndAllowThreads(__tstate);
37769 if (PyErr_Occurred()) SWIG_fail;
37770 }
37771 resultobj = SWIG_Py_Void();
37772 return resultobj;
37773 fail:
37774 return NULL;
37775 }
37776
37777
37778 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37779 PyObject *resultobj = 0;
37780 wxWindow *arg1 = (wxWindow *) 0 ;
37781 wxRect *arg2 = 0 ;
37782 bool arg3 = (bool) true ;
37783 void *argp1 = 0 ;
37784 int res1 = 0 ;
37785 wxRect temp2 ;
37786 bool val3 ;
37787 int ecode3 = 0 ;
37788 PyObject * obj0 = 0 ;
37789 PyObject * obj1 = 0 ;
37790 PyObject * obj2 = 0 ;
37791 char * kwnames[] = {
37792 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37793 };
37794
37795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37797 if (!SWIG_IsOK(res1)) {
37798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37799 }
37800 arg1 = reinterpret_cast< wxWindow * >(argp1);
37801 {
37802 arg2 = &temp2;
37803 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37804 }
37805 if (obj2) {
37806 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37807 if (!SWIG_IsOK(ecode3)) {
37808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37809 }
37810 arg3 = static_cast< bool >(val3);
37811 }
37812 {
37813 PyThreadState* __tstate = wxPyBeginAllowThreads();
37814 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37815 wxPyEndAllowThreads(__tstate);
37816 if (PyErr_Occurred()) SWIG_fail;
37817 }
37818 resultobj = SWIG_Py_Void();
37819 return resultobj;
37820 fail:
37821 return NULL;
37822 }
37823
37824
37825 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37826 PyObject *resultobj = 0;
37827 wxWindow *arg1 = (wxWindow *) 0 ;
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_wxWindow, 0 | 0 );
37835 if (!SWIG_IsOK(res1)) {
37836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37837 }
37838 arg1 = reinterpret_cast< wxWindow * >(argp1);
37839 {
37840 PyThreadState* __tstate = wxPyBeginAllowThreads();
37841 (arg1)->Update();
37842 wxPyEndAllowThreads(__tstate);
37843 if (PyErr_Occurred()) SWIG_fail;
37844 }
37845 resultobj = SWIG_Py_Void();
37846 return resultobj;
37847 fail:
37848 return NULL;
37849 }
37850
37851
37852 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37853 PyObject *resultobj = 0;
37854 wxWindow *arg1 = (wxWindow *) 0 ;
37855 void *argp1 = 0 ;
37856 int res1 = 0 ;
37857 PyObject *swig_obj[1] ;
37858
37859 if (!args) SWIG_fail;
37860 swig_obj[0] = args;
37861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37862 if (!SWIG_IsOK(res1)) {
37863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37864 }
37865 arg1 = reinterpret_cast< wxWindow * >(argp1);
37866 {
37867 PyThreadState* __tstate = wxPyBeginAllowThreads();
37868 (arg1)->ClearBackground();
37869 wxPyEndAllowThreads(__tstate);
37870 if (PyErr_Occurred()) SWIG_fail;
37871 }
37872 resultobj = SWIG_Py_Void();
37873 return resultobj;
37874 fail:
37875 return NULL;
37876 }
37877
37878
37879 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37880 PyObject *resultobj = 0;
37881 wxWindow *arg1 = (wxWindow *) 0 ;
37882 void *argp1 = 0 ;
37883 int res1 = 0 ;
37884 PyObject *swig_obj[1] ;
37885
37886 if (!args) SWIG_fail;
37887 swig_obj[0] = args;
37888 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37889 if (!SWIG_IsOK(res1)) {
37890 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37891 }
37892 arg1 = reinterpret_cast< wxWindow * >(argp1);
37893 {
37894 PyThreadState* __tstate = wxPyBeginAllowThreads();
37895 (arg1)->Freeze();
37896 wxPyEndAllowThreads(__tstate);
37897 if (PyErr_Occurred()) SWIG_fail;
37898 }
37899 resultobj = SWIG_Py_Void();
37900 return resultobj;
37901 fail:
37902 return NULL;
37903 }
37904
37905
37906 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37907 PyObject *resultobj = 0;
37908 wxWindow *arg1 = (wxWindow *) 0 ;
37909 bool result;
37910 void *argp1 = 0 ;
37911 int res1 = 0 ;
37912 PyObject *swig_obj[1] ;
37913
37914 if (!args) SWIG_fail;
37915 swig_obj[0] = args;
37916 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37917 if (!SWIG_IsOK(res1)) {
37918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37919 }
37920 arg1 = reinterpret_cast< wxWindow * >(argp1);
37921 {
37922 PyThreadState* __tstate = wxPyBeginAllowThreads();
37923 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37924 wxPyEndAllowThreads(__tstate);
37925 if (PyErr_Occurred()) SWIG_fail;
37926 }
37927 {
37928 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37929 }
37930 return resultobj;
37931 fail:
37932 return NULL;
37933 }
37934
37935
37936 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37937 PyObject *resultobj = 0;
37938 wxWindow *arg1 = (wxWindow *) 0 ;
37939 void *argp1 = 0 ;
37940 int res1 = 0 ;
37941 PyObject *swig_obj[1] ;
37942
37943 if (!args) SWIG_fail;
37944 swig_obj[0] = args;
37945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37946 if (!SWIG_IsOK(res1)) {
37947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37948 }
37949 arg1 = reinterpret_cast< wxWindow * >(argp1);
37950 {
37951 PyThreadState* __tstate = wxPyBeginAllowThreads();
37952 (arg1)->Thaw();
37953 wxPyEndAllowThreads(__tstate);
37954 if (PyErr_Occurred()) SWIG_fail;
37955 }
37956 resultobj = SWIG_Py_Void();
37957 return resultobj;
37958 fail:
37959 return NULL;
37960 }
37961
37962
37963 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37964 PyObject *resultobj = 0;
37965 wxWindow *arg1 = (wxWindow *) 0 ;
37966 wxDC *arg2 = 0 ;
37967 void *argp1 = 0 ;
37968 int res1 = 0 ;
37969 void *argp2 = 0 ;
37970 int res2 = 0 ;
37971 PyObject * obj0 = 0 ;
37972 PyObject * obj1 = 0 ;
37973 char * kwnames[] = {
37974 (char *) "self",(char *) "dc", NULL
37975 };
37976
37977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37979 if (!SWIG_IsOK(res1)) {
37980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37981 }
37982 arg1 = reinterpret_cast< wxWindow * >(argp1);
37983 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37984 if (!SWIG_IsOK(res2)) {
37985 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37986 }
37987 if (!argp2) {
37988 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
37989 }
37990 arg2 = reinterpret_cast< wxDC * >(argp2);
37991 {
37992 PyThreadState* __tstate = wxPyBeginAllowThreads();
37993 (arg1)->PrepareDC(*arg2);
37994 wxPyEndAllowThreads(__tstate);
37995 if (PyErr_Occurred()) SWIG_fail;
37996 }
37997 resultobj = SWIG_Py_Void();
37998 return resultobj;
37999 fail:
38000 return NULL;
38001 }
38002
38003
38004 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38005 PyObject *resultobj = 0;
38006 wxWindow *arg1 = (wxWindow *) 0 ;
38007 bool result;
38008 void *argp1 = 0 ;
38009 int res1 = 0 ;
38010 PyObject *swig_obj[1] ;
38011
38012 if (!args) SWIG_fail;
38013 swig_obj[0] = args;
38014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38015 if (!SWIG_IsOK(res1)) {
38016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38017 }
38018 arg1 = reinterpret_cast< wxWindow * >(argp1);
38019 {
38020 PyThreadState* __tstate = wxPyBeginAllowThreads();
38021 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38022 wxPyEndAllowThreads(__tstate);
38023 if (PyErr_Occurred()) SWIG_fail;
38024 }
38025 {
38026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38027 }
38028 return resultobj;
38029 fail:
38030 return NULL;
38031 }
38032
38033
38034 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38035 PyObject *resultobj = 0;
38036 wxWindow *arg1 = (wxWindow *) 0 ;
38037 wxRegion *result = 0 ;
38038 void *argp1 = 0 ;
38039 int res1 = 0 ;
38040 PyObject *swig_obj[1] ;
38041
38042 if (!args) SWIG_fail;
38043 swig_obj[0] = args;
38044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38045 if (!SWIG_IsOK(res1)) {
38046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38047 }
38048 arg1 = reinterpret_cast< wxWindow * >(argp1);
38049 {
38050 PyThreadState* __tstate = wxPyBeginAllowThreads();
38051 {
38052 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38053 result = (wxRegion *) &_result_ref;
38054 }
38055 wxPyEndAllowThreads(__tstate);
38056 if (PyErr_Occurred()) SWIG_fail;
38057 }
38058 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38059 return resultobj;
38060 fail:
38061 return NULL;
38062 }
38063
38064
38065 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38066 PyObject *resultobj = 0;
38067 wxWindow *arg1 = (wxWindow *) 0 ;
38068 wxRect result;
38069 void *argp1 = 0 ;
38070 int res1 = 0 ;
38071 PyObject *swig_obj[1] ;
38072
38073 if (!args) SWIG_fail;
38074 swig_obj[0] = args;
38075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38076 if (!SWIG_IsOK(res1)) {
38077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38078 }
38079 arg1 = reinterpret_cast< wxWindow * >(argp1);
38080 {
38081 PyThreadState* __tstate = wxPyBeginAllowThreads();
38082 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38083 wxPyEndAllowThreads(__tstate);
38084 if (PyErr_Occurred()) SWIG_fail;
38085 }
38086 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38087 return resultobj;
38088 fail:
38089 return NULL;
38090 }
38091
38092
38093 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38094 PyObject *resultobj = 0;
38095 wxWindow *arg1 = (wxWindow *) 0 ;
38096 int arg2 ;
38097 int arg3 ;
38098 int arg4 = (int) 1 ;
38099 int arg5 = (int) 1 ;
38100 bool result;
38101 void *argp1 = 0 ;
38102 int res1 = 0 ;
38103 int val2 ;
38104 int ecode2 = 0 ;
38105 int val3 ;
38106 int ecode3 = 0 ;
38107 int val4 ;
38108 int ecode4 = 0 ;
38109 int val5 ;
38110 int ecode5 = 0 ;
38111 PyObject * obj0 = 0 ;
38112 PyObject * obj1 = 0 ;
38113 PyObject * obj2 = 0 ;
38114 PyObject * obj3 = 0 ;
38115 PyObject * obj4 = 0 ;
38116 char * kwnames[] = {
38117 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38118 };
38119
38120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38122 if (!SWIG_IsOK(res1)) {
38123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38124 }
38125 arg1 = reinterpret_cast< wxWindow * >(argp1);
38126 ecode2 = SWIG_AsVal_int(obj1, &val2);
38127 if (!SWIG_IsOK(ecode2)) {
38128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38129 }
38130 arg2 = static_cast< int >(val2);
38131 ecode3 = SWIG_AsVal_int(obj2, &val3);
38132 if (!SWIG_IsOK(ecode3)) {
38133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38134 }
38135 arg3 = static_cast< int >(val3);
38136 if (obj3) {
38137 ecode4 = SWIG_AsVal_int(obj3, &val4);
38138 if (!SWIG_IsOK(ecode4)) {
38139 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38140 }
38141 arg4 = static_cast< int >(val4);
38142 }
38143 if (obj4) {
38144 ecode5 = SWIG_AsVal_int(obj4, &val5);
38145 if (!SWIG_IsOK(ecode5)) {
38146 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38147 }
38148 arg5 = static_cast< int >(val5);
38149 }
38150 {
38151 PyThreadState* __tstate = wxPyBeginAllowThreads();
38152 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38153 wxPyEndAllowThreads(__tstate);
38154 if (PyErr_Occurred()) SWIG_fail;
38155 }
38156 {
38157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38158 }
38159 return resultobj;
38160 fail:
38161 return NULL;
38162 }
38163
38164
38165 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38166 PyObject *resultobj = 0;
38167 wxWindow *arg1 = (wxWindow *) 0 ;
38168 wxPoint *arg2 = 0 ;
38169 bool result;
38170 void *argp1 = 0 ;
38171 int res1 = 0 ;
38172 wxPoint temp2 ;
38173 PyObject * obj0 = 0 ;
38174 PyObject * obj1 = 0 ;
38175 char * kwnames[] = {
38176 (char *) "self",(char *) "pt", NULL
38177 };
38178
38179 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38180 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38181 if (!SWIG_IsOK(res1)) {
38182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38183 }
38184 arg1 = reinterpret_cast< wxWindow * >(argp1);
38185 {
38186 arg2 = &temp2;
38187 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38188 }
38189 {
38190 PyThreadState* __tstate = wxPyBeginAllowThreads();
38191 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38192 wxPyEndAllowThreads(__tstate);
38193 if (PyErr_Occurred()) SWIG_fail;
38194 }
38195 {
38196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38197 }
38198 return resultobj;
38199 fail:
38200 return NULL;
38201 }
38202
38203
38204 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38205 PyObject *resultobj = 0;
38206 wxWindow *arg1 = (wxWindow *) 0 ;
38207 wxRect *arg2 = 0 ;
38208 bool result;
38209 void *argp1 = 0 ;
38210 int res1 = 0 ;
38211 wxRect temp2 ;
38212 PyObject * obj0 = 0 ;
38213 PyObject * obj1 = 0 ;
38214 char * kwnames[] = {
38215 (char *) "self",(char *) "rect", NULL
38216 };
38217
38218 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38219 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38220 if (!SWIG_IsOK(res1)) {
38221 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38222 }
38223 arg1 = reinterpret_cast< wxWindow * >(argp1);
38224 {
38225 arg2 = &temp2;
38226 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38227 }
38228 {
38229 PyThreadState* __tstate = wxPyBeginAllowThreads();
38230 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38231 wxPyEndAllowThreads(__tstate);
38232 if (PyErr_Occurred()) SWIG_fail;
38233 }
38234 {
38235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38236 }
38237 return resultobj;
38238 fail:
38239 return NULL;
38240 }
38241
38242
38243 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38244 PyObject *resultobj = 0;
38245 wxWindow *arg1 = (wxWindow *) 0 ;
38246 SwigValueWrapper<wxVisualAttributes > result;
38247 void *argp1 = 0 ;
38248 int res1 = 0 ;
38249 PyObject *swig_obj[1] ;
38250
38251 if (!args) SWIG_fail;
38252 swig_obj[0] = args;
38253 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38254 if (!SWIG_IsOK(res1)) {
38255 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38256 }
38257 arg1 = reinterpret_cast< wxWindow * >(argp1);
38258 {
38259 PyThreadState* __tstate = wxPyBeginAllowThreads();
38260 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38261 wxPyEndAllowThreads(__tstate);
38262 if (PyErr_Occurred()) SWIG_fail;
38263 }
38264 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38265 return resultobj;
38266 fail:
38267 return NULL;
38268 }
38269
38270
38271 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38272 PyObject *resultobj = 0;
38273 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38274 SwigValueWrapper<wxVisualAttributes > result;
38275 int val1 ;
38276 int ecode1 = 0 ;
38277 PyObject * obj0 = 0 ;
38278 char * kwnames[] = {
38279 (char *) "variant", NULL
38280 };
38281
38282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38283 if (obj0) {
38284 ecode1 = SWIG_AsVal_int(obj0, &val1);
38285 if (!SWIG_IsOK(ecode1)) {
38286 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38287 }
38288 arg1 = static_cast< wxWindowVariant >(val1);
38289 }
38290 {
38291 if (!wxPyCheckForApp()) SWIG_fail;
38292 PyThreadState* __tstate = wxPyBeginAllowThreads();
38293 result = wxWindow::GetClassDefaultAttributes(arg1);
38294 wxPyEndAllowThreads(__tstate);
38295 if (PyErr_Occurred()) SWIG_fail;
38296 }
38297 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38298 return resultobj;
38299 fail:
38300 return NULL;
38301 }
38302
38303
38304 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38305 PyObject *resultobj = 0;
38306 wxWindow *arg1 = (wxWindow *) 0 ;
38307 wxColour *arg2 = 0 ;
38308 bool result;
38309 void *argp1 = 0 ;
38310 int res1 = 0 ;
38311 wxColour temp2 ;
38312 PyObject * obj0 = 0 ;
38313 PyObject * obj1 = 0 ;
38314 char * kwnames[] = {
38315 (char *) "self",(char *) "colour", NULL
38316 };
38317
38318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38320 if (!SWIG_IsOK(res1)) {
38321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38322 }
38323 arg1 = reinterpret_cast< wxWindow * >(argp1);
38324 {
38325 arg2 = &temp2;
38326 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38327 }
38328 {
38329 PyThreadState* __tstate = wxPyBeginAllowThreads();
38330 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38331 wxPyEndAllowThreads(__tstate);
38332 if (PyErr_Occurred()) SWIG_fail;
38333 }
38334 {
38335 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38336 }
38337 return resultobj;
38338 fail:
38339 return NULL;
38340 }
38341
38342
38343 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38344 PyObject *resultobj = 0;
38345 wxWindow *arg1 = (wxWindow *) 0 ;
38346 wxColour *arg2 = 0 ;
38347 void *argp1 = 0 ;
38348 int res1 = 0 ;
38349 wxColour temp2 ;
38350 PyObject * obj0 = 0 ;
38351 PyObject * obj1 = 0 ;
38352 char * kwnames[] = {
38353 (char *) "self",(char *) "colour", NULL
38354 };
38355
38356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38358 if (!SWIG_IsOK(res1)) {
38359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38360 }
38361 arg1 = reinterpret_cast< wxWindow * >(argp1);
38362 {
38363 arg2 = &temp2;
38364 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38365 }
38366 {
38367 PyThreadState* __tstate = wxPyBeginAllowThreads();
38368 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38369 wxPyEndAllowThreads(__tstate);
38370 if (PyErr_Occurred()) SWIG_fail;
38371 }
38372 resultobj = SWIG_Py_Void();
38373 return resultobj;
38374 fail:
38375 return NULL;
38376 }
38377
38378
38379 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38380 PyObject *resultobj = 0;
38381 wxWindow *arg1 = (wxWindow *) 0 ;
38382 wxColour *arg2 = 0 ;
38383 bool result;
38384 void *argp1 = 0 ;
38385 int res1 = 0 ;
38386 wxColour temp2 ;
38387 PyObject * obj0 = 0 ;
38388 PyObject * obj1 = 0 ;
38389 char * kwnames[] = {
38390 (char *) "self",(char *) "colour", NULL
38391 };
38392
38393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38395 if (!SWIG_IsOK(res1)) {
38396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38397 }
38398 arg1 = reinterpret_cast< wxWindow * >(argp1);
38399 {
38400 arg2 = &temp2;
38401 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38402 }
38403 {
38404 PyThreadState* __tstate = wxPyBeginAllowThreads();
38405 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38406 wxPyEndAllowThreads(__tstate);
38407 if (PyErr_Occurred()) SWIG_fail;
38408 }
38409 {
38410 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38411 }
38412 return resultobj;
38413 fail:
38414 return NULL;
38415 }
38416
38417
38418 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38419 PyObject *resultobj = 0;
38420 wxWindow *arg1 = (wxWindow *) 0 ;
38421 wxColour *arg2 = 0 ;
38422 void *argp1 = 0 ;
38423 int res1 = 0 ;
38424 wxColour temp2 ;
38425 PyObject * obj0 = 0 ;
38426 PyObject * obj1 = 0 ;
38427 char * kwnames[] = {
38428 (char *) "self",(char *) "colour", NULL
38429 };
38430
38431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38433 if (!SWIG_IsOK(res1)) {
38434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38435 }
38436 arg1 = reinterpret_cast< wxWindow * >(argp1);
38437 {
38438 arg2 = &temp2;
38439 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38440 }
38441 {
38442 PyThreadState* __tstate = wxPyBeginAllowThreads();
38443 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38444 wxPyEndAllowThreads(__tstate);
38445 if (PyErr_Occurred()) SWIG_fail;
38446 }
38447 resultobj = SWIG_Py_Void();
38448 return resultobj;
38449 fail:
38450 return NULL;
38451 }
38452
38453
38454 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38455 PyObject *resultobj = 0;
38456 wxWindow *arg1 = (wxWindow *) 0 ;
38457 wxColour result;
38458 void *argp1 = 0 ;
38459 int res1 = 0 ;
38460 PyObject *swig_obj[1] ;
38461
38462 if (!args) SWIG_fail;
38463 swig_obj[0] = args;
38464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38465 if (!SWIG_IsOK(res1)) {
38466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38467 }
38468 arg1 = reinterpret_cast< wxWindow * >(argp1);
38469 {
38470 PyThreadState* __tstate = wxPyBeginAllowThreads();
38471 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38472 wxPyEndAllowThreads(__tstate);
38473 if (PyErr_Occurred()) SWIG_fail;
38474 }
38475 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38476 return resultobj;
38477 fail:
38478 return NULL;
38479 }
38480
38481
38482 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38483 PyObject *resultobj = 0;
38484 wxWindow *arg1 = (wxWindow *) 0 ;
38485 wxColour result;
38486 void *argp1 = 0 ;
38487 int res1 = 0 ;
38488 PyObject *swig_obj[1] ;
38489
38490 if (!args) SWIG_fail;
38491 swig_obj[0] = args;
38492 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38493 if (!SWIG_IsOK(res1)) {
38494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38495 }
38496 arg1 = reinterpret_cast< wxWindow * >(argp1);
38497 {
38498 PyThreadState* __tstate = wxPyBeginAllowThreads();
38499 result = ((wxWindow const *)arg1)->GetForegroundColour();
38500 wxPyEndAllowThreads(__tstate);
38501 if (PyErr_Occurred()) SWIG_fail;
38502 }
38503 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38504 return resultobj;
38505 fail:
38506 return NULL;
38507 }
38508
38509
38510 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38511 PyObject *resultobj = 0;
38512 wxWindow *arg1 = (wxWindow *) 0 ;
38513 bool result;
38514 void *argp1 = 0 ;
38515 int res1 = 0 ;
38516 PyObject *swig_obj[1] ;
38517
38518 if (!args) SWIG_fail;
38519 swig_obj[0] = args;
38520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38521 if (!SWIG_IsOK(res1)) {
38522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38523 }
38524 arg1 = reinterpret_cast< wxWindow * >(argp1);
38525 {
38526 PyThreadState* __tstate = wxPyBeginAllowThreads();
38527 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38528 wxPyEndAllowThreads(__tstate);
38529 if (PyErr_Occurred()) SWIG_fail;
38530 }
38531 {
38532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38533 }
38534 return resultobj;
38535 fail:
38536 return NULL;
38537 }
38538
38539
38540 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38541 PyObject *resultobj = 0;
38542 wxWindow *arg1 = (wxWindow *) 0 ;
38543 bool result;
38544 void *argp1 = 0 ;
38545 int res1 = 0 ;
38546 PyObject *swig_obj[1] ;
38547
38548 if (!args) SWIG_fail;
38549 swig_obj[0] = args;
38550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38551 if (!SWIG_IsOK(res1)) {
38552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38553 }
38554 arg1 = reinterpret_cast< wxWindow * >(argp1);
38555 {
38556 PyThreadState* __tstate = wxPyBeginAllowThreads();
38557 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38558 wxPyEndAllowThreads(__tstate);
38559 if (PyErr_Occurred()) SWIG_fail;
38560 }
38561 {
38562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38563 }
38564 return resultobj;
38565 fail:
38566 return NULL;
38567 }
38568
38569
38570 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38571 PyObject *resultobj = 0;
38572 wxWindow *arg1 = (wxWindow *) 0 ;
38573 wxBackgroundStyle arg2 ;
38574 bool result;
38575 void *argp1 = 0 ;
38576 int res1 = 0 ;
38577 int val2 ;
38578 int ecode2 = 0 ;
38579 PyObject * obj0 = 0 ;
38580 PyObject * obj1 = 0 ;
38581 char * kwnames[] = {
38582 (char *) "self",(char *) "style", NULL
38583 };
38584
38585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38587 if (!SWIG_IsOK(res1)) {
38588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38589 }
38590 arg1 = reinterpret_cast< wxWindow * >(argp1);
38591 ecode2 = SWIG_AsVal_int(obj1, &val2);
38592 if (!SWIG_IsOK(ecode2)) {
38593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38594 }
38595 arg2 = static_cast< wxBackgroundStyle >(val2);
38596 {
38597 PyThreadState* __tstate = wxPyBeginAllowThreads();
38598 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38599 wxPyEndAllowThreads(__tstate);
38600 if (PyErr_Occurred()) SWIG_fail;
38601 }
38602 {
38603 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38604 }
38605 return resultobj;
38606 fail:
38607 return NULL;
38608 }
38609
38610
38611 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38612 PyObject *resultobj = 0;
38613 wxWindow *arg1 = (wxWindow *) 0 ;
38614 wxBackgroundStyle result;
38615 void *argp1 = 0 ;
38616 int res1 = 0 ;
38617 PyObject *swig_obj[1] ;
38618
38619 if (!args) SWIG_fail;
38620 swig_obj[0] = args;
38621 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38622 if (!SWIG_IsOK(res1)) {
38623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38624 }
38625 arg1 = reinterpret_cast< wxWindow * >(argp1);
38626 {
38627 PyThreadState* __tstate = wxPyBeginAllowThreads();
38628 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38629 wxPyEndAllowThreads(__tstate);
38630 if (PyErr_Occurred()) SWIG_fail;
38631 }
38632 resultobj = SWIG_From_int(static_cast< int >(result));
38633 return resultobj;
38634 fail:
38635 return NULL;
38636 }
38637
38638
38639 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38640 PyObject *resultobj = 0;
38641 wxWindow *arg1 = (wxWindow *) 0 ;
38642 bool result;
38643 void *argp1 = 0 ;
38644 int res1 = 0 ;
38645 PyObject *swig_obj[1] ;
38646
38647 if (!args) SWIG_fail;
38648 swig_obj[0] = args;
38649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38650 if (!SWIG_IsOK(res1)) {
38651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38652 }
38653 arg1 = reinterpret_cast< wxWindow * >(argp1);
38654 {
38655 PyThreadState* __tstate = wxPyBeginAllowThreads();
38656 result = (bool)(arg1)->HasTransparentBackground();
38657 wxPyEndAllowThreads(__tstate);
38658 if (PyErr_Occurred()) SWIG_fail;
38659 }
38660 {
38661 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38662 }
38663 return resultobj;
38664 fail:
38665 return NULL;
38666 }
38667
38668
38669 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38670 PyObject *resultobj = 0;
38671 wxWindow *arg1 = (wxWindow *) 0 ;
38672 wxCursor *arg2 = 0 ;
38673 bool result;
38674 void *argp1 = 0 ;
38675 int res1 = 0 ;
38676 void *argp2 = 0 ;
38677 int res2 = 0 ;
38678 PyObject * obj0 = 0 ;
38679 PyObject * obj1 = 0 ;
38680 char * kwnames[] = {
38681 (char *) "self",(char *) "cursor", NULL
38682 };
38683
38684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38686 if (!SWIG_IsOK(res1)) {
38687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38688 }
38689 arg1 = reinterpret_cast< wxWindow * >(argp1);
38690 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38691 if (!SWIG_IsOK(res2)) {
38692 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38693 }
38694 if (!argp2) {
38695 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38696 }
38697 arg2 = reinterpret_cast< wxCursor * >(argp2);
38698 {
38699 PyThreadState* __tstate = wxPyBeginAllowThreads();
38700 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38701 wxPyEndAllowThreads(__tstate);
38702 if (PyErr_Occurred()) SWIG_fail;
38703 }
38704 {
38705 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38706 }
38707 return resultobj;
38708 fail:
38709 return NULL;
38710 }
38711
38712
38713 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38714 PyObject *resultobj = 0;
38715 wxWindow *arg1 = (wxWindow *) 0 ;
38716 wxCursor result;
38717 void *argp1 = 0 ;
38718 int res1 = 0 ;
38719 PyObject *swig_obj[1] ;
38720
38721 if (!args) SWIG_fail;
38722 swig_obj[0] = args;
38723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38724 if (!SWIG_IsOK(res1)) {
38725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38726 }
38727 arg1 = reinterpret_cast< wxWindow * >(argp1);
38728 {
38729 PyThreadState* __tstate = wxPyBeginAllowThreads();
38730 result = (arg1)->GetCursor();
38731 wxPyEndAllowThreads(__tstate);
38732 if (PyErr_Occurred()) SWIG_fail;
38733 }
38734 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38735 return resultobj;
38736 fail:
38737 return NULL;
38738 }
38739
38740
38741 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38742 PyObject *resultobj = 0;
38743 wxWindow *arg1 = (wxWindow *) 0 ;
38744 wxFont *arg2 = 0 ;
38745 bool result;
38746 void *argp1 = 0 ;
38747 int res1 = 0 ;
38748 void *argp2 = 0 ;
38749 int res2 = 0 ;
38750 PyObject * obj0 = 0 ;
38751 PyObject * obj1 = 0 ;
38752 char * kwnames[] = {
38753 (char *) "self",(char *) "font", NULL
38754 };
38755
38756 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38757 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38758 if (!SWIG_IsOK(res1)) {
38759 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38760 }
38761 arg1 = reinterpret_cast< wxWindow * >(argp1);
38762 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38763 if (!SWIG_IsOK(res2)) {
38764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38765 }
38766 if (!argp2) {
38767 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38768 }
38769 arg2 = reinterpret_cast< wxFont * >(argp2);
38770 {
38771 PyThreadState* __tstate = wxPyBeginAllowThreads();
38772 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38773 wxPyEndAllowThreads(__tstate);
38774 if (PyErr_Occurred()) SWIG_fail;
38775 }
38776 {
38777 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38778 }
38779 return resultobj;
38780 fail:
38781 return NULL;
38782 }
38783
38784
38785 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38786 PyObject *resultobj = 0;
38787 wxWindow *arg1 = (wxWindow *) 0 ;
38788 wxFont *arg2 = 0 ;
38789 void *argp1 = 0 ;
38790 int res1 = 0 ;
38791 void *argp2 = 0 ;
38792 int res2 = 0 ;
38793 PyObject * obj0 = 0 ;
38794 PyObject * obj1 = 0 ;
38795 char * kwnames[] = {
38796 (char *) "self",(char *) "font", NULL
38797 };
38798
38799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38800 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38801 if (!SWIG_IsOK(res1)) {
38802 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38803 }
38804 arg1 = reinterpret_cast< wxWindow * >(argp1);
38805 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38806 if (!SWIG_IsOK(res2)) {
38807 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38808 }
38809 if (!argp2) {
38810 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38811 }
38812 arg2 = reinterpret_cast< wxFont * >(argp2);
38813 {
38814 PyThreadState* __tstate = wxPyBeginAllowThreads();
38815 (arg1)->SetOwnFont((wxFont const &)*arg2);
38816 wxPyEndAllowThreads(__tstate);
38817 if (PyErr_Occurred()) SWIG_fail;
38818 }
38819 resultobj = SWIG_Py_Void();
38820 return resultobj;
38821 fail:
38822 return NULL;
38823 }
38824
38825
38826 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38827 PyObject *resultobj = 0;
38828 wxWindow *arg1 = (wxWindow *) 0 ;
38829 wxFont result;
38830 void *argp1 = 0 ;
38831 int res1 = 0 ;
38832 PyObject *swig_obj[1] ;
38833
38834 if (!args) SWIG_fail;
38835 swig_obj[0] = args;
38836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38837 if (!SWIG_IsOK(res1)) {
38838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38839 }
38840 arg1 = reinterpret_cast< wxWindow * >(argp1);
38841 {
38842 PyThreadState* __tstate = wxPyBeginAllowThreads();
38843 result = (arg1)->GetFont();
38844 wxPyEndAllowThreads(__tstate);
38845 if (PyErr_Occurred()) SWIG_fail;
38846 }
38847 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38848 return resultobj;
38849 fail:
38850 return NULL;
38851 }
38852
38853
38854 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38855 PyObject *resultobj = 0;
38856 wxWindow *arg1 = (wxWindow *) 0 ;
38857 wxCaret *arg2 = (wxCaret *) 0 ;
38858 void *argp1 = 0 ;
38859 int res1 = 0 ;
38860 int res2 = 0 ;
38861 PyObject * obj0 = 0 ;
38862 PyObject * obj1 = 0 ;
38863 char * kwnames[] = {
38864 (char *) "self",(char *) "caret", NULL
38865 };
38866
38867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38869 if (!SWIG_IsOK(res1)) {
38870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38871 }
38872 arg1 = reinterpret_cast< wxWindow * >(argp1);
38873 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38874 if (!SWIG_IsOK(res2)) {
38875 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38876 }
38877 {
38878 PyThreadState* __tstate = wxPyBeginAllowThreads();
38879 (arg1)->SetCaret(arg2);
38880 wxPyEndAllowThreads(__tstate);
38881 if (PyErr_Occurred()) SWIG_fail;
38882 }
38883 resultobj = SWIG_Py_Void();
38884 return resultobj;
38885 fail:
38886 return NULL;
38887 }
38888
38889
38890 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38891 PyObject *resultobj = 0;
38892 wxWindow *arg1 = (wxWindow *) 0 ;
38893 wxCaret *result = 0 ;
38894 void *argp1 = 0 ;
38895 int res1 = 0 ;
38896 PyObject *swig_obj[1] ;
38897
38898 if (!args) SWIG_fail;
38899 swig_obj[0] = args;
38900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38901 if (!SWIG_IsOK(res1)) {
38902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38903 }
38904 arg1 = reinterpret_cast< wxWindow * >(argp1);
38905 {
38906 PyThreadState* __tstate = wxPyBeginAllowThreads();
38907 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38908 wxPyEndAllowThreads(__tstate);
38909 if (PyErr_Occurred()) SWIG_fail;
38910 }
38911 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38912 return resultobj;
38913 fail:
38914 return NULL;
38915 }
38916
38917
38918 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38919 PyObject *resultobj = 0;
38920 wxWindow *arg1 = (wxWindow *) 0 ;
38921 int result;
38922 void *argp1 = 0 ;
38923 int res1 = 0 ;
38924 PyObject *swig_obj[1] ;
38925
38926 if (!args) SWIG_fail;
38927 swig_obj[0] = args;
38928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38929 if (!SWIG_IsOK(res1)) {
38930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38931 }
38932 arg1 = reinterpret_cast< wxWindow * >(argp1);
38933 {
38934 PyThreadState* __tstate = wxPyBeginAllowThreads();
38935 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38936 wxPyEndAllowThreads(__tstate);
38937 if (PyErr_Occurred()) SWIG_fail;
38938 }
38939 resultobj = SWIG_From_int(static_cast< int >(result));
38940 return resultobj;
38941 fail:
38942 return NULL;
38943 }
38944
38945
38946 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38947 PyObject *resultobj = 0;
38948 wxWindow *arg1 = (wxWindow *) 0 ;
38949 int result;
38950 void *argp1 = 0 ;
38951 int res1 = 0 ;
38952 PyObject *swig_obj[1] ;
38953
38954 if (!args) SWIG_fail;
38955 swig_obj[0] = args;
38956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38957 if (!SWIG_IsOK(res1)) {
38958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38959 }
38960 arg1 = reinterpret_cast< wxWindow * >(argp1);
38961 {
38962 PyThreadState* __tstate = wxPyBeginAllowThreads();
38963 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38964 wxPyEndAllowThreads(__tstate);
38965 if (PyErr_Occurred()) SWIG_fail;
38966 }
38967 resultobj = SWIG_From_int(static_cast< int >(result));
38968 return resultobj;
38969 fail:
38970 return NULL;
38971 }
38972
38973
38974 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38975 PyObject *resultobj = 0;
38976 wxWindow *arg1 = (wxWindow *) 0 ;
38977 wxString *arg2 = 0 ;
38978 int *arg3 = (int *) 0 ;
38979 int *arg4 = (int *) 0 ;
38980 void *argp1 = 0 ;
38981 int res1 = 0 ;
38982 bool temp2 = false ;
38983 int temp3 ;
38984 int res3 = SWIG_TMPOBJ ;
38985 int temp4 ;
38986 int res4 = SWIG_TMPOBJ ;
38987 PyObject * obj0 = 0 ;
38988 PyObject * obj1 = 0 ;
38989 char * kwnames[] = {
38990 (char *) "self",(char *) "string", NULL
38991 };
38992
38993 arg3 = &temp3;
38994 arg4 = &temp4;
38995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
38996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38997 if (!SWIG_IsOK(res1)) {
38998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
38999 }
39000 arg1 = reinterpret_cast< wxWindow * >(argp1);
39001 {
39002 arg2 = wxString_in_helper(obj1);
39003 if (arg2 == NULL) SWIG_fail;
39004 temp2 = true;
39005 }
39006 {
39007 PyThreadState* __tstate = wxPyBeginAllowThreads();
39008 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39009 wxPyEndAllowThreads(__tstate);
39010 if (PyErr_Occurred()) SWIG_fail;
39011 }
39012 resultobj = SWIG_Py_Void();
39013 if (SWIG_IsTmpObj(res3)) {
39014 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39015 } else {
39016 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39017 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39018 }
39019 if (SWIG_IsTmpObj(res4)) {
39020 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39021 } else {
39022 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39023 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39024 }
39025 {
39026 if (temp2)
39027 delete arg2;
39028 }
39029 return resultobj;
39030 fail:
39031 {
39032 if (temp2)
39033 delete arg2;
39034 }
39035 return NULL;
39036 }
39037
39038
39039 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39040 PyObject *resultobj = 0;
39041 wxWindow *arg1 = (wxWindow *) 0 ;
39042 wxString *arg2 = 0 ;
39043 int *arg3 = (int *) 0 ;
39044 int *arg4 = (int *) 0 ;
39045 int *arg5 = (int *) 0 ;
39046 int *arg6 = (int *) 0 ;
39047 wxFont *arg7 = (wxFont *) NULL ;
39048 void *argp1 = 0 ;
39049 int res1 = 0 ;
39050 bool temp2 = false ;
39051 int temp3 ;
39052 int res3 = SWIG_TMPOBJ ;
39053 int temp4 ;
39054 int res4 = SWIG_TMPOBJ ;
39055 int temp5 ;
39056 int res5 = SWIG_TMPOBJ ;
39057 int temp6 ;
39058 int res6 = SWIG_TMPOBJ ;
39059 void *argp7 = 0 ;
39060 int res7 = 0 ;
39061 PyObject * obj0 = 0 ;
39062 PyObject * obj1 = 0 ;
39063 PyObject * obj2 = 0 ;
39064 char * kwnames[] = {
39065 (char *) "self",(char *) "string",(char *) "font", NULL
39066 };
39067
39068 arg3 = &temp3;
39069 arg4 = &temp4;
39070 arg5 = &temp5;
39071 arg6 = &temp6;
39072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39074 if (!SWIG_IsOK(res1)) {
39075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39076 }
39077 arg1 = reinterpret_cast< wxWindow * >(argp1);
39078 {
39079 arg2 = wxString_in_helper(obj1);
39080 if (arg2 == NULL) SWIG_fail;
39081 temp2 = true;
39082 }
39083 if (obj2) {
39084 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39085 if (!SWIG_IsOK(res7)) {
39086 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39087 }
39088 arg7 = reinterpret_cast< wxFont * >(argp7);
39089 }
39090 {
39091 PyThreadState* __tstate = wxPyBeginAllowThreads();
39092 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39093 wxPyEndAllowThreads(__tstate);
39094 if (PyErr_Occurred()) SWIG_fail;
39095 }
39096 resultobj = SWIG_Py_Void();
39097 if (SWIG_IsTmpObj(res3)) {
39098 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39099 } else {
39100 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39101 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39102 }
39103 if (SWIG_IsTmpObj(res4)) {
39104 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39105 } else {
39106 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39107 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39108 }
39109 if (SWIG_IsTmpObj(res5)) {
39110 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39111 } else {
39112 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39113 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39114 }
39115 if (SWIG_IsTmpObj(res6)) {
39116 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39117 } else {
39118 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39119 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39120 }
39121 {
39122 if (temp2)
39123 delete arg2;
39124 }
39125 return resultobj;
39126 fail:
39127 {
39128 if (temp2)
39129 delete arg2;
39130 }
39131 return NULL;
39132 }
39133
39134
39135 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39136 PyObject *resultobj = 0;
39137 wxWindow *arg1 = (wxWindow *) 0 ;
39138 int *arg2 = (int *) 0 ;
39139 int *arg3 = (int *) 0 ;
39140 void *argp1 = 0 ;
39141 int res1 = 0 ;
39142 int temp2 ;
39143 int res2 = 0 ;
39144 int temp3 ;
39145 int res3 = 0 ;
39146 PyObject * obj0 = 0 ;
39147 PyObject * obj1 = 0 ;
39148 PyObject * obj2 = 0 ;
39149 char * kwnames[] = {
39150 (char *) "self",(char *) "x",(char *) "y", NULL
39151 };
39152
39153 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39154 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39155 if (!SWIG_IsOK(res1)) {
39156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39157 }
39158 arg1 = reinterpret_cast< wxWindow * >(argp1);
39159 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39160 int val;
39161 int ecode = SWIG_AsVal_int(obj1, &val);
39162 if (!SWIG_IsOK(ecode)) {
39163 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39164 }
39165 temp2 = static_cast< int >(val);
39166 arg2 = &temp2;
39167 res2 = SWIG_AddTmpMask(ecode);
39168 }
39169 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39170 int val;
39171 int ecode = SWIG_AsVal_int(obj2, &val);
39172 if (!SWIG_IsOK(ecode)) {
39173 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39174 }
39175 temp3 = static_cast< int >(val);
39176 arg3 = &temp3;
39177 res3 = SWIG_AddTmpMask(ecode);
39178 }
39179 {
39180 PyThreadState* __tstate = wxPyBeginAllowThreads();
39181 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39182 wxPyEndAllowThreads(__tstate);
39183 if (PyErr_Occurred()) SWIG_fail;
39184 }
39185 resultobj = SWIG_Py_Void();
39186 if (SWIG_IsTmpObj(res2)) {
39187 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39188 } else {
39189 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39191 }
39192 if (SWIG_IsTmpObj(res3)) {
39193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39194 } else {
39195 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39197 }
39198 return resultobj;
39199 fail:
39200 return NULL;
39201 }
39202
39203
39204 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39205 PyObject *resultobj = 0;
39206 wxWindow *arg1 = (wxWindow *) 0 ;
39207 int *arg2 = (int *) 0 ;
39208 int *arg3 = (int *) 0 ;
39209 void *argp1 = 0 ;
39210 int res1 = 0 ;
39211 int temp2 ;
39212 int res2 = 0 ;
39213 int temp3 ;
39214 int res3 = 0 ;
39215 PyObject * obj0 = 0 ;
39216 PyObject * obj1 = 0 ;
39217 PyObject * obj2 = 0 ;
39218 char * kwnames[] = {
39219 (char *) "self",(char *) "x",(char *) "y", NULL
39220 };
39221
39222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39224 if (!SWIG_IsOK(res1)) {
39225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39226 }
39227 arg1 = reinterpret_cast< wxWindow * >(argp1);
39228 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39229 int val;
39230 int ecode = SWIG_AsVal_int(obj1, &val);
39231 if (!SWIG_IsOK(ecode)) {
39232 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39233 }
39234 temp2 = static_cast< int >(val);
39235 arg2 = &temp2;
39236 res2 = SWIG_AddTmpMask(ecode);
39237 }
39238 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39239 int val;
39240 int ecode = SWIG_AsVal_int(obj2, &val);
39241 if (!SWIG_IsOK(ecode)) {
39242 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39243 }
39244 temp3 = static_cast< int >(val);
39245 arg3 = &temp3;
39246 res3 = SWIG_AddTmpMask(ecode);
39247 }
39248 {
39249 PyThreadState* __tstate = wxPyBeginAllowThreads();
39250 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39251 wxPyEndAllowThreads(__tstate);
39252 if (PyErr_Occurred()) SWIG_fail;
39253 }
39254 resultobj = SWIG_Py_Void();
39255 if (SWIG_IsTmpObj(res2)) {
39256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39257 } else {
39258 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39259 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39260 }
39261 if (SWIG_IsTmpObj(res3)) {
39262 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39263 } else {
39264 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39265 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39266 }
39267 return resultobj;
39268 fail:
39269 return NULL;
39270 }
39271
39272
39273 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39274 PyObject *resultobj = 0;
39275 wxWindow *arg1 = (wxWindow *) 0 ;
39276 wxPoint *arg2 = 0 ;
39277 wxPoint result;
39278 void *argp1 = 0 ;
39279 int res1 = 0 ;
39280 wxPoint temp2 ;
39281 PyObject * obj0 = 0 ;
39282 PyObject * obj1 = 0 ;
39283 char * kwnames[] = {
39284 (char *) "self",(char *) "pt", NULL
39285 };
39286
39287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39289 if (!SWIG_IsOK(res1)) {
39290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39291 }
39292 arg1 = reinterpret_cast< wxWindow * >(argp1);
39293 {
39294 arg2 = &temp2;
39295 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39296 }
39297 {
39298 PyThreadState* __tstate = wxPyBeginAllowThreads();
39299 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39300 wxPyEndAllowThreads(__tstate);
39301 if (PyErr_Occurred()) SWIG_fail;
39302 }
39303 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39304 return resultobj;
39305 fail:
39306 return NULL;
39307 }
39308
39309
39310 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39311 PyObject *resultobj = 0;
39312 wxWindow *arg1 = (wxWindow *) 0 ;
39313 wxPoint *arg2 = 0 ;
39314 wxPoint result;
39315 void *argp1 = 0 ;
39316 int res1 = 0 ;
39317 wxPoint temp2 ;
39318 PyObject * obj0 = 0 ;
39319 PyObject * obj1 = 0 ;
39320 char * kwnames[] = {
39321 (char *) "self",(char *) "pt", NULL
39322 };
39323
39324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39326 if (!SWIG_IsOK(res1)) {
39327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39328 }
39329 arg1 = reinterpret_cast< wxWindow * >(argp1);
39330 {
39331 arg2 = &temp2;
39332 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39333 }
39334 {
39335 PyThreadState* __tstate = wxPyBeginAllowThreads();
39336 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39337 wxPyEndAllowThreads(__tstate);
39338 if (PyErr_Occurred()) SWIG_fail;
39339 }
39340 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39341 return resultobj;
39342 fail:
39343 return NULL;
39344 }
39345
39346
39347 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39348 PyObject *resultobj = 0;
39349 wxWindow *arg1 = (wxWindow *) 0 ;
39350 int arg2 ;
39351 int arg3 ;
39352 wxHitTest result;
39353 void *argp1 = 0 ;
39354 int res1 = 0 ;
39355 int val2 ;
39356 int ecode2 = 0 ;
39357 int val3 ;
39358 int ecode3 = 0 ;
39359 PyObject * obj0 = 0 ;
39360 PyObject * obj1 = 0 ;
39361 PyObject * obj2 = 0 ;
39362 char * kwnames[] = {
39363 (char *) "self",(char *) "x",(char *) "y", NULL
39364 };
39365
39366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39368 if (!SWIG_IsOK(res1)) {
39369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39370 }
39371 arg1 = reinterpret_cast< wxWindow * >(argp1);
39372 ecode2 = SWIG_AsVal_int(obj1, &val2);
39373 if (!SWIG_IsOK(ecode2)) {
39374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39375 }
39376 arg2 = static_cast< int >(val2);
39377 ecode3 = SWIG_AsVal_int(obj2, &val3);
39378 if (!SWIG_IsOK(ecode3)) {
39379 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39380 }
39381 arg3 = static_cast< int >(val3);
39382 {
39383 PyThreadState* __tstate = wxPyBeginAllowThreads();
39384 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39385 wxPyEndAllowThreads(__tstate);
39386 if (PyErr_Occurred()) SWIG_fail;
39387 }
39388 resultobj = SWIG_From_int(static_cast< int >(result));
39389 return resultobj;
39390 fail:
39391 return NULL;
39392 }
39393
39394
39395 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39396 PyObject *resultobj = 0;
39397 wxWindow *arg1 = (wxWindow *) 0 ;
39398 wxPoint *arg2 = 0 ;
39399 wxHitTest result;
39400 void *argp1 = 0 ;
39401 int res1 = 0 ;
39402 wxPoint temp2 ;
39403 PyObject * obj0 = 0 ;
39404 PyObject * obj1 = 0 ;
39405 char * kwnames[] = {
39406 (char *) "self",(char *) "pt", NULL
39407 };
39408
39409 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39410 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39411 if (!SWIG_IsOK(res1)) {
39412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39413 }
39414 arg1 = reinterpret_cast< wxWindow * >(argp1);
39415 {
39416 arg2 = &temp2;
39417 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39418 }
39419 {
39420 PyThreadState* __tstate = wxPyBeginAllowThreads();
39421 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39422 wxPyEndAllowThreads(__tstate);
39423 if (PyErr_Occurred()) SWIG_fail;
39424 }
39425 resultobj = SWIG_From_int(static_cast< int >(result));
39426 return resultobj;
39427 fail:
39428 return NULL;
39429 }
39430
39431
39432 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39433 PyObject *resultobj = 0;
39434 wxWindow *arg1 = (wxWindow *) 0 ;
39435 long arg2 ;
39436 wxBorder result;
39437 void *argp1 = 0 ;
39438 int res1 = 0 ;
39439 long val2 ;
39440 int ecode2 = 0 ;
39441
39442 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39443 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39444 if (!SWIG_IsOK(res1)) {
39445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39446 }
39447 arg1 = reinterpret_cast< wxWindow * >(argp1);
39448 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39449 if (!SWIG_IsOK(ecode2)) {
39450 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39451 }
39452 arg2 = static_cast< long >(val2);
39453 {
39454 PyThreadState* __tstate = wxPyBeginAllowThreads();
39455 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39456 wxPyEndAllowThreads(__tstate);
39457 if (PyErr_Occurred()) SWIG_fail;
39458 }
39459 resultobj = SWIG_From_int(static_cast< int >(result));
39460 return resultobj;
39461 fail:
39462 return NULL;
39463 }
39464
39465
39466 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39467 PyObject *resultobj = 0;
39468 wxWindow *arg1 = (wxWindow *) 0 ;
39469 wxBorder result;
39470 void *argp1 = 0 ;
39471 int res1 = 0 ;
39472
39473 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39474 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39475 if (!SWIG_IsOK(res1)) {
39476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39477 }
39478 arg1 = reinterpret_cast< wxWindow * >(argp1);
39479 {
39480 PyThreadState* __tstate = wxPyBeginAllowThreads();
39481 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39482 wxPyEndAllowThreads(__tstate);
39483 if (PyErr_Occurred()) SWIG_fail;
39484 }
39485 resultobj = SWIG_From_int(static_cast< int >(result));
39486 return resultobj;
39487 fail:
39488 return NULL;
39489 }
39490
39491
39492 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39493 int argc;
39494 PyObject *argv[3];
39495
39496 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39497 --argc;
39498 if (argc == 1) {
39499 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39500 }
39501 if (argc == 2) {
39502 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39503 }
39504
39505 fail:
39506 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39507 return NULL;
39508 }
39509
39510
39511 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39512 PyObject *resultobj = 0;
39513 wxWindow *arg1 = (wxWindow *) 0 ;
39514 long arg2 = (long) wxUPDATE_UI_NONE ;
39515 void *argp1 = 0 ;
39516 int res1 = 0 ;
39517 long val2 ;
39518 int ecode2 = 0 ;
39519 PyObject * obj0 = 0 ;
39520 PyObject * obj1 = 0 ;
39521 char * kwnames[] = {
39522 (char *) "self",(char *) "flags", NULL
39523 };
39524
39525 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39526 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39527 if (!SWIG_IsOK(res1)) {
39528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39529 }
39530 arg1 = reinterpret_cast< wxWindow * >(argp1);
39531 if (obj1) {
39532 ecode2 = SWIG_AsVal_long(obj1, &val2);
39533 if (!SWIG_IsOK(ecode2)) {
39534 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39535 }
39536 arg2 = static_cast< long >(val2);
39537 }
39538 {
39539 PyThreadState* __tstate = wxPyBeginAllowThreads();
39540 (arg1)->UpdateWindowUI(arg2);
39541 wxPyEndAllowThreads(__tstate);
39542 if (PyErr_Occurred()) SWIG_fail;
39543 }
39544 resultobj = SWIG_Py_Void();
39545 return resultobj;
39546 fail:
39547 return NULL;
39548 }
39549
39550
39551 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39552 PyObject *resultobj = 0;
39553 wxWindow *arg1 = (wxWindow *) 0 ;
39554 wxMenu *arg2 = (wxMenu *) 0 ;
39555 int arg3 = (int) -1 ;
39556 int arg4 = (int) -1 ;
39557 bool result;
39558 void *argp1 = 0 ;
39559 int res1 = 0 ;
39560 void *argp2 = 0 ;
39561 int res2 = 0 ;
39562 int val3 ;
39563 int ecode3 = 0 ;
39564 int val4 ;
39565 int ecode4 = 0 ;
39566 PyObject * obj0 = 0 ;
39567 PyObject * obj1 = 0 ;
39568 PyObject * obj2 = 0 ;
39569 PyObject * obj3 = 0 ;
39570 char * kwnames[] = {
39571 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39572 };
39573
39574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39576 if (!SWIG_IsOK(res1)) {
39577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39578 }
39579 arg1 = reinterpret_cast< wxWindow * >(argp1);
39580 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39581 if (!SWIG_IsOK(res2)) {
39582 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39583 }
39584 arg2 = reinterpret_cast< wxMenu * >(argp2);
39585 if (obj2) {
39586 ecode3 = SWIG_AsVal_int(obj2, &val3);
39587 if (!SWIG_IsOK(ecode3)) {
39588 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39589 }
39590 arg3 = static_cast< int >(val3);
39591 }
39592 if (obj3) {
39593 ecode4 = SWIG_AsVal_int(obj3, &val4);
39594 if (!SWIG_IsOK(ecode4)) {
39595 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39596 }
39597 arg4 = static_cast< int >(val4);
39598 }
39599 {
39600 PyThreadState* __tstate = wxPyBeginAllowThreads();
39601 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39602 wxPyEndAllowThreads(__tstate);
39603 if (PyErr_Occurred()) SWIG_fail;
39604 }
39605 {
39606 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39607 }
39608 return resultobj;
39609 fail:
39610 return NULL;
39611 }
39612
39613
39614 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39615 PyObject *resultobj = 0;
39616 wxWindow *arg1 = (wxWindow *) 0 ;
39617 wxMenu *arg2 = (wxMenu *) 0 ;
39618 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39619 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39620 bool result;
39621 void *argp1 = 0 ;
39622 int res1 = 0 ;
39623 void *argp2 = 0 ;
39624 int res2 = 0 ;
39625 wxPoint temp3 ;
39626 PyObject * obj0 = 0 ;
39627 PyObject * obj1 = 0 ;
39628 PyObject * obj2 = 0 ;
39629 char * kwnames[] = {
39630 (char *) "self",(char *) "menu",(char *) "pos", NULL
39631 };
39632
39633 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39634 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39635 if (!SWIG_IsOK(res1)) {
39636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39637 }
39638 arg1 = reinterpret_cast< wxWindow * >(argp1);
39639 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39640 if (!SWIG_IsOK(res2)) {
39641 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39642 }
39643 arg2 = reinterpret_cast< wxMenu * >(argp2);
39644 if (obj2) {
39645 {
39646 arg3 = &temp3;
39647 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39648 }
39649 }
39650 {
39651 PyThreadState* __tstate = wxPyBeginAllowThreads();
39652 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39653 wxPyEndAllowThreads(__tstate);
39654 if (PyErr_Occurred()) SWIG_fail;
39655 }
39656 {
39657 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39658 }
39659 return resultobj;
39660 fail:
39661 return NULL;
39662 }
39663
39664
39665 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39666 PyObject *resultobj = 0;
39667 wxWindow *arg1 = (wxWindow *) 0 ;
39668 bool result;
39669 void *argp1 = 0 ;
39670 int res1 = 0 ;
39671 PyObject *swig_obj[1] ;
39672
39673 if (!args) SWIG_fail;
39674 swig_obj[0] = args;
39675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39676 if (!SWIG_IsOK(res1)) {
39677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39678 }
39679 arg1 = reinterpret_cast< wxWindow * >(argp1);
39680 {
39681 PyThreadState* __tstate = wxPyBeginAllowThreads();
39682 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39683 wxPyEndAllowThreads(__tstate);
39684 if (PyErr_Occurred()) SWIG_fail;
39685 }
39686 {
39687 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39688 }
39689 return resultobj;
39690 fail:
39691 return NULL;
39692 }
39693
39694
39695 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39696 PyObject *resultobj = 0;
39697 wxWindow *arg1 = (wxWindow *) 0 ;
39698 long result;
39699 void *argp1 = 0 ;
39700 int res1 = 0 ;
39701 PyObject *swig_obj[1] ;
39702
39703 if (!args) SWIG_fail;
39704 swig_obj[0] = args;
39705 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39706 if (!SWIG_IsOK(res1)) {
39707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39708 }
39709 arg1 = reinterpret_cast< wxWindow * >(argp1);
39710 {
39711 PyThreadState* __tstate = wxPyBeginAllowThreads();
39712 result = (long)wxWindow_GetHandle(arg1);
39713 wxPyEndAllowThreads(__tstate);
39714 if (PyErr_Occurred()) SWIG_fail;
39715 }
39716 resultobj = SWIG_From_long(static_cast< long >(result));
39717 return resultobj;
39718 fail:
39719 return NULL;
39720 }
39721
39722
39723 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39724 PyObject *resultobj = 0;
39725 wxWindow *arg1 = (wxWindow *) 0 ;
39726 long arg2 ;
39727 void *argp1 = 0 ;
39728 int res1 = 0 ;
39729 long val2 ;
39730 int ecode2 = 0 ;
39731 PyObject * obj0 = 0 ;
39732 PyObject * obj1 = 0 ;
39733 char * kwnames[] = {
39734 (char *) "self",(char *) "handle", NULL
39735 };
39736
39737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39739 if (!SWIG_IsOK(res1)) {
39740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39741 }
39742 arg1 = reinterpret_cast< wxWindow * >(argp1);
39743 ecode2 = SWIG_AsVal_long(obj1, &val2);
39744 if (!SWIG_IsOK(ecode2)) {
39745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39746 }
39747 arg2 = static_cast< long >(val2);
39748 {
39749 PyThreadState* __tstate = wxPyBeginAllowThreads();
39750 wxWindow_AssociateHandle(arg1,arg2);
39751 wxPyEndAllowThreads(__tstate);
39752 if (PyErr_Occurred()) SWIG_fail;
39753 }
39754 resultobj = SWIG_Py_Void();
39755 return resultobj;
39756 fail:
39757 return NULL;
39758 }
39759
39760
39761 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39762 PyObject *resultobj = 0;
39763 wxWindow *arg1 = (wxWindow *) 0 ;
39764 void *argp1 = 0 ;
39765 int res1 = 0 ;
39766 PyObject *swig_obj[1] ;
39767
39768 if (!args) SWIG_fail;
39769 swig_obj[0] = args;
39770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39771 if (!SWIG_IsOK(res1)) {
39772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39773 }
39774 arg1 = reinterpret_cast< wxWindow * >(argp1);
39775 {
39776 PyThreadState* __tstate = wxPyBeginAllowThreads();
39777 (arg1)->DissociateHandle();
39778 wxPyEndAllowThreads(__tstate);
39779 if (PyErr_Occurred()) SWIG_fail;
39780 }
39781 resultobj = SWIG_Py_Void();
39782 return resultobj;
39783 fail:
39784 return NULL;
39785 }
39786
39787
39788 SWIGINTERN PyObject *_wrap_Window_OnPaint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39789 PyObject *resultobj = 0;
39790 wxWindow *arg1 = (wxWindow *) 0 ;
39791 wxPaintEvent *arg2 = 0 ;
39792 void *argp1 = 0 ;
39793 int res1 = 0 ;
39794 void *argp2 = 0 ;
39795 int res2 = 0 ;
39796 PyObject * obj0 = 0 ;
39797 PyObject * obj1 = 0 ;
39798 char * kwnames[] = {
39799 (char *) "self",(char *) "event", NULL
39800 };
39801
39802 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_OnPaint",kwnames,&obj0,&obj1)) SWIG_fail;
39803 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39804 if (!SWIG_IsOK(res1)) {
39805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_OnPaint" "', expected argument " "1"" of type '" "wxWindow *""'");
39806 }
39807 arg1 = reinterpret_cast< wxWindow * >(argp1);
39808 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxPaintEvent, 0 );
39809 if (!SWIG_IsOK(res2)) {
39810 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39811 }
39812 if (!argp2) {
39813 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_OnPaint" "', expected argument " "2"" of type '" "wxPaintEvent &""'");
39814 }
39815 arg2 = reinterpret_cast< wxPaintEvent * >(argp2);
39816 {
39817 PyThreadState* __tstate = wxPyBeginAllowThreads();
39818 (arg1)->OnPaint(*arg2);
39819 wxPyEndAllowThreads(__tstate);
39820 if (PyErr_Occurred()) SWIG_fail;
39821 }
39822 resultobj = SWIG_Py_Void();
39823 return resultobj;
39824 fail:
39825 return NULL;
39826 }
39827
39828
39829 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39830 PyObject *resultobj = 0;
39831 wxWindow *arg1 = (wxWindow *) 0 ;
39832 int arg2 ;
39833 bool result;
39834 void *argp1 = 0 ;
39835 int res1 = 0 ;
39836 int val2 ;
39837 int ecode2 = 0 ;
39838 PyObject * obj0 = 0 ;
39839 PyObject * obj1 = 0 ;
39840 char * kwnames[] = {
39841 (char *) "self",(char *) "orient", NULL
39842 };
39843
39844 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39845 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39846 if (!SWIG_IsOK(res1)) {
39847 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39848 }
39849 arg1 = reinterpret_cast< wxWindow * >(argp1);
39850 ecode2 = SWIG_AsVal_int(obj1, &val2);
39851 if (!SWIG_IsOK(ecode2)) {
39852 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39853 }
39854 arg2 = static_cast< int >(val2);
39855 {
39856 PyThreadState* __tstate = wxPyBeginAllowThreads();
39857 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39858 wxPyEndAllowThreads(__tstate);
39859 if (PyErr_Occurred()) SWIG_fail;
39860 }
39861 {
39862 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39863 }
39864 return resultobj;
39865 fail:
39866 return NULL;
39867 }
39868
39869
39870 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39871 PyObject *resultobj = 0;
39872 wxWindow *arg1 = (wxWindow *) 0 ;
39873 int arg2 ;
39874 int arg3 ;
39875 int arg4 ;
39876 int arg5 ;
39877 bool arg6 = (bool) true ;
39878 void *argp1 = 0 ;
39879 int res1 = 0 ;
39880 int val2 ;
39881 int ecode2 = 0 ;
39882 int val3 ;
39883 int ecode3 = 0 ;
39884 int val4 ;
39885 int ecode4 = 0 ;
39886 int val5 ;
39887 int ecode5 = 0 ;
39888 bool val6 ;
39889 int ecode6 = 0 ;
39890 PyObject * obj0 = 0 ;
39891 PyObject * obj1 = 0 ;
39892 PyObject * obj2 = 0 ;
39893 PyObject * obj3 = 0 ;
39894 PyObject * obj4 = 0 ;
39895 PyObject * obj5 = 0 ;
39896 char * kwnames[] = {
39897 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39898 };
39899
39900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39901 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39902 if (!SWIG_IsOK(res1)) {
39903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39904 }
39905 arg1 = reinterpret_cast< wxWindow * >(argp1);
39906 ecode2 = SWIG_AsVal_int(obj1, &val2);
39907 if (!SWIG_IsOK(ecode2)) {
39908 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39909 }
39910 arg2 = static_cast< int >(val2);
39911 ecode3 = SWIG_AsVal_int(obj2, &val3);
39912 if (!SWIG_IsOK(ecode3)) {
39913 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39914 }
39915 arg3 = static_cast< int >(val3);
39916 ecode4 = SWIG_AsVal_int(obj3, &val4);
39917 if (!SWIG_IsOK(ecode4)) {
39918 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39919 }
39920 arg4 = static_cast< int >(val4);
39921 ecode5 = SWIG_AsVal_int(obj4, &val5);
39922 if (!SWIG_IsOK(ecode5)) {
39923 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39924 }
39925 arg5 = static_cast< int >(val5);
39926 if (obj5) {
39927 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39928 if (!SWIG_IsOK(ecode6)) {
39929 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39930 }
39931 arg6 = static_cast< bool >(val6);
39932 }
39933 {
39934 PyThreadState* __tstate = wxPyBeginAllowThreads();
39935 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39936 wxPyEndAllowThreads(__tstate);
39937 if (PyErr_Occurred()) SWIG_fail;
39938 }
39939 resultobj = SWIG_Py_Void();
39940 return resultobj;
39941 fail:
39942 return NULL;
39943 }
39944
39945
39946 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39947 PyObject *resultobj = 0;
39948 wxWindow *arg1 = (wxWindow *) 0 ;
39949 int arg2 ;
39950 int arg3 ;
39951 bool arg4 = (bool) true ;
39952 void *argp1 = 0 ;
39953 int res1 = 0 ;
39954 int val2 ;
39955 int ecode2 = 0 ;
39956 int val3 ;
39957 int ecode3 = 0 ;
39958 bool val4 ;
39959 int ecode4 = 0 ;
39960 PyObject * obj0 = 0 ;
39961 PyObject * obj1 = 0 ;
39962 PyObject * obj2 = 0 ;
39963 PyObject * obj3 = 0 ;
39964 char * kwnames[] = {
39965 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39966 };
39967
39968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39970 if (!SWIG_IsOK(res1)) {
39971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39972 }
39973 arg1 = reinterpret_cast< wxWindow * >(argp1);
39974 ecode2 = SWIG_AsVal_int(obj1, &val2);
39975 if (!SWIG_IsOK(ecode2)) {
39976 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39977 }
39978 arg2 = static_cast< int >(val2);
39979 ecode3 = SWIG_AsVal_int(obj2, &val3);
39980 if (!SWIG_IsOK(ecode3)) {
39981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39982 }
39983 arg3 = static_cast< int >(val3);
39984 if (obj3) {
39985 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39986 if (!SWIG_IsOK(ecode4)) {
39987 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39988 }
39989 arg4 = static_cast< bool >(val4);
39990 }
39991 {
39992 PyThreadState* __tstate = wxPyBeginAllowThreads();
39993 (arg1)->SetScrollPos(arg2,arg3,arg4);
39994 wxPyEndAllowThreads(__tstate);
39995 if (PyErr_Occurred()) SWIG_fail;
39996 }
39997 resultobj = SWIG_Py_Void();
39998 return resultobj;
39999 fail:
40000 return NULL;
40001 }
40002
40003
40004 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40005 PyObject *resultobj = 0;
40006 wxWindow *arg1 = (wxWindow *) 0 ;
40007 int arg2 ;
40008 int result;
40009 void *argp1 = 0 ;
40010 int res1 = 0 ;
40011 int val2 ;
40012 int ecode2 = 0 ;
40013 PyObject * obj0 = 0 ;
40014 PyObject * obj1 = 0 ;
40015 char * kwnames[] = {
40016 (char *) "self",(char *) "orientation", NULL
40017 };
40018
40019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
40020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40021 if (!SWIG_IsOK(res1)) {
40022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
40023 }
40024 arg1 = reinterpret_cast< wxWindow * >(argp1);
40025 ecode2 = SWIG_AsVal_int(obj1, &val2);
40026 if (!SWIG_IsOK(ecode2)) {
40027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40028 }
40029 arg2 = static_cast< int >(val2);
40030 {
40031 PyThreadState* __tstate = wxPyBeginAllowThreads();
40032 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40033 wxPyEndAllowThreads(__tstate);
40034 if (PyErr_Occurred()) SWIG_fail;
40035 }
40036 resultobj = SWIG_From_int(static_cast< int >(result));
40037 return resultobj;
40038 fail:
40039 return NULL;
40040 }
40041
40042
40043 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40044 PyObject *resultobj = 0;
40045 wxWindow *arg1 = (wxWindow *) 0 ;
40046 int arg2 ;
40047 int result;
40048 void *argp1 = 0 ;
40049 int res1 = 0 ;
40050 int val2 ;
40051 int ecode2 = 0 ;
40052 PyObject * obj0 = 0 ;
40053 PyObject * obj1 = 0 ;
40054 char * kwnames[] = {
40055 (char *) "self",(char *) "orientation", NULL
40056 };
40057
40058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40060 if (!SWIG_IsOK(res1)) {
40061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40062 }
40063 arg1 = reinterpret_cast< wxWindow * >(argp1);
40064 ecode2 = SWIG_AsVal_int(obj1, &val2);
40065 if (!SWIG_IsOK(ecode2)) {
40066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40067 }
40068 arg2 = static_cast< int >(val2);
40069 {
40070 PyThreadState* __tstate = wxPyBeginAllowThreads();
40071 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40072 wxPyEndAllowThreads(__tstate);
40073 if (PyErr_Occurred()) SWIG_fail;
40074 }
40075 resultobj = SWIG_From_int(static_cast< int >(result));
40076 return resultobj;
40077 fail:
40078 return NULL;
40079 }
40080
40081
40082 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40083 PyObject *resultobj = 0;
40084 wxWindow *arg1 = (wxWindow *) 0 ;
40085 int arg2 ;
40086 int result;
40087 void *argp1 = 0 ;
40088 int res1 = 0 ;
40089 int val2 ;
40090 int ecode2 = 0 ;
40091 PyObject * obj0 = 0 ;
40092 PyObject * obj1 = 0 ;
40093 char * kwnames[] = {
40094 (char *) "self",(char *) "orientation", NULL
40095 };
40096
40097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40099 if (!SWIG_IsOK(res1)) {
40100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40101 }
40102 arg1 = reinterpret_cast< wxWindow * >(argp1);
40103 ecode2 = SWIG_AsVal_int(obj1, &val2);
40104 if (!SWIG_IsOK(ecode2)) {
40105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40106 }
40107 arg2 = static_cast< int >(val2);
40108 {
40109 PyThreadState* __tstate = wxPyBeginAllowThreads();
40110 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40111 wxPyEndAllowThreads(__tstate);
40112 if (PyErr_Occurred()) SWIG_fail;
40113 }
40114 resultobj = SWIG_From_int(static_cast< int >(result));
40115 return resultobj;
40116 fail:
40117 return NULL;
40118 }
40119
40120
40121 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40122 PyObject *resultobj = 0;
40123 wxWindow *arg1 = (wxWindow *) 0 ;
40124 int arg2 ;
40125 int arg3 ;
40126 wxRect *arg4 = (wxRect *) NULL ;
40127 void *argp1 = 0 ;
40128 int res1 = 0 ;
40129 int val2 ;
40130 int ecode2 = 0 ;
40131 int val3 ;
40132 int ecode3 = 0 ;
40133 void *argp4 = 0 ;
40134 int res4 = 0 ;
40135 PyObject * obj0 = 0 ;
40136 PyObject * obj1 = 0 ;
40137 PyObject * obj2 = 0 ;
40138 PyObject * obj3 = 0 ;
40139 char * kwnames[] = {
40140 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40141 };
40142
40143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40145 if (!SWIG_IsOK(res1)) {
40146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40147 }
40148 arg1 = reinterpret_cast< wxWindow * >(argp1);
40149 ecode2 = SWIG_AsVal_int(obj1, &val2);
40150 if (!SWIG_IsOK(ecode2)) {
40151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40152 }
40153 arg2 = static_cast< int >(val2);
40154 ecode3 = SWIG_AsVal_int(obj2, &val3);
40155 if (!SWIG_IsOK(ecode3)) {
40156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40157 }
40158 arg3 = static_cast< int >(val3);
40159 if (obj3) {
40160 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40161 if (!SWIG_IsOK(res4)) {
40162 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40163 }
40164 arg4 = reinterpret_cast< wxRect * >(argp4);
40165 }
40166 {
40167 PyThreadState* __tstate = wxPyBeginAllowThreads();
40168 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40169 wxPyEndAllowThreads(__tstate);
40170 if (PyErr_Occurred()) SWIG_fail;
40171 }
40172 resultobj = SWIG_Py_Void();
40173 return resultobj;
40174 fail:
40175 return NULL;
40176 }
40177
40178
40179 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40180 PyObject *resultobj = 0;
40181 wxWindow *arg1 = (wxWindow *) 0 ;
40182 int arg2 ;
40183 bool result;
40184 void *argp1 = 0 ;
40185 int res1 = 0 ;
40186 int val2 ;
40187 int ecode2 = 0 ;
40188 PyObject * obj0 = 0 ;
40189 PyObject * obj1 = 0 ;
40190 char * kwnames[] = {
40191 (char *) "self",(char *) "lines", NULL
40192 };
40193
40194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40196 if (!SWIG_IsOK(res1)) {
40197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40198 }
40199 arg1 = reinterpret_cast< wxWindow * >(argp1);
40200 ecode2 = SWIG_AsVal_int(obj1, &val2);
40201 if (!SWIG_IsOK(ecode2)) {
40202 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40203 }
40204 arg2 = static_cast< int >(val2);
40205 {
40206 PyThreadState* __tstate = wxPyBeginAllowThreads();
40207 result = (bool)(arg1)->ScrollLines(arg2);
40208 wxPyEndAllowThreads(__tstate);
40209 if (PyErr_Occurred()) SWIG_fail;
40210 }
40211 {
40212 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40213 }
40214 return resultobj;
40215 fail:
40216 return NULL;
40217 }
40218
40219
40220 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40221 PyObject *resultobj = 0;
40222 wxWindow *arg1 = (wxWindow *) 0 ;
40223 int arg2 ;
40224 bool result;
40225 void *argp1 = 0 ;
40226 int res1 = 0 ;
40227 int val2 ;
40228 int ecode2 = 0 ;
40229 PyObject * obj0 = 0 ;
40230 PyObject * obj1 = 0 ;
40231 char * kwnames[] = {
40232 (char *) "self",(char *) "pages", NULL
40233 };
40234
40235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40236 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40237 if (!SWIG_IsOK(res1)) {
40238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40239 }
40240 arg1 = reinterpret_cast< wxWindow * >(argp1);
40241 ecode2 = SWIG_AsVal_int(obj1, &val2);
40242 if (!SWIG_IsOK(ecode2)) {
40243 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40244 }
40245 arg2 = static_cast< int >(val2);
40246 {
40247 PyThreadState* __tstate = wxPyBeginAllowThreads();
40248 result = (bool)(arg1)->ScrollPages(arg2);
40249 wxPyEndAllowThreads(__tstate);
40250 if (PyErr_Occurred()) SWIG_fail;
40251 }
40252 {
40253 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40254 }
40255 return resultobj;
40256 fail:
40257 return NULL;
40258 }
40259
40260
40261 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40262 PyObject *resultobj = 0;
40263 wxWindow *arg1 = (wxWindow *) 0 ;
40264 bool result;
40265 void *argp1 = 0 ;
40266 int res1 = 0 ;
40267 PyObject *swig_obj[1] ;
40268
40269 if (!args) SWIG_fail;
40270 swig_obj[0] = args;
40271 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40272 if (!SWIG_IsOK(res1)) {
40273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40274 }
40275 arg1 = reinterpret_cast< wxWindow * >(argp1);
40276 {
40277 PyThreadState* __tstate = wxPyBeginAllowThreads();
40278 result = (bool)(arg1)->LineUp();
40279 wxPyEndAllowThreads(__tstate);
40280 if (PyErr_Occurred()) SWIG_fail;
40281 }
40282 {
40283 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40284 }
40285 return resultobj;
40286 fail:
40287 return NULL;
40288 }
40289
40290
40291 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40292 PyObject *resultobj = 0;
40293 wxWindow *arg1 = (wxWindow *) 0 ;
40294 bool result;
40295 void *argp1 = 0 ;
40296 int res1 = 0 ;
40297 PyObject *swig_obj[1] ;
40298
40299 if (!args) SWIG_fail;
40300 swig_obj[0] = args;
40301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40302 if (!SWIG_IsOK(res1)) {
40303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40304 }
40305 arg1 = reinterpret_cast< wxWindow * >(argp1);
40306 {
40307 PyThreadState* __tstate = wxPyBeginAllowThreads();
40308 result = (bool)(arg1)->LineDown();
40309 wxPyEndAllowThreads(__tstate);
40310 if (PyErr_Occurred()) SWIG_fail;
40311 }
40312 {
40313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40314 }
40315 return resultobj;
40316 fail:
40317 return NULL;
40318 }
40319
40320
40321 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40322 PyObject *resultobj = 0;
40323 wxWindow *arg1 = (wxWindow *) 0 ;
40324 bool result;
40325 void *argp1 = 0 ;
40326 int res1 = 0 ;
40327 PyObject *swig_obj[1] ;
40328
40329 if (!args) SWIG_fail;
40330 swig_obj[0] = args;
40331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40332 if (!SWIG_IsOK(res1)) {
40333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40334 }
40335 arg1 = reinterpret_cast< wxWindow * >(argp1);
40336 {
40337 PyThreadState* __tstate = wxPyBeginAllowThreads();
40338 result = (bool)(arg1)->PageUp();
40339 wxPyEndAllowThreads(__tstate);
40340 if (PyErr_Occurred()) SWIG_fail;
40341 }
40342 {
40343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40344 }
40345 return resultobj;
40346 fail:
40347 return NULL;
40348 }
40349
40350
40351 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40352 PyObject *resultobj = 0;
40353 wxWindow *arg1 = (wxWindow *) 0 ;
40354 bool result;
40355 void *argp1 = 0 ;
40356 int res1 = 0 ;
40357 PyObject *swig_obj[1] ;
40358
40359 if (!args) SWIG_fail;
40360 swig_obj[0] = args;
40361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40362 if (!SWIG_IsOK(res1)) {
40363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40364 }
40365 arg1 = reinterpret_cast< wxWindow * >(argp1);
40366 {
40367 PyThreadState* __tstate = wxPyBeginAllowThreads();
40368 result = (bool)(arg1)->PageDown();
40369 wxPyEndAllowThreads(__tstate);
40370 if (PyErr_Occurred()) SWIG_fail;
40371 }
40372 {
40373 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40374 }
40375 return resultobj;
40376 fail:
40377 return NULL;
40378 }
40379
40380
40381 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40382 PyObject *resultobj = 0;
40383 wxWindow *arg1 = (wxWindow *) 0 ;
40384 wxString *arg2 = 0 ;
40385 void *argp1 = 0 ;
40386 int res1 = 0 ;
40387 bool temp2 = false ;
40388 PyObject * obj0 = 0 ;
40389 PyObject * obj1 = 0 ;
40390 char * kwnames[] = {
40391 (char *) "self",(char *) "text", NULL
40392 };
40393
40394 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40395 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40396 if (!SWIG_IsOK(res1)) {
40397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40398 }
40399 arg1 = reinterpret_cast< wxWindow * >(argp1);
40400 {
40401 arg2 = wxString_in_helper(obj1);
40402 if (arg2 == NULL) SWIG_fail;
40403 temp2 = true;
40404 }
40405 {
40406 PyThreadState* __tstate = wxPyBeginAllowThreads();
40407 (arg1)->SetHelpText((wxString const &)*arg2);
40408 wxPyEndAllowThreads(__tstate);
40409 if (PyErr_Occurred()) SWIG_fail;
40410 }
40411 resultobj = SWIG_Py_Void();
40412 {
40413 if (temp2)
40414 delete arg2;
40415 }
40416 return resultobj;
40417 fail:
40418 {
40419 if (temp2)
40420 delete arg2;
40421 }
40422 return NULL;
40423 }
40424
40425
40426 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40427 PyObject *resultobj = 0;
40428 wxWindow *arg1 = (wxWindow *) 0 ;
40429 wxString *arg2 = 0 ;
40430 void *argp1 = 0 ;
40431 int res1 = 0 ;
40432 bool temp2 = false ;
40433 PyObject * obj0 = 0 ;
40434 PyObject * obj1 = 0 ;
40435 char * kwnames[] = {
40436 (char *) "self",(char *) "text", NULL
40437 };
40438
40439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40441 if (!SWIG_IsOK(res1)) {
40442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40443 }
40444 arg1 = reinterpret_cast< wxWindow * >(argp1);
40445 {
40446 arg2 = wxString_in_helper(obj1);
40447 if (arg2 == NULL) SWIG_fail;
40448 temp2 = true;
40449 }
40450 {
40451 PyThreadState* __tstate = wxPyBeginAllowThreads();
40452 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40453 wxPyEndAllowThreads(__tstate);
40454 if (PyErr_Occurred()) SWIG_fail;
40455 }
40456 resultobj = SWIG_Py_Void();
40457 {
40458 if (temp2)
40459 delete arg2;
40460 }
40461 return resultobj;
40462 fail:
40463 {
40464 if (temp2)
40465 delete arg2;
40466 }
40467 return NULL;
40468 }
40469
40470
40471 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40472 PyObject *resultobj = 0;
40473 wxWindow *arg1 = (wxWindow *) 0 ;
40474 wxPoint *arg2 = 0 ;
40475 wxHelpEvent::Origin arg3 ;
40476 wxString result;
40477 void *argp1 = 0 ;
40478 int res1 = 0 ;
40479 wxPoint temp2 ;
40480 void *argp3 ;
40481 int res3 = 0 ;
40482 PyObject * obj0 = 0 ;
40483 PyObject * obj1 = 0 ;
40484 PyObject * obj2 = 0 ;
40485 char * kwnames[] = {
40486 (char *) "self",(char *) "pt",(char *) "origin", NULL
40487 };
40488
40489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40491 if (!SWIG_IsOK(res1)) {
40492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40493 }
40494 arg1 = reinterpret_cast< wxWindow * >(argp1);
40495 {
40496 arg2 = &temp2;
40497 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40498 }
40499 {
40500 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40501 if (!SWIG_IsOK(res3)) {
40502 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40503 }
40504 if (!argp3) {
40505 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40506 } else {
40507 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40508 arg3 = *temp;
40509 if (SWIG_IsNewObj(res3)) delete temp;
40510 }
40511 }
40512 {
40513 PyThreadState* __tstate = wxPyBeginAllowThreads();
40514 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40515 wxPyEndAllowThreads(__tstate);
40516 if (PyErr_Occurred()) SWIG_fail;
40517 }
40518 {
40519 #if wxUSE_UNICODE
40520 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40521 #else
40522 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40523 #endif
40524 }
40525 return resultobj;
40526 fail:
40527 return NULL;
40528 }
40529
40530
40531 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40532 PyObject *resultobj = 0;
40533 wxWindow *arg1 = (wxWindow *) 0 ;
40534 wxString result;
40535 void *argp1 = 0 ;
40536 int res1 = 0 ;
40537 PyObject *swig_obj[1] ;
40538
40539 if (!args) SWIG_fail;
40540 swig_obj[0] = args;
40541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40542 if (!SWIG_IsOK(res1)) {
40543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40544 }
40545 arg1 = reinterpret_cast< wxWindow * >(argp1);
40546 {
40547 PyThreadState* __tstate = wxPyBeginAllowThreads();
40548 result = ((wxWindow const *)arg1)->GetHelpText();
40549 wxPyEndAllowThreads(__tstate);
40550 if (PyErr_Occurred()) SWIG_fail;
40551 }
40552 {
40553 #if wxUSE_UNICODE
40554 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40555 #else
40556 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40557 #endif
40558 }
40559 return resultobj;
40560 fail:
40561 return NULL;
40562 }
40563
40564
40565 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40566 PyObject *resultobj = 0;
40567 wxWindow *arg1 = (wxWindow *) 0 ;
40568 wxString *arg2 = 0 ;
40569 void *argp1 = 0 ;
40570 int res1 = 0 ;
40571 bool temp2 = false ;
40572 PyObject * obj0 = 0 ;
40573 PyObject * obj1 = 0 ;
40574 char * kwnames[] = {
40575 (char *) "self",(char *) "tip", NULL
40576 };
40577
40578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40580 if (!SWIG_IsOK(res1)) {
40581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40582 }
40583 arg1 = reinterpret_cast< wxWindow * >(argp1);
40584 {
40585 arg2 = wxString_in_helper(obj1);
40586 if (arg2 == NULL) SWIG_fail;
40587 temp2 = true;
40588 }
40589 {
40590 PyThreadState* __tstate = wxPyBeginAllowThreads();
40591 (arg1)->SetToolTip((wxString const &)*arg2);
40592 wxPyEndAllowThreads(__tstate);
40593 if (PyErr_Occurred()) SWIG_fail;
40594 }
40595 resultobj = SWIG_Py_Void();
40596 {
40597 if (temp2)
40598 delete arg2;
40599 }
40600 return resultobj;
40601 fail:
40602 {
40603 if (temp2)
40604 delete arg2;
40605 }
40606 return NULL;
40607 }
40608
40609
40610 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40611 PyObject *resultobj = 0;
40612 wxWindow *arg1 = (wxWindow *) 0 ;
40613 wxToolTip *arg2 = (wxToolTip *) 0 ;
40614 void *argp1 = 0 ;
40615 int res1 = 0 ;
40616 int res2 = 0 ;
40617 PyObject * obj0 = 0 ;
40618 PyObject * obj1 = 0 ;
40619 char * kwnames[] = {
40620 (char *) "self",(char *) "tip", NULL
40621 };
40622
40623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40625 if (!SWIG_IsOK(res1)) {
40626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40627 }
40628 arg1 = reinterpret_cast< wxWindow * >(argp1);
40629 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40630 if (!SWIG_IsOK(res2)) {
40631 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40632 }
40633 {
40634 PyThreadState* __tstate = wxPyBeginAllowThreads();
40635 (arg1)->SetToolTip(arg2);
40636 wxPyEndAllowThreads(__tstate);
40637 if (PyErr_Occurred()) SWIG_fail;
40638 }
40639 resultobj = SWIG_Py_Void();
40640 return resultobj;
40641 fail:
40642 return NULL;
40643 }
40644
40645
40646 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40647 PyObject *resultobj = 0;
40648 wxWindow *arg1 = (wxWindow *) 0 ;
40649 wxToolTip *result = 0 ;
40650 void *argp1 = 0 ;
40651 int res1 = 0 ;
40652 PyObject *swig_obj[1] ;
40653
40654 if (!args) SWIG_fail;
40655 swig_obj[0] = args;
40656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40657 if (!SWIG_IsOK(res1)) {
40658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40659 }
40660 arg1 = reinterpret_cast< wxWindow * >(argp1);
40661 {
40662 PyThreadState* __tstate = wxPyBeginAllowThreads();
40663 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40664 wxPyEndAllowThreads(__tstate);
40665 if (PyErr_Occurred()) SWIG_fail;
40666 }
40667 {
40668 resultobj = wxPyMake_wxObject(result, (bool)0);
40669 }
40670 return resultobj;
40671 fail:
40672 return NULL;
40673 }
40674
40675
40676 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40677 PyObject *resultobj = 0;
40678 wxWindow *arg1 = (wxWindow *) 0 ;
40679 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40680 void *argp1 = 0 ;
40681 int res1 = 0 ;
40682 int res2 = 0 ;
40683 PyObject * obj0 = 0 ;
40684 PyObject * obj1 = 0 ;
40685 char * kwnames[] = {
40686 (char *) "self",(char *) "dropTarget", NULL
40687 };
40688
40689 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40690 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40691 if (!SWIG_IsOK(res1)) {
40692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40693 }
40694 arg1 = reinterpret_cast< wxWindow * >(argp1);
40695 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40696 if (!SWIG_IsOK(res2)) {
40697 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40698 }
40699 {
40700 PyThreadState* __tstate = wxPyBeginAllowThreads();
40701 (arg1)->SetDropTarget(arg2);
40702 wxPyEndAllowThreads(__tstate);
40703 if (PyErr_Occurred()) SWIG_fail;
40704 }
40705 resultobj = SWIG_Py_Void();
40706 return resultobj;
40707 fail:
40708 return NULL;
40709 }
40710
40711
40712 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40713 PyObject *resultobj = 0;
40714 wxWindow *arg1 = (wxWindow *) 0 ;
40715 wxPyDropTarget *result = 0 ;
40716 void *argp1 = 0 ;
40717 int res1 = 0 ;
40718 PyObject *swig_obj[1] ;
40719
40720 if (!args) SWIG_fail;
40721 swig_obj[0] = args;
40722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40723 if (!SWIG_IsOK(res1)) {
40724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40725 }
40726 arg1 = reinterpret_cast< wxWindow * >(argp1);
40727 {
40728 PyThreadState* __tstate = wxPyBeginAllowThreads();
40729 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40730 wxPyEndAllowThreads(__tstate);
40731 if (PyErr_Occurred()) SWIG_fail;
40732 }
40733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40734 return resultobj;
40735 fail:
40736 return NULL;
40737 }
40738
40739
40740 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40741 PyObject *resultobj = 0;
40742 wxWindow *arg1 = (wxWindow *) 0 ;
40743 bool arg2 ;
40744 void *argp1 = 0 ;
40745 int res1 = 0 ;
40746 bool val2 ;
40747 int ecode2 = 0 ;
40748 PyObject * obj0 = 0 ;
40749 PyObject * obj1 = 0 ;
40750 char * kwnames[] = {
40751 (char *) "self",(char *) "accept", NULL
40752 };
40753
40754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40756 if (!SWIG_IsOK(res1)) {
40757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40758 }
40759 arg1 = reinterpret_cast< wxWindow * >(argp1);
40760 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40761 if (!SWIG_IsOK(ecode2)) {
40762 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40763 }
40764 arg2 = static_cast< bool >(val2);
40765 {
40766 PyThreadState* __tstate = wxPyBeginAllowThreads();
40767 (arg1)->DragAcceptFiles(arg2);
40768 wxPyEndAllowThreads(__tstate);
40769 if (PyErr_Occurred()) SWIG_fail;
40770 }
40771 resultobj = SWIG_Py_Void();
40772 return resultobj;
40773 fail:
40774 return NULL;
40775 }
40776
40777
40778 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40779 PyObject *resultobj = 0;
40780 wxWindow *arg1 = (wxWindow *) 0 ;
40781 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40782 void *argp1 = 0 ;
40783 int res1 = 0 ;
40784 int res2 = 0 ;
40785 PyObject * obj0 = 0 ;
40786 PyObject * obj1 = 0 ;
40787 char * kwnames[] = {
40788 (char *) "self",(char *) "constraints", NULL
40789 };
40790
40791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40793 if (!SWIG_IsOK(res1)) {
40794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40795 }
40796 arg1 = reinterpret_cast< wxWindow * >(argp1);
40797 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40798 if (!SWIG_IsOK(res2)) {
40799 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40800 }
40801 {
40802 PyThreadState* __tstate = wxPyBeginAllowThreads();
40803 (arg1)->SetConstraints(arg2);
40804 wxPyEndAllowThreads(__tstate);
40805 if (PyErr_Occurred()) SWIG_fail;
40806 }
40807 resultobj = SWIG_Py_Void();
40808 return resultobj;
40809 fail:
40810 return NULL;
40811 }
40812
40813
40814 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40815 PyObject *resultobj = 0;
40816 wxWindow *arg1 = (wxWindow *) 0 ;
40817 wxLayoutConstraints *result = 0 ;
40818 void *argp1 = 0 ;
40819 int res1 = 0 ;
40820 PyObject *swig_obj[1] ;
40821
40822 if (!args) SWIG_fail;
40823 swig_obj[0] = args;
40824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40825 if (!SWIG_IsOK(res1)) {
40826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40827 }
40828 arg1 = reinterpret_cast< wxWindow * >(argp1);
40829 {
40830 PyThreadState* __tstate = wxPyBeginAllowThreads();
40831 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40832 wxPyEndAllowThreads(__tstate);
40833 if (PyErr_Occurred()) SWIG_fail;
40834 }
40835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40836 return resultobj;
40837 fail:
40838 return NULL;
40839 }
40840
40841
40842 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40843 PyObject *resultobj = 0;
40844 wxWindow *arg1 = (wxWindow *) 0 ;
40845 bool arg2 ;
40846 void *argp1 = 0 ;
40847 int res1 = 0 ;
40848 bool val2 ;
40849 int ecode2 = 0 ;
40850 PyObject * obj0 = 0 ;
40851 PyObject * obj1 = 0 ;
40852 char * kwnames[] = {
40853 (char *) "self",(char *) "autoLayout", NULL
40854 };
40855
40856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40858 if (!SWIG_IsOK(res1)) {
40859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40860 }
40861 arg1 = reinterpret_cast< wxWindow * >(argp1);
40862 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40863 if (!SWIG_IsOK(ecode2)) {
40864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40865 }
40866 arg2 = static_cast< bool >(val2);
40867 {
40868 PyThreadState* __tstate = wxPyBeginAllowThreads();
40869 (arg1)->SetAutoLayout(arg2);
40870 wxPyEndAllowThreads(__tstate);
40871 if (PyErr_Occurred()) SWIG_fail;
40872 }
40873 resultobj = SWIG_Py_Void();
40874 return resultobj;
40875 fail:
40876 return NULL;
40877 }
40878
40879
40880 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40881 PyObject *resultobj = 0;
40882 wxWindow *arg1 = (wxWindow *) 0 ;
40883 bool result;
40884 void *argp1 = 0 ;
40885 int res1 = 0 ;
40886 PyObject *swig_obj[1] ;
40887
40888 if (!args) SWIG_fail;
40889 swig_obj[0] = args;
40890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40891 if (!SWIG_IsOK(res1)) {
40892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40893 }
40894 arg1 = reinterpret_cast< wxWindow * >(argp1);
40895 {
40896 PyThreadState* __tstate = wxPyBeginAllowThreads();
40897 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40898 wxPyEndAllowThreads(__tstate);
40899 if (PyErr_Occurred()) SWIG_fail;
40900 }
40901 {
40902 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40903 }
40904 return resultobj;
40905 fail:
40906 return NULL;
40907 }
40908
40909
40910 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40911 PyObject *resultobj = 0;
40912 wxWindow *arg1 = (wxWindow *) 0 ;
40913 bool result;
40914 void *argp1 = 0 ;
40915 int res1 = 0 ;
40916 PyObject *swig_obj[1] ;
40917
40918 if (!args) SWIG_fail;
40919 swig_obj[0] = args;
40920 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40921 if (!SWIG_IsOK(res1)) {
40922 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40923 }
40924 arg1 = reinterpret_cast< wxWindow * >(argp1);
40925 {
40926 PyThreadState* __tstate = wxPyBeginAllowThreads();
40927 result = (bool)(arg1)->Layout();
40928 wxPyEndAllowThreads(__tstate);
40929 if (PyErr_Occurred()) SWIG_fail;
40930 }
40931 {
40932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40933 }
40934 return resultobj;
40935 fail:
40936 return NULL;
40937 }
40938
40939
40940 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40941 PyObject *resultobj = 0;
40942 wxWindow *arg1 = (wxWindow *) 0 ;
40943 wxSizer *arg2 = (wxSizer *) 0 ;
40944 bool arg3 = (bool) true ;
40945 void *argp1 = 0 ;
40946 int res1 = 0 ;
40947 int res2 = 0 ;
40948 bool val3 ;
40949 int ecode3 = 0 ;
40950 PyObject * obj0 = 0 ;
40951 PyObject * obj1 = 0 ;
40952 PyObject * obj2 = 0 ;
40953 char * kwnames[] = {
40954 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40955 };
40956
40957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40959 if (!SWIG_IsOK(res1)) {
40960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40961 }
40962 arg1 = reinterpret_cast< wxWindow * >(argp1);
40963 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40964 if (!SWIG_IsOK(res2)) {
40965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40966 }
40967 if (obj2) {
40968 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40969 if (!SWIG_IsOK(ecode3)) {
40970 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40971 }
40972 arg3 = static_cast< bool >(val3);
40973 }
40974 {
40975 PyThreadState* __tstate = wxPyBeginAllowThreads();
40976 (arg1)->SetSizer(arg2,arg3);
40977 wxPyEndAllowThreads(__tstate);
40978 if (PyErr_Occurred()) SWIG_fail;
40979 }
40980 resultobj = SWIG_Py_Void();
40981 return resultobj;
40982 fail:
40983 return NULL;
40984 }
40985
40986
40987 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40988 PyObject *resultobj = 0;
40989 wxWindow *arg1 = (wxWindow *) 0 ;
40990 wxSizer *arg2 = (wxSizer *) 0 ;
40991 bool arg3 = (bool) true ;
40992 void *argp1 = 0 ;
40993 int res1 = 0 ;
40994 int res2 = 0 ;
40995 bool val3 ;
40996 int ecode3 = 0 ;
40997 PyObject * obj0 = 0 ;
40998 PyObject * obj1 = 0 ;
40999 PyObject * obj2 = 0 ;
41000 char * kwnames[] = {
41001 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
41002 };
41003
41004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41006 if (!SWIG_IsOK(res1)) {
41007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
41008 }
41009 arg1 = reinterpret_cast< wxWindow * >(argp1);
41010 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
41011 if (!SWIG_IsOK(res2)) {
41012 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
41013 }
41014 if (obj2) {
41015 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41016 if (!SWIG_IsOK(ecode3)) {
41017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
41018 }
41019 arg3 = static_cast< bool >(val3);
41020 }
41021 {
41022 PyThreadState* __tstate = wxPyBeginAllowThreads();
41023 (arg1)->SetSizerAndFit(arg2,arg3);
41024 wxPyEndAllowThreads(__tstate);
41025 if (PyErr_Occurred()) SWIG_fail;
41026 }
41027 resultobj = SWIG_Py_Void();
41028 return resultobj;
41029 fail:
41030 return NULL;
41031 }
41032
41033
41034 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41035 PyObject *resultobj = 0;
41036 wxWindow *arg1 = (wxWindow *) 0 ;
41037 wxSizer *result = 0 ;
41038 void *argp1 = 0 ;
41039 int res1 = 0 ;
41040 PyObject *swig_obj[1] ;
41041
41042 if (!args) SWIG_fail;
41043 swig_obj[0] = args;
41044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41045 if (!SWIG_IsOK(res1)) {
41046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41047 }
41048 arg1 = reinterpret_cast< wxWindow * >(argp1);
41049 {
41050 PyThreadState* __tstate = wxPyBeginAllowThreads();
41051 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41052 wxPyEndAllowThreads(__tstate);
41053 if (PyErr_Occurred()) SWIG_fail;
41054 }
41055 {
41056 resultobj = wxPyMake_wxObject(result, (bool)0);
41057 }
41058 return resultobj;
41059 fail:
41060 return NULL;
41061 }
41062
41063
41064 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41065 PyObject *resultobj = 0;
41066 wxWindow *arg1 = (wxWindow *) 0 ;
41067 wxSizer *arg2 = (wxSizer *) 0 ;
41068 void *argp1 = 0 ;
41069 int res1 = 0 ;
41070 void *argp2 = 0 ;
41071 int res2 = 0 ;
41072 PyObject * obj0 = 0 ;
41073 PyObject * obj1 = 0 ;
41074 char * kwnames[] = {
41075 (char *) "self",(char *) "sizer", NULL
41076 };
41077
41078 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41079 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41080 if (!SWIG_IsOK(res1)) {
41081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41082 }
41083 arg1 = reinterpret_cast< wxWindow * >(argp1);
41084 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41085 if (!SWIG_IsOK(res2)) {
41086 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41087 }
41088 arg2 = reinterpret_cast< wxSizer * >(argp2);
41089 {
41090 PyThreadState* __tstate = wxPyBeginAllowThreads();
41091 (arg1)->SetContainingSizer(arg2);
41092 wxPyEndAllowThreads(__tstate);
41093 if (PyErr_Occurred()) SWIG_fail;
41094 }
41095 resultobj = SWIG_Py_Void();
41096 return resultobj;
41097 fail:
41098 return NULL;
41099 }
41100
41101
41102 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41103 PyObject *resultobj = 0;
41104 wxWindow *arg1 = (wxWindow *) 0 ;
41105 wxSizer *result = 0 ;
41106 void *argp1 = 0 ;
41107 int res1 = 0 ;
41108 PyObject *swig_obj[1] ;
41109
41110 if (!args) SWIG_fail;
41111 swig_obj[0] = args;
41112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41113 if (!SWIG_IsOK(res1)) {
41114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41115 }
41116 arg1 = reinterpret_cast< wxWindow * >(argp1);
41117 {
41118 PyThreadState* __tstate = wxPyBeginAllowThreads();
41119 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41120 wxPyEndAllowThreads(__tstate);
41121 if (PyErr_Occurred()) SWIG_fail;
41122 }
41123 {
41124 resultobj = wxPyMake_wxObject(result, (bool)0);
41125 }
41126 return resultobj;
41127 fail:
41128 return NULL;
41129 }
41130
41131
41132 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41133 PyObject *resultobj = 0;
41134 wxWindow *arg1 = (wxWindow *) 0 ;
41135 void *argp1 = 0 ;
41136 int res1 = 0 ;
41137 PyObject *swig_obj[1] ;
41138
41139 if (!args) SWIG_fail;
41140 swig_obj[0] = args;
41141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41142 if (!SWIG_IsOK(res1)) {
41143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41144 }
41145 arg1 = reinterpret_cast< wxWindow * >(argp1);
41146 {
41147 PyThreadState* __tstate = wxPyBeginAllowThreads();
41148 (arg1)->InheritAttributes();
41149 wxPyEndAllowThreads(__tstate);
41150 if (PyErr_Occurred()) SWIG_fail;
41151 }
41152 resultobj = SWIG_Py_Void();
41153 return resultobj;
41154 fail:
41155 return NULL;
41156 }
41157
41158
41159 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41160 PyObject *resultobj = 0;
41161 wxWindow *arg1 = (wxWindow *) 0 ;
41162 bool result;
41163 void *argp1 = 0 ;
41164 int res1 = 0 ;
41165 PyObject *swig_obj[1] ;
41166
41167 if (!args) SWIG_fail;
41168 swig_obj[0] = args;
41169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41170 if (!SWIG_IsOK(res1)) {
41171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41172 }
41173 arg1 = reinterpret_cast< wxWindow * >(argp1);
41174 {
41175 PyThreadState* __tstate = wxPyBeginAllowThreads();
41176 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41177 wxPyEndAllowThreads(__tstate);
41178 if (PyErr_Occurred()) SWIG_fail;
41179 }
41180 {
41181 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41182 }
41183 return resultobj;
41184 fail:
41185 return NULL;
41186 }
41187
41188
41189 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41190 PyObject *resultobj = 0;
41191 wxWindow *arg1 = (wxWindow *) 0 ;
41192 bool result;
41193 void *argp1 = 0 ;
41194 int res1 = 0 ;
41195 PyObject *swig_obj[1] ;
41196
41197 if (!args) SWIG_fail;
41198 swig_obj[0] = args;
41199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41200 if (!SWIG_IsOK(res1)) {
41201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41202 }
41203 arg1 = reinterpret_cast< wxWindow * >(argp1);
41204 {
41205 PyThreadState* __tstate = wxPyBeginAllowThreads();
41206 result = (bool)(arg1)->CanSetTransparent();
41207 wxPyEndAllowThreads(__tstate);
41208 if (PyErr_Occurred()) SWIG_fail;
41209 }
41210 {
41211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41212 }
41213 return resultobj;
41214 fail:
41215 return NULL;
41216 }
41217
41218
41219 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41220 PyObject *resultobj = 0;
41221 wxWindow *arg1 = (wxWindow *) 0 ;
41222 byte arg2 ;
41223 bool result;
41224 void *argp1 = 0 ;
41225 int res1 = 0 ;
41226 unsigned char val2 ;
41227 int ecode2 = 0 ;
41228 PyObject * obj0 = 0 ;
41229 PyObject * obj1 = 0 ;
41230 char * kwnames[] = {
41231 (char *) "self",(char *) "alpha", NULL
41232 };
41233
41234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41236 if (!SWIG_IsOK(res1)) {
41237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41238 }
41239 arg1 = reinterpret_cast< wxWindow * >(argp1);
41240 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41241 if (!SWIG_IsOK(ecode2)) {
41242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41243 }
41244 arg2 = static_cast< byte >(val2);
41245 {
41246 PyThreadState* __tstate = wxPyBeginAllowThreads();
41247 result = (bool)(arg1)->SetTransparent(arg2);
41248 wxPyEndAllowThreads(__tstate);
41249 if (PyErr_Occurred()) SWIG_fail;
41250 }
41251 {
41252 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41253 }
41254 return resultobj;
41255 fail:
41256 return NULL;
41257 }
41258
41259
41260 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41261 PyObject *obj;
41262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41263 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41264 return SWIG_Py_Void();
41265 }
41266
41267 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41268 return SWIG_Python_InitShadowInstance(args);
41269 }
41270
41271 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41272 PyObject *resultobj = 0;
41273 long arg1 ;
41274 wxWindow *arg2 = (wxWindow *) NULL ;
41275 wxWindow *result = 0 ;
41276 long val1 ;
41277 int ecode1 = 0 ;
41278 void *argp2 = 0 ;
41279 int res2 = 0 ;
41280 PyObject * obj0 = 0 ;
41281 PyObject * obj1 = 0 ;
41282 char * kwnames[] = {
41283 (char *) "id",(char *) "parent", NULL
41284 };
41285
41286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41287 ecode1 = SWIG_AsVal_long(obj0, &val1);
41288 if (!SWIG_IsOK(ecode1)) {
41289 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41290 }
41291 arg1 = static_cast< long >(val1);
41292 if (obj1) {
41293 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41294 if (!SWIG_IsOK(res2)) {
41295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41296 }
41297 arg2 = reinterpret_cast< wxWindow * >(argp2);
41298 }
41299 {
41300 if (!wxPyCheckForApp()) SWIG_fail;
41301 PyThreadState* __tstate = wxPyBeginAllowThreads();
41302 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41303 wxPyEndAllowThreads(__tstate);
41304 if (PyErr_Occurred()) SWIG_fail;
41305 }
41306 {
41307 resultobj = wxPyMake_wxObject(result, 0);
41308 }
41309 return resultobj;
41310 fail:
41311 return NULL;
41312 }
41313
41314
41315 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41316 PyObject *resultobj = 0;
41317 wxString *arg1 = 0 ;
41318 wxWindow *arg2 = (wxWindow *) NULL ;
41319 wxWindow *result = 0 ;
41320 bool temp1 = false ;
41321 void *argp2 = 0 ;
41322 int res2 = 0 ;
41323 PyObject * obj0 = 0 ;
41324 PyObject * obj1 = 0 ;
41325 char * kwnames[] = {
41326 (char *) "name",(char *) "parent", NULL
41327 };
41328
41329 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41330 {
41331 arg1 = wxString_in_helper(obj0);
41332 if (arg1 == NULL) SWIG_fail;
41333 temp1 = true;
41334 }
41335 if (obj1) {
41336 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41337 if (!SWIG_IsOK(res2)) {
41338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41339 }
41340 arg2 = reinterpret_cast< wxWindow * >(argp2);
41341 }
41342 {
41343 if (!wxPyCheckForApp()) SWIG_fail;
41344 PyThreadState* __tstate = wxPyBeginAllowThreads();
41345 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41346 wxPyEndAllowThreads(__tstate);
41347 if (PyErr_Occurred()) SWIG_fail;
41348 }
41349 {
41350 resultobj = wxPyMake_wxObject(result, 0);
41351 }
41352 {
41353 if (temp1)
41354 delete arg1;
41355 }
41356 return resultobj;
41357 fail:
41358 {
41359 if (temp1)
41360 delete arg1;
41361 }
41362 return NULL;
41363 }
41364
41365
41366 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41367 PyObject *resultobj = 0;
41368 wxString *arg1 = 0 ;
41369 wxWindow *arg2 = (wxWindow *) NULL ;
41370 wxWindow *result = 0 ;
41371 bool temp1 = false ;
41372 void *argp2 = 0 ;
41373 int res2 = 0 ;
41374 PyObject * obj0 = 0 ;
41375 PyObject * obj1 = 0 ;
41376 char * kwnames[] = {
41377 (char *) "label",(char *) "parent", NULL
41378 };
41379
41380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41381 {
41382 arg1 = wxString_in_helper(obj0);
41383 if (arg1 == NULL) SWIG_fail;
41384 temp1 = true;
41385 }
41386 if (obj1) {
41387 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41388 if (!SWIG_IsOK(res2)) {
41389 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41390 }
41391 arg2 = reinterpret_cast< wxWindow * >(argp2);
41392 }
41393 {
41394 if (!wxPyCheckForApp()) SWIG_fail;
41395 PyThreadState* __tstate = wxPyBeginAllowThreads();
41396 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41397 wxPyEndAllowThreads(__tstate);
41398 if (PyErr_Occurred()) SWIG_fail;
41399 }
41400 {
41401 resultobj = wxPyMake_wxObject(result, 0);
41402 }
41403 {
41404 if (temp1)
41405 delete arg1;
41406 }
41407 return resultobj;
41408 fail:
41409 {
41410 if (temp1)
41411 delete arg1;
41412 }
41413 return NULL;
41414 }
41415
41416
41417 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41418 PyObject *resultobj = 0;
41419 wxWindow *arg1 = (wxWindow *) 0 ;
41420 unsigned long arg2 ;
41421 wxWindow *result = 0 ;
41422 void *argp1 = 0 ;
41423 int res1 = 0 ;
41424 unsigned long val2 ;
41425 int ecode2 = 0 ;
41426 PyObject * obj0 = 0 ;
41427 PyObject * obj1 = 0 ;
41428 char * kwnames[] = {
41429 (char *) "parent",(char *) "_hWnd", NULL
41430 };
41431
41432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41434 if (!SWIG_IsOK(res1)) {
41435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41436 }
41437 arg1 = reinterpret_cast< wxWindow * >(argp1);
41438 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41439 if (!SWIG_IsOK(ecode2)) {
41440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41441 }
41442 arg2 = static_cast< unsigned long >(val2);
41443 {
41444 if (!wxPyCheckForApp()) SWIG_fail;
41445 PyThreadState* __tstate = wxPyBeginAllowThreads();
41446 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41447 wxPyEndAllowThreads(__tstate);
41448 if (PyErr_Occurred()) SWIG_fail;
41449 }
41450 {
41451 resultobj = wxPyMake_wxObject(result, 0);
41452 }
41453 return resultobj;
41454 fail:
41455 return NULL;
41456 }
41457
41458
41459 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41460 PyObject *resultobj = 0;
41461 PyObject *result = 0 ;
41462
41463 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41464 {
41465 PyThreadState* __tstate = wxPyBeginAllowThreads();
41466 result = (PyObject *)GetTopLevelWindows();
41467 wxPyEndAllowThreads(__tstate);
41468 if (PyErr_Occurred()) SWIG_fail;
41469 }
41470 resultobj = result;
41471 return resultobj;
41472 fail:
41473 return NULL;
41474 }
41475
41476
41477 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41478 PyObject *resultobj = 0;
41479 wxValidator *result = 0 ;
41480
41481 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41482 {
41483 PyThreadState* __tstate = wxPyBeginAllowThreads();
41484 result = (wxValidator *)new wxValidator();
41485 wxPyEndAllowThreads(__tstate);
41486 if (PyErr_Occurred()) SWIG_fail;
41487 }
41488 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41489 return resultobj;
41490 fail:
41491 return NULL;
41492 }
41493
41494
41495 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41496 PyObject *resultobj = 0;
41497 wxValidator *arg1 = (wxValidator *) 0 ;
41498 wxValidator *result = 0 ;
41499 void *argp1 = 0 ;
41500 int res1 = 0 ;
41501 PyObject *swig_obj[1] ;
41502
41503 if (!args) SWIG_fail;
41504 swig_obj[0] = args;
41505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41506 if (!SWIG_IsOK(res1)) {
41507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41508 }
41509 arg1 = reinterpret_cast< wxValidator * >(argp1);
41510 {
41511 PyThreadState* __tstate = wxPyBeginAllowThreads();
41512 result = (wxValidator *)(arg1)->Clone();
41513 wxPyEndAllowThreads(__tstate);
41514 if (PyErr_Occurred()) SWIG_fail;
41515 }
41516 {
41517 resultobj = wxPyMake_wxObject(result, 0);
41518 }
41519 return resultobj;
41520 fail:
41521 return NULL;
41522 }
41523
41524
41525 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41526 PyObject *resultobj = 0;
41527 wxValidator *arg1 = (wxValidator *) 0 ;
41528 wxWindow *arg2 = (wxWindow *) 0 ;
41529 bool result;
41530 void *argp1 = 0 ;
41531 int res1 = 0 ;
41532 void *argp2 = 0 ;
41533 int res2 = 0 ;
41534 PyObject * obj0 = 0 ;
41535 PyObject * obj1 = 0 ;
41536 char * kwnames[] = {
41537 (char *) "self",(char *) "parent", NULL
41538 };
41539
41540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41542 if (!SWIG_IsOK(res1)) {
41543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41544 }
41545 arg1 = reinterpret_cast< wxValidator * >(argp1);
41546 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41547 if (!SWIG_IsOK(res2)) {
41548 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41549 }
41550 arg2 = reinterpret_cast< wxWindow * >(argp2);
41551 {
41552 PyThreadState* __tstate = wxPyBeginAllowThreads();
41553 result = (bool)(arg1)->Validate(arg2);
41554 wxPyEndAllowThreads(__tstate);
41555 if (PyErr_Occurred()) SWIG_fail;
41556 }
41557 {
41558 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41559 }
41560 return resultobj;
41561 fail:
41562 return NULL;
41563 }
41564
41565
41566 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41567 PyObject *resultobj = 0;
41568 wxValidator *arg1 = (wxValidator *) 0 ;
41569 bool result;
41570 void *argp1 = 0 ;
41571 int res1 = 0 ;
41572 PyObject *swig_obj[1] ;
41573
41574 if (!args) SWIG_fail;
41575 swig_obj[0] = args;
41576 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41577 if (!SWIG_IsOK(res1)) {
41578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41579 }
41580 arg1 = reinterpret_cast< wxValidator * >(argp1);
41581 {
41582 PyThreadState* __tstate = wxPyBeginAllowThreads();
41583 result = (bool)(arg1)->TransferToWindow();
41584 wxPyEndAllowThreads(__tstate);
41585 if (PyErr_Occurred()) SWIG_fail;
41586 }
41587 {
41588 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41589 }
41590 return resultobj;
41591 fail:
41592 return NULL;
41593 }
41594
41595
41596 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41597 PyObject *resultobj = 0;
41598 wxValidator *arg1 = (wxValidator *) 0 ;
41599 bool result;
41600 void *argp1 = 0 ;
41601 int res1 = 0 ;
41602 PyObject *swig_obj[1] ;
41603
41604 if (!args) SWIG_fail;
41605 swig_obj[0] = args;
41606 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41607 if (!SWIG_IsOK(res1)) {
41608 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41609 }
41610 arg1 = reinterpret_cast< wxValidator * >(argp1);
41611 {
41612 PyThreadState* __tstate = wxPyBeginAllowThreads();
41613 result = (bool)(arg1)->TransferFromWindow();
41614 wxPyEndAllowThreads(__tstate);
41615 if (PyErr_Occurred()) SWIG_fail;
41616 }
41617 {
41618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41619 }
41620 return resultobj;
41621 fail:
41622 return NULL;
41623 }
41624
41625
41626 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41627 PyObject *resultobj = 0;
41628 wxValidator *arg1 = (wxValidator *) 0 ;
41629 wxWindow *result = 0 ;
41630 void *argp1 = 0 ;
41631 int res1 = 0 ;
41632 PyObject *swig_obj[1] ;
41633
41634 if (!args) SWIG_fail;
41635 swig_obj[0] = args;
41636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41637 if (!SWIG_IsOK(res1)) {
41638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41639 }
41640 arg1 = reinterpret_cast< wxValidator * >(argp1);
41641 {
41642 PyThreadState* __tstate = wxPyBeginAllowThreads();
41643 result = (wxWindow *)(arg1)->GetWindow();
41644 wxPyEndAllowThreads(__tstate);
41645 if (PyErr_Occurred()) SWIG_fail;
41646 }
41647 {
41648 resultobj = wxPyMake_wxObject(result, 0);
41649 }
41650 return resultobj;
41651 fail:
41652 return NULL;
41653 }
41654
41655
41656 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41657 PyObject *resultobj = 0;
41658 wxValidator *arg1 = (wxValidator *) 0 ;
41659 wxWindow *arg2 = (wxWindow *) 0 ;
41660 void *argp1 = 0 ;
41661 int res1 = 0 ;
41662 void *argp2 = 0 ;
41663 int res2 = 0 ;
41664 PyObject * obj0 = 0 ;
41665 PyObject * obj1 = 0 ;
41666 char * kwnames[] = {
41667 (char *) "self",(char *) "window", NULL
41668 };
41669
41670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41672 if (!SWIG_IsOK(res1)) {
41673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41674 }
41675 arg1 = reinterpret_cast< wxValidator * >(argp1);
41676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41677 if (!SWIG_IsOK(res2)) {
41678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41679 }
41680 arg2 = reinterpret_cast< wxWindow * >(argp2);
41681 {
41682 PyThreadState* __tstate = wxPyBeginAllowThreads();
41683 (arg1)->SetWindow(arg2);
41684 wxPyEndAllowThreads(__tstate);
41685 if (PyErr_Occurred()) SWIG_fail;
41686 }
41687 resultobj = SWIG_Py_Void();
41688 return resultobj;
41689 fail:
41690 return NULL;
41691 }
41692
41693
41694 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41695 PyObject *resultobj = 0;
41696 bool result;
41697
41698 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41699 {
41700 PyThreadState* __tstate = wxPyBeginAllowThreads();
41701 result = (bool)wxValidator::IsSilent();
41702 wxPyEndAllowThreads(__tstate);
41703 if (PyErr_Occurred()) SWIG_fail;
41704 }
41705 {
41706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41707 }
41708 return resultobj;
41709 fail:
41710 return NULL;
41711 }
41712
41713
41714 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41715 PyObject *resultobj = 0;
41716 int arg1 = (int) true ;
41717 int val1 ;
41718 int ecode1 = 0 ;
41719 PyObject * obj0 = 0 ;
41720 char * kwnames[] = {
41721 (char *) "doIt", NULL
41722 };
41723
41724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41725 if (obj0) {
41726 ecode1 = SWIG_AsVal_int(obj0, &val1);
41727 if (!SWIG_IsOK(ecode1)) {
41728 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41729 }
41730 arg1 = static_cast< int >(val1);
41731 }
41732 {
41733 PyThreadState* __tstate = wxPyBeginAllowThreads();
41734 wxValidator::SetBellOnError(arg1);
41735 wxPyEndAllowThreads(__tstate);
41736 if (PyErr_Occurred()) SWIG_fail;
41737 }
41738 resultobj = SWIG_Py_Void();
41739 return resultobj;
41740 fail:
41741 return NULL;
41742 }
41743
41744
41745 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41746 PyObject *obj;
41747 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41748 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41749 return SWIG_Py_Void();
41750 }
41751
41752 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41753 return SWIG_Python_InitShadowInstance(args);
41754 }
41755
41756 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41757 PyObject *resultobj = 0;
41758 wxPyValidator *result = 0 ;
41759
41760 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41761 {
41762 PyThreadState* __tstate = wxPyBeginAllowThreads();
41763 result = (wxPyValidator *)new wxPyValidator();
41764 wxPyEndAllowThreads(__tstate);
41765 if (PyErr_Occurred()) SWIG_fail;
41766 }
41767 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41768 return resultobj;
41769 fail:
41770 return NULL;
41771 }
41772
41773
41774 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41775 PyObject *resultobj = 0;
41776 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41777 PyObject *arg2 = (PyObject *) 0 ;
41778 PyObject *arg3 = (PyObject *) 0 ;
41779 int arg4 = (int) 1 ;
41780 void *argp1 = 0 ;
41781 int res1 = 0 ;
41782 int val4 ;
41783 int ecode4 = 0 ;
41784 PyObject * obj0 = 0 ;
41785 PyObject * obj1 = 0 ;
41786 PyObject * obj2 = 0 ;
41787 PyObject * obj3 = 0 ;
41788 char * kwnames[] = {
41789 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41790 };
41791
41792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41793 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41794 if (!SWIG_IsOK(res1)) {
41795 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41796 }
41797 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41798 arg2 = obj1;
41799 arg3 = obj2;
41800 if (obj3) {
41801 ecode4 = SWIG_AsVal_int(obj3, &val4);
41802 if (!SWIG_IsOK(ecode4)) {
41803 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41804 }
41805 arg4 = static_cast< int >(val4);
41806 }
41807 {
41808 PyThreadState* __tstate = wxPyBeginAllowThreads();
41809 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41810 wxPyEndAllowThreads(__tstate);
41811 if (PyErr_Occurred()) SWIG_fail;
41812 }
41813 resultobj = SWIG_Py_Void();
41814 return resultobj;
41815 fail:
41816 return NULL;
41817 }
41818
41819
41820 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41821 PyObject *obj;
41822 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41823 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41824 return SWIG_Py_Void();
41825 }
41826
41827 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41828 return SWIG_Python_InitShadowInstance(args);
41829 }
41830
41831 SWIGINTERN int DefaultValidator_set(PyObject *) {
41832 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41833 return 1;
41834 }
41835
41836
41837 SWIGINTERN PyObject *DefaultValidator_get(void) {
41838 PyObject *pyobj = 0;
41839
41840 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41841 return pyobj;
41842 }
41843
41844
41845 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41846 PyObject *resultobj = 0;
41847 wxString const &arg1_defvalue = wxPyEmptyString ;
41848 wxString *arg1 = (wxString *) &arg1_defvalue ;
41849 long arg2 = (long) 0 ;
41850 wxMenu *result = 0 ;
41851 bool temp1 = false ;
41852 long val2 ;
41853 int ecode2 = 0 ;
41854 PyObject * obj0 = 0 ;
41855 PyObject * obj1 = 0 ;
41856 char * kwnames[] = {
41857 (char *) "title",(char *) "style", NULL
41858 };
41859
41860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41861 if (obj0) {
41862 {
41863 arg1 = wxString_in_helper(obj0);
41864 if (arg1 == NULL) SWIG_fail;
41865 temp1 = true;
41866 }
41867 }
41868 if (obj1) {
41869 ecode2 = SWIG_AsVal_long(obj1, &val2);
41870 if (!SWIG_IsOK(ecode2)) {
41871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41872 }
41873 arg2 = static_cast< long >(val2);
41874 }
41875 {
41876 if (!wxPyCheckForApp()) SWIG_fail;
41877 PyThreadState* __tstate = wxPyBeginAllowThreads();
41878 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41879 wxPyEndAllowThreads(__tstate);
41880 if (PyErr_Occurred()) SWIG_fail;
41881 }
41882 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41883 {
41884 if (temp1)
41885 delete arg1;
41886 }
41887 return resultobj;
41888 fail:
41889 {
41890 if (temp1)
41891 delete arg1;
41892 }
41893 return NULL;
41894 }
41895
41896
41897 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41898 PyObject *resultobj = 0;
41899 wxMenu *arg1 = (wxMenu *) 0 ;
41900 int arg2 ;
41901 wxString const &arg3_defvalue = wxPyEmptyString ;
41902 wxString *arg3 = (wxString *) &arg3_defvalue ;
41903 wxString const &arg4_defvalue = wxPyEmptyString ;
41904 wxString *arg4 = (wxString *) &arg4_defvalue ;
41905 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41906 wxMenuItem *result = 0 ;
41907 void *argp1 = 0 ;
41908 int res1 = 0 ;
41909 int val2 ;
41910 int ecode2 = 0 ;
41911 bool temp3 = false ;
41912 bool temp4 = false ;
41913 int val5 ;
41914 int ecode5 = 0 ;
41915 PyObject * obj0 = 0 ;
41916 PyObject * obj1 = 0 ;
41917 PyObject * obj2 = 0 ;
41918 PyObject * obj3 = 0 ;
41919 PyObject * obj4 = 0 ;
41920 char * kwnames[] = {
41921 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41922 };
41923
41924 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41925 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41926 if (!SWIG_IsOK(res1)) {
41927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41928 }
41929 arg1 = reinterpret_cast< wxMenu * >(argp1);
41930 ecode2 = SWIG_AsVal_int(obj1, &val2);
41931 if (!SWIG_IsOK(ecode2)) {
41932 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41933 }
41934 arg2 = static_cast< int >(val2);
41935 if (obj2) {
41936 {
41937 arg3 = wxString_in_helper(obj2);
41938 if (arg3 == NULL) SWIG_fail;
41939 temp3 = true;
41940 }
41941 }
41942 if (obj3) {
41943 {
41944 arg4 = wxString_in_helper(obj3);
41945 if (arg4 == NULL) SWIG_fail;
41946 temp4 = true;
41947 }
41948 }
41949 if (obj4) {
41950 ecode5 = SWIG_AsVal_int(obj4, &val5);
41951 if (!SWIG_IsOK(ecode5)) {
41952 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41953 }
41954 arg5 = static_cast< wxItemKind >(val5);
41955 }
41956 {
41957 PyThreadState* __tstate = wxPyBeginAllowThreads();
41958 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41959 wxPyEndAllowThreads(__tstate);
41960 if (PyErr_Occurred()) SWIG_fail;
41961 }
41962 {
41963 resultobj = wxPyMake_wxObject(result, (bool)0);
41964 }
41965 {
41966 if (temp3)
41967 delete arg3;
41968 }
41969 {
41970 if (temp4)
41971 delete arg4;
41972 }
41973 return resultobj;
41974 fail:
41975 {
41976 if (temp3)
41977 delete arg3;
41978 }
41979 {
41980 if (temp4)
41981 delete arg4;
41982 }
41983 return NULL;
41984 }
41985
41986
41987 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41988 PyObject *resultobj = 0;
41989 wxMenu *arg1 = (wxMenu *) 0 ;
41990 wxMenuItem *result = 0 ;
41991 void *argp1 = 0 ;
41992 int res1 = 0 ;
41993 PyObject *swig_obj[1] ;
41994
41995 if (!args) SWIG_fail;
41996 swig_obj[0] = args;
41997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41998 if (!SWIG_IsOK(res1)) {
41999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42000 }
42001 arg1 = reinterpret_cast< wxMenu * >(argp1);
42002 {
42003 PyThreadState* __tstate = wxPyBeginAllowThreads();
42004 result = (wxMenuItem *)(arg1)->AppendSeparator();
42005 wxPyEndAllowThreads(__tstate);
42006 if (PyErr_Occurred()) SWIG_fail;
42007 }
42008 {
42009 resultobj = wxPyMake_wxObject(result, (bool)0);
42010 }
42011 return resultobj;
42012 fail:
42013 return NULL;
42014 }
42015
42016
42017 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42018 PyObject *resultobj = 0;
42019 wxMenu *arg1 = (wxMenu *) 0 ;
42020 int arg2 ;
42021 wxString *arg3 = 0 ;
42022 wxString const &arg4_defvalue = wxPyEmptyString ;
42023 wxString *arg4 = (wxString *) &arg4_defvalue ;
42024 wxMenuItem *result = 0 ;
42025 void *argp1 = 0 ;
42026 int res1 = 0 ;
42027 int val2 ;
42028 int ecode2 = 0 ;
42029 bool temp3 = false ;
42030 bool temp4 = false ;
42031 PyObject * obj0 = 0 ;
42032 PyObject * obj1 = 0 ;
42033 PyObject * obj2 = 0 ;
42034 PyObject * obj3 = 0 ;
42035 char * kwnames[] = {
42036 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42037 };
42038
42039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42041 if (!SWIG_IsOK(res1)) {
42042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42043 }
42044 arg1 = reinterpret_cast< wxMenu * >(argp1);
42045 ecode2 = SWIG_AsVal_int(obj1, &val2);
42046 if (!SWIG_IsOK(ecode2)) {
42047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42048 }
42049 arg2 = static_cast< int >(val2);
42050 {
42051 arg3 = wxString_in_helper(obj2);
42052 if (arg3 == NULL) SWIG_fail;
42053 temp3 = true;
42054 }
42055 if (obj3) {
42056 {
42057 arg4 = wxString_in_helper(obj3);
42058 if (arg4 == NULL) SWIG_fail;
42059 temp4 = true;
42060 }
42061 }
42062 {
42063 PyThreadState* __tstate = wxPyBeginAllowThreads();
42064 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42065 wxPyEndAllowThreads(__tstate);
42066 if (PyErr_Occurred()) SWIG_fail;
42067 }
42068 {
42069 resultobj = wxPyMake_wxObject(result, (bool)0);
42070 }
42071 {
42072 if (temp3)
42073 delete arg3;
42074 }
42075 {
42076 if (temp4)
42077 delete arg4;
42078 }
42079 return resultobj;
42080 fail:
42081 {
42082 if (temp3)
42083 delete arg3;
42084 }
42085 {
42086 if (temp4)
42087 delete arg4;
42088 }
42089 return NULL;
42090 }
42091
42092
42093 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42094 PyObject *resultobj = 0;
42095 wxMenu *arg1 = (wxMenu *) 0 ;
42096 int arg2 ;
42097 wxString *arg3 = 0 ;
42098 wxString const &arg4_defvalue = wxPyEmptyString ;
42099 wxString *arg4 = (wxString *) &arg4_defvalue ;
42100 wxMenuItem *result = 0 ;
42101 void *argp1 = 0 ;
42102 int res1 = 0 ;
42103 int val2 ;
42104 int ecode2 = 0 ;
42105 bool temp3 = false ;
42106 bool temp4 = false ;
42107 PyObject * obj0 = 0 ;
42108 PyObject * obj1 = 0 ;
42109 PyObject * obj2 = 0 ;
42110 PyObject * obj3 = 0 ;
42111 char * kwnames[] = {
42112 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42113 };
42114
42115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42117 if (!SWIG_IsOK(res1)) {
42118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42119 }
42120 arg1 = reinterpret_cast< wxMenu * >(argp1);
42121 ecode2 = SWIG_AsVal_int(obj1, &val2);
42122 if (!SWIG_IsOK(ecode2)) {
42123 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42124 }
42125 arg2 = static_cast< int >(val2);
42126 {
42127 arg3 = wxString_in_helper(obj2);
42128 if (arg3 == NULL) SWIG_fail;
42129 temp3 = true;
42130 }
42131 if (obj3) {
42132 {
42133 arg4 = wxString_in_helper(obj3);
42134 if (arg4 == NULL) SWIG_fail;
42135 temp4 = true;
42136 }
42137 }
42138 {
42139 PyThreadState* __tstate = wxPyBeginAllowThreads();
42140 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42141 wxPyEndAllowThreads(__tstate);
42142 if (PyErr_Occurred()) SWIG_fail;
42143 }
42144 {
42145 resultobj = wxPyMake_wxObject(result, (bool)0);
42146 }
42147 {
42148 if (temp3)
42149 delete arg3;
42150 }
42151 {
42152 if (temp4)
42153 delete arg4;
42154 }
42155 return resultobj;
42156 fail:
42157 {
42158 if (temp3)
42159 delete arg3;
42160 }
42161 {
42162 if (temp4)
42163 delete arg4;
42164 }
42165 return NULL;
42166 }
42167
42168
42169 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42170 PyObject *resultobj = 0;
42171 wxMenu *arg1 = (wxMenu *) 0 ;
42172 int arg2 ;
42173 wxString *arg3 = 0 ;
42174 wxMenu *arg4 = (wxMenu *) 0 ;
42175 wxString const &arg5_defvalue = wxPyEmptyString ;
42176 wxString *arg5 = (wxString *) &arg5_defvalue ;
42177 wxMenuItem *result = 0 ;
42178 void *argp1 = 0 ;
42179 int res1 = 0 ;
42180 int val2 ;
42181 int ecode2 = 0 ;
42182 bool temp3 = false ;
42183 void *argp4 = 0 ;
42184 int res4 = 0 ;
42185 bool temp5 = false ;
42186 PyObject * obj0 = 0 ;
42187 PyObject * obj1 = 0 ;
42188 PyObject * obj2 = 0 ;
42189 PyObject * obj3 = 0 ;
42190 PyObject * obj4 = 0 ;
42191 char * kwnames[] = {
42192 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42193 };
42194
42195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42197 if (!SWIG_IsOK(res1)) {
42198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42199 }
42200 arg1 = reinterpret_cast< wxMenu * >(argp1);
42201 ecode2 = SWIG_AsVal_int(obj1, &val2);
42202 if (!SWIG_IsOK(ecode2)) {
42203 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42204 }
42205 arg2 = static_cast< int >(val2);
42206 {
42207 arg3 = wxString_in_helper(obj2);
42208 if (arg3 == NULL) SWIG_fail;
42209 temp3 = true;
42210 }
42211 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42212 if (!SWIG_IsOK(res4)) {
42213 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42214 }
42215 arg4 = reinterpret_cast< wxMenu * >(argp4);
42216 if (obj4) {
42217 {
42218 arg5 = wxString_in_helper(obj4);
42219 if (arg5 == NULL) SWIG_fail;
42220 temp5 = true;
42221 }
42222 }
42223 {
42224 PyThreadState* __tstate = wxPyBeginAllowThreads();
42225 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42226 wxPyEndAllowThreads(__tstate);
42227 if (PyErr_Occurred()) SWIG_fail;
42228 }
42229 {
42230 resultobj = wxPyMake_wxObject(result, (bool)0);
42231 }
42232 {
42233 if (temp3)
42234 delete arg3;
42235 }
42236 {
42237 if (temp5)
42238 delete arg5;
42239 }
42240 return resultobj;
42241 fail:
42242 {
42243 if (temp3)
42244 delete arg3;
42245 }
42246 {
42247 if (temp5)
42248 delete arg5;
42249 }
42250 return NULL;
42251 }
42252
42253
42254 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42255 PyObject *resultobj = 0;
42256 wxMenu *arg1 = (wxMenu *) 0 ;
42257 wxMenu *arg2 = (wxMenu *) 0 ;
42258 wxString *arg3 = 0 ;
42259 wxString const &arg4_defvalue = wxPyEmptyString ;
42260 wxString *arg4 = (wxString *) &arg4_defvalue ;
42261 wxMenuItem *result = 0 ;
42262 void *argp1 = 0 ;
42263 int res1 = 0 ;
42264 void *argp2 = 0 ;
42265 int res2 = 0 ;
42266 bool temp3 = false ;
42267 bool temp4 = false ;
42268 PyObject * obj0 = 0 ;
42269 PyObject * obj1 = 0 ;
42270 PyObject * obj2 = 0 ;
42271 PyObject * obj3 = 0 ;
42272 char * kwnames[] = {
42273 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42274 };
42275
42276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42278 if (!SWIG_IsOK(res1)) {
42279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42280 }
42281 arg1 = reinterpret_cast< wxMenu * >(argp1);
42282 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42283 if (!SWIG_IsOK(res2)) {
42284 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42285 }
42286 arg2 = reinterpret_cast< wxMenu * >(argp2);
42287 {
42288 arg3 = wxString_in_helper(obj2);
42289 if (arg3 == NULL) SWIG_fail;
42290 temp3 = true;
42291 }
42292 if (obj3) {
42293 {
42294 arg4 = wxString_in_helper(obj3);
42295 if (arg4 == NULL) SWIG_fail;
42296 temp4 = true;
42297 }
42298 }
42299 {
42300 PyThreadState* __tstate = wxPyBeginAllowThreads();
42301 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42302 wxPyEndAllowThreads(__tstate);
42303 if (PyErr_Occurred()) SWIG_fail;
42304 }
42305 {
42306 resultobj = wxPyMake_wxObject(result, (bool)0);
42307 }
42308 {
42309 if (temp3)
42310 delete arg3;
42311 }
42312 {
42313 if (temp4)
42314 delete arg4;
42315 }
42316 return resultobj;
42317 fail:
42318 {
42319 if (temp3)
42320 delete arg3;
42321 }
42322 {
42323 if (temp4)
42324 delete arg4;
42325 }
42326 return NULL;
42327 }
42328
42329
42330 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42331 PyObject *resultobj = 0;
42332 wxMenu *arg1 = (wxMenu *) 0 ;
42333 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42334 wxMenuItem *result = 0 ;
42335 void *argp1 = 0 ;
42336 int res1 = 0 ;
42337 int res2 = 0 ;
42338 PyObject * obj0 = 0 ;
42339 PyObject * obj1 = 0 ;
42340 char * kwnames[] = {
42341 (char *) "self",(char *) "item", NULL
42342 };
42343
42344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42346 if (!SWIG_IsOK(res1)) {
42347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42348 }
42349 arg1 = reinterpret_cast< wxMenu * >(argp1);
42350 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42351 if (!SWIG_IsOK(res2)) {
42352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42353 }
42354 {
42355 PyThreadState* __tstate = wxPyBeginAllowThreads();
42356 result = (wxMenuItem *)(arg1)->Append(arg2);
42357 wxPyEndAllowThreads(__tstate);
42358 if (PyErr_Occurred()) SWIG_fail;
42359 }
42360 {
42361 resultobj = wxPyMake_wxObject(result, (bool)0);
42362 }
42363 return resultobj;
42364 fail:
42365 return NULL;
42366 }
42367
42368
42369 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42370 PyObject *resultobj = 0;
42371 wxMenu *arg1 = (wxMenu *) 0 ;
42372 size_t arg2 ;
42373 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42374 wxMenuItem *result = 0 ;
42375 void *argp1 = 0 ;
42376 int res1 = 0 ;
42377 size_t val2 ;
42378 int ecode2 = 0 ;
42379 int res3 = 0 ;
42380 PyObject * obj0 = 0 ;
42381 PyObject * obj1 = 0 ;
42382 PyObject * obj2 = 0 ;
42383 char * kwnames[] = {
42384 (char *) "self",(char *) "pos",(char *) "item", NULL
42385 };
42386
42387 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42388 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42389 if (!SWIG_IsOK(res1)) {
42390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42391 }
42392 arg1 = reinterpret_cast< wxMenu * >(argp1);
42393 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42394 if (!SWIG_IsOK(ecode2)) {
42395 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42396 }
42397 arg2 = static_cast< size_t >(val2);
42398 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42399 if (!SWIG_IsOK(res3)) {
42400 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42401 }
42402 {
42403 PyThreadState* __tstate = wxPyBeginAllowThreads();
42404 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42405 wxPyEndAllowThreads(__tstate);
42406 if (PyErr_Occurred()) SWIG_fail;
42407 }
42408 {
42409 resultobj = wxPyMake_wxObject(result, (bool)0);
42410 }
42411 return resultobj;
42412 fail:
42413 return NULL;
42414 }
42415
42416
42417 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42418 PyObject *resultobj = 0;
42419 wxMenu *arg1 = (wxMenu *) 0 ;
42420 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42421 wxMenuItem *result = 0 ;
42422 void *argp1 = 0 ;
42423 int res1 = 0 ;
42424 int res2 = 0 ;
42425 PyObject * obj0 = 0 ;
42426 PyObject * obj1 = 0 ;
42427 char * kwnames[] = {
42428 (char *) "self",(char *) "item", NULL
42429 };
42430
42431 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42432 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42433 if (!SWIG_IsOK(res1)) {
42434 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42435 }
42436 arg1 = reinterpret_cast< wxMenu * >(argp1);
42437 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42438 if (!SWIG_IsOK(res2)) {
42439 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42440 }
42441 {
42442 PyThreadState* __tstate = wxPyBeginAllowThreads();
42443 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42444 wxPyEndAllowThreads(__tstate);
42445 if (PyErr_Occurred()) SWIG_fail;
42446 }
42447 {
42448 resultobj = wxPyMake_wxObject(result, (bool)0);
42449 }
42450 return resultobj;
42451 fail:
42452 return NULL;
42453 }
42454
42455
42456 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42457 PyObject *resultobj = 0;
42458 wxMenu *arg1 = (wxMenu *) 0 ;
42459 void *argp1 = 0 ;
42460 int res1 = 0 ;
42461 PyObject *swig_obj[1] ;
42462
42463 if (!args) SWIG_fail;
42464 swig_obj[0] = args;
42465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42466 if (!SWIG_IsOK(res1)) {
42467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42468 }
42469 arg1 = reinterpret_cast< wxMenu * >(argp1);
42470 {
42471 PyThreadState* __tstate = wxPyBeginAllowThreads();
42472 (arg1)->Break();
42473 wxPyEndAllowThreads(__tstate);
42474 if (PyErr_Occurred()) SWIG_fail;
42475 }
42476 resultobj = SWIG_Py_Void();
42477 return resultobj;
42478 fail:
42479 return NULL;
42480 }
42481
42482
42483 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42484 PyObject *resultobj = 0;
42485 wxMenu *arg1 = (wxMenu *) 0 ;
42486 size_t arg2 ;
42487 int arg3 ;
42488 wxString const &arg4_defvalue = wxPyEmptyString ;
42489 wxString *arg4 = (wxString *) &arg4_defvalue ;
42490 wxString const &arg5_defvalue = wxPyEmptyString ;
42491 wxString *arg5 = (wxString *) &arg5_defvalue ;
42492 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42493 wxMenuItem *result = 0 ;
42494 void *argp1 = 0 ;
42495 int res1 = 0 ;
42496 size_t val2 ;
42497 int ecode2 = 0 ;
42498 int val3 ;
42499 int ecode3 = 0 ;
42500 bool temp4 = false ;
42501 bool temp5 = false ;
42502 int val6 ;
42503 int ecode6 = 0 ;
42504 PyObject * obj0 = 0 ;
42505 PyObject * obj1 = 0 ;
42506 PyObject * obj2 = 0 ;
42507 PyObject * obj3 = 0 ;
42508 PyObject * obj4 = 0 ;
42509 PyObject * obj5 = 0 ;
42510 char * kwnames[] = {
42511 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42512 };
42513
42514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42516 if (!SWIG_IsOK(res1)) {
42517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42518 }
42519 arg1 = reinterpret_cast< wxMenu * >(argp1);
42520 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42521 if (!SWIG_IsOK(ecode2)) {
42522 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42523 }
42524 arg2 = static_cast< size_t >(val2);
42525 ecode3 = SWIG_AsVal_int(obj2, &val3);
42526 if (!SWIG_IsOK(ecode3)) {
42527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42528 }
42529 arg3 = static_cast< int >(val3);
42530 if (obj3) {
42531 {
42532 arg4 = wxString_in_helper(obj3);
42533 if (arg4 == NULL) SWIG_fail;
42534 temp4 = true;
42535 }
42536 }
42537 if (obj4) {
42538 {
42539 arg5 = wxString_in_helper(obj4);
42540 if (arg5 == NULL) SWIG_fail;
42541 temp5 = true;
42542 }
42543 }
42544 if (obj5) {
42545 ecode6 = SWIG_AsVal_int(obj5, &val6);
42546 if (!SWIG_IsOK(ecode6)) {
42547 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42548 }
42549 arg6 = static_cast< wxItemKind >(val6);
42550 }
42551 {
42552 PyThreadState* __tstate = wxPyBeginAllowThreads();
42553 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42554 wxPyEndAllowThreads(__tstate);
42555 if (PyErr_Occurred()) SWIG_fail;
42556 }
42557 {
42558 resultobj = wxPyMake_wxObject(result, (bool)0);
42559 }
42560 {
42561 if (temp4)
42562 delete arg4;
42563 }
42564 {
42565 if (temp5)
42566 delete arg5;
42567 }
42568 return resultobj;
42569 fail:
42570 {
42571 if (temp4)
42572 delete arg4;
42573 }
42574 {
42575 if (temp5)
42576 delete arg5;
42577 }
42578 return NULL;
42579 }
42580
42581
42582 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42583 PyObject *resultobj = 0;
42584 wxMenu *arg1 = (wxMenu *) 0 ;
42585 size_t arg2 ;
42586 wxMenuItem *result = 0 ;
42587 void *argp1 = 0 ;
42588 int res1 = 0 ;
42589 size_t val2 ;
42590 int ecode2 = 0 ;
42591 PyObject * obj0 = 0 ;
42592 PyObject * obj1 = 0 ;
42593 char * kwnames[] = {
42594 (char *) "self",(char *) "pos", NULL
42595 };
42596
42597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42599 if (!SWIG_IsOK(res1)) {
42600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42601 }
42602 arg1 = reinterpret_cast< wxMenu * >(argp1);
42603 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42604 if (!SWIG_IsOK(ecode2)) {
42605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42606 }
42607 arg2 = static_cast< size_t >(val2);
42608 {
42609 PyThreadState* __tstate = wxPyBeginAllowThreads();
42610 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42611 wxPyEndAllowThreads(__tstate);
42612 if (PyErr_Occurred()) SWIG_fail;
42613 }
42614 {
42615 resultobj = wxPyMake_wxObject(result, (bool)0);
42616 }
42617 return resultobj;
42618 fail:
42619 return NULL;
42620 }
42621
42622
42623 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42624 PyObject *resultobj = 0;
42625 wxMenu *arg1 = (wxMenu *) 0 ;
42626 size_t arg2 ;
42627 int arg3 ;
42628 wxString *arg4 = 0 ;
42629 wxString const &arg5_defvalue = wxPyEmptyString ;
42630 wxString *arg5 = (wxString *) &arg5_defvalue ;
42631 wxMenuItem *result = 0 ;
42632 void *argp1 = 0 ;
42633 int res1 = 0 ;
42634 size_t val2 ;
42635 int ecode2 = 0 ;
42636 int val3 ;
42637 int ecode3 = 0 ;
42638 bool temp4 = false ;
42639 bool temp5 = false ;
42640 PyObject * obj0 = 0 ;
42641 PyObject * obj1 = 0 ;
42642 PyObject * obj2 = 0 ;
42643 PyObject * obj3 = 0 ;
42644 PyObject * obj4 = 0 ;
42645 char * kwnames[] = {
42646 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42647 };
42648
42649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42651 if (!SWIG_IsOK(res1)) {
42652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42653 }
42654 arg1 = reinterpret_cast< wxMenu * >(argp1);
42655 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42656 if (!SWIG_IsOK(ecode2)) {
42657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42658 }
42659 arg2 = static_cast< size_t >(val2);
42660 ecode3 = SWIG_AsVal_int(obj2, &val3);
42661 if (!SWIG_IsOK(ecode3)) {
42662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42663 }
42664 arg3 = static_cast< int >(val3);
42665 {
42666 arg4 = wxString_in_helper(obj3);
42667 if (arg4 == NULL) SWIG_fail;
42668 temp4 = true;
42669 }
42670 if (obj4) {
42671 {
42672 arg5 = wxString_in_helper(obj4);
42673 if (arg5 == NULL) SWIG_fail;
42674 temp5 = true;
42675 }
42676 }
42677 {
42678 PyThreadState* __tstate = wxPyBeginAllowThreads();
42679 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42680 wxPyEndAllowThreads(__tstate);
42681 if (PyErr_Occurred()) SWIG_fail;
42682 }
42683 {
42684 resultobj = wxPyMake_wxObject(result, (bool)0);
42685 }
42686 {
42687 if (temp4)
42688 delete arg4;
42689 }
42690 {
42691 if (temp5)
42692 delete arg5;
42693 }
42694 return resultobj;
42695 fail:
42696 {
42697 if (temp4)
42698 delete arg4;
42699 }
42700 {
42701 if (temp5)
42702 delete arg5;
42703 }
42704 return NULL;
42705 }
42706
42707
42708 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42709 PyObject *resultobj = 0;
42710 wxMenu *arg1 = (wxMenu *) 0 ;
42711 size_t arg2 ;
42712 int arg3 ;
42713 wxString *arg4 = 0 ;
42714 wxString const &arg5_defvalue = wxPyEmptyString ;
42715 wxString *arg5 = (wxString *) &arg5_defvalue ;
42716 wxMenuItem *result = 0 ;
42717 void *argp1 = 0 ;
42718 int res1 = 0 ;
42719 size_t val2 ;
42720 int ecode2 = 0 ;
42721 int val3 ;
42722 int ecode3 = 0 ;
42723 bool temp4 = false ;
42724 bool temp5 = false ;
42725 PyObject * obj0 = 0 ;
42726 PyObject * obj1 = 0 ;
42727 PyObject * obj2 = 0 ;
42728 PyObject * obj3 = 0 ;
42729 PyObject * obj4 = 0 ;
42730 char * kwnames[] = {
42731 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42732 };
42733
42734 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42735 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42736 if (!SWIG_IsOK(res1)) {
42737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42738 }
42739 arg1 = reinterpret_cast< wxMenu * >(argp1);
42740 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42741 if (!SWIG_IsOK(ecode2)) {
42742 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42743 }
42744 arg2 = static_cast< size_t >(val2);
42745 ecode3 = SWIG_AsVal_int(obj2, &val3);
42746 if (!SWIG_IsOK(ecode3)) {
42747 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42748 }
42749 arg3 = static_cast< int >(val3);
42750 {
42751 arg4 = wxString_in_helper(obj3);
42752 if (arg4 == NULL) SWIG_fail;
42753 temp4 = true;
42754 }
42755 if (obj4) {
42756 {
42757 arg5 = wxString_in_helper(obj4);
42758 if (arg5 == NULL) SWIG_fail;
42759 temp5 = true;
42760 }
42761 }
42762 {
42763 PyThreadState* __tstate = wxPyBeginAllowThreads();
42764 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42765 wxPyEndAllowThreads(__tstate);
42766 if (PyErr_Occurred()) SWIG_fail;
42767 }
42768 {
42769 resultobj = wxPyMake_wxObject(result, (bool)0);
42770 }
42771 {
42772 if (temp4)
42773 delete arg4;
42774 }
42775 {
42776 if (temp5)
42777 delete arg5;
42778 }
42779 return resultobj;
42780 fail:
42781 {
42782 if (temp4)
42783 delete arg4;
42784 }
42785 {
42786 if (temp5)
42787 delete arg5;
42788 }
42789 return NULL;
42790 }
42791
42792
42793 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42794 PyObject *resultobj = 0;
42795 wxMenu *arg1 = (wxMenu *) 0 ;
42796 size_t arg2 ;
42797 int arg3 ;
42798 wxString *arg4 = 0 ;
42799 wxMenu *arg5 = (wxMenu *) 0 ;
42800 wxString const &arg6_defvalue = wxPyEmptyString ;
42801 wxString *arg6 = (wxString *) &arg6_defvalue ;
42802 wxMenuItem *result = 0 ;
42803 void *argp1 = 0 ;
42804 int res1 = 0 ;
42805 size_t val2 ;
42806 int ecode2 = 0 ;
42807 int val3 ;
42808 int ecode3 = 0 ;
42809 bool temp4 = false ;
42810 void *argp5 = 0 ;
42811 int res5 = 0 ;
42812 bool temp6 = false ;
42813 PyObject * obj0 = 0 ;
42814 PyObject * obj1 = 0 ;
42815 PyObject * obj2 = 0 ;
42816 PyObject * obj3 = 0 ;
42817 PyObject * obj4 = 0 ;
42818 PyObject * obj5 = 0 ;
42819 char * kwnames[] = {
42820 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42821 };
42822
42823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42825 if (!SWIG_IsOK(res1)) {
42826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42827 }
42828 arg1 = reinterpret_cast< wxMenu * >(argp1);
42829 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42830 if (!SWIG_IsOK(ecode2)) {
42831 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42832 }
42833 arg2 = static_cast< size_t >(val2);
42834 ecode3 = SWIG_AsVal_int(obj2, &val3);
42835 if (!SWIG_IsOK(ecode3)) {
42836 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42837 }
42838 arg3 = static_cast< int >(val3);
42839 {
42840 arg4 = wxString_in_helper(obj3);
42841 if (arg4 == NULL) SWIG_fail;
42842 temp4 = true;
42843 }
42844 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42845 if (!SWIG_IsOK(res5)) {
42846 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42847 }
42848 arg5 = reinterpret_cast< wxMenu * >(argp5);
42849 if (obj5) {
42850 {
42851 arg6 = wxString_in_helper(obj5);
42852 if (arg6 == NULL) SWIG_fail;
42853 temp6 = true;
42854 }
42855 }
42856 {
42857 PyThreadState* __tstate = wxPyBeginAllowThreads();
42858 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42859 wxPyEndAllowThreads(__tstate);
42860 if (PyErr_Occurred()) SWIG_fail;
42861 }
42862 {
42863 resultobj = wxPyMake_wxObject(result, (bool)0);
42864 }
42865 {
42866 if (temp4)
42867 delete arg4;
42868 }
42869 {
42870 if (temp6)
42871 delete arg6;
42872 }
42873 return resultobj;
42874 fail:
42875 {
42876 if (temp4)
42877 delete arg4;
42878 }
42879 {
42880 if (temp6)
42881 delete arg6;
42882 }
42883 return NULL;
42884 }
42885
42886
42887 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42888 PyObject *resultobj = 0;
42889 wxMenu *arg1 = (wxMenu *) 0 ;
42890 int arg2 ;
42891 wxString const &arg3_defvalue = wxPyEmptyString ;
42892 wxString *arg3 = (wxString *) &arg3_defvalue ;
42893 wxString const &arg4_defvalue = wxPyEmptyString ;
42894 wxString *arg4 = (wxString *) &arg4_defvalue ;
42895 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42896 wxMenuItem *result = 0 ;
42897 void *argp1 = 0 ;
42898 int res1 = 0 ;
42899 int val2 ;
42900 int ecode2 = 0 ;
42901 bool temp3 = false ;
42902 bool temp4 = false ;
42903 int val5 ;
42904 int ecode5 = 0 ;
42905 PyObject * obj0 = 0 ;
42906 PyObject * obj1 = 0 ;
42907 PyObject * obj2 = 0 ;
42908 PyObject * obj3 = 0 ;
42909 PyObject * obj4 = 0 ;
42910 char * kwnames[] = {
42911 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42912 };
42913
42914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42916 if (!SWIG_IsOK(res1)) {
42917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42918 }
42919 arg1 = reinterpret_cast< wxMenu * >(argp1);
42920 ecode2 = SWIG_AsVal_int(obj1, &val2);
42921 if (!SWIG_IsOK(ecode2)) {
42922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42923 }
42924 arg2 = static_cast< int >(val2);
42925 if (obj2) {
42926 {
42927 arg3 = wxString_in_helper(obj2);
42928 if (arg3 == NULL) SWIG_fail;
42929 temp3 = true;
42930 }
42931 }
42932 if (obj3) {
42933 {
42934 arg4 = wxString_in_helper(obj3);
42935 if (arg4 == NULL) SWIG_fail;
42936 temp4 = true;
42937 }
42938 }
42939 if (obj4) {
42940 ecode5 = SWIG_AsVal_int(obj4, &val5);
42941 if (!SWIG_IsOK(ecode5)) {
42942 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42943 }
42944 arg5 = static_cast< wxItemKind >(val5);
42945 }
42946 {
42947 PyThreadState* __tstate = wxPyBeginAllowThreads();
42948 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42949 wxPyEndAllowThreads(__tstate);
42950 if (PyErr_Occurred()) SWIG_fail;
42951 }
42952 {
42953 resultobj = wxPyMake_wxObject(result, (bool)0);
42954 }
42955 {
42956 if (temp3)
42957 delete arg3;
42958 }
42959 {
42960 if (temp4)
42961 delete arg4;
42962 }
42963 return resultobj;
42964 fail:
42965 {
42966 if (temp3)
42967 delete arg3;
42968 }
42969 {
42970 if (temp4)
42971 delete arg4;
42972 }
42973 return NULL;
42974 }
42975
42976
42977 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42978 PyObject *resultobj = 0;
42979 wxMenu *arg1 = (wxMenu *) 0 ;
42980 wxMenuItem *result = 0 ;
42981 void *argp1 = 0 ;
42982 int res1 = 0 ;
42983 PyObject *swig_obj[1] ;
42984
42985 if (!args) SWIG_fail;
42986 swig_obj[0] = args;
42987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42988 if (!SWIG_IsOK(res1)) {
42989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42990 }
42991 arg1 = reinterpret_cast< wxMenu * >(argp1);
42992 {
42993 PyThreadState* __tstate = wxPyBeginAllowThreads();
42994 result = (wxMenuItem *)(arg1)->PrependSeparator();
42995 wxPyEndAllowThreads(__tstate);
42996 if (PyErr_Occurred()) SWIG_fail;
42997 }
42998 {
42999 resultobj = wxPyMake_wxObject(result, (bool)0);
43000 }
43001 return resultobj;
43002 fail:
43003 return NULL;
43004 }
43005
43006
43007 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43008 PyObject *resultobj = 0;
43009 wxMenu *arg1 = (wxMenu *) 0 ;
43010 int arg2 ;
43011 wxString *arg3 = 0 ;
43012 wxString const &arg4_defvalue = wxPyEmptyString ;
43013 wxString *arg4 = (wxString *) &arg4_defvalue ;
43014 wxMenuItem *result = 0 ;
43015 void *argp1 = 0 ;
43016 int res1 = 0 ;
43017 int val2 ;
43018 int ecode2 = 0 ;
43019 bool temp3 = false ;
43020 bool temp4 = false ;
43021 PyObject * obj0 = 0 ;
43022 PyObject * obj1 = 0 ;
43023 PyObject * obj2 = 0 ;
43024 PyObject * obj3 = 0 ;
43025 char * kwnames[] = {
43026 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43027 };
43028
43029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43031 if (!SWIG_IsOK(res1)) {
43032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43033 }
43034 arg1 = reinterpret_cast< wxMenu * >(argp1);
43035 ecode2 = SWIG_AsVal_int(obj1, &val2);
43036 if (!SWIG_IsOK(ecode2)) {
43037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43038 }
43039 arg2 = static_cast< int >(val2);
43040 {
43041 arg3 = wxString_in_helper(obj2);
43042 if (arg3 == NULL) SWIG_fail;
43043 temp3 = true;
43044 }
43045 if (obj3) {
43046 {
43047 arg4 = wxString_in_helper(obj3);
43048 if (arg4 == NULL) SWIG_fail;
43049 temp4 = true;
43050 }
43051 }
43052 {
43053 PyThreadState* __tstate = wxPyBeginAllowThreads();
43054 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43055 wxPyEndAllowThreads(__tstate);
43056 if (PyErr_Occurred()) SWIG_fail;
43057 }
43058 {
43059 resultobj = wxPyMake_wxObject(result, (bool)0);
43060 }
43061 {
43062 if (temp3)
43063 delete arg3;
43064 }
43065 {
43066 if (temp4)
43067 delete arg4;
43068 }
43069 return resultobj;
43070 fail:
43071 {
43072 if (temp3)
43073 delete arg3;
43074 }
43075 {
43076 if (temp4)
43077 delete arg4;
43078 }
43079 return NULL;
43080 }
43081
43082
43083 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43084 PyObject *resultobj = 0;
43085 wxMenu *arg1 = (wxMenu *) 0 ;
43086 int arg2 ;
43087 wxString *arg3 = 0 ;
43088 wxString const &arg4_defvalue = wxPyEmptyString ;
43089 wxString *arg4 = (wxString *) &arg4_defvalue ;
43090 wxMenuItem *result = 0 ;
43091 void *argp1 = 0 ;
43092 int res1 = 0 ;
43093 int val2 ;
43094 int ecode2 = 0 ;
43095 bool temp3 = false ;
43096 bool temp4 = false ;
43097 PyObject * obj0 = 0 ;
43098 PyObject * obj1 = 0 ;
43099 PyObject * obj2 = 0 ;
43100 PyObject * obj3 = 0 ;
43101 char * kwnames[] = {
43102 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43103 };
43104
43105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43107 if (!SWIG_IsOK(res1)) {
43108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43109 }
43110 arg1 = reinterpret_cast< wxMenu * >(argp1);
43111 ecode2 = SWIG_AsVal_int(obj1, &val2);
43112 if (!SWIG_IsOK(ecode2)) {
43113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43114 }
43115 arg2 = static_cast< int >(val2);
43116 {
43117 arg3 = wxString_in_helper(obj2);
43118 if (arg3 == NULL) SWIG_fail;
43119 temp3 = true;
43120 }
43121 if (obj3) {
43122 {
43123 arg4 = wxString_in_helper(obj3);
43124 if (arg4 == NULL) SWIG_fail;
43125 temp4 = true;
43126 }
43127 }
43128 {
43129 PyThreadState* __tstate = wxPyBeginAllowThreads();
43130 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43131 wxPyEndAllowThreads(__tstate);
43132 if (PyErr_Occurred()) SWIG_fail;
43133 }
43134 {
43135 resultobj = wxPyMake_wxObject(result, (bool)0);
43136 }
43137 {
43138 if (temp3)
43139 delete arg3;
43140 }
43141 {
43142 if (temp4)
43143 delete arg4;
43144 }
43145 return resultobj;
43146 fail:
43147 {
43148 if (temp3)
43149 delete arg3;
43150 }
43151 {
43152 if (temp4)
43153 delete arg4;
43154 }
43155 return NULL;
43156 }
43157
43158
43159 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43160 PyObject *resultobj = 0;
43161 wxMenu *arg1 = (wxMenu *) 0 ;
43162 int arg2 ;
43163 wxString *arg3 = 0 ;
43164 wxMenu *arg4 = (wxMenu *) 0 ;
43165 wxString const &arg5_defvalue = wxPyEmptyString ;
43166 wxString *arg5 = (wxString *) &arg5_defvalue ;
43167 wxMenuItem *result = 0 ;
43168 void *argp1 = 0 ;
43169 int res1 = 0 ;
43170 int val2 ;
43171 int ecode2 = 0 ;
43172 bool temp3 = false ;
43173 void *argp4 = 0 ;
43174 int res4 = 0 ;
43175 bool temp5 = false ;
43176 PyObject * obj0 = 0 ;
43177 PyObject * obj1 = 0 ;
43178 PyObject * obj2 = 0 ;
43179 PyObject * obj3 = 0 ;
43180 PyObject * obj4 = 0 ;
43181 char * kwnames[] = {
43182 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43183 };
43184
43185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43187 if (!SWIG_IsOK(res1)) {
43188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43189 }
43190 arg1 = reinterpret_cast< wxMenu * >(argp1);
43191 ecode2 = SWIG_AsVal_int(obj1, &val2);
43192 if (!SWIG_IsOK(ecode2)) {
43193 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43194 }
43195 arg2 = static_cast< int >(val2);
43196 {
43197 arg3 = wxString_in_helper(obj2);
43198 if (arg3 == NULL) SWIG_fail;
43199 temp3 = true;
43200 }
43201 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43202 if (!SWIG_IsOK(res4)) {
43203 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43204 }
43205 arg4 = reinterpret_cast< wxMenu * >(argp4);
43206 if (obj4) {
43207 {
43208 arg5 = wxString_in_helper(obj4);
43209 if (arg5 == NULL) SWIG_fail;
43210 temp5 = true;
43211 }
43212 }
43213 {
43214 PyThreadState* __tstate = wxPyBeginAllowThreads();
43215 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43216 wxPyEndAllowThreads(__tstate);
43217 if (PyErr_Occurred()) SWIG_fail;
43218 }
43219 {
43220 resultobj = wxPyMake_wxObject(result, (bool)0);
43221 }
43222 {
43223 if (temp3)
43224 delete arg3;
43225 }
43226 {
43227 if (temp5)
43228 delete arg5;
43229 }
43230 return resultobj;
43231 fail:
43232 {
43233 if (temp3)
43234 delete arg3;
43235 }
43236 {
43237 if (temp5)
43238 delete arg5;
43239 }
43240 return NULL;
43241 }
43242
43243
43244 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43245 PyObject *resultobj = 0;
43246 wxMenu *arg1 = (wxMenu *) 0 ;
43247 int arg2 ;
43248 wxMenuItem *result = 0 ;
43249 void *argp1 = 0 ;
43250 int res1 = 0 ;
43251 int val2 ;
43252 int ecode2 = 0 ;
43253 PyObject * obj0 = 0 ;
43254 PyObject * obj1 = 0 ;
43255 char * kwnames[] = {
43256 (char *) "self",(char *) "id", NULL
43257 };
43258
43259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43261 if (!SWIG_IsOK(res1)) {
43262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43263 }
43264 arg1 = reinterpret_cast< wxMenu * >(argp1);
43265 ecode2 = SWIG_AsVal_int(obj1, &val2);
43266 if (!SWIG_IsOK(ecode2)) {
43267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43268 }
43269 arg2 = static_cast< int >(val2);
43270 {
43271 PyThreadState* __tstate = wxPyBeginAllowThreads();
43272 result = (wxMenuItem *)(arg1)->Remove(arg2);
43273 wxPyEndAllowThreads(__tstate);
43274 if (PyErr_Occurred()) SWIG_fail;
43275 }
43276 {
43277 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43278 }
43279 return resultobj;
43280 fail:
43281 return NULL;
43282 }
43283
43284
43285 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43286 PyObject *resultobj = 0;
43287 wxMenu *arg1 = (wxMenu *) 0 ;
43288 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43289 wxMenuItem *result = 0 ;
43290 void *argp1 = 0 ;
43291 int res1 = 0 ;
43292 void *argp2 = 0 ;
43293 int res2 = 0 ;
43294 PyObject * obj0 = 0 ;
43295 PyObject * obj1 = 0 ;
43296 char * kwnames[] = {
43297 (char *) "self",(char *) "item", NULL
43298 };
43299
43300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43302 if (!SWIG_IsOK(res1)) {
43303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43304 }
43305 arg1 = reinterpret_cast< wxMenu * >(argp1);
43306 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43307 if (!SWIG_IsOK(res2)) {
43308 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43309 }
43310 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43311 {
43312 PyThreadState* __tstate = wxPyBeginAllowThreads();
43313 result = (wxMenuItem *)(arg1)->Remove(arg2);
43314 wxPyEndAllowThreads(__tstate);
43315 if (PyErr_Occurred()) SWIG_fail;
43316 }
43317 {
43318 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43319 }
43320 return resultobj;
43321 fail:
43322 return NULL;
43323 }
43324
43325
43326 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43327 PyObject *resultobj = 0;
43328 wxMenu *arg1 = (wxMenu *) 0 ;
43329 int arg2 ;
43330 bool result;
43331 void *argp1 = 0 ;
43332 int res1 = 0 ;
43333 int val2 ;
43334 int ecode2 = 0 ;
43335 PyObject * obj0 = 0 ;
43336 PyObject * obj1 = 0 ;
43337 char * kwnames[] = {
43338 (char *) "self",(char *) "id", NULL
43339 };
43340
43341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43343 if (!SWIG_IsOK(res1)) {
43344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43345 }
43346 arg1 = reinterpret_cast< wxMenu * >(argp1);
43347 ecode2 = SWIG_AsVal_int(obj1, &val2);
43348 if (!SWIG_IsOK(ecode2)) {
43349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43350 }
43351 arg2 = static_cast< int >(val2);
43352 {
43353 PyThreadState* __tstate = wxPyBeginAllowThreads();
43354 result = (bool)(arg1)->Delete(arg2);
43355 wxPyEndAllowThreads(__tstate);
43356 if (PyErr_Occurred()) SWIG_fail;
43357 }
43358 {
43359 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43360 }
43361 return resultobj;
43362 fail:
43363 return NULL;
43364 }
43365
43366
43367 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43368 PyObject *resultobj = 0;
43369 wxMenu *arg1 = (wxMenu *) 0 ;
43370 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43371 bool result;
43372 void *argp1 = 0 ;
43373 int res1 = 0 ;
43374 void *argp2 = 0 ;
43375 int res2 = 0 ;
43376 PyObject * obj0 = 0 ;
43377 PyObject * obj1 = 0 ;
43378 char * kwnames[] = {
43379 (char *) "self",(char *) "item", NULL
43380 };
43381
43382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43384 if (!SWIG_IsOK(res1)) {
43385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43386 }
43387 arg1 = reinterpret_cast< wxMenu * >(argp1);
43388 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43389 if (!SWIG_IsOK(res2)) {
43390 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43391 }
43392 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43393 {
43394 PyThreadState* __tstate = wxPyBeginAllowThreads();
43395 result = (bool)(arg1)->Delete(arg2);
43396 wxPyEndAllowThreads(__tstate);
43397 if (PyErr_Occurred()) SWIG_fail;
43398 }
43399 {
43400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43401 }
43402 return resultobj;
43403 fail:
43404 return NULL;
43405 }
43406
43407
43408 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43409 PyObject *resultobj = 0;
43410 wxMenu *arg1 = (wxMenu *) 0 ;
43411 void *argp1 = 0 ;
43412 int res1 = 0 ;
43413 PyObject *swig_obj[1] ;
43414
43415 if (!args) SWIG_fail;
43416 swig_obj[0] = args;
43417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43418 if (!SWIG_IsOK(res1)) {
43419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43420 }
43421 arg1 = reinterpret_cast< wxMenu * >(argp1);
43422 {
43423 PyThreadState* __tstate = wxPyBeginAllowThreads();
43424 wxMenu_Destroy(arg1);
43425 wxPyEndAllowThreads(__tstate);
43426 if (PyErr_Occurred()) SWIG_fail;
43427 }
43428 resultobj = SWIG_Py_Void();
43429 return resultobj;
43430 fail:
43431 return NULL;
43432 }
43433
43434
43435 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43436 PyObject *resultobj = 0;
43437 wxMenu *arg1 = (wxMenu *) 0 ;
43438 int arg2 ;
43439 bool result;
43440 void *argp1 = 0 ;
43441 int res1 = 0 ;
43442 int val2 ;
43443 int ecode2 = 0 ;
43444 PyObject * obj0 = 0 ;
43445 PyObject * obj1 = 0 ;
43446 char * kwnames[] = {
43447 (char *) "self",(char *) "id", NULL
43448 };
43449
43450 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43451 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43452 if (!SWIG_IsOK(res1)) {
43453 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43454 }
43455 arg1 = reinterpret_cast< wxMenu * >(argp1);
43456 ecode2 = SWIG_AsVal_int(obj1, &val2);
43457 if (!SWIG_IsOK(ecode2)) {
43458 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43459 }
43460 arg2 = static_cast< int >(val2);
43461 {
43462 PyThreadState* __tstate = wxPyBeginAllowThreads();
43463 result = (bool)(arg1)->Destroy(arg2);
43464 wxPyEndAllowThreads(__tstate);
43465 if (PyErr_Occurred()) SWIG_fail;
43466 }
43467 {
43468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43469 }
43470 return resultobj;
43471 fail:
43472 return NULL;
43473 }
43474
43475
43476 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43477 PyObject *resultobj = 0;
43478 wxMenu *arg1 = (wxMenu *) 0 ;
43479 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43480 bool result;
43481 void *argp1 = 0 ;
43482 int res1 = 0 ;
43483 void *argp2 = 0 ;
43484 int res2 = 0 ;
43485 PyObject * obj0 = 0 ;
43486 PyObject * obj1 = 0 ;
43487 char * kwnames[] = {
43488 (char *) "self",(char *) "item", NULL
43489 };
43490
43491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43493 if (!SWIG_IsOK(res1)) {
43494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43495 }
43496 arg1 = reinterpret_cast< wxMenu * >(argp1);
43497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43498 if (!SWIG_IsOK(res2)) {
43499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43500 }
43501 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43502 {
43503 PyThreadState* __tstate = wxPyBeginAllowThreads();
43504 result = (bool)(arg1)->Destroy(arg2);
43505 wxPyEndAllowThreads(__tstate);
43506 if (PyErr_Occurred()) SWIG_fail;
43507 }
43508 {
43509 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43510 }
43511 return resultobj;
43512 fail:
43513 return NULL;
43514 }
43515
43516
43517 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43518 PyObject *resultobj = 0;
43519 wxMenu *arg1 = (wxMenu *) 0 ;
43520 size_t result;
43521 void *argp1 = 0 ;
43522 int res1 = 0 ;
43523 PyObject *swig_obj[1] ;
43524
43525 if (!args) SWIG_fail;
43526 swig_obj[0] = args;
43527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43528 if (!SWIG_IsOK(res1)) {
43529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43530 }
43531 arg1 = reinterpret_cast< wxMenu * >(argp1);
43532 {
43533 PyThreadState* __tstate = wxPyBeginAllowThreads();
43534 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43535 wxPyEndAllowThreads(__tstate);
43536 if (PyErr_Occurred()) SWIG_fail;
43537 }
43538 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43539 return resultobj;
43540 fail:
43541 return NULL;
43542 }
43543
43544
43545 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43546 PyObject *resultobj = 0;
43547 wxMenu *arg1 = (wxMenu *) 0 ;
43548 PyObject *result = 0 ;
43549 void *argp1 = 0 ;
43550 int res1 = 0 ;
43551 PyObject *swig_obj[1] ;
43552
43553 if (!args) SWIG_fail;
43554 swig_obj[0] = args;
43555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43556 if (!SWIG_IsOK(res1)) {
43557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43558 }
43559 arg1 = reinterpret_cast< wxMenu * >(argp1);
43560 {
43561 PyThreadState* __tstate = wxPyBeginAllowThreads();
43562 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43563 wxPyEndAllowThreads(__tstate);
43564 if (PyErr_Occurred()) SWIG_fail;
43565 }
43566 resultobj = result;
43567 return resultobj;
43568 fail:
43569 return NULL;
43570 }
43571
43572
43573 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43574 PyObject *resultobj = 0;
43575 wxMenu *arg1 = (wxMenu *) 0 ;
43576 wxString *arg2 = 0 ;
43577 int result;
43578 void *argp1 = 0 ;
43579 int res1 = 0 ;
43580 bool temp2 = false ;
43581 PyObject * obj0 = 0 ;
43582 PyObject * obj1 = 0 ;
43583 char * kwnames[] = {
43584 (char *) "self",(char *) "item", NULL
43585 };
43586
43587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43589 if (!SWIG_IsOK(res1)) {
43590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43591 }
43592 arg1 = reinterpret_cast< wxMenu * >(argp1);
43593 {
43594 arg2 = wxString_in_helper(obj1);
43595 if (arg2 == NULL) SWIG_fail;
43596 temp2 = true;
43597 }
43598 {
43599 PyThreadState* __tstate = wxPyBeginAllowThreads();
43600 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43601 wxPyEndAllowThreads(__tstate);
43602 if (PyErr_Occurred()) SWIG_fail;
43603 }
43604 resultobj = SWIG_From_int(static_cast< int >(result));
43605 {
43606 if (temp2)
43607 delete arg2;
43608 }
43609 return resultobj;
43610 fail:
43611 {
43612 if (temp2)
43613 delete arg2;
43614 }
43615 return NULL;
43616 }
43617
43618
43619 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43620 PyObject *resultobj = 0;
43621 wxMenu *arg1 = (wxMenu *) 0 ;
43622 int arg2 ;
43623 wxMenuItem *result = 0 ;
43624 void *argp1 = 0 ;
43625 int res1 = 0 ;
43626 int val2 ;
43627 int ecode2 = 0 ;
43628 PyObject * obj0 = 0 ;
43629 PyObject * obj1 = 0 ;
43630 char * kwnames[] = {
43631 (char *) "self",(char *) "id", NULL
43632 };
43633
43634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43636 if (!SWIG_IsOK(res1)) {
43637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43638 }
43639 arg1 = reinterpret_cast< wxMenu * >(argp1);
43640 ecode2 = SWIG_AsVal_int(obj1, &val2);
43641 if (!SWIG_IsOK(ecode2)) {
43642 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43643 }
43644 arg2 = static_cast< int >(val2);
43645 {
43646 PyThreadState* __tstate = wxPyBeginAllowThreads();
43647 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43648 wxPyEndAllowThreads(__tstate);
43649 if (PyErr_Occurred()) SWIG_fail;
43650 }
43651 {
43652 resultobj = wxPyMake_wxObject(result, (bool)0);
43653 }
43654 return resultobj;
43655 fail:
43656 return NULL;
43657 }
43658
43659
43660 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43661 PyObject *resultobj = 0;
43662 wxMenu *arg1 = (wxMenu *) 0 ;
43663 size_t arg2 ;
43664 wxMenuItem *result = 0 ;
43665 void *argp1 = 0 ;
43666 int res1 = 0 ;
43667 size_t val2 ;
43668 int ecode2 = 0 ;
43669 PyObject * obj0 = 0 ;
43670 PyObject * obj1 = 0 ;
43671 char * kwnames[] = {
43672 (char *) "self",(char *) "position", NULL
43673 };
43674
43675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43677 if (!SWIG_IsOK(res1)) {
43678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43679 }
43680 arg1 = reinterpret_cast< wxMenu * >(argp1);
43681 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43682 if (!SWIG_IsOK(ecode2)) {
43683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43684 }
43685 arg2 = static_cast< size_t >(val2);
43686 {
43687 PyThreadState* __tstate = wxPyBeginAllowThreads();
43688 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43689 wxPyEndAllowThreads(__tstate);
43690 if (PyErr_Occurred()) SWIG_fail;
43691 }
43692 {
43693 resultobj = wxPyMake_wxObject(result, (bool)0);
43694 }
43695 return resultobj;
43696 fail:
43697 return NULL;
43698 }
43699
43700
43701 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43702 PyObject *resultobj = 0;
43703 wxMenu *arg1 = (wxMenu *) 0 ;
43704 int arg2 ;
43705 bool arg3 ;
43706 void *argp1 = 0 ;
43707 int res1 = 0 ;
43708 int val2 ;
43709 int ecode2 = 0 ;
43710 bool val3 ;
43711 int ecode3 = 0 ;
43712 PyObject * obj0 = 0 ;
43713 PyObject * obj1 = 0 ;
43714 PyObject * obj2 = 0 ;
43715 char * kwnames[] = {
43716 (char *) "self",(char *) "id",(char *) "enable", NULL
43717 };
43718
43719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43721 if (!SWIG_IsOK(res1)) {
43722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43723 }
43724 arg1 = reinterpret_cast< wxMenu * >(argp1);
43725 ecode2 = SWIG_AsVal_int(obj1, &val2);
43726 if (!SWIG_IsOK(ecode2)) {
43727 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43728 }
43729 arg2 = static_cast< int >(val2);
43730 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43731 if (!SWIG_IsOK(ecode3)) {
43732 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43733 }
43734 arg3 = static_cast< bool >(val3);
43735 {
43736 PyThreadState* __tstate = wxPyBeginAllowThreads();
43737 (arg1)->Enable(arg2,arg3);
43738 wxPyEndAllowThreads(__tstate);
43739 if (PyErr_Occurred()) SWIG_fail;
43740 }
43741 resultobj = SWIG_Py_Void();
43742 return resultobj;
43743 fail:
43744 return NULL;
43745 }
43746
43747
43748 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43749 PyObject *resultobj = 0;
43750 wxMenu *arg1 = (wxMenu *) 0 ;
43751 int arg2 ;
43752 bool result;
43753 void *argp1 = 0 ;
43754 int res1 = 0 ;
43755 int val2 ;
43756 int ecode2 = 0 ;
43757 PyObject * obj0 = 0 ;
43758 PyObject * obj1 = 0 ;
43759 char * kwnames[] = {
43760 (char *) "self",(char *) "id", NULL
43761 };
43762
43763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43765 if (!SWIG_IsOK(res1)) {
43766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43767 }
43768 arg1 = reinterpret_cast< wxMenu * >(argp1);
43769 ecode2 = SWIG_AsVal_int(obj1, &val2);
43770 if (!SWIG_IsOK(ecode2)) {
43771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43772 }
43773 arg2 = static_cast< int >(val2);
43774 {
43775 PyThreadState* __tstate = wxPyBeginAllowThreads();
43776 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43777 wxPyEndAllowThreads(__tstate);
43778 if (PyErr_Occurred()) SWIG_fail;
43779 }
43780 {
43781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43782 }
43783 return resultobj;
43784 fail:
43785 return NULL;
43786 }
43787
43788
43789 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43790 PyObject *resultobj = 0;
43791 wxMenu *arg1 = (wxMenu *) 0 ;
43792 int arg2 ;
43793 bool arg3 ;
43794 void *argp1 = 0 ;
43795 int res1 = 0 ;
43796 int val2 ;
43797 int ecode2 = 0 ;
43798 bool val3 ;
43799 int ecode3 = 0 ;
43800 PyObject * obj0 = 0 ;
43801 PyObject * obj1 = 0 ;
43802 PyObject * obj2 = 0 ;
43803 char * kwnames[] = {
43804 (char *) "self",(char *) "id",(char *) "check", NULL
43805 };
43806
43807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43809 if (!SWIG_IsOK(res1)) {
43810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43811 }
43812 arg1 = reinterpret_cast< wxMenu * >(argp1);
43813 ecode2 = SWIG_AsVal_int(obj1, &val2);
43814 if (!SWIG_IsOK(ecode2)) {
43815 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43816 }
43817 arg2 = static_cast< int >(val2);
43818 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43819 if (!SWIG_IsOK(ecode3)) {
43820 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43821 }
43822 arg3 = static_cast< bool >(val3);
43823 {
43824 PyThreadState* __tstate = wxPyBeginAllowThreads();
43825 (arg1)->Check(arg2,arg3);
43826 wxPyEndAllowThreads(__tstate);
43827 if (PyErr_Occurred()) SWIG_fail;
43828 }
43829 resultobj = SWIG_Py_Void();
43830 return resultobj;
43831 fail:
43832 return NULL;
43833 }
43834
43835
43836 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43837 PyObject *resultobj = 0;
43838 wxMenu *arg1 = (wxMenu *) 0 ;
43839 int arg2 ;
43840 bool result;
43841 void *argp1 = 0 ;
43842 int res1 = 0 ;
43843 int val2 ;
43844 int ecode2 = 0 ;
43845 PyObject * obj0 = 0 ;
43846 PyObject * obj1 = 0 ;
43847 char * kwnames[] = {
43848 (char *) "self",(char *) "id", NULL
43849 };
43850
43851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43853 if (!SWIG_IsOK(res1)) {
43854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43855 }
43856 arg1 = reinterpret_cast< wxMenu * >(argp1);
43857 ecode2 = SWIG_AsVal_int(obj1, &val2);
43858 if (!SWIG_IsOK(ecode2)) {
43859 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43860 }
43861 arg2 = static_cast< int >(val2);
43862 {
43863 PyThreadState* __tstate = wxPyBeginAllowThreads();
43864 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43865 wxPyEndAllowThreads(__tstate);
43866 if (PyErr_Occurred()) SWIG_fail;
43867 }
43868 {
43869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43870 }
43871 return resultobj;
43872 fail:
43873 return NULL;
43874 }
43875
43876
43877 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43878 PyObject *resultobj = 0;
43879 wxMenu *arg1 = (wxMenu *) 0 ;
43880 int arg2 ;
43881 wxString *arg3 = 0 ;
43882 void *argp1 = 0 ;
43883 int res1 = 0 ;
43884 int val2 ;
43885 int ecode2 = 0 ;
43886 bool temp3 = false ;
43887 PyObject * obj0 = 0 ;
43888 PyObject * obj1 = 0 ;
43889 PyObject * obj2 = 0 ;
43890 char * kwnames[] = {
43891 (char *) "self",(char *) "id",(char *) "label", NULL
43892 };
43893
43894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43896 if (!SWIG_IsOK(res1)) {
43897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43898 }
43899 arg1 = reinterpret_cast< wxMenu * >(argp1);
43900 ecode2 = SWIG_AsVal_int(obj1, &val2);
43901 if (!SWIG_IsOK(ecode2)) {
43902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43903 }
43904 arg2 = static_cast< int >(val2);
43905 {
43906 arg3 = wxString_in_helper(obj2);
43907 if (arg3 == NULL) SWIG_fail;
43908 temp3 = true;
43909 }
43910 {
43911 PyThreadState* __tstate = wxPyBeginAllowThreads();
43912 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43913 wxPyEndAllowThreads(__tstate);
43914 if (PyErr_Occurred()) SWIG_fail;
43915 }
43916 resultobj = SWIG_Py_Void();
43917 {
43918 if (temp3)
43919 delete arg3;
43920 }
43921 return resultobj;
43922 fail:
43923 {
43924 if (temp3)
43925 delete arg3;
43926 }
43927 return NULL;
43928 }
43929
43930
43931 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43932 PyObject *resultobj = 0;
43933 wxMenu *arg1 = (wxMenu *) 0 ;
43934 int arg2 ;
43935 wxString result;
43936 void *argp1 = 0 ;
43937 int res1 = 0 ;
43938 int val2 ;
43939 int ecode2 = 0 ;
43940 PyObject * obj0 = 0 ;
43941 PyObject * obj1 = 0 ;
43942 char * kwnames[] = {
43943 (char *) "self",(char *) "id", NULL
43944 };
43945
43946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43948 if (!SWIG_IsOK(res1)) {
43949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43950 }
43951 arg1 = reinterpret_cast< wxMenu * >(argp1);
43952 ecode2 = SWIG_AsVal_int(obj1, &val2);
43953 if (!SWIG_IsOK(ecode2)) {
43954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43955 }
43956 arg2 = static_cast< int >(val2);
43957 {
43958 PyThreadState* __tstate = wxPyBeginAllowThreads();
43959 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43960 wxPyEndAllowThreads(__tstate);
43961 if (PyErr_Occurred()) SWIG_fail;
43962 }
43963 {
43964 #if wxUSE_UNICODE
43965 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43966 #else
43967 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43968 #endif
43969 }
43970 return resultobj;
43971 fail:
43972 return NULL;
43973 }
43974
43975
43976 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43977 PyObject *resultobj = 0;
43978 wxMenu *arg1 = (wxMenu *) 0 ;
43979 int arg2 ;
43980 wxString *arg3 = 0 ;
43981 void *argp1 = 0 ;
43982 int res1 = 0 ;
43983 int val2 ;
43984 int ecode2 = 0 ;
43985 bool temp3 = false ;
43986 PyObject * obj0 = 0 ;
43987 PyObject * obj1 = 0 ;
43988 PyObject * obj2 = 0 ;
43989 char * kwnames[] = {
43990 (char *) "self",(char *) "id",(char *) "helpString", NULL
43991 };
43992
43993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43995 if (!SWIG_IsOK(res1)) {
43996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43997 }
43998 arg1 = reinterpret_cast< wxMenu * >(argp1);
43999 ecode2 = SWIG_AsVal_int(obj1, &val2);
44000 if (!SWIG_IsOK(ecode2)) {
44001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
44002 }
44003 arg2 = static_cast< int >(val2);
44004 {
44005 arg3 = wxString_in_helper(obj2);
44006 if (arg3 == NULL) SWIG_fail;
44007 temp3 = true;
44008 }
44009 {
44010 PyThreadState* __tstate = wxPyBeginAllowThreads();
44011 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
44012 wxPyEndAllowThreads(__tstate);
44013 if (PyErr_Occurred()) SWIG_fail;
44014 }
44015 resultobj = SWIG_Py_Void();
44016 {
44017 if (temp3)
44018 delete arg3;
44019 }
44020 return resultobj;
44021 fail:
44022 {
44023 if (temp3)
44024 delete arg3;
44025 }
44026 return NULL;
44027 }
44028
44029
44030 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44031 PyObject *resultobj = 0;
44032 wxMenu *arg1 = (wxMenu *) 0 ;
44033 int arg2 ;
44034 wxString result;
44035 void *argp1 = 0 ;
44036 int res1 = 0 ;
44037 int val2 ;
44038 int ecode2 = 0 ;
44039 PyObject * obj0 = 0 ;
44040 PyObject * obj1 = 0 ;
44041 char * kwnames[] = {
44042 (char *) "self",(char *) "id", NULL
44043 };
44044
44045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44047 if (!SWIG_IsOK(res1)) {
44048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44049 }
44050 arg1 = reinterpret_cast< wxMenu * >(argp1);
44051 ecode2 = SWIG_AsVal_int(obj1, &val2);
44052 if (!SWIG_IsOK(ecode2)) {
44053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44054 }
44055 arg2 = static_cast< int >(val2);
44056 {
44057 PyThreadState* __tstate = wxPyBeginAllowThreads();
44058 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44059 wxPyEndAllowThreads(__tstate);
44060 if (PyErr_Occurred()) SWIG_fail;
44061 }
44062 {
44063 #if wxUSE_UNICODE
44064 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44065 #else
44066 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44067 #endif
44068 }
44069 return resultobj;
44070 fail:
44071 return NULL;
44072 }
44073
44074
44075 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44076 PyObject *resultobj = 0;
44077 wxMenu *arg1 = (wxMenu *) 0 ;
44078 wxString *arg2 = 0 ;
44079 void *argp1 = 0 ;
44080 int res1 = 0 ;
44081 bool temp2 = false ;
44082 PyObject * obj0 = 0 ;
44083 PyObject * obj1 = 0 ;
44084 char * kwnames[] = {
44085 (char *) "self",(char *) "title", NULL
44086 };
44087
44088 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44089 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44090 if (!SWIG_IsOK(res1)) {
44091 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44092 }
44093 arg1 = reinterpret_cast< wxMenu * >(argp1);
44094 {
44095 arg2 = wxString_in_helper(obj1);
44096 if (arg2 == NULL) SWIG_fail;
44097 temp2 = true;
44098 }
44099 {
44100 PyThreadState* __tstate = wxPyBeginAllowThreads();
44101 (arg1)->SetTitle((wxString const &)*arg2);
44102 wxPyEndAllowThreads(__tstate);
44103 if (PyErr_Occurred()) SWIG_fail;
44104 }
44105 resultobj = SWIG_Py_Void();
44106 {
44107 if (temp2)
44108 delete arg2;
44109 }
44110 return resultobj;
44111 fail:
44112 {
44113 if (temp2)
44114 delete arg2;
44115 }
44116 return NULL;
44117 }
44118
44119
44120 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44121 PyObject *resultobj = 0;
44122 wxMenu *arg1 = (wxMenu *) 0 ;
44123 wxString result;
44124 void *argp1 = 0 ;
44125 int res1 = 0 ;
44126 PyObject *swig_obj[1] ;
44127
44128 if (!args) SWIG_fail;
44129 swig_obj[0] = args;
44130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44131 if (!SWIG_IsOK(res1)) {
44132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44133 }
44134 arg1 = reinterpret_cast< wxMenu * >(argp1);
44135 {
44136 PyThreadState* __tstate = wxPyBeginAllowThreads();
44137 result = ((wxMenu const *)arg1)->GetTitle();
44138 wxPyEndAllowThreads(__tstate);
44139 if (PyErr_Occurred()) SWIG_fail;
44140 }
44141 {
44142 #if wxUSE_UNICODE
44143 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44144 #else
44145 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44146 #endif
44147 }
44148 return resultobj;
44149 fail:
44150 return NULL;
44151 }
44152
44153
44154 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44155 PyObject *resultobj = 0;
44156 wxMenu *arg1 = (wxMenu *) 0 ;
44157 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44158 void *argp1 = 0 ;
44159 int res1 = 0 ;
44160 void *argp2 = 0 ;
44161 int res2 = 0 ;
44162 PyObject * obj0 = 0 ;
44163 PyObject * obj1 = 0 ;
44164 char * kwnames[] = {
44165 (char *) "self",(char *) "handler", NULL
44166 };
44167
44168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44170 if (!SWIG_IsOK(res1)) {
44171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44172 }
44173 arg1 = reinterpret_cast< wxMenu * >(argp1);
44174 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44175 if (!SWIG_IsOK(res2)) {
44176 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44177 }
44178 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44179 {
44180 PyThreadState* __tstate = wxPyBeginAllowThreads();
44181 (arg1)->SetEventHandler(arg2);
44182 wxPyEndAllowThreads(__tstate);
44183 if (PyErr_Occurred()) SWIG_fail;
44184 }
44185 resultobj = SWIG_Py_Void();
44186 return resultobj;
44187 fail:
44188 return NULL;
44189 }
44190
44191
44192 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44193 PyObject *resultobj = 0;
44194 wxMenu *arg1 = (wxMenu *) 0 ;
44195 wxEvtHandler *result = 0 ;
44196 void *argp1 = 0 ;
44197 int res1 = 0 ;
44198 PyObject *swig_obj[1] ;
44199
44200 if (!args) SWIG_fail;
44201 swig_obj[0] = args;
44202 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44203 if (!SWIG_IsOK(res1)) {
44204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44205 }
44206 arg1 = reinterpret_cast< wxMenu * >(argp1);
44207 {
44208 PyThreadState* __tstate = wxPyBeginAllowThreads();
44209 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44210 wxPyEndAllowThreads(__tstate);
44211 if (PyErr_Occurred()) SWIG_fail;
44212 }
44213 {
44214 resultobj = wxPyMake_wxObject(result, 0);
44215 }
44216 return resultobj;
44217 fail:
44218 return NULL;
44219 }
44220
44221
44222 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44223 PyObject *resultobj = 0;
44224 wxMenu *arg1 = (wxMenu *) 0 ;
44225 wxWindow *arg2 = (wxWindow *) 0 ;
44226 void *argp1 = 0 ;
44227 int res1 = 0 ;
44228 void *argp2 = 0 ;
44229 int res2 = 0 ;
44230 PyObject * obj0 = 0 ;
44231 PyObject * obj1 = 0 ;
44232 char * kwnames[] = {
44233 (char *) "self",(char *) "win", NULL
44234 };
44235
44236 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44237 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44238 if (!SWIG_IsOK(res1)) {
44239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44240 }
44241 arg1 = reinterpret_cast< wxMenu * >(argp1);
44242 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44243 if (!SWIG_IsOK(res2)) {
44244 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44245 }
44246 arg2 = reinterpret_cast< wxWindow * >(argp2);
44247 {
44248 PyThreadState* __tstate = wxPyBeginAllowThreads();
44249 (arg1)->SetInvokingWindow(arg2);
44250 wxPyEndAllowThreads(__tstate);
44251 if (PyErr_Occurred()) SWIG_fail;
44252 }
44253 resultobj = SWIG_Py_Void();
44254 return resultobj;
44255 fail:
44256 return NULL;
44257 }
44258
44259
44260 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44261 PyObject *resultobj = 0;
44262 wxMenu *arg1 = (wxMenu *) 0 ;
44263 wxWindow *result = 0 ;
44264 void *argp1 = 0 ;
44265 int res1 = 0 ;
44266 PyObject *swig_obj[1] ;
44267
44268 if (!args) SWIG_fail;
44269 swig_obj[0] = args;
44270 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44271 if (!SWIG_IsOK(res1)) {
44272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44273 }
44274 arg1 = reinterpret_cast< wxMenu * >(argp1);
44275 {
44276 PyThreadState* __tstate = wxPyBeginAllowThreads();
44277 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44278 wxPyEndAllowThreads(__tstate);
44279 if (PyErr_Occurred()) SWIG_fail;
44280 }
44281 {
44282 resultobj = wxPyMake_wxObject(result, 0);
44283 }
44284 return resultobj;
44285 fail:
44286 return NULL;
44287 }
44288
44289
44290 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44291 PyObject *resultobj = 0;
44292 wxMenu *arg1 = (wxMenu *) 0 ;
44293 long result;
44294 void *argp1 = 0 ;
44295 int res1 = 0 ;
44296 PyObject *swig_obj[1] ;
44297
44298 if (!args) SWIG_fail;
44299 swig_obj[0] = args;
44300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44301 if (!SWIG_IsOK(res1)) {
44302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44303 }
44304 arg1 = reinterpret_cast< wxMenu * >(argp1);
44305 {
44306 PyThreadState* __tstate = wxPyBeginAllowThreads();
44307 result = (long)((wxMenu const *)arg1)->GetStyle();
44308 wxPyEndAllowThreads(__tstate);
44309 if (PyErr_Occurred()) SWIG_fail;
44310 }
44311 resultobj = SWIG_From_long(static_cast< long >(result));
44312 return resultobj;
44313 fail:
44314 return NULL;
44315 }
44316
44317
44318 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44319 PyObject *resultobj = 0;
44320 wxMenu *arg1 = (wxMenu *) 0 ;
44321 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44322 void *argp1 = 0 ;
44323 int res1 = 0 ;
44324 void *argp2 = 0 ;
44325 int res2 = 0 ;
44326 PyObject * obj0 = 0 ;
44327 PyObject * obj1 = 0 ;
44328 char * kwnames[] = {
44329 (char *) "self",(char *) "source", NULL
44330 };
44331
44332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44334 if (!SWIG_IsOK(res1)) {
44335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44336 }
44337 arg1 = reinterpret_cast< wxMenu * >(argp1);
44338 if (obj1) {
44339 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44340 if (!SWIG_IsOK(res2)) {
44341 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44342 }
44343 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44344 }
44345 {
44346 PyThreadState* __tstate = wxPyBeginAllowThreads();
44347 (arg1)->UpdateUI(arg2);
44348 wxPyEndAllowThreads(__tstate);
44349 if (PyErr_Occurred()) SWIG_fail;
44350 }
44351 resultobj = SWIG_Py_Void();
44352 return resultobj;
44353 fail:
44354 return NULL;
44355 }
44356
44357
44358 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44359 PyObject *resultobj = 0;
44360 wxMenu *arg1 = (wxMenu *) 0 ;
44361 wxMenuBar *result = 0 ;
44362 void *argp1 = 0 ;
44363 int res1 = 0 ;
44364 PyObject *swig_obj[1] ;
44365
44366 if (!args) SWIG_fail;
44367 swig_obj[0] = args;
44368 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44369 if (!SWIG_IsOK(res1)) {
44370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44371 }
44372 arg1 = reinterpret_cast< wxMenu * >(argp1);
44373 {
44374 PyThreadState* __tstate = wxPyBeginAllowThreads();
44375 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44376 wxPyEndAllowThreads(__tstate);
44377 if (PyErr_Occurred()) SWIG_fail;
44378 }
44379 {
44380 resultobj = wxPyMake_wxObject(result, (bool)0);
44381 }
44382 return resultobj;
44383 fail:
44384 return NULL;
44385 }
44386
44387
44388 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44389 PyObject *resultobj = 0;
44390 wxMenu *arg1 = (wxMenu *) 0 ;
44391 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44392 void *argp1 = 0 ;
44393 int res1 = 0 ;
44394 void *argp2 = 0 ;
44395 int res2 = 0 ;
44396 PyObject * obj0 = 0 ;
44397 PyObject * obj1 = 0 ;
44398 char * kwnames[] = {
44399 (char *) "self",(char *) "menubar", NULL
44400 };
44401
44402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44404 if (!SWIG_IsOK(res1)) {
44405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44406 }
44407 arg1 = reinterpret_cast< wxMenu * >(argp1);
44408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44409 if (!SWIG_IsOK(res2)) {
44410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44411 }
44412 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44413 {
44414 PyThreadState* __tstate = wxPyBeginAllowThreads();
44415 (arg1)->Attach(arg2);
44416 wxPyEndAllowThreads(__tstate);
44417 if (PyErr_Occurred()) SWIG_fail;
44418 }
44419 resultobj = SWIG_Py_Void();
44420 return resultobj;
44421 fail:
44422 return NULL;
44423 }
44424
44425
44426 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44427 PyObject *resultobj = 0;
44428 wxMenu *arg1 = (wxMenu *) 0 ;
44429 void *argp1 = 0 ;
44430 int res1 = 0 ;
44431 PyObject *swig_obj[1] ;
44432
44433 if (!args) SWIG_fail;
44434 swig_obj[0] = args;
44435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44436 if (!SWIG_IsOK(res1)) {
44437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44438 }
44439 arg1 = reinterpret_cast< wxMenu * >(argp1);
44440 {
44441 PyThreadState* __tstate = wxPyBeginAllowThreads();
44442 (arg1)->Detach();
44443 wxPyEndAllowThreads(__tstate);
44444 if (PyErr_Occurred()) SWIG_fail;
44445 }
44446 resultobj = SWIG_Py_Void();
44447 return resultobj;
44448 fail:
44449 return NULL;
44450 }
44451
44452
44453 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44454 PyObject *resultobj = 0;
44455 wxMenu *arg1 = (wxMenu *) 0 ;
44456 bool result;
44457 void *argp1 = 0 ;
44458 int res1 = 0 ;
44459 PyObject *swig_obj[1] ;
44460
44461 if (!args) SWIG_fail;
44462 swig_obj[0] = args;
44463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44464 if (!SWIG_IsOK(res1)) {
44465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44466 }
44467 arg1 = reinterpret_cast< wxMenu * >(argp1);
44468 {
44469 PyThreadState* __tstate = wxPyBeginAllowThreads();
44470 result = (bool)((wxMenu const *)arg1)->IsAttached();
44471 wxPyEndAllowThreads(__tstate);
44472 if (PyErr_Occurred()) SWIG_fail;
44473 }
44474 {
44475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44476 }
44477 return resultobj;
44478 fail:
44479 return NULL;
44480 }
44481
44482
44483 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44484 PyObject *resultobj = 0;
44485 wxMenu *arg1 = (wxMenu *) 0 ;
44486 wxMenu *arg2 = (wxMenu *) 0 ;
44487 void *argp1 = 0 ;
44488 int res1 = 0 ;
44489 void *argp2 = 0 ;
44490 int res2 = 0 ;
44491 PyObject * obj0 = 0 ;
44492 PyObject * obj1 = 0 ;
44493 char * kwnames[] = {
44494 (char *) "self",(char *) "parent", NULL
44495 };
44496
44497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44498 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44499 if (!SWIG_IsOK(res1)) {
44500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44501 }
44502 arg1 = reinterpret_cast< wxMenu * >(argp1);
44503 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44504 if (!SWIG_IsOK(res2)) {
44505 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44506 }
44507 arg2 = reinterpret_cast< wxMenu * >(argp2);
44508 {
44509 PyThreadState* __tstate = wxPyBeginAllowThreads();
44510 (arg1)->SetParent(arg2);
44511 wxPyEndAllowThreads(__tstate);
44512 if (PyErr_Occurred()) SWIG_fail;
44513 }
44514 resultobj = SWIG_Py_Void();
44515 return resultobj;
44516 fail:
44517 return NULL;
44518 }
44519
44520
44521 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44522 PyObject *resultobj = 0;
44523 wxMenu *arg1 = (wxMenu *) 0 ;
44524 wxMenu *result = 0 ;
44525 void *argp1 = 0 ;
44526 int res1 = 0 ;
44527 PyObject *swig_obj[1] ;
44528
44529 if (!args) SWIG_fail;
44530 swig_obj[0] = args;
44531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44532 if (!SWIG_IsOK(res1)) {
44533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44534 }
44535 arg1 = reinterpret_cast< wxMenu * >(argp1);
44536 {
44537 PyThreadState* __tstate = wxPyBeginAllowThreads();
44538 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44539 wxPyEndAllowThreads(__tstate);
44540 if (PyErr_Occurred()) SWIG_fail;
44541 }
44542 {
44543 resultobj = wxPyMake_wxObject(result, 0);
44544 }
44545 return resultobj;
44546 fail:
44547 return NULL;
44548 }
44549
44550
44551 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44552 PyObject *obj;
44553 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44554 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44555 return SWIG_Py_Void();
44556 }
44557
44558 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44559 return SWIG_Python_InitShadowInstance(args);
44560 }
44561
44562 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44563 PyObject *resultobj = 0;
44564 long arg1 = (long) 0 ;
44565 wxMenuBar *result = 0 ;
44566 long val1 ;
44567 int ecode1 = 0 ;
44568 PyObject * obj0 = 0 ;
44569 char * kwnames[] = {
44570 (char *) "style", NULL
44571 };
44572
44573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44574 if (obj0) {
44575 ecode1 = SWIG_AsVal_long(obj0, &val1);
44576 if (!SWIG_IsOK(ecode1)) {
44577 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44578 }
44579 arg1 = static_cast< long >(val1);
44580 }
44581 {
44582 if (!wxPyCheckForApp()) SWIG_fail;
44583 PyThreadState* __tstate = wxPyBeginAllowThreads();
44584 result = (wxMenuBar *)new wxMenuBar(arg1);
44585 wxPyEndAllowThreads(__tstate);
44586 if (PyErr_Occurred()) SWIG_fail;
44587 }
44588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44589 return resultobj;
44590 fail:
44591 return NULL;
44592 }
44593
44594
44595 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44596 PyObject *resultobj = 0;
44597 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44598 wxMenu *arg2 = (wxMenu *) 0 ;
44599 wxString *arg3 = 0 ;
44600 bool result;
44601 void *argp1 = 0 ;
44602 int res1 = 0 ;
44603 void *argp2 = 0 ;
44604 int res2 = 0 ;
44605 bool temp3 = false ;
44606 PyObject * obj0 = 0 ;
44607 PyObject * obj1 = 0 ;
44608 PyObject * obj2 = 0 ;
44609 char * kwnames[] = {
44610 (char *) "self",(char *) "menu",(char *) "title", NULL
44611 };
44612
44613 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44614 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44615 if (!SWIG_IsOK(res1)) {
44616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44617 }
44618 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44619 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44620 if (!SWIG_IsOK(res2)) {
44621 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44622 }
44623 arg2 = reinterpret_cast< wxMenu * >(argp2);
44624 {
44625 arg3 = wxString_in_helper(obj2);
44626 if (arg3 == NULL) SWIG_fail;
44627 temp3 = true;
44628 }
44629 {
44630 PyThreadState* __tstate = wxPyBeginAllowThreads();
44631 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44632 wxPyEndAllowThreads(__tstate);
44633 if (PyErr_Occurred()) SWIG_fail;
44634 }
44635 {
44636 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44637 }
44638 {
44639 if (temp3)
44640 delete arg3;
44641 }
44642 return resultobj;
44643 fail:
44644 {
44645 if (temp3)
44646 delete arg3;
44647 }
44648 return NULL;
44649 }
44650
44651
44652 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44653 PyObject *resultobj = 0;
44654 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44655 size_t arg2 ;
44656 wxMenu *arg3 = (wxMenu *) 0 ;
44657 wxString *arg4 = 0 ;
44658 bool result;
44659 void *argp1 = 0 ;
44660 int res1 = 0 ;
44661 size_t val2 ;
44662 int ecode2 = 0 ;
44663 void *argp3 = 0 ;
44664 int res3 = 0 ;
44665 bool temp4 = false ;
44666 PyObject * obj0 = 0 ;
44667 PyObject * obj1 = 0 ;
44668 PyObject * obj2 = 0 ;
44669 PyObject * obj3 = 0 ;
44670 char * kwnames[] = {
44671 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44672 };
44673
44674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44676 if (!SWIG_IsOK(res1)) {
44677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44678 }
44679 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44680 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44681 if (!SWIG_IsOK(ecode2)) {
44682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44683 }
44684 arg2 = static_cast< size_t >(val2);
44685 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44686 if (!SWIG_IsOK(res3)) {
44687 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44688 }
44689 arg3 = reinterpret_cast< wxMenu * >(argp3);
44690 {
44691 arg4 = wxString_in_helper(obj3);
44692 if (arg4 == NULL) SWIG_fail;
44693 temp4 = true;
44694 }
44695 {
44696 PyThreadState* __tstate = wxPyBeginAllowThreads();
44697 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44698 wxPyEndAllowThreads(__tstate);
44699 if (PyErr_Occurred()) SWIG_fail;
44700 }
44701 {
44702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44703 }
44704 {
44705 if (temp4)
44706 delete arg4;
44707 }
44708 return resultobj;
44709 fail:
44710 {
44711 if (temp4)
44712 delete arg4;
44713 }
44714 return NULL;
44715 }
44716
44717
44718 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44719 PyObject *resultobj = 0;
44720 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44721 size_t result;
44722 void *argp1 = 0 ;
44723 int res1 = 0 ;
44724 PyObject *swig_obj[1] ;
44725
44726 if (!args) SWIG_fail;
44727 swig_obj[0] = args;
44728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44729 if (!SWIG_IsOK(res1)) {
44730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44731 }
44732 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44733 {
44734 PyThreadState* __tstate = wxPyBeginAllowThreads();
44735 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44736 wxPyEndAllowThreads(__tstate);
44737 if (PyErr_Occurred()) SWIG_fail;
44738 }
44739 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44740 return resultobj;
44741 fail:
44742 return NULL;
44743 }
44744
44745
44746 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44747 PyObject *resultobj = 0;
44748 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44749 size_t arg2 ;
44750 wxMenu *result = 0 ;
44751 void *argp1 = 0 ;
44752 int res1 = 0 ;
44753 size_t val2 ;
44754 int ecode2 = 0 ;
44755 PyObject * obj0 = 0 ;
44756 PyObject * obj1 = 0 ;
44757 char * kwnames[] = {
44758 (char *) "self",(char *) "pos", NULL
44759 };
44760
44761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44762 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44763 if (!SWIG_IsOK(res1)) {
44764 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44765 }
44766 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44767 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44768 if (!SWIG_IsOK(ecode2)) {
44769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44770 }
44771 arg2 = static_cast< size_t >(val2);
44772 {
44773 PyThreadState* __tstate = wxPyBeginAllowThreads();
44774 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44775 wxPyEndAllowThreads(__tstate);
44776 if (PyErr_Occurred()) SWIG_fail;
44777 }
44778 {
44779 resultobj = wxPyMake_wxObject(result, 0);
44780 }
44781 return resultobj;
44782 fail:
44783 return NULL;
44784 }
44785
44786
44787 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44788 PyObject *resultobj = 0;
44789 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44790 size_t arg2 ;
44791 wxMenu *arg3 = (wxMenu *) 0 ;
44792 wxString *arg4 = 0 ;
44793 wxMenu *result = 0 ;
44794 void *argp1 = 0 ;
44795 int res1 = 0 ;
44796 size_t val2 ;
44797 int ecode2 = 0 ;
44798 void *argp3 = 0 ;
44799 int res3 = 0 ;
44800 bool temp4 = false ;
44801 PyObject * obj0 = 0 ;
44802 PyObject * obj1 = 0 ;
44803 PyObject * obj2 = 0 ;
44804 PyObject * obj3 = 0 ;
44805 char * kwnames[] = {
44806 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44807 };
44808
44809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44811 if (!SWIG_IsOK(res1)) {
44812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44813 }
44814 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44815 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44816 if (!SWIG_IsOK(ecode2)) {
44817 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44818 }
44819 arg2 = static_cast< size_t >(val2);
44820 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44821 if (!SWIG_IsOK(res3)) {
44822 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44823 }
44824 arg3 = reinterpret_cast< wxMenu * >(argp3);
44825 {
44826 arg4 = wxString_in_helper(obj3);
44827 if (arg4 == NULL) SWIG_fail;
44828 temp4 = true;
44829 }
44830 {
44831 PyThreadState* __tstate = wxPyBeginAllowThreads();
44832 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44833 wxPyEndAllowThreads(__tstate);
44834 if (PyErr_Occurred()) SWIG_fail;
44835 }
44836 {
44837 resultobj = wxPyMake_wxObject(result, 0);
44838 }
44839 {
44840 if (temp4)
44841 delete arg4;
44842 }
44843 return resultobj;
44844 fail:
44845 {
44846 if (temp4)
44847 delete arg4;
44848 }
44849 return NULL;
44850 }
44851
44852
44853 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44854 PyObject *resultobj = 0;
44855 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44856 size_t arg2 ;
44857 wxMenu *result = 0 ;
44858 void *argp1 = 0 ;
44859 int res1 = 0 ;
44860 size_t val2 ;
44861 int ecode2 = 0 ;
44862 PyObject * obj0 = 0 ;
44863 PyObject * obj1 = 0 ;
44864 char * kwnames[] = {
44865 (char *) "self",(char *) "pos", NULL
44866 };
44867
44868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44870 if (!SWIG_IsOK(res1)) {
44871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44872 }
44873 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44874 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44875 if (!SWIG_IsOK(ecode2)) {
44876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44877 }
44878 arg2 = static_cast< size_t >(val2);
44879 {
44880 PyThreadState* __tstate = wxPyBeginAllowThreads();
44881 result = (wxMenu *)(arg1)->Remove(arg2);
44882 wxPyEndAllowThreads(__tstate);
44883 if (PyErr_Occurred()) SWIG_fail;
44884 }
44885 {
44886 resultobj = wxPyMake_wxObject(result, 0);
44887 }
44888 return resultobj;
44889 fail:
44890 return NULL;
44891 }
44892
44893
44894 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44895 PyObject *resultobj = 0;
44896 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44897 size_t arg2 ;
44898 bool arg3 ;
44899 void *argp1 = 0 ;
44900 int res1 = 0 ;
44901 size_t val2 ;
44902 int ecode2 = 0 ;
44903 bool val3 ;
44904 int ecode3 = 0 ;
44905 PyObject * obj0 = 0 ;
44906 PyObject * obj1 = 0 ;
44907 PyObject * obj2 = 0 ;
44908 char * kwnames[] = {
44909 (char *) "self",(char *) "pos",(char *) "enable", NULL
44910 };
44911
44912 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44913 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44914 if (!SWIG_IsOK(res1)) {
44915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44916 }
44917 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44918 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44919 if (!SWIG_IsOK(ecode2)) {
44920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44921 }
44922 arg2 = static_cast< size_t >(val2);
44923 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44924 if (!SWIG_IsOK(ecode3)) {
44925 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44926 }
44927 arg3 = static_cast< bool >(val3);
44928 {
44929 PyThreadState* __tstate = wxPyBeginAllowThreads();
44930 (arg1)->EnableTop(arg2,arg3);
44931 wxPyEndAllowThreads(__tstate);
44932 if (PyErr_Occurred()) SWIG_fail;
44933 }
44934 resultobj = SWIG_Py_Void();
44935 return resultobj;
44936 fail:
44937 return NULL;
44938 }
44939
44940
44941 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44942 PyObject *resultobj = 0;
44943 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44944 size_t arg2 ;
44945 bool result;
44946 void *argp1 = 0 ;
44947 int res1 = 0 ;
44948 size_t val2 ;
44949 int ecode2 = 0 ;
44950 PyObject * obj0 = 0 ;
44951 PyObject * obj1 = 0 ;
44952 char * kwnames[] = {
44953 (char *) "self",(char *) "pos", NULL
44954 };
44955
44956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44958 if (!SWIG_IsOK(res1)) {
44959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44960 }
44961 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44962 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44963 if (!SWIG_IsOK(ecode2)) {
44964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44965 }
44966 arg2 = static_cast< size_t >(val2);
44967 {
44968 PyThreadState* __tstate = wxPyBeginAllowThreads();
44969 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44970 wxPyEndAllowThreads(__tstate);
44971 if (PyErr_Occurred()) SWIG_fail;
44972 }
44973 {
44974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44975 }
44976 return resultobj;
44977 fail:
44978 return NULL;
44979 }
44980
44981
44982 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44983 PyObject *resultobj = 0;
44984 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44985 size_t arg2 ;
44986 wxString *arg3 = 0 ;
44987 void *argp1 = 0 ;
44988 int res1 = 0 ;
44989 size_t val2 ;
44990 int ecode2 = 0 ;
44991 bool temp3 = false ;
44992 PyObject * obj0 = 0 ;
44993 PyObject * obj1 = 0 ;
44994 PyObject * obj2 = 0 ;
44995 char * kwnames[] = {
44996 (char *) "self",(char *) "pos",(char *) "label", NULL
44997 };
44998
44999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45001 if (!SWIG_IsOK(res1)) {
45002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45003 }
45004 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45005 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45006 if (!SWIG_IsOK(ecode2)) {
45007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45008 }
45009 arg2 = static_cast< size_t >(val2);
45010 {
45011 arg3 = wxString_in_helper(obj2);
45012 if (arg3 == NULL) SWIG_fail;
45013 temp3 = true;
45014 }
45015 {
45016 PyThreadState* __tstate = wxPyBeginAllowThreads();
45017 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
45018 wxPyEndAllowThreads(__tstate);
45019 if (PyErr_Occurred()) SWIG_fail;
45020 }
45021 resultobj = SWIG_Py_Void();
45022 {
45023 if (temp3)
45024 delete arg3;
45025 }
45026 return resultobj;
45027 fail:
45028 {
45029 if (temp3)
45030 delete arg3;
45031 }
45032 return NULL;
45033 }
45034
45035
45036 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45037 PyObject *resultobj = 0;
45038 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45039 size_t arg2 ;
45040 wxString result;
45041 void *argp1 = 0 ;
45042 int res1 = 0 ;
45043 size_t val2 ;
45044 int ecode2 = 0 ;
45045 PyObject * obj0 = 0 ;
45046 PyObject * obj1 = 0 ;
45047 char * kwnames[] = {
45048 (char *) "self",(char *) "pos", NULL
45049 };
45050
45051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45053 if (!SWIG_IsOK(res1)) {
45054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45055 }
45056 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45057 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45058 if (!SWIG_IsOK(ecode2)) {
45059 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45060 }
45061 arg2 = static_cast< size_t >(val2);
45062 {
45063 PyThreadState* __tstate = wxPyBeginAllowThreads();
45064 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45065 wxPyEndAllowThreads(__tstate);
45066 if (PyErr_Occurred()) SWIG_fail;
45067 }
45068 {
45069 #if wxUSE_UNICODE
45070 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45071 #else
45072 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45073 #endif
45074 }
45075 return resultobj;
45076 fail:
45077 return NULL;
45078 }
45079
45080
45081 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45082 PyObject *resultobj = 0;
45083 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45084 wxString *arg2 = 0 ;
45085 wxString *arg3 = 0 ;
45086 int result;
45087 void *argp1 = 0 ;
45088 int res1 = 0 ;
45089 bool temp2 = false ;
45090 bool temp3 = false ;
45091 PyObject * obj0 = 0 ;
45092 PyObject * obj1 = 0 ;
45093 PyObject * obj2 = 0 ;
45094 char * kwnames[] = {
45095 (char *) "self",(char *) "menu",(char *) "item", NULL
45096 };
45097
45098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45100 if (!SWIG_IsOK(res1)) {
45101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45102 }
45103 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45104 {
45105 arg2 = wxString_in_helper(obj1);
45106 if (arg2 == NULL) SWIG_fail;
45107 temp2 = true;
45108 }
45109 {
45110 arg3 = wxString_in_helper(obj2);
45111 if (arg3 == NULL) SWIG_fail;
45112 temp3 = true;
45113 }
45114 {
45115 PyThreadState* __tstate = wxPyBeginAllowThreads();
45116 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45117 wxPyEndAllowThreads(__tstate);
45118 if (PyErr_Occurred()) SWIG_fail;
45119 }
45120 resultobj = SWIG_From_int(static_cast< int >(result));
45121 {
45122 if (temp2)
45123 delete arg2;
45124 }
45125 {
45126 if (temp3)
45127 delete arg3;
45128 }
45129 return resultobj;
45130 fail:
45131 {
45132 if (temp2)
45133 delete arg2;
45134 }
45135 {
45136 if (temp3)
45137 delete arg3;
45138 }
45139 return NULL;
45140 }
45141
45142
45143 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45144 PyObject *resultobj = 0;
45145 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45146 int arg2 ;
45147 wxMenuItem *result = 0 ;
45148 void *argp1 = 0 ;
45149 int res1 = 0 ;
45150 int val2 ;
45151 int ecode2 = 0 ;
45152 PyObject * obj0 = 0 ;
45153 PyObject * obj1 = 0 ;
45154 char * kwnames[] = {
45155 (char *) "self",(char *) "id", NULL
45156 };
45157
45158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45160 if (!SWIG_IsOK(res1)) {
45161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45162 }
45163 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45164 ecode2 = SWIG_AsVal_int(obj1, &val2);
45165 if (!SWIG_IsOK(ecode2)) {
45166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45167 }
45168 arg2 = static_cast< int >(val2);
45169 {
45170 PyThreadState* __tstate = wxPyBeginAllowThreads();
45171 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45172 wxPyEndAllowThreads(__tstate);
45173 if (PyErr_Occurred()) SWIG_fail;
45174 }
45175 {
45176 resultobj = wxPyMake_wxObject(result, (bool)0);
45177 }
45178 return resultobj;
45179 fail:
45180 return NULL;
45181 }
45182
45183
45184 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45185 PyObject *resultobj = 0;
45186 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45187 wxString *arg2 = 0 ;
45188 int result;
45189 void *argp1 = 0 ;
45190 int res1 = 0 ;
45191 bool temp2 = false ;
45192 PyObject * obj0 = 0 ;
45193 PyObject * obj1 = 0 ;
45194 char * kwnames[] = {
45195 (char *) "self",(char *) "title", NULL
45196 };
45197
45198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45200 if (!SWIG_IsOK(res1)) {
45201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45202 }
45203 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45204 {
45205 arg2 = wxString_in_helper(obj1);
45206 if (arg2 == NULL) SWIG_fail;
45207 temp2 = true;
45208 }
45209 {
45210 PyThreadState* __tstate = wxPyBeginAllowThreads();
45211 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45212 wxPyEndAllowThreads(__tstate);
45213 if (PyErr_Occurred()) SWIG_fail;
45214 }
45215 resultobj = SWIG_From_int(static_cast< int >(result));
45216 {
45217 if (temp2)
45218 delete arg2;
45219 }
45220 return resultobj;
45221 fail:
45222 {
45223 if (temp2)
45224 delete arg2;
45225 }
45226 return NULL;
45227 }
45228
45229
45230 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45231 PyObject *resultobj = 0;
45232 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45233 int arg2 ;
45234 bool arg3 ;
45235 void *argp1 = 0 ;
45236 int res1 = 0 ;
45237 int val2 ;
45238 int ecode2 = 0 ;
45239 bool val3 ;
45240 int ecode3 = 0 ;
45241 PyObject * obj0 = 0 ;
45242 PyObject * obj1 = 0 ;
45243 PyObject * obj2 = 0 ;
45244 char * kwnames[] = {
45245 (char *) "self",(char *) "id",(char *) "enable", NULL
45246 };
45247
45248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45250 if (!SWIG_IsOK(res1)) {
45251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45252 }
45253 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45254 ecode2 = SWIG_AsVal_int(obj1, &val2);
45255 if (!SWIG_IsOK(ecode2)) {
45256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45257 }
45258 arg2 = static_cast< int >(val2);
45259 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45260 if (!SWIG_IsOK(ecode3)) {
45261 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45262 }
45263 arg3 = static_cast< bool >(val3);
45264 {
45265 PyThreadState* __tstate = wxPyBeginAllowThreads();
45266 (arg1)->Enable(arg2,arg3);
45267 wxPyEndAllowThreads(__tstate);
45268 if (PyErr_Occurred()) SWIG_fail;
45269 }
45270 resultobj = SWIG_Py_Void();
45271 return resultobj;
45272 fail:
45273 return NULL;
45274 }
45275
45276
45277 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45278 PyObject *resultobj = 0;
45279 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45280 int arg2 ;
45281 bool arg3 ;
45282 void *argp1 = 0 ;
45283 int res1 = 0 ;
45284 int val2 ;
45285 int ecode2 = 0 ;
45286 bool val3 ;
45287 int ecode3 = 0 ;
45288 PyObject * obj0 = 0 ;
45289 PyObject * obj1 = 0 ;
45290 PyObject * obj2 = 0 ;
45291 char * kwnames[] = {
45292 (char *) "self",(char *) "id",(char *) "check", NULL
45293 };
45294
45295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45297 if (!SWIG_IsOK(res1)) {
45298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45299 }
45300 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45301 ecode2 = SWIG_AsVal_int(obj1, &val2);
45302 if (!SWIG_IsOK(ecode2)) {
45303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45304 }
45305 arg2 = static_cast< int >(val2);
45306 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45307 if (!SWIG_IsOK(ecode3)) {
45308 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45309 }
45310 arg3 = static_cast< bool >(val3);
45311 {
45312 PyThreadState* __tstate = wxPyBeginAllowThreads();
45313 (arg1)->Check(arg2,arg3);
45314 wxPyEndAllowThreads(__tstate);
45315 if (PyErr_Occurred()) SWIG_fail;
45316 }
45317 resultobj = SWIG_Py_Void();
45318 return resultobj;
45319 fail:
45320 return NULL;
45321 }
45322
45323
45324 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45325 PyObject *resultobj = 0;
45326 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45327 int arg2 ;
45328 bool result;
45329 void *argp1 = 0 ;
45330 int res1 = 0 ;
45331 int val2 ;
45332 int ecode2 = 0 ;
45333 PyObject * obj0 = 0 ;
45334 PyObject * obj1 = 0 ;
45335 char * kwnames[] = {
45336 (char *) "self",(char *) "id", NULL
45337 };
45338
45339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45341 if (!SWIG_IsOK(res1)) {
45342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45343 }
45344 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45345 ecode2 = SWIG_AsVal_int(obj1, &val2);
45346 if (!SWIG_IsOK(ecode2)) {
45347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45348 }
45349 arg2 = static_cast< int >(val2);
45350 {
45351 PyThreadState* __tstate = wxPyBeginAllowThreads();
45352 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45353 wxPyEndAllowThreads(__tstate);
45354 if (PyErr_Occurred()) SWIG_fail;
45355 }
45356 {
45357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45358 }
45359 return resultobj;
45360 fail:
45361 return NULL;
45362 }
45363
45364
45365 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45366 PyObject *resultobj = 0;
45367 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45368 int arg2 ;
45369 bool result;
45370 void *argp1 = 0 ;
45371 int res1 = 0 ;
45372 int val2 ;
45373 int ecode2 = 0 ;
45374 PyObject * obj0 = 0 ;
45375 PyObject * obj1 = 0 ;
45376 char * kwnames[] = {
45377 (char *) "self",(char *) "id", NULL
45378 };
45379
45380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45382 if (!SWIG_IsOK(res1)) {
45383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45384 }
45385 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45386 ecode2 = SWIG_AsVal_int(obj1, &val2);
45387 if (!SWIG_IsOK(ecode2)) {
45388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45389 }
45390 arg2 = static_cast< int >(val2);
45391 {
45392 PyThreadState* __tstate = wxPyBeginAllowThreads();
45393 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45394 wxPyEndAllowThreads(__tstate);
45395 if (PyErr_Occurred()) SWIG_fail;
45396 }
45397 {
45398 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45399 }
45400 return resultobj;
45401 fail:
45402 return NULL;
45403 }
45404
45405
45406 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45407 PyObject *resultobj = 0;
45408 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45409 int arg2 ;
45410 wxString *arg3 = 0 ;
45411 void *argp1 = 0 ;
45412 int res1 = 0 ;
45413 int val2 ;
45414 int ecode2 = 0 ;
45415 bool temp3 = false ;
45416 PyObject * obj0 = 0 ;
45417 PyObject * obj1 = 0 ;
45418 PyObject * obj2 = 0 ;
45419 char * kwnames[] = {
45420 (char *) "self",(char *) "id",(char *) "label", NULL
45421 };
45422
45423 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45424 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45425 if (!SWIG_IsOK(res1)) {
45426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45427 }
45428 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45429 ecode2 = SWIG_AsVal_int(obj1, &val2);
45430 if (!SWIG_IsOK(ecode2)) {
45431 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45432 }
45433 arg2 = static_cast< int >(val2);
45434 {
45435 arg3 = wxString_in_helper(obj2);
45436 if (arg3 == NULL) SWIG_fail;
45437 temp3 = true;
45438 }
45439 {
45440 PyThreadState* __tstate = wxPyBeginAllowThreads();
45441 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45442 wxPyEndAllowThreads(__tstate);
45443 if (PyErr_Occurred()) SWIG_fail;
45444 }
45445 resultobj = SWIG_Py_Void();
45446 {
45447 if (temp3)
45448 delete arg3;
45449 }
45450 return resultobj;
45451 fail:
45452 {
45453 if (temp3)
45454 delete arg3;
45455 }
45456 return NULL;
45457 }
45458
45459
45460 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45461 PyObject *resultobj = 0;
45462 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45463 int arg2 ;
45464 wxString result;
45465 void *argp1 = 0 ;
45466 int res1 = 0 ;
45467 int val2 ;
45468 int ecode2 = 0 ;
45469 PyObject * obj0 = 0 ;
45470 PyObject * obj1 = 0 ;
45471 char * kwnames[] = {
45472 (char *) "self",(char *) "id", NULL
45473 };
45474
45475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45477 if (!SWIG_IsOK(res1)) {
45478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45479 }
45480 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45481 ecode2 = SWIG_AsVal_int(obj1, &val2);
45482 if (!SWIG_IsOK(ecode2)) {
45483 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45484 }
45485 arg2 = static_cast< int >(val2);
45486 {
45487 PyThreadState* __tstate = wxPyBeginAllowThreads();
45488 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45489 wxPyEndAllowThreads(__tstate);
45490 if (PyErr_Occurred()) SWIG_fail;
45491 }
45492 {
45493 #if wxUSE_UNICODE
45494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45495 #else
45496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45497 #endif
45498 }
45499 return resultobj;
45500 fail:
45501 return NULL;
45502 }
45503
45504
45505 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45506 PyObject *resultobj = 0;
45507 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45508 int arg2 ;
45509 wxString *arg3 = 0 ;
45510 void *argp1 = 0 ;
45511 int res1 = 0 ;
45512 int val2 ;
45513 int ecode2 = 0 ;
45514 bool temp3 = false ;
45515 PyObject * obj0 = 0 ;
45516 PyObject * obj1 = 0 ;
45517 PyObject * obj2 = 0 ;
45518 char * kwnames[] = {
45519 (char *) "self",(char *) "id",(char *) "helpString", NULL
45520 };
45521
45522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45524 if (!SWIG_IsOK(res1)) {
45525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45526 }
45527 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45528 ecode2 = SWIG_AsVal_int(obj1, &val2);
45529 if (!SWIG_IsOK(ecode2)) {
45530 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45531 }
45532 arg2 = static_cast< int >(val2);
45533 {
45534 arg3 = wxString_in_helper(obj2);
45535 if (arg3 == NULL) SWIG_fail;
45536 temp3 = true;
45537 }
45538 {
45539 PyThreadState* __tstate = wxPyBeginAllowThreads();
45540 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45541 wxPyEndAllowThreads(__tstate);
45542 if (PyErr_Occurred()) SWIG_fail;
45543 }
45544 resultobj = SWIG_Py_Void();
45545 {
45546 if (temp3)
45547 delete arg3;
45548 }
45549 return resultobj;
45550 fail:
45551 {
45552 if (temp3)
45553 delete arg3;
45554 }
45555 return NULL;
45556 }
45557
45558
45559 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45560 PyObject *resultobj = 0;
45561 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45562 int arg2 ;
45563 wxString result;
45564 void *argp1 = 0 ;
45565 int res1 = 0 ;
45566 int val2 ;
45567 int ecode2 = 0 ;
45568 PyObject * obj0 = 0 ;
45569 PyObject * obj1 = 0 ;
45570 char * kwnames[] = {
45571 (char *) "self",(char *) "id", NULL
45572 };
45573
45574 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45575 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45576 if (!SWIG_IsOK(res1)) {
45577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45578 }
45579 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45580 ecode2 = SWIG_AsVal_int(obj1, &val2);
45581 if (!SWIG_IsOK(ecode2)) {
45582 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45583 }
45584 arg2 = static_cast< int >(val2);
45585 {
45586 PyThreadState* __tstate = wxPyBeginAllowThreads();
45587 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45588 wxPyEndAllowThreads(__tstate);
45589 if (PyErr_Occurred()) SWIG_fail;
45590 }
45591 {
45592 #if wxUSE_UNICODE
45593 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45594 #else
45595 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45596 #endif
45597 }
45598 return resultobj;
45599 fail:
45600 return NULL;
45601 }
45602
45603
45604 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45605 PyObject *resultobj = 0;
45606 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45607 wxFrame *result = 0 ;
45608 void *argp1 = 0 ;
45609 int res1 = 0 ;
45610 PyObject *swig_obj[1] ;
45611
45612 if (!args) SWIG_fail;
45613 swig_obj[0] = args;
45614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45615 if (!SWIG_IsOK(res1)) {
45616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45617 }
45618 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45619 {
45620 PyThreadState* __tstate = wxPyBeginAllowThreads();
45621 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45622 wxPyEndAllowThreads(__tstate);
45623 if (PyErr_Occurred()) SWIG_fail;
45624 }
45625 {
45626 resultobj = wxPyMake_wxObject(result, (bool)0);
45627 }
45628 return resultobj;
45629 fail:
45630 return NULL;
45631 }
45632
45633
45634 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45635 PyObject *resultobj = 0;
45636 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45637 bool result;
45638 void *argp1 = 0 ;
45639 int res1 = 0 ;
45640 PyObject *swig_obj[1] ;
45641
45642 if (!args) SWIG_fail;
45643 swig_obj[0] = args;
45644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45645 if (!SWIG_IsOK(res1)) {
45646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45647 }
45648 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45649 {
45650 PyThreadState* __tstate = wxPyBeginAllowThreads();
45651 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45652 wxPyEndAllowThreads(__tstate);
45653 if (PyErr_Occurred()) SWIG_fail;
45654 }
45655 {
45656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45657 }
45658 return resultobj;
45659 fail:
45660 return NULL;
45661 }
45662
45663
45664 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45665 PyObject *resultobj = 0;
45666 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45667 wxFrame *arg2 = (wxFrame *) 0 ;
45668 void *argp1 = 0 ;
45669 int res1 = 0 ;
45670 void *argp2 = 0 ;
45671 int res2 = 0 ;
45672 PyObject * obj0 = 0 ;
45673 PyObject * obj1 = 0 ;
45674 char * kwnames[] = {
45675 (char *) "self",(char *) "frame", NULL
45676 };
45677
45678 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45679 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45680 if (!SWIG_IsOK(res1)) {
45681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45682 }
45683 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45684 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45685 if (!SWIG_IsOK(res2)) {
45686 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45687 }
45688 arg2 = reinterpret_cast< wxFrame * >(argp2);
45689 {
45690 PyThreadState* __tstate = wxPyBeginAllowThreads();
45691 (arg1)->Attach(arg2);
45692 wxPyEndAllowThreads(__tstate);
45693 if (PyErr_Occurred()) SWIG_fail;
45694 }
45695 resultobj = SWIG_Py_Void();
45696 return resultobj;
45697 fail:
45698 return NULL;
45699 }
45700
45701
45702 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45703 PyObject *resultobj = 0;
45704 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45705 void *argp1 = 0 ;
45706 int res1 = 0 ;
45707 PyObject *swig_obj[1] ;
45708
45709 if (!args) SWIG_fail;
45710 swig_obj[0] = args;
45711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45712 if (!SWIG_IsOK(res1)) {
45713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45714 }
45715 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45716 {
45717 PyThreadState* __tstate = wxPyBeginAllowThreads();
45718 (arg1)->Detach();
45719 wxPyEndAllowThreads(__tstate);
45720 if (PyErr_Occurred()) SWIG_fail;
45721 }
45722 resultobj = SWIG_Py_Void();
45723 return resultobj;
45724 fail:
45725 return NULL;
45726 }
45727
45728
45729 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45730 PyObject *resultobj = 0;
45731 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45732 void *argp1 = 0 ;
45733 int res1 = 0 ;
45734 PyObject *swig_obj[1] ;
45735
45736 if (!args) SWIG_fail;
45737 swig_obj[0] = args;
45738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45739 if (!SWIG_IsOK(res1)) {
45740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45741 }
45742 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45743 {
45744 PyThreadState* __tstate = wxPyBeginAllowThreads();
45745 (arg1)->UpdateMenus();
45746 wxPyEndAllowThreads(__tstate);
45747 if (PyErr_Occurred()) SWIG_fail;
45748 }
45749 resultobj = SWIG_Py_Void();
45750 return resultobj;
45751 fail:
45752 return NULL;
45753 }
45754
45755
45756 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45757 PyObject *resultobj = 0;
45758 bool arg1 ;
45759 bool val1 ;
45760 int ecode1 = 0 ;
45761 PyObject * obj0 = 0 ;
45762 char * kwnames[] = {
45763 (char *) "enable", NULL
45764 };
45765
45766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45767 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45768 if (!SWIG_IsOK(ecode1)) {
45769 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45770 }
45771 arg1 = static_cast< bool >(val1);
45772 {
45773 PyThreadState* __tstate = wxPyBeginAllowThreads();
45774 wxMenuBar_SetAutoWindowMenu(arg1);
45775 wxPyEndAllowThreads(__tstate);
45776 if (PyErr_Occurred()) SWIG_fail;
45777 }
45778 resultobj = SWIG_Py_Void();
45779 return resultobj;
45780 fail:
45781 return NULL;
45782 }
45783
45784
45785 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45786 PyObject *resultobj = 0;
45787 bool result;
45788
45789 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45790 {
45791 PyThreadState* __tstate = wxPyBeginAllowThreads();
45792 result = (bool)wxMenuBar_GetAutoWindowMenu();
45793 wxPyEndAllowThreads(__tstate);
45794 if (PyErr_Occurred()) SWIG_fail;
45795 }
45796 {
45797 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45798 }
45799 return resultobj;
45800 fail:
45801 return NULL;
45802 }
45803
45804
45805 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45806 PyObject *obj;
45807 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45808 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45809 return SWIG_Py_Void();
45810 }
45811
45812 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45813 return SWIG_Python_InitShadowInstance(args);
45814 }
45815
45816 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45817 PyObject *resultobj = 0;
45818 wxMenu *arg1 = (wxMenu *) NULL ;
45819 int arg2 = (int) wxID_SEPARATOR ;
45820 wxString const &arg3_defvalue = wxPyEmptyString ;
45821 wxString *arg3 = (wxString *) &arg3_defvalue ;
45822 wxString const &arg4_defvalue = wxPyEmptyString ;
45823 wxString *arg4 = (wxString *) &arg4_defvalue ;
45824 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45825 wxMenu *arg6 = (wxMenu *) NULL ;
45826 wxMenuItem *result = 0 ;
45827 void *argp1 = 0 ;
45828 int res1 = 0 ;
45829 int val2 ;
45830 int ecode2 = 0 ;
45831 bool temp3 = false ;
45832 bool temp4 = false ;
45833 int val5 ;
45834 int ecode5 = 0 ;
45835 void *argp6 = 0 ;
45836 int res6 = 0 ;
45837 PyObject * obj0 = 0 ;
45838 PyObject * obj1 = 0 ;
45839 PyObject * obj2 = 0 ;
45840 PyObject * obj3 = 0 ;
45841 PyObject * obj4 = 0 ;
45842 PyObject * obj5 = 0 ;
45843 char * kwnames[] = {
45844 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45845 };
45846
45847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45848 if (obj0) {
45849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45850 if (!SWIG_IsOK(res1)) {
45851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45852 }
45853 arg1 = reinterpret_cast< wxMenu * >(argp1);
45854 }
45855 if (obj1) {
45856 ecode2 = SWIG_AsVal_int(obj1, &val2);
45857 if (!SWIG_IsOK(ecode2)) {
45858 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45859 }
45860 arg2 = static_cast< int >(val2);
45861 }
45862 if (obj2) {
45863 {
45864 arg3 = wxString_in_helper(obj2);
45865 if (arg3 == NULL) SWIG_fail;
45866 temp3 = true;
45867 }
45868 }
45869 if (obj3) {
45870 {
45871 arg4 = wxString_in_helper(obj3);
45872 if (arg4 == NULL) SWIG_fail;
45873 temp4 = true;
45874 }
45875 }
45876 if (obj4) {
45877 ecode5 = SWIG_AsVal_int(obj4, &val5);
45878 if (!SWIG_IsOK(ecode5)) {
45879 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45880 }
45881 arg5 = static_cast< wxItemKind >(val5);
45882 }
45883 if (obj5) {
45884 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45885 if (!SWIG_IsOK(res6)) {
45886 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45887 }
45888 arg6 = reinterpret_cast< wxMenu * >(argp6);
45889 }
45890 {
45891 PyThreadState* __tstate = wxPyBeginAllowThreads();
45892 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45893 wxPyEndAllowThreads(__tstate);
45894 if (PyErr_Occurred()) SWIG_fail;
45895 }
45896 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45897 {
45898 if (temp3)
45899 delete arg3;
45900 }
45901 {
45902 if (temp4)
45903 delete arg4;
45904 }
45905 return resultobj;
45906 fail:
45907 {
45908 if (temp3)
45909 delete arg3;
45910 }
45911 {
45912 if (temp4)
45913 delete arg4;
45914 }
45915 return NULL;
45916 }
45917
45918
45919 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45920 PyObject *resultobj = 0;
45921 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45922 void *argp1 = 0 ;
45923 int res1 = 0 ;
45924 PyObject *swig_obj[1] ;
45925
45926 if (!args) SWIG_fail;
45927 swig_obj[0] = args;
45928 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45929 if (!SWIG_IsOK(res1)) {
45930 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45931 }
45932 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45933 {
45934 PyThreadState* __tstate = wxPyBeginAllowThreads();
45935 delete arg1;
45936
45937 wxPyEndAllowThreads(__tstate);
45938 if (PyErr_Occurred()) SWIG_fail;
45939 }
45940 resultobj = SWIG_Py_Void();
45941 return resultobj;
45942 fail:
45943 return NULL;
45944 }
45945
45946
45947 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45948 PyObject *resultobj = 0;
45949 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45950 wxMenu *result = 0 ;
45951 void *argp1 = 0 ;
45952 int res1 = 0 ;
45953 PyObject *swig_obj[1] ;
45954
45955 if (!args) SWIG_fail;
45956 swig_obj[0] = args;
45957 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45958 if (!SWIG_IsOK(res1)) {
45959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45960 }
45961 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45962 {
45963 PyThreadState* __tstate = wxPyBeginAllowThreads();
45964 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45965 wxPyEndAllowThreads(__tstate);
45966 if (PyErr_Occurred()) SWIG_fail;
45967 }
45968 {
45969 resultobj = wxPyMake_wxObject(result, 0);
45970 }
45971 return resultobj;
45972 fail:
45973 return NULL;
45974 }
45975
45976
45977 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45978 PyObject *resultobj = 0;
45979 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45980 wxMenu *arg2 = (wxMenu *) 0 ;
45981 void *argp1 = 0 ;
45982 int res1 = 0 ;
45983 void *argp2 = 0 ;
45984 int res2 = 0 ;
45985 PyObject * obj0 = 0 ;
45986 PyObject * obj1 = 0 ;
45987 char * kwnames[] = {
45988 (char *) "self",(char *) "menu", NULL
45989 };
45990
45991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45993 if (!SWIG_IsOK(res1)) {
45994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45995 }
45996 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45997 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45998 if (!SWIG_IsOK(res2)) {
45999 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46000 }
46001 arg2 = reinterpret_cast< wxMenu * >(argp2);
46002 {
46003 PyThreadState* __tstate = wxPyBeginAllowThreads();
46004 (arg1)->SetMenu(arg2);
46005 wxPyEndAllowThreads(__tstate);
46006 if (PyErr_Occurred()) SWIG_fail;
46007 }
46008 resultobj = SWIG_Py_Void();
46009 return resultobj;
46010 fail:
46011 return NULL;
46012 }
46013
46014
46015 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46016 PyObject *resultobj = 0;
46017 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46018 int arg2 ;
46019 void *argp1 = 0 ;
46020 int res1 = 0 ;
46021 int val2 ;
46022 int ecode2 = 0 ;
46023 PyObject * obj0 = 0 ;
46024 PyObject * obj1 = 0 ;
46025 char * kwnames[] = {
46026 (char *) "self",(char *) "id", NULL
46027 };
46028
46029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46031 if (!SWIG_IsOK(res1)) {
46032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46033 }
46034 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46035 ecode2 = SWIG_AsVal_int(obj1, &val2);
46036 if (!SWIG_IsOK(ecode2)) {
46037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46038 }
46039 arg2 = static_cast< int >(val2);
46040 {
46041 PyThreadState* __tstate = wxPyBeginAllowThreads();
46042 (arg1)->SetId(arg2);
46043 wxPyEndAllowThreads(__tstate);
46044 if (PyErr_Occurred()) SWIG_fail;
46045 }
46046 resultobj = SWIG_Py_Void();
46047 return resultobj;
46048 fail:
46049 return NULL;
46050 }
46051
46052
46053 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46054 PyObject *resultobj = 0;
46055 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46056 int result;
46057 void *argp1 = 0 ;
46058 int res1 = 0 ;
46059 PyObject *swig_obj[1] ;
46060
46061 if (!args) SWIG_fail;
46062 swig_obj[0] = args;
46063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46064 if (!SWIG_IsOK(res1)) {
46065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46066 }
46067 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46068 {
46069 PyThreadState* __tstate = wxPyBeginAllowThreads();
46070 result = (int)((wxMenuItem const *)arg1)->GetId();
46071 wxPyEndAllowThreads(__tstate);
46072 if (PyErr_Occurred()) SWIG_fail;
46073 }
46074 resultobj = SWIG_From_int(static_cast< int >(result));
46075 return resultobj;
46076 fail:
46077 return NULL;
46078 }
46079
46080
46081 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46082 PyObject *resultobj = 0;
46083 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46084 bool result;
46085 void *argp1 = 0 ;
46086 int res1 = 0 ;
46087 PyObject *swig_obj[1] ;
46088
46089 if (!args) SWIG_fail;
46090 swig_obj[0] = args;
46091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46092 if (!SWIG_IsOK(res1)) {
46093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46094 }
46095 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46096 {
46097 PyThreadState* __tstate = wxPyBeginAllowThreads();
46098 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46099 wxPyEndAllowThreads(__tstate);
46100 if (PyErr_Occurred()) SWIG_fail;
46101 }
46102 {
46103 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46104 }
46105 return resultobj;
46106 fail:
46107 return NULL;
46108 }
46109
46110
46111 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46112 PyObject *resultobj = 0;
46113 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46114 wxString *arg2 = 0 ;
46115 void *argp1 = 0 ;
46116 int res1 = 0 ;
46117 bool temp2 = false ;
46118 PyObject * obj0 = 0 ;
46119 PyObject * obj1 = 0 ;
46120 char * kwnames[] = {
46121 (char *) "self",(char *) "str", NULL
46122 };
46123
46124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46126 if (!SWIG_IsOK(res1)) {
46127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46128 }
46129 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46130 {
46131 arg2 = wxString_in_helper(obj1);
46132 if (arg2 == NULL) SWIG_fail;
46133 temp2 = true;
46134 }
46135 {
46136 PyThreadState* __tstate = wxPyBeginAllowThreads();
46137 (arg1)->SetText((wxString const &)*arg2);
46138 wxPyEndAllowThreads(__tstate);
46139 if (PyErr_Occurred()) SWIG_fail;
46140 }
46141 resultobj = SWIG_Py_Void();
46142 {
46143 if (temp2)
46144 delete arg2;
46145 }
46146 return resultobj;
46147 fail:
46148 {
46149 if (temp2)
46150 delete arg2;
46151 }
46152 return NULL;
46153 }
46154
46155
46156 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46157 PyObject *resultobj = 0;
46158 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46159 wxString result;
46160 void *argp1 = 0 ;
46161 int res1 = 0 ;
46162 PyObject *swig_obj[1] ;
46163
46164 if (!args) SWIG_fail;
46165 swig_obj[0] = args;
46166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46167 if (!SWIG_IsOK(res1)) {
46168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46169 }
46170 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46171 {
46172 PyThreadState* __tstate = wxPyBeginAllowThreads();
46173 result = ((wxMenuItem const *)arg1)->GetLabel();
46174 wxPyEndAllowThreads(__tstate);
46175 if (PyErr_Occurred()) SWIG_fail;
46176 }
46177 {
46178 #if wxUSE_UNICODE
46179 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46180 #else
46181 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46182 #endif
46183 }
46184 return resultobj;
46185 fail:
46186 return NULL;
46187 }
46188
46189
46190 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46191 PyObject *resultobj = 0;
46192 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46193 wxString *result = 0 ;
46194 void *argp1 = 0 ;
46195 int res1 = 0 ;
46196 PyObject *swig_obj[1] ;
46197
46198 if (!args) SWIG_fail;
46199 swig_obj[0] = args;
46200 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46201 if (!SWIG_IsOK(res1)) {
46202 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46203 }
46204 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46205 {
46206 PyThreadState* __tstate = wxPyBeginAllowThreads();
46207 {
46208 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46209 result = (wxString *) &_result_ref;
46210 }
46211 wxPyEndAllowThreads(__tstate);
46212 if (PyErr_Occurred()) SWIG_fail;
46213 }
46214 {
46215 #if wxUSE_UNICODE
46216 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46217 #else
46218 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46219 #endif
46220 }
46221 return resultobj;
46222 fail:
46223 return NULL;
46224 }
46225
46226
46227 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46228 PyObject *resultobj = 0;
46229 wxString *arg1 = 0 ;
46230 wxString result;
46231 bool temp1 = false ;
46232 PyObject * obj0 = 0 ;
46233 char * kwnames[] = {
46234 (char *) "text", NULL
46235 };
46236
46237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46238 {
46239 arg1 = wxString_in_helper(obj0);
46240 if (arg1 == NULL) SWIG_fail;
46241 temp1 = true;
46242 }
46243 {
46244 PyThreadState* __tstate = wxPyBeginAllowThreads();
46245 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46246 wxPyEndAllowThreads(__tstate);
46247 if (PyErr_Occurred()) SWIG_fail;
46248 }
46249 {
46250 #if wxUSE_UNICODE
46251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46252 #else
46253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46254 #endif
46255 }
46256 {
46257 if (temp1)
46258 delete arg1;
46259 }
46260 return resultobj;
46261 fail:
46262 {
46263 if (temp1)
46264 delete arg1;
46265 }
46266 return NULL;
46267 }
46268
46269
46270 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46271 PyObject *resultobj = 0;
46272 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46273 wxItemKind result;
46274 void *argp1 = 0 ;
46275 int res1 = 0 ;
46276 PyObject *swig_obj[1] ;
46277
46278 if (!args) SWIG_fail;
46279 swig_obj[0] = args;
46280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46281 if (!SWIG_IsOK(res1)) {
46282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46283 }
46284 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46285 {
46286 PyThreadState* __tstate = wxPyBeginAllowThreads();
46287 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46288 wxPyEndAllowThreads(__tstate);
46289 if (PyErr_Occurred()) SWIG_fail;
46290 }
46291 resultobj = SWIG_From_int(static_cast< int >(result));
46292 return resultobj;
46293 fail:
46294 return NULL;
46295 }
46296
46297
46298 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46299 PyObject *resultobj = 0;
46300 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46301 wxItemKind arg2 ;
46302 void *argp1 = 0 ;
46303 int res1 = 0 ;
46304 int val2 ;
46305 int ecode2 = 0 ;
46306 PyObject * obj0 = 0 ;
46307 PyObject * obj1 = 0 ;
46308 char * kwnames[] = {
46309 (char *) "self",(char *) "kind", NULL
46310 };
46311
46312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46314 if (!SWIG_IsOK(res1)) {
46315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46316 }
46317 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46318 ecode2 = SWIG_AsVal_int(obj1, &val2);
46319 if (!SWIG_IsOK(ecode2)) {
46320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46321 }
46322 arg2 = static_cast< wxItemKind >(val2);
46323 {
46324 PyThreadState* __tstate = wxPyBeginAllowThreads();
46325 (arg1)->SetKind(arg2);
46326 wxPyEndAllowThreads(__tstate);
46327 if (PyErr_Occurred()) SWIG_fail;
46328 }
46329 resultobj = SWIG_Py_Void();
46330 return resultobj;
46331 fail:
46332 return NULL;
46333 }
46334
46335
46336 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46337 PyObject *resultobj = 0;
46338 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46339 bool arg2 ;
46340 void *argp1 = 0 ;
46341 int res1 = 0 ;
46342 bool val2 ;
46343 int ecode2 = 0 ;
46344 PyObject * obj0 = 0 ;
46345 PyObject * obj1 = 0 ;
46346 char * kwnames[] = {
46347 (char *) "self",(char *) "checkable", NULL
46348 };
46349
46350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46352 if (!SWIG_IsOK(res1)) {
46353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46354 }
46355 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46356 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46357 if (!SWIG_IsOK(ecode2)) {
46358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46359 }
46360 arg2 = static_cast< bool >(val2);
46361 {
46362 PyThreadState* __tstate = wxPyBeginAllowThreads();
46363 (arg1)->SetCheckable(arg2);
46364 wxPyEndAllowThreads(__tstate);
46365 if (PyErr_Occurred()) SWIG_fail;
46366 }
46367 resultobj = SWIG_Py_Void();
46368 return resultobj;
46369 fail:
46370 return NULL;
46371 }
46372
46373
46374 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46375 PyObject *resultobj = 0;
46376 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46377 bool result;
46378 void *argp1 = 0 ;
46379 int res1 = 0 ;
46380 PyObject *swig_obj[1] ;
46381
46382 if (!args) SWIG_fail;
46383 swig_obj[0] = args;
46384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46385 if (!SWIG_IsOK(res1)) {
46386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46387 }
46388 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46389 {
46390 PyThreadState* __tstate = wxPyBeginAllowThreads();
46391 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46392 wxPyEndAllowThreads(__tstate);
46393 if (PyErr_Occurred()) SWIG_fail;
46394 }
46395 {
46396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46397 }
46398 return resultobj;
46399 fail:
46400 return NULL;
46401 }
46402
46403
46404 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46405 PyObject *resultobj = 0;
46406 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46407 bool result;
46408 void *argp1 = 0 ;
46409 int res1 = 0 ;
46410 PyObject *swig_obj[1] ;
46411
46412 if (!args) SWIG_fail;
46413 swig_obj[0] = args;
46414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46415 if (!SWIG_IsOK(res1)) {
46416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46417 }
46418 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46419 {
46420 PyThreadState* __tstate = wxPyBeginAllowThreads();
46421 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46422 wxPyEndAllowThreads(__tstate);
46423 if (PyErr_Occurred()) SWIG_fail;
46424 }
46425 {
46426 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46427 }
46428 return resultobj;
46429 fail:
46430 return NULL;
46431 }
46432
46433
46434 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46435 PyObject *resultobj = 0;
46436 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46437 wxMenu *arg2 = (wxMenu *) 0 ;
46438 void *argp1 = 0 ;
46439 int res1 = 0 ;
46440 void *argp2 = 0 ;
46441 int res2 = 0 ;
46442 PyObject * obj0 = 0 ;
46443 PyObject * obj1 = 0 ;
46444 char * kwnames[] = {
46445 (char *) "self",(char *) "menu", NULL
46446 };
46447
46448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46450 if (!SWIG_IsOK(res1)) {
46451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46452 }
46453 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46454 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46455 if (!SWIG_IsOK(res2)) {
46456 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46457 }
46458 arg2 = reinterpret_cast< wxMenu * >(argp2);
46459 {
46460 PyThreadState* __tstate = wxPyBeginAllowThreads();
46461 (arg1)->SetSubMenu(arg2);
46462 wxPyEndAllowThreads(__tstate);
46463 if (PyErr_Occurred()) SWIG_fail;
46464 }
46465 resultobj = SWIG_Py_Void();
46466 return resultobj;
46467 fail:
46468 return NULL;
46469 }
46470
46471
46472 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46473 PyObject *resultobj = 0;
46474 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46475 wxMenu *result = 0 ;
46476 void *argp1 = 0 ;
46477 int res1 = 0 ;
46478 PyObject *swig_obj[1] ;
46479
46480 if (!args) SWIG_fail;
46481 swig_obj[0] = args;
46482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46483 if (!SWIG_IsOK(res1)) {
46484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46485 }
46486 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46487 {
46488 PyThreadState* __tstate = wxPyBeginAllowThreads();
46489 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46490 wxPyEndAllowThreads(__tstate);
46491 if (PyErr_Occurred()) SWIG_fail;
46492 }
46493 {
46494 resultobj = wxPyMake_wxObject(result, 0);
46495 }
46496 return resultobj;
46497 fail:
46498 return NULL;
46499 }
46500
46501
46502 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46503 PyObject *resultobj = 0;
46504 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46505 bool arg2 = (bool) true ;
46506 void *argp1 = 0 ;
46507 int res1 = 0 ;
46508 bool val2 ;
46509 int ecode2 = 0 ;
46510 PyObject * obj0 = 0 ;
46511 PyObject * obj1 = 0 ;
46512 char * kwnames[] = {
46513 (char *) "self",(char *) "enable", NULL
46514 };
46515
46516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46518 if (!SWIG_IsOK(res1)) {
46519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46520 }
46521 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46522 if (obj1) {
46523 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46524 if (!SWIG_IsOK(ecode2)) {
46525 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46526 }
46527 arg2 = static_cast< bool >(val2);
46528 }
46529 {
46530 PyThreadState* __tstate = wxPyBeginAllowThreads();
46531 (arg1)->Enable(arg2);
46532 wxPyEndAllowThreads(__tstate);
46533 if (PyErr_Occurred()) SWIG_fail;
46534 }
46535 resultobj = SWIG_Py_Void();
46536 return resultobj;
46537 fail:
46538 return NULL;
46539 }
46540
46541
46542 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46543 PyObject *resultobj = 0;
46544 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46545 bool result;
46546 void *argp1 = 0 ;
46547 int res1 = 0 ;
46548 PyObject *swig_obj[1] ;
46549
46550 if (!args) SWIG_fail;
46551 swig_obj[0] = args;
46552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46553 if (!SWIG_IsOK(res1)) {
46554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46555 }
46556 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46557 {
46558 PyThreadState* __tstate = wxPyBeginAllowThreads();
46559 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46560 wxPyEndAllowThreads(__tstate);
46561 if (PyErr_Occurred()) SWIG_fail;
46562 }
46563 {
46564 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46565 }
46566 return resultobj;
46567 fail:
46568 return NULL;
46569 }
46570
46571
46572 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46573 PyObject *resultobj = 0;
46574 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46575 bool arg2 = (bool) true ;
46576 void *argp1 = 0 ;
46577 int res1 = 0 ;
46578 bool val2 ;
46579 int ecode2 = 0 ;
46580 PyObject * obj0 = 0 ;
46581 PyObject * obj1 = 0 ;
46582 char * kwnames[] = {
46583 (char *) "self",(char *) "check", NULL
46584 };
46585
46586 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46587 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46588 if (!SWIG_IsOK(res1)) {
46589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46590 }
46591 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46592 if (obj1) {
46593 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46594 if (!SWIG_IsOK(ecode2)) {
46595 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46596 }
46597 arg2 = static_cast< bool >(val2);
46598 }
46599 {
46600 PyThreadState* __tstate = wxPyBeginAllowThreads();
46601 (arg1)->Check(arg2);
46602 wxPyEndAllowThreads(__tstate);
46603 if (PyErr_Occurred()) SWIG_fail;
46604 }
46605 resultobj = SWIG_Py_Void();
46606 return resultobj;
46607 fail:
46608 return NULL;
46609 }
46610
46611
46612 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46613 PyObject *resultobj = 0;
46614 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46615 bool result;
46616 void *argp1 = 0 ;
46617 int res1 = 0 ;
46618 PyObject *swig_obj[1] ;
46619
46620 if (!args) SWIG_fail;
46621 swig_obj[0] = args;
46622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46623 if (!SWIG_IsOK(res1)) {
46624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46625 }
46626 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46627 {
46628 PyThreadState* __tstate = wxPyBeginAllowThreads();
46629 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46630 wxPyEndAllowThreads(__tstate);
46631 if (PyErr_Occurred()) SWIG_fail;
46632 }
46633 {
46634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46635 }
46636 return resultobj;
46637 fail:
46638 return NULL;
46639 }
46640
46641
46642 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46643 PyObject *resultobj = 0;
46644 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46645 void *argp1 = 0 ;
46646 int res1 = 0 ;
46647 PyObject *swig_obj[1] ;
46648
46649 if (!args) SWIG_fail;
46650 swig_obj[0] = args;
46651 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46652 if (!SWIG_IsOK(res1)) {
46653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46654 }
46655 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46656 {
46657 PyThreadState* __tstate = wxPyBeginAllowThreads();
46658 (arg1)->Toggle();
46659 wxPyEndAllowThreads(__tstate);
46660 if (PyErr_Occurred()) SWIG_fail;
46661 }
46662 resultobj = SWIG_Py_Void();
46663 return resultobj;
46664 fail:
46665 return NULL;
46666 }
46667
46668
46669 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46670 PyObject *resultobj = 0;
46671 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46672 wxString *arg2 = 0 ;
46673 void *argp1 = 0 ;
46674 int res1 = 0 ;
46675 bool temp2 = false ;
46676 PyObject * obj0 = 0 ;
46677 PyObject * obj1 = 0 ;
46678 char * kwnames[] = {
46679 (char *) "self",(char *) "str", NULL
46680 };
46681
46682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46684 if (!SWIG_IsOK(res1)) {
46685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46686 }
46687 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46688 {
46689 arg2 = wxString_in_helper(obj1);
46690 if (arg2 == NULL) SWIG_fail;
46691 temp2 = true;
46692 }
46693 {
46694 PyThreadState* __tstate = wxPyBeginAllowThreads();
46695 (arg1)->SetHelp((wxString const &)*arg2);
46696 wxPyEndAllowThreads(__tstate);
46697 if (PyErr_Occurred()) SWIG_fail;
46698 }
46699 resultobj = SWIG_Py_Void();
46700 {
46701 if (temp2)
46702 delete arg2;
46703 }
46704 return resultobj;
46705 fail:
46706 {
46707 if (temp2)
46708 delete arg2;
46709 }
46710 return NULL;
46711 }
46712
46713
46714 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46715 PyObject *resultobj = 0;
46716 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46717 wxString *result = 0 ;
46718 void *argp1 = 0 ;
46719 int res1 = 0 ;
46720 PyObject *swig_obj[1] ;
46721
46722 if (!args) SWIG_fail;
46723 swig_obj[0] = args;
46724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46725 if (!SWIG_IsOK(res1)) {
46726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46727 }
46728 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46729 {
46730 PyThreadState* __tstate = wxPyBeginAllowThreads();
46731 {
46732 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46733 result = (wxString *) &_result_ref;
46734 }
46735 wxPyEndAllowThreads(__tstate);
46736 if (PyErr_Occurred()) SWIG_fail;
46737 }
46738 {
46739 #if wxUSE_UNICODE
46740 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46741 #else
46742 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46743 #endif
46744 }
46745 return resultobj;
46746 fail:
46747 return NULL;
46748 }
46749
46750
46751 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46752 PyObject *resultobj = 0;
46753 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46754 wxAcceleratorEntry *result = 0 ;
46755 void *argp1 = 0 ;
46756 int res1 = 0 ;
46757 PyObject *swig_obj[1] ;
46758
46759 if (!args) SWIG_fail;
46760 swig_obj[0] = args;
46761 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46762 if (!SWIG_IsOK(res1)) {
46763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46764 }
46765 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46766 {
46767 PyThreadState* __tstate = wxPyBeginAllowThreads();
46768 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46769 wxPyEndAllowThreads(__tstate);
46770 if (PyErr_Occurred()) SWIG_fail;
46771 }
46772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46773 return resultobj;
46774 fail:
46775 return NULL;
46776 }
46777
46778
46779 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46780 PyObject *resultobj = 0;
46781 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46782 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46783 void *argp1 = 0 ;
46784 int res1 = 0 ;
46785 void *argp2 = 0 ;
46786 int res2 = 0 ;
46787 PyObject * obj0 = 0 ;
46788 PyObject * obj1 = 0 ;
46789 char * kwnames[] = {
46790 (char *) "self",(char *) "accel", NULL
46791 };
46792
46793 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46794 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46795 if (!SWIG_IsOK(res1)) {
46796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46797 }
46798 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46799 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46800 if (!SWIG_IsOK(res2)) {
46801 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46802 }
46803 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46804 {
46805 PyThreadState* __tstate = wxPyBeginAllowThreads();
46806 (arg1)->SetAccel(arg2);
46807 wxPyEndAllowThreads(__tstate);
46808 if (PyErr_Occurred()) SWIG_fail;
46809 }
46810 resultobj = SWIG_Py_Void();
46811 return resultobj;
46812 fail:
46813 return NULL;
46814 }
46815
46816
46817 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46818 PyObject *resultobj = 0;
46819 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46820 wxBitmap *arg2 = 0 ;
46821 void *argp1 = 0 ;
46822 int res1 = 0 ;
46823 void *argp2 = 0 ;
46824 int res2 = 0 ;
46825 PyObject * obj0 = 0 ;
46826 PyObject * obj1 = 0 ;
46827 char * kwnames[] = {
46828 (char *) "self",(char *) "bitmap", NULL
46829 };
46830
46831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46833 if (!SWIG_IsOK(res1)) {
46834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46835 }
46836 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46837 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46838 if (!SWIG_IsOK(res2)) {
46839 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46840 }
46841 if (!argp2) {
46842 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46843 }
46844 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46845 {
46846 PyThreadState* __tstate = wxPyBeginAllowThreads();
46847 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46848 wxPyEndAllowThreads(__tstate);
46849 if (PyErr_Occurred()) SWIG_fail;
46850 }
46851 resultobj = SWIG_Py_Void();
46852 return resultobj;
46853 fail:
46854 return NULL;
46855 }
46856
46857
46858 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46859 PyObject *resultobj = 0;
46860 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46861 wxBitmap *result = 0 ;
46862 void *argp1 = 0 ;
46863 int res1 = 0 ;
46864 PyObject *swig_obj[1] ;
46865
46866 if (!args) SWIG_fail;
46867 swig_obj[0] = args;
46868 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46869 if (!SWIG_IsOK(res1)) {
46870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46871 }
46872 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46873 {
46874 PyThreadState* __tstate = wxPyBeginAllowThreads();
46875 {
46876 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46877 result = (wxBitmap *) &_result_ref;
46878 }
46879 wxPyEndAllowThreads(__tstate);
46880 if (PyErr_Occurred()) SWIG_fail;
46881 }
46882 {
46883 wxBitmap* resultptr = new wxBitmap(*result);
46884 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46885 }
46886 return resultobj;
46887 fail:
46888 return NULL;
46889 }
46890
46891
46892 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46893 PyObject *resultobj = 0;
46894 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46895 wxFont *arg2 = 0 ;
46896 void *argp1 = 0 ;
46897 int res1 = 0 ;
46898 void *argp2 = 0 ;
46899 int res2 = 0 ;
46900 PyObject * obj0 = 0 ;
46901 PyObject * obj1 = 0 ;
46902 char * kwnames[] = {
46903 (char *) "self",(char *) "font", NULL
46904 };
46905
46906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46908 if (!SWIG_IsOK(res1)) {
46909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46910 }
46911 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46912 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46913 if (!SWIG_IsOK(res2)) {
46914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46915 }
46916 if (!argp2) {
46917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46918 }
46919 arg2 = reinterpret_cast< wxFont * >(argp2);
46920 {
46921 PyThreadState* __tstate = wxPyBeginAllowThreads();
46922 (arg1)->SetFont((wxFont const &)*arg2);
46923 wxPyEndAllowThreads(__tstate);
46924 if (PyErr_Occurred()) SWIG_fail;
46925 }
46926 resultobj = SWIG_Py_Void();
46927 return resultobj;
46928 fail:
46929 return NULL;
46930 }
46931
46932
46933 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46934 PyObject *resultobj = 0;
46935 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46936 wxFont result;
46937 void *argp1 = 0 ;
46938 int res1 = 0 ;
46939 PyObject *swig_obj[1] ;
46940
46941 if (!args) SWIG_fail;
46942 swig_obj[0] = args;
46943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46944 if (!SWIG_IsOK(res1)) {
46945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46946 }
46947 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46948 {
46949 PyThreadState* __tstate = wxPyBeginAllowThreads();
46950 result = (arg1)->GetFont();
46951 wxPyEndAllowThreads(__tstate);
46952 if (PyErr_Occurred()) SWIG_fail;
46953 }
46954 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46955 return resultobj;
46956 fail:
46957 return NULL;
46958 }
46959
46960
46961 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46962 PyObject *resultobj = 0;
46963 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46964 wxColour *arg2 = 0 ;
46965 void *argp1 = 0 ;
46966 int res1 = 0 ;
46967 wxColour temp2 ;
46968 PyObject * obj0 = 0 ;
46969 PyObject * obj1 = 0 ;
46970 char * kwnames[] = {
46971 (char *) "self",(char *) "colText", NULL
46972 };
46973
46974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46975 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46976 if (!SWIG_IsOK(res1)) {
46977 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46978 }
46979 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46980 {
46981 arg2 = &temp2;
46982 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46983 }
46984 {
46985 PyThreadState* __tstate = wxPyBeginAllowThreads();
46986 (arg1)->SetTextColour((wxColour const &)*arg2);
46987 wxPyEndAllowThreads(__tstate);
46988 if (PyErr_Occurred()) SWIG_fail;
46989 }
46990 resultobj = SWIG_Py_Void();
46991 return resultobj;
46992 fail:
46993 return NULL;
46994 }
46995
46996
46997 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46998 PyObject *resultobj = 0;
46999 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47000 wxColour result;
47001 void *argp1 = 0 ;
47002 int res1 = 0 ;
47003 PyObject *swig_obj[1] ;
47004
47005 if (!args) SWIG_fail;
47006 swig_obj[0] = args;
47007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47008 if (!SWIG_IsOK(res1)) {
47009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47010 }
47011 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47012 {
47013 PyThreadState* __tstate = wxPyBeginAllowThreads();
47014 result = (arg1)->GetTextColour();
47015 wxPyEndAllowThreads(__tstate);
47016 if (PyErr_Occurred()) SWIG_fail;
47017 }
47018 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47019 return resultobj;
47020 fail:
47021 return NULL;
47022 }
47023
47024
47025 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47026 PyObject *resultobj = 0;
47027 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47028 wxColour *arg2 = 0 ;
47029 void *argp1 = 0 ;
47030 int res1 = 0 ;
47031 wxColour temp2 ;
47032 PyObject * obj0 = 0 ;
47033 PyObject * obj1 = 0 ;
47034 char * kwnames[] = {
47035 (char *) "self",(char *) "colBack", NULL
47036 };
47037
47038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47040 if (!SWIG_IsOK(res1)) {
47041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47042 }
47043 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47044 {
47045 arg2 = &temp2;
47046 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47047 }
47048 {
47049 PyThreadState* __tstate = wxPyBeginAllowThreads();
47050 (arg1)->SetBackgroundColour((wxColour const &)*arg2);
47051 wxPyEndAllowThreads(__tstate);
47052 if (PyErr_Occurred()) SWIG_fail;
47053 }
47054 resultobj = SWIG_Py_Void();
47055 return resultobj;
47056 fail:
47057 return NULL;
47058 }
47059
47060
47061 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47062 PyObject *resultobj = 0;
47063 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47064 wxColour result;
47065 void *argp1 = 0 ;
47066 int res1 = 0 ;
47067 PyObject *swig_obj[1] ;
47068
47069 if (!args) SWIG_fail;
47070 swig_obj[0] = args;
47071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47072 if (!SWIG_IsOK(res1)) {
47073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47074 }
47075 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47076 {
47077 PyThreadState* __tstate = wxPyBeginAllowThreads();
47078 result = (arg1)->GetBackgroundColour();
47079 wxPyEndAllowThreads(__tstate);
47080 if (PyErr_Occurred()) SWIG_fail;
47081 }
47082 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47083 return resultobj;
47084 fail:
47085 return NULL;
47086 }
47087
47088
47089 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47090 PyObject *resultobj = 0;
47091 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47092 wxBitmap *arg2 = 0 ;
47093 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47094 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47095 void *argp1 = 0 ;
47096 int res1 = 0 ;
47097 void *argp2 = 0 ;
47098 int res2 = 0 ;
47099 void *argp3 = 0 ;
47100 int res3 = 0 ;
47101 PyObject * obj0 = 0 ;
47102 PyObject * obj1 = 0 ;
47103 PyObject * obj2 = 0 ;
47104 char * kwnames[] = {
47105 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47106 };
47107
47108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47110 if (!SWIG_IsOK(res1)) {
47111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47112 }
47113 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47114 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47115 if (!SWIG_IsOK(res2)) {
47116 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47117 }
47118 if (!argp2) {
47119 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47120 }
47121 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47122 if (obj2) {
47123 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47124 if (!SWIG_IsOK(res3)) {
47125 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47126 }
47127 if (!argp3) {
47128 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47129 }
47130 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47131 }
47132 {
47133 PyThreadState* __tstate = wxPyBeginAllowThreads();
47134 (arg1)->SetBitmaps((wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47135 wxPyEndAllowThreads(__tstate);
47136 if (PyErr_Occurred()) SWIG_fail;
47137 }
47138 resultobj = SWIG_Py_Void();
47139 return resultobj;
47140 fail:
47141 return NULL;
47142 }
47143
47144
47145 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47146 PyObject *resultobj = 0;
47147 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47148 wxBitmap *arg2 = 0 ;
47149 void *argp1 = 0 ;
47150 int res1 = 0 ;
47151 void *argp2 = 0 ;
47152 int res2 = 0 ;
47153 PyObject * obj0 = 0 ;
47154 PyObject * obj1 = 0 ;
47155 char * kwnames[] = {
47156 (char *) "self",(char *) "bmpDisabled", NULL
47157 };
47158
47159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47161 if (!SWIG_IsOK(res1)) {
47162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47163 }
47164 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47165 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47166 if (!SWIG_IsOK(res2)) {
47167 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47168 }
47169 if (!argp2) {
47170 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47171 }
47172 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47173 {
47174 PyThreadState* __tstate = wxPyBeginAllowThreads();
47175 (arg1)->SetDisabledBitmap((wxBitmap const &)*arg2);
47176 wxPyEndAllowThreads(__tstate);
47177 if (PyErr_Occurred()) SWIG_fail;
47178 }
47179 resultobj = SWIG_Py_Void();
47180 return resultobj;
47181 fail:
47182 return NULL;
47183 }
47184
47185
47186 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47187 PyObject *resultobj = 0;
47188 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47189 wxBitmap *result = 0 ;
47190 void *argp1 = 0 ;
47191 int res1 = 0 ;
47192 PyObject *swig_obj[1] ;
47193
47194 if (!args) SWIG_fail;
47195 swig_obj[0] = args;
47196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47197 if (!SWIG_IsOK(res1)) {
47198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47199 }
47200 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47201 {
47202 PyThreadState* __tstate = wxPyBeginAllowThreads();
47203 {
47204 wxBitmap const &_result_ref = ((wxMenuItem const *)arg1)->GetDisabledBitmap();
47205 result = (wxBitmap *) &_result_ref;
47206 }
47207 wxPyEndAllowThreads(__tstate);
47208 if (PyErr_Occurred()) SWIG_fail;
47209 }
47210 {
47211 wxBitmap* resultptr = new wxBitmap(*result);
47212 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47213 }
47214 return resultobj;
47215 fail:
47216 return NULL;
47217 }
47218
47219
47220 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47221 PyObject *resultobj = 0;
47222 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47223 int arg2 ;
47224 void *argp1 = 0 ;
47225 int res1 = 0 ;
47226 int val2 ;
47227 int ecode2 = 0 ;
47228 PyObject * obj0 = 0 ;
47229 PyObject * obj1 = 0 ;
47230 char * kwnames[] = {
47231 (char *) "self",(char *) "nWidth", NULL
47232 };
47233
47234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47236 if (!SWIG_IsOK(res1)) {
47237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47238 }
47239 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47240 ecode2 = SWIG_AsVal_int(obj1, &val2);
47241 if (!SWIG_IsOK(ecode2)) {
47242 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47243 }
47244 arg2 = static_cast< int >(val2);
47245 {
47246 PyThreadState* __tstate = wxPyBeginAllowThreads();
47247 (arg1)->SetMarginWidth(arg2);
47248 wxPyEndAllowThreads(__tstate);
47249 if (PyErr_Occurred()) SWIG_fail;
47250 }
47251 resultobj = SWIG_Py_Void();
47252 return resultobj;
47253 fail:
47254 return NULL;
47255 }
47256
47257
47258 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47259 PyObject *resultobj = 0;
47260 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47261 int result;
47262 void *argp1 = 0 ;
47263 int res1 = 0 ;
47264 PyObject *swig_obj[1] ;
47265
47266 if (!args) SWIG_fail;
47267 swig_obj[0] = args;
47268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47269 if (!SWIG_IsOK(res1)) {
47270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47271 }
47272 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47273 {
47274 PyThreadState* __tstate = wxPyBeginAllowThreads();
47275 result = (int)(arg1)->GetMarginWidth();
47276 wxPyEndAllowThreads(__tstate);
47277 if (PyErr_Occurred()) SWIG_fail;
47278 }
47279 resultobj = SWIG_From_int(static_cast< int >(result));
47280 return resultobj;
47281 fail:
47282 return NULL;
47283 }
47284
47285
47286 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47287 PyObject *resultobj = 0;
47288 int result;
47289
47290 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47291 {
47292 PyThreadState* __tstate = wxPyBeginAllowThreads();
47293 result = (int)wxMenuItem::GetDefaultMarginWidth();
47294 wxPyEndAllowThreads(__tstate);
47295 if (PyErr_Occurred()) SWIG_fail;
47296 }
47297 resultobj = SWIG_From_int(static_cast< int >(result));
47298 return resultobj;
47299 fail:
47300 return NULL;
47301 }
47302
47303
47304 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47305 PyObject *resultobj = 0;
47306 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47307 bool result;
47308 void *argp1 = 0 ;
47309 int res1 = 0 ;
47310 PyObject *swig_obj[1] ;
47311
47312 if (!args) SWIG_fail;
47313 swig_obj[0] = args;
47314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47315 if (!SWIG_IsOK(res1)) {
47316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47317 }
47318 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47319 {
47320 PyThreadState* __tstate = wxPyBeginAllowThreads();
47321 result = (bool)(arg1)->IsOwnerDrawn();
47322 wxPyEndAllowThreads(__tstate);
47323 if (PyErr_Occurred()) SWIG_fail;
47324 }
47325 {
47326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47327 }
47328 return resultobj;
47329 fail:
47330 return NULL;
47331 }
47332
47333
47334 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47335 PyObject *resultobj = 0;
47336 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47337 bool arg2 = (bool) true ;
47338 void *argp1 = 0 ;
47339 int res1 = 0 ;
47340 bool val2 ;
47341 int ecode2 = 0 ;
47342 PyObject * obj0 = 0 ;
47343 PyObject * obj1 = 0 ;
47344 char * kwnames[] = {
47345 (char *) "self",(char *) "ownerDrawn", NULL
47346 };
47347
47348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47350 if (!SWIG_IsOK(res1)) {
47351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47352 }
47353 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47354 if (obj1) {
47355 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47356 if (!SWIG_IsOK(ecode2)) {
47357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47358 }
47359 arg2 = static_cast< bool >(val2);
47360 }
47361 {
47362 PyThreadState* __tstate = wxPyBeginAllowThreads();
47363 (arg1)->SetOwnerDrawn(arg2);
47364 wxPyEndAllowThreads(__tstate);
47365 if (PyErr_Occurred()) SWIG_fail;
47366 }
47367 resultobj = SWIG_Py_Void();
47368 return resultobj;
47369 fail:
47370 return NULL;
47371 }
47372
47373
47374 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47375 PyObject *resultobj = 0;
47376 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47377 void *argp1 = 0 ;
47378 int res1 = 0 ;
47379 PyObject *swig_obj[1] ;
47380
47381 if (!args) SWIG_fail;
47382 swig_obj[0] = args;
47383 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47384 if (!SWIG_IsOK(res1)) {
47385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47386 }
47387 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47388 {
47389 PyThreadState* __tstate = wxPyBeginAllowThreads();
47390 (arg1)->ResetOwnerDrawn();
47391 wxPyEndAllowThreads(__tstate);
47392 if (PyErr_Occurred()) SWIG_fail;
47393 }
47394 resultobj = SWIG_Py_Void();
47395 return resultobj;
47396 fail:
47397 return NULL;
47398 }
47399
47400
47401 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47402 PyObject *obj;
47403 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47404 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47405 return SWIG_Py_Void();
47406 }
47407
47408 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47409 return SWIG_Python_InitShadowInstance(args);
47410 }
47411
47412 SWIGINTERN int ControlNameStr_set(PyObject *) {
47413 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47414 return 1;
47415 }
47416
47417
47418 SWIGINTERN PyObject *ControlNameStr_get(void) {
47419 PyObject *pyobj = 0;
47420
47421 {
47422 #if wxUSE_UNICODE
47423 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47424 #else
47425 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47426 #endif
47427 }
47428 return pyobj;
47429 }
47430
47431
47432 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47433 PyObject *resultobj = 0;
47434 wxWindow *arg1 = (wxWindow *) 0 ;
47435 int arg2 = (int) -1 ;
47436 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47437 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47438 wxSize const &arg4_defvalue = wxDefaultSize ;
47439 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47440 long arg5 = (long) 0 ;
47441 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47442 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47443 wxString const &arg7_defvalue = wxPyControlNameStr ;
47444 wxString *arg7 = (wxString *) &arg7_defvalue ;
47445 wxControl *result = 0 ;
47446 void *argp1 = 0 ;
47447 int res1 = 0 ;
47448 int val2 ;
47449 int ecode2 = 0 ;
47450 wxPoint temp3 ;
47451 wxSize temp4 ;
47452 long val5 ;
47453 int ecode5 = 0 ;
47454 void *argp6 = 0 ;
47455 int res6 = 0 ;
47456 bool temp7 = false ;
47457 PyObject * obj0 = 0 ;
47458 PyObject * obj1 = 0 ;
47459 PyObject * obj2 = 0 ;
47460 PyObject * obj3 = 0 ;
47461 PyObject * obj4 = 0 ;
47462 PyObject * obj5 = 0 ;
47463 PyObject * obj6 = 0 ;
47464 char * kwnames[] = {
47465 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47466 };
47467
47468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47470 if (!SWIG_IsOK(res1)) {
47471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47472 }
47473 arg1 = reinterpret_cast< wxWindow * >(argp1);
47474 if (obj1) {
47475 ecode2 = SWIG_AsVal_int(obj1, &val2);
47476 if (!SWIG_IsOK(ecode2)) {
47477 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47478 }
47479 arg2 = static_cast< int >(val2);
47480 }
47481 if (obj2) {
47482 {
47483 arg3 = &temp3;
47484 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47485 }
47486 }
47487 if (obj3) {
47488 {
47489 arg4 = &temp4;
47490 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47491 }
47492 }
47493 if (obj4) {
47494 ecode5 = SWIG_AsVal_long(obj4, &val5);
47495 if (!SWIG_IsOK(ecode5)) {
47496 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47497 }
47498 arg5 = static_cast< long >(val5);
47499 }
47500 if (obj5) {
47501 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47502 if (!SWIG_IsOK(res6)) {
47503 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47504 }
47505 if (!argp6) {
47506 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47507 }
47508 arg6 = reinterpret_cast< wxValidator * >(argp6);
47509 }
47510 if (obj6) {
47511 {
47512 arg7 = wxString_in_helper(obj6);
47513 if (arg7 == NULL) SWIG_fail;
47514 temp7 = true;
47515 }
47516 }
47517 {
47518 if (!wxPyCheckForApp()) SWIG_fail;
47519 PyThreadState* __tstate = wxPyBeginAllowThreads();
47520 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47521 wxPyEndAllowThreads(__tstate);
47522 if (PyErr_Occurred()) SWIG_fail;
47523 }
47524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47525 {
47526 if (temp7)
47527 delete arg7;
47528 }
47529 return resultobj;
47530 fail:
47531 {
47532 if (temp7)
47533 delete arg7;
47534 }
47535 return NULL;
47536 }
47537
47538
47539 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47540 PyObject *resultobj = 0;
47541 wxControl *result = 0 ;
47542
47543 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47544 {
47545 if (!wxPyCheckForApp()) SWIG_fail;
47546 PyThreadState* __tstate = wxPyBeginAllowThreads();
47547 result = (wxControl *)new wxControl();
47548 wxPyEndAllowThreads(__tstate);
47549 if (PyErr_Occurred()) SWIG_fail;
47550 }
47551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47552 return resultobj;
47553 fail:
47554 return NULL;
47555 }
47556
47557
47558 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47559 PyObject *resultobj = 0;
47560 wxControl *arg1 = (wxControl *) 0 ;
47561 wxWindow *arg2 = (wxWindow *) 0 ;
47562 int arg3 = (int) -1 ;
47563 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47564 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47565 wxSize const &arg5_defvalue = wxDefaultSize ;
47566 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47567 long arg6 = (long) 0 ;
47568 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47569 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47570 wxString const &arg8_defvalue = wxPyControlNameStr ;
47571 wxString *arg8 = (wxString *) &arg8_defvalue ;
47572 bool result;
47573 void *argp1 = 0 ;
47574 int res1 = 0 ;
47575 void *argp2 = 0 ;
47576 int res2 = 0 ;
47577 int val3 ;
47578 int ecode3 = 0 ;
47579 wxPoint temp4 ;
47580 wxSize temp5 ;
47581 long val6 ;
47582 int ecode6 = 0 ;
47583 void *argp7 = 0 ;
47584 int res7 = 0 ;
47585 bool temp8 = false ;
47586 PyObject * obj0 = 0 ;
47587 PyObject * obj1 = 0 ;
47588 PyObject * obj2 = 0 ;
47589 PyObject * obj3 = 0 ;
47590 PyObject * obj4 = 0 ;
47591 PyObject * obj5 = 0 ;
47592 PyObject * obj6 = 0 ;
47593 PyObject * obj7 = 0 ;
47594 char * kwnames[] = {
47595 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47596 };
47597
47598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47600 if (!SWIG_IsOK(res1)) {
47601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47602 }
47603 arg1 = reinterpret_cast< wxControl * >(argp1);
47604 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47605 if (!SWIG_IsOK(res2)) {
47606 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47607 }
47608 arg2 = reinterpret_cast< wxWindow * >(argp2);
47609 if (obj2) {
47610 ecode3 = SWIG_AsVal_int(obj2, &val3);
47611 if (!SWIG_IsOK(ecode3)) {
47612 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47613 }
47614 arg3 = static_cast< int >(val3);
47615 }
47616 if (obj3) {
47617 {
47618 arg4 = &temp4;
47619 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47620 }
47621 }
47622 if (obj4) {
47623 {
47624 arg5 = &temp5;
47625 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47626 }
47627 }
47628 if (obj5) {
47629 ecode6 = SWIG_AsVal_long(obj5, &val6);
47630 if (!SWIG_IsOK(ecode6)) {
47631 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47632 }
47633 arg6 = static_cast< long >(val6);
47634 }
47635 if (obj6) {
47636 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47637 if (!SWIG_IsOK(res7)) {
47638 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47639 }
47640 if (!argp7) {
47641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47642 }
47643 arg7 = reinterpret_cast< wxValidator * >(argp7);
47644 }
47645 if (obj7) {
47646 {
47647 arg8 = wxString_in_helper(obj7);
47648 if (arg8 == NULL) SWIG_fail;
47649 temp8 = true;
47650 }
47651 }
47652 {
47653 PyThreadState* __tstate = wxPyBeginAllowThreads();
47654 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47655 wxPyEndAllowThreads(__tstate);
47656 if (PyErr_Occurred()) SWIG_fail;
47657 }
47658 {
47659 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47660 }
47661 {
47662 if (temp8)
47663 delete arg8;
47664 }
47665 return resultobj;
47666 fail:
47667 {
47668 if (temp8)
47669 delete arg8;
47670 }
47671 return NULL;
47672 }
47673
47674
47675 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47676 PyObject *resultobj = 0;
47677 wxControl *arg1 = (wxControl *) 0 ;
47678 int result;
47679 void *argp1 = 0 ;
47680 int res1 = 0 ;
47681 PyObject *swig_obj[1] ;
47682
47683 if (!args) SWIG_fail;
47684 swig_obj[0] = args;
47685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47686 if (!SWIG_IsOK(res1)) {
47687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47688 }
47689 arg1 = reinterpret_cast< wxControl * >(argp1);
47690 {
47691 PyThreadState* __tstate = wxPyBeginAllowThreads();
47692 result = (int)((wxControl const *)arg1)->GetAlignment();
47693 wxPyEndAllowThreads(__tstate);
47694 if (PyErr_Occurred()) SWIG_fail;
47695 }
47696 resultobj = SWIG_From_int(static_cast< int >(result));
47697 return resultobj;
47698 fail:
47699 return NULL;
47700 }
47701
47702
47703 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47704 PyObject *resultobj = 0;
47705 wxControl *arg1 = (wxControl *) 0 ;
47706 wxString result;
47707 void *argp1 = 0 ;
47708 int res1 = 0 ;
47709 PyObject *swig_obj[1] ;
47710
47711 if (!args) SWIG_fail;
47712 swig_obj[0] = args;
47713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47714 if (!SWIG_IsOK(res1)) {
47715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47716 }
47717 arg1 = reinterpret_cast< wxControl * >(argp1);
47718 {
47719 PyThreadState* __tstate = wxPyBeginAllowThreads();
47720 result = ((wxControl const *)arg1)->GetLabelText();
47721 wxPyEndAllowThreads(__tstate);
47722 if (PyErr_Occurred()) SWIG_fail;
47723 }
47724 {
47725 #if wxUSE_UNICODE
47726 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47727 #else
47728 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47729 #endif
47730 }
47731 return resultobj;
47732 fail:
47733 return NULL;
47734 }
47735
47736
47737 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47738 PyObject *resultobj = 0;
47739 wxControl *arg1 = (wxControl *) 0 ;
47740 wxCommandEvent *arg2 = 0 ;
47741 void *argp1 = 0 ;
47742 int res1 = 0 ;
47743 void *argp2 = 0 ;
47744 int res2 = 0 ;
47745 PyObject * obj0 = 0 ;
47746 PyObject * obj1 = 0 ;
47747 char * kwnames[] = {
47748 (char *) "self",(char *) "event", NULL
47749 };
47750
47751 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47752 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47753 if (!SWIG_IsOK(res1)) {
47754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47755 }
47756 arg1 = reinterpret_cast< wxControl * >(argp1);
47757 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47758 if (!SWIG_IsOK(res2)) {
47759 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47760 }
47761 if (!argp2) {
47762 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47763 }
47764 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47765 {
47766 PyThreadState* __tstate = wxPyBeginAllowThreads();
47767 (arg1)->Command(*arg2);
47768 wxPyEndAllowThreads(__tstate);
47769 if (PyErr_Occurred()) SWIG_fail;
47770 }
47771 resultobj = SWIG_Py_Void();
47772 return resultobj;
47773 fail:
47774 return NULL;
47775 }
47776
47777
47778 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47779 PyObject *resultobj = 0;
47780 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47781 SwigValueWrapper<wxVisualAttributes > result;
47782 int val1 ;
47783 int ecode1 = 0 ;
47784 PyObject * obj0 = 0 ;
47785 char * kwnames[] = {
47786 (char *) "variant", NULL
47787 };
47788
47789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47790 if (obj0) {
47791 ecode1 = SWIG_AsVal_int(obj0, &val1);
47792 if (!SWIG_IsOK(ecode1)) {
47793 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47794 }
47795 arg1 = static_cast< wxWindowVariant >(val1);
47796 }
47797 {
47798 if (!wxPyCheckForApp()) SWIG_fail;
47799 PyThreadState* __tstate = wxPyBeginAllowThreads();
47800 result = wxControl::GetClassDefaultAttributes(arg1);
47801 wxPyEndAllowThreads(__tstate);
47802 if (PyErr_Occurred()) SWIG_fail;
47803 }
47804 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47805 return resultobj;
47806 fail:
47807 return NULL;
47808 }
47809
47810
47811 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47812 PyObject *obj;
47813 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47814 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47815 return SWIG_Py_Void();
47816 }
47817
47818 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47819 return SWIG_Python_InitShadowInstance(args);
47820 }
47821
47822 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47823 PyObject *resultobj = 0;
47824 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47825 wxString *arg2 = 0 ;
47826 PyObject *arg3 = (PyObject *) NULL ;
47827 int result;
47828 void *argp1 = 0 ;
47829 int res1 = 0 ;
47830 bool temp2 = false ;
47831 PyObject * obj0 = 0 ;
47832 PyObject * obj1 = 0 ;
47833 PyObject * obj2 = 0 ;
47834 char * kwnames[] = {
47835 (char *) "self",(char *) "item",(char *) "clientData", NULL
47836 };
47837
47838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47839 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47840 if (!SWIG_IsOK(res1)) {
47841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47842 }
47843 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47844 {
47845 arg2 = wxString_in_helper(obj1);
47846 if (arg2 == NULL) SWIG_fail;
47847 temp2 = true;
47848 }
47849 if (obj2) {
47850 arg3 = obj2;
47851 }
47852 {
47853 PyThreadState* __tstate = wxPyBeginAllowThreads();
47854 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47855 wxPyEndAllowThreads(__tstate);
47856 if (PyErr_Occurred()) SWIG_fail;
47857 }
47858 resultobj = SWIG_From_int(static_cast< int >(result));
47859 {
47860 if (temp2)
47861 delete arg2;
47862 }
47863 return resultobj;
47864 fail:
47865 {
47866 if (temp2)
47867 delete arg2;
47868 }
47869 return NULL;
47870 }
47871
47872
47873 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47874 PyObject *resultobj = 0;
47875 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47876 wxArrayString *arg2 = 0 ;
47877 void *argp1 = 0 ;
47878 int res1 = 0 ;
47879 bool temp2 = false ;
47880 PyObject * obj0 = 0 ;
47881 PyObject * obj1 = 0 ;
47882 char * kwnames[] = {
47883 (char *) "self",(char *) "strings", NULL
47884 };
47885
47886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47888 if (!SWIG_IsOK(res1)) {
47889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47890 }
47891 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47892 {
47893 if (! PySequence_Check(obj1)) {
47894 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47895 SWIG_fail;
47896 }
47897 arg2 = new wxArrayString;
47898 temp2 = true;
47899 int i, len=PySequence_Length(obj1);
47900 for (i=0; i<len; i++) {
47901 PyObject* item = PySequence_GetItem(obj1, i);
47902 wxString* s = wxString_in_helper(item);
47903 if (PyErr_Occurred()) SWIG_fail;
47904 arg2->Add(*s);
47905 delete s;
47906 Py_DECREF(item);
47907 }
47908 }
47909 {
47910 PyThreadState* __tstate = wxPyBeginAllowThreads();
47911 (arg1)->Append((wxArrayString const &)*arg2);
47912 wxPyEndAllowThreads(__tstate);
47913 if (PyErr_Occurred()) SWIG_fail;
47914 }
47915 resultobj = SWIG_Py_Void();
47916 {
47917 if (temp2) delete arg2;
47918 }
47919 return resultobj;
47920 fail:
47921 {
47922 if (temp2) delete arg2;
47923 }
47924 return NULL;
47925 }
47926
47927
47928 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47929 PyObject *resultobj = 0;
47930 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47931 wxString *arg2 = 0 ;
47932 int arg3 ;
47933 PyObject *arg4 = (PyObject *) NULL ;
47934 int result;
47935 void *argp1 = 0 ;
47936 int res1 = 0 ;
47937 bool temp2 = false ;
47938 int val3 ;
47939 int ecode3 = 0 ;
47940 PyObject * obj0 = 0 ;
47941 PyObject * obj1 = 0 ;
47942 PyObject * obj2 = 0 ;
47943 PyObject * obj3 = 0 ;
47944 char * kwnames[] = {
47945 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47946 };
47947
47948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47950 if (!SWIG_IsOK(res1)) {
47951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47952 }
47953 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47954 {
47955 arg2 = wxString_in_helper(obj1);
47956 if (arg2 == NULL) SWIG_fail;
47957 temp2 = true;
47958 }
47959 ecode3 = SWIG_AsVal_int(obj2, &val3);
47960 if (!SWIG_IsOK(ecode3)) {
47961 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
47962 }
47963 arg3 = static_cast< int >(val3);
47964 if (obj3) {
47965 arg4 = obj3;
47966 }
47967 {
47968 PyThreadState* __tstate = wxPyBeginAllowThreads();
47969 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47970 wxPyEndAllowThreads(__tstate);
47971 if (PyErr_Occurred()) SWIG_fail;
47972 }
47973 resultobj = SWIG_From_int(static_cast< int >(result));
47974 {
47975 if (temp2)
47976 delete arg2;
47977 }
47978 return resultobj;
47979 fail:
47980 {
47981 if (temp2)
47982 delete arg2;
47983 }
47984 return NULL;
47985 }
47986
47987
47988 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47989 PyObject *resultobj = 0;
47990 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47991 void *argp1 = 0 ;
47992 int res1 = 0 ;
47993 PyObject *swig_obj[1] ;
47994
47995 if (!args) SWIG_fail;
47996 swig_obj[0] = args;
47997 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47998 if (!SWIG_IsOK(res1)) {
47999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48000 }
48001 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48002 {
48003 PyThreadState* __tstate = wxPyBeginAllowThreads();
48004 (arg1)->Clear();
48005 wxPyEndAllowThreads(__tstate);
48006 if (PyErr_Occurred()) SWIG_fail;
48007 }
48008 resultobj = SWIG_Py_Void();
48009 return resultobj;
48010 fail:
48011 return NULL;
48012 }
48013
48014
48015 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48016 PyObject *resultobj = 0;
48017 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48018 int arg2 ;
48019 void *argp1 = 0 ;
48020 int res1 = 0 ;
48021 int val2 ;
48022 int ecode2 = 0 ;
48023 PyObject * obj0 = 0 ;
48024 PyObject * obj1 = 0 ;
48025 char * kwnames[] = {
48026 (char *) "self",(char *) "n", NULL
48027 };
48028
48029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48030 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48031 if (!SWIG_IsOK(res1)) {
48032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48033 }
48034 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48035 ecode2 = SWIG_AsVal_int(obj1, &val2);
48036 if (!SWIG_IsOK(ecode2)) {
48037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48038 }
48039 arg2 = static_cast< int >(val2);
48040 {
48041 PyThreadState* __tstate = wxPyBeginAllowThreads();
48042 (arg1)->Delete(arg2);
48043 wxPyEndAllowThreads(__tstate);
48044 if (PyErr_Occurred()) SWIG_fail;
48045 }
48046 resultobj = SWIG_Py_Void();
48047 return resultobj;
48048 fail:
48049 return NULL;
48050 }
48051
48052
48053 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48054 PyObject *resultobj = 0;
48055 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48056 int arg2 ;
48057 PyObject *result = 0 ;
48058 void *argp1 = 0 ;
48059 int res1 = 0 ;
48060 int val2 ;
48061 int ecode2 = 0 ;
48062 PyObject * obj0 = 0 ;
48063 PyObject * obj1 = 0 ;
48064 char * kwnames[] = {
48065 (char *) "self",(char *) "n", NULL
48066 };
48067
48068 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48069 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48070 if (!SWIG_IsOK(res1)) {
48071 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48072 }
48073 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48074 ecode2 = SWIG_AsVal_int(obj1, &val2);
48075 if (!SWIG_IsOK(ecode2)) {
48076 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48077 }
48078 arg2 = static_cast< int >(val2);
48079 {
48080 PyThreadState* __tstate = wxPyBeginAllowThreads();
48081 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48082 wxPyEndAllowThreads(__tstate);
48083 if (PyErr_Occurred()) SWIG_fail;
48084 }
48085 resultobj = result;
48086 return resultobj;
48087 fail:
48088 return NULL;
48089 }
48090
48091
48092 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48093 PyObject *resultobj = 0;
48094 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48095 int arg2 ;
48096 PyObject *arg3 = (PyObject *) 0 ;
48097 void *argp1 = 0 ;
48098 int res1 = 0 ;
48099 int val2 ;
48100 int ecode2 = 0 ;
48101 PyObject * obj0 = 0 ;
48102 PyObject * obj1 = 0 ;
48103 PyObject * obj2 = 0 ;
48104 char * kwnames[] = {
48105 (char *) "self",(char *) "n",(char *) "clientData", NULL
48106 };
48107
48108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48110 if (!SWIG_IsOK(res1)) {
48111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48112 }
48113 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48114 ecode2 = SWIG_AsVal_int(obj1, &val2);
48115 if (!SWIG_IsOK(ecode2)) {
48116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48117 }
48118 arg2 = static_cast< int >(val2);
48119 arg3 = obj2;
48120 {
48121 PyThreadState* __tstate = wxPyBeginAllowThreads();
48122 wxItemContainer_SetClientData(arg1,arg2,arg3);
48123 wxPyEndAllowThreads(__tstate);
48124 if (PyErr_Occurred()) SWIG_fail;
48125 }
48126 resultobj = SWIG_Py_Void();
48127 return resultobj;
48128 fail:
48129 return NULL;
48130 }
48131
48132
48133 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48134 PyObject *resultobj = 0;
48135 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48136 int result;
48137 void *argp1 = 0 ;
48138 int res1 = 0 ;
48139 PyObject *swig_obj[1] ;
48140
48141 if (!args) SWIG_fail;
48142 swig_obj[0] = args;
48143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48144 if (!SWIG_IsOK(res1)) {
48145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48146 }
48147 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48148 {
48149 PyThreadState* __tstate = wxPyBeginAllowThreads();
48150 result = (int)((wxItemContainer const *)arg1)->GetCount();
48151 wxPyEndAllowThreads(__tstate);
48152 if (PyErr_Occurred()) SWIG_fail;
48153 }
48154 resultobj = SWIG_From_int(static_cast< int >(result));
48155 return resultobj;
48156 fail:
48157 return NULL;
48158 }
48159
48160
48161 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48162 PyObject *resultobj = 0;
48163 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48164 bool result;
48165 void *argp1 = 0 ;
48166 int res1 = 0 ;
48167 PyObject *swig_obj[1] ;
48168
48169 if (!args) SWIG_fail;
48170 swig_obj[0] = args;
48171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48172 if (!SWIG_IsOK(res1)) {
48173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48174 }
48175 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48176 {
48177 PyThreadState* __tstate = wxPyBeginAllowThreads();
48178 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48179 wxPyEndAllowThreads(__tstate);
48180 if (PyErr_Occurred()) SWIG_fail;
48181 }
48182 {
48183 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48184 }
48185 return resultobj;
48186 fail:
48187 return NULL;
48188 }
48189
48190
48191 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48192 PyObject *resultobj = 0;
48193 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48194 int arg2 ;
48195 wxString result;
48196 void *argp1 = 0 ;
48197 int res1 = 0 ;
48198 int val2 ;
48199 int ecode2 = 0 ;
48200 PyObject * obj0 = 0 ;
48201 PyObject * obj1 = 0 ;
48202 char * kwnames[] = {
48203 (char *) "self",(char *) "n", NULL
48204 };
48205
48206 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48207 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48208 if (!SWIG_IsOK(res1)) {
48209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48210 }
48211 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48212 ecode2 = SWIG_AsVal_int(obj1, &val2);
48213 if (!SWIG_IsOK(ecode2)) {
48214 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48215 }
48216 arg2 = static_cast< int >(val2);
48217 {
48218 PyThreadState* __tstate = wxPyBeginAllowThreads();
48219 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48220 wxPyEndAllowThreads(__tstate);
48221 if (PyErr_Occurred()) SWIG_fail;
48222 }
48223 {
48224 #if wxUSE_UNICODE
48225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48226 #else
48227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48228 #endif
48229 }
48230 return resultobj;
48231 fail:
48232 return NULL;
48233 }
48234
48235
48236 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48237 PyObject *resultobj = 0;
48238 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48239 wxArrayString result;
48240 void *argp1 = 0 ;
48241 int res1 = 0 ;
48242 PyObject *swig_obj[1] ;
48243
48244 if (!args) SWIG_fail;
48245 swig_obj[0] = args;
48246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48247 if (!SWIG_IsOK(res1)) {
48248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48249 }
48250 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48251 {
48252 PyThreadState* __tstate = wxPyBeginAllowThreads();
48253 result = ((wxItemContainer const *)arg1)->GetStrings();
48254 wxPyEndAllowThreads(__tstate);
48255 if (PyErr_Occurred()) SWIG_fail;
48256 }
48257 {
48258 resultobj = wxArrayString2PyList_helper(result);
48259 }
48260 return resultobj;
48261 fail:
48262 return NULL;
48263 }
48264
48265
48266 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48267 PyObject *resultobj = 0;
48268 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48269 int arg2 ;
48270 wxString *arg3 = 0 ;
48271 void *argp1 = 0 ;
48272 int res1 = 0 ;
48273 int val2 ;
48274 int ecode2 = 0 ;
48275 bool temp3 = false ;
48276 PyObject * obj0 = 0 ;
48277 PyObject * obj1 = 0 ;
48278 PyObject * obj2 = 0 ;
48279 char * kwnames[] = {
48280 (char *) "self",(char *) "n",(char *) "s", NULL
48281 };
48282
48283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48284 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48285 if (!SWIG_IsOK(res1)) {
48286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48287 }
48288 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48289 ecode2 = SWIG_AsVal_int(obj1, &val2);
48290 if (!SWIG_IsOK(ecode2)) {
48291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48292 }
48293 arg2 = static_cast< int >(val2);
48294 {
48295 arg3 = wxString_in_helper(obj2);
48296 if (arg3 == NULL) SWIG_fail;
48297 temp3 = true;
48298 }
48299 {
48300 PyThreadState* __tstate = wxPyBeginAllowThreads();
48301 (arg1)->SetString(arg2,(wxString const &)*arg3);
48302 wxPyEndAllowThreads(__tstate);
48303 if (PyErr_Occurred()) SWIG_fail;
48304 }
48305 resultobj = SWIG_Py_Void();
48306 {
48307 if (temp3)
48308 delete arg3;
48309 }
48310 return resultobj;
48311 fail:
48312 {
48313 if (temp3)
48314 delete arg3;
48315 }
48316 return NULL;
48317 }
48318
48319
48320 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48321 PyObject *resultobj = 0;
48322 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48323 wxString *arg2 = 0 ;
48324 int result;
48325 void *argp1 = 0 ;
48326 int res1 = 0 ;
48327 bool temp2 = false ;
48328 PyObject * obj0 = 0 ;
48329 PyObject * obj1 = 0 ;
48330 char * kwnames[] = {
48331 (char *) "self",(char *) "s", NULL
48332 };
48333
48334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48335 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48336 if (!SWIG_IsOK(res1)) {
48337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48338 }
48339 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48340 {
48341 arg2 = wxString_in_helper(obj1);
48342 if (arg2 == NULL) SWIG_fail;
48343 temp2 = true;
48344 }
48345 {
48346 PyThreadState* __tstate = wxPyBeginAllowThreads();
48347 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48348 wxPyEndAllowThreads(__tstate);
48349 if (PyErr_Occurred()) SWIG_fail;
48350 }
48351 resultobj = SWIG_From_int(static_cast< int >(result));
48352 {
48353 if (temp2)
48354 delete arg2;
48355 }
48356 return resultobj;
48357 fail:
48358 {
48359 if (temp2)
48360 delete arg2;
48361 }
48362 return NULL;
48363 }
48364
48365
48366 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48367 PyObject *resultobj = 0;
48368 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48369 int arg2 ;
48370 void *argp1 = 0 ;
48371 int res1 = 0 ;
48372 int val2 ;
48373 int ecode2 = 0 ;
48374 PyObject * obj0 = 0 ;
48375 PyObject * obj1 = 0 ;
48376 char * kwnames[] = {
48377 (char *) "self",(char *) "n", NULL
48378 };
48379
48380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48382 if (!SWIG_IsOK(res1)) {
48383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48384 }
48385 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48386 ecode2 = SWIG_AsVal_int(obj1, &val2);
48387 if (!SWIG_IsOK(ecode2)) {
48388 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48389 }
48390 arg2 = static_cast< int >(val2);
48391 {
48392 PyThreadState* __tstate = wxPyBeginAllowThreads();
48393 (arg1)->SetSelection(arg2);
48394 wxPyEndAllowThreads(__tstate);
48395 if (PyErr_Occurred()) SWIG_fail;
48396 }
48397 resultobj = SWIG_Py_Void();
48398 return resultobj;
48399 fail:
48400 return NULL;
48401 }
48402
48403
48404 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48405 PyObject *resultobj = 0;
48406 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48407 int result;
48408 void *argp1 = 0 ;
48409 int res1 = 0 ;
48410 PyObject *swig_obj[1] ;
48411
48412 if (!args) SWIG_fail;
48413 swig_obj[0] = args;
48414 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48415 if (!SWIG_IsOK(res1)) {
48416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48417 }
48418 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48419 {
48420 PyThreadState* __tstate = wxPyBeginAllowThreads();
48421 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48422 wxPyEndAllowThreads(__tstate);
48423 if (PyErr_Occurred()) SWIG_fail;
48424 }
48425 resultobj = SWIG_From_int(static_cast< int >(result));
48426 return resultobj;
48427 fail:
48428 return NULL;
48429 }
48430
48431
48432 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48433 PyObject *resultobj = 0;
48434 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48435 wxString *arg2 = 0 ;
48436 bool result;
48437 void *argp1 = 0 ;
48438 int res1 = 0 ;
48439 bool temp2 = false ;
48440 PyObject * obj0 = 0 ;
48441 PyObject * obj1 = 0 ;
48442 char * kwnames[] = {
48443 (char *) "self",(char *) "s", NULL
48444 };
48445
48446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48448 if (!SWIG_IsOK(res1)) {
48449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48450 }
48451 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48452 {
48453 arg2 = wxString_in_helper(obj1);
48454 if (arg2 == NULL) SWIG_fail;
48455 temp2 = true;
48456 }
48457 {
48458 PyThreadState* __tstate = wxPyBeginAllowThreads();
48459 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48460 wxPyEndAllowThreads(__tstate);
48461 if (PyErr_Occurred()) SWIG_fail;
48462 }
48463 {
48464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48465 }
48466 {
48467 if (temp2)
48468 delete arg2;
48469 }
48470 return resultobj;
48471 fail:
48472 {
48473 if (temp2)
48474 delete arg2;
48475 }
48476 return NULL;
48477 }
48478
48479
48480 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48481 PyObject *resultobj = 0;
48482 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48483 wxString result;
48484 void *argp1 = 0 ;
48485 int res1 = 0 ;
48486 PyObject *swig_obj[1] ;
48487
48488 if (!args) SWIG_fail;
48489 swig_obj[0] = args;
48490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48491 if (!SWIG_IsOK(res1)) {
48492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48493 }
48494 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48495 {
48496 PyThreadState* __tstate = wxPyBeginAllowThreads();
48497 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48498 wxPyEndAllowThreads(__tstate);
48499 if (PyErr_Occurred()) SWIG_fail;
48500 }
48501 {
48502 #if wxUSE_UNICODE
48503 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48504 #else
48505 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48506 #endif
48507 }
48508 return resultobj;
48509 fail:
48510 return NULL;
48511 }
48512
48513
48514 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48515 PyObject *resultobj = 0;
48516 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48517 int arg2 ;
48518 void *argp1 = 0 ;
48519 int res1 = 0 ;
48520 int val2 ;
48521 int ecode2 = 0 ;
48522 PyObject * obj0 = 0 ;
48523 PyObject * obj1 = 0 ;
48524 char * kwnames[] = {
48525 (char *) "self",(char *) "n", NULL
48526 };
48527
48528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48530 if (!SWIG_IsOK(res1)) {
48531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48532 }
48533 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48534 ecode2 = SWIG_AsVal_int(obj1, &val2);
48535 if (!SWIG_IsOK(ecode2)) {
48536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48537 }
48538 arg2 = static_cast< int >(val2);
48539 {
48540 PyThreadState* __tstate = wxPyBeginAllowThreads();
48541 (arg1)->Select(arg2);
48542 wxPyEndAllowThreads(__tstate);
48543 if (PyErr_Occurred()) SWIG_fail;
48544 }
48545 resultobj = SWIG_Py_Void();
48546 return resultobj;
48547 fail:
48548 return NULL;
48549 }
48550
48551
48552 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48553 PyObject *obj;
48554 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48555 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48556 return SWIG_Py_Void();
48557 }
48558
48559 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48560 PyObject *obj;
48561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48562 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48563 return SWIG_Py_Void();
48564 }
48565
48566 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48567 PyObject *resultobj = 0;
48568 wxSizerItem *result = 0 ;
48569
48570 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48571 {
48572 PyThreadState* __tstate = wxPyBeginAllowThreads();
48573 result = (wxSizerItem *)new wxSizerItem();
48574 wxPyEndAllowThreads(__tstate);
48575 if (PyErr_Occurred()) SWIG_fail;
48576 }
48577 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48578 return resultobj;
48579 fail:
48580 return NULL;
48581 }
48582
48583
48584 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48585 PyObject *resultobj = 0;
48586 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48587 void *argp1 = 0 ;
48588 int res1 = 0 ;
48589 PyObject *swig_obj[1] ;
48590
48591 if (!args) SWIG_fail;
48592 swig_obj[0] = args;
48593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48594 if (!SWIG_IsOK(res1)) {
48595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48596 }
48597 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48598 {
48599 PyThreadState* __tstate = wxPyBeginAllowThreads();
48600 delete arg1;
48601
48602 wxPyEndAllowThreads(__tstate);
48603 if (PyErr_Occurred()) SWIG_fail;
48604 }
48605 resultobj = SWIG_Py_Void();
48606 return resultobj;
48607 fail:
48608 return NULL;
48609 }
48610
48611
48612 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48613 PyObject *resultobj = 0;
48614 wxWindow *arg1 = (wxWindow *) 0 ;
48615 int arg2 ;
48616 int arg3 ;
48617 int arg4 ;
48618 PyObject *arg5 = (PyObject *) NULL ;
48619 wxSizerItem *result = 0 ;
48620 void *argp1 = 0 ;
48621 int res1 = 0 ;
48622 int val2 ;
48623 int ecode2 = 0 ;
48624 int val3 ;
48625 int ecode3 = 0 ;
48626 int val4 ;
48627 int ecode4 = 0 ;
48628 PyObject * obj0 = 0 ;
48629 PyObject * obj1 = 0 ;
48630 PyObject * obj2 = 0 ;
48631 PyObject * obj3 = 0 ;
48632 PyObject * obj4 = 0 ;
48633 char * kwnames[] = {
48634 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48635 };
48636
48637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48639 if (!SWIG_IsOK(res1)) {
48640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48641 }
48642 arg1 = reinterpret_cast< wxWindow * >(argp1);
48643 ecode2 = SWIG_AsVal_int(obj1, &val2);
48644 if (!SWIG_IsOK(ecode2)) {
48645 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48646 }
48647 arg2 = static_cast< int >(val2);
48648 ecode3 = SWIG_AsVal_int(obj2, &val3);
48649 if (!SWIG_IsOK(ecode3)) {
48650 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48651 }
48652 arg3 = static_cast< int >(val3);
48653 ecode4 = SWIG_AsVal_int(obj3, &val4);
48654 if (!SWIG_IsOK(ecode4)) {
48655 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48656 }
48657 arg4 = static_cast< int >(val4);
48658 if (obj4) {
48659 arg5 = obj4;
48660 }
48661 {
48662 PyThreadState* __tstate = wxPyBeginAllowThreads();
48663 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48664 wxPyEndAllowThreads(__tstate);
48665 if (PyErr_Occurred()) SWIG_fail;
48666 }
48667 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48668 return resultobj;
48669 fail:
48670 return NULL;
48671 }
48672
48673
48674 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48675 PyObject *resultobj = 0;
48676 int arg1 ;
48677 int arg2 ;
48678 int arg3 ;
48679 int arg4 ;
48680 int arg5 ;
48681 PyObject *arg6 = (PyObject *) NULL ;
48682 wxSizerItem *result = 0 ;
48683 int val1 ;
48684 int ecode1 = 0 ;
48685 int val2 ;
48686 int ecode2 = 0 ;
48687 int val3 ;
48688 int ecode3 = 0 ;
48689 int val4 ;
48690 int ecode4 = 0 ;
48691 int val5 ;
48692 int ecode5 = 0 ;
48693 PyObject * obj0 = 0 ;
48694 PyObject * obj1 = 0 ;
48695 PyObject * obj2 = 0 ;
48696 PyObject * obj3 = 0 ;
48697 PyObject * obj4 = 0 ;
48698 PyObject * obj5 = 0 ;
48699 char * kwnames[] = {
48700 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48701 };
48702
48703 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48704 ecode1 = SWIG_AsVal_int(obj0, &val1);
48705 if (!SWIG_IsOK(ecode1)) {
48706 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48707 }
48708 arg1 = static_cast< int >(val1);
48709 ecode2 = SWIG_AsVal_int(obj1, &val2);
48710 if (!SWIG_IsOK(ecode2)) {
48711 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48712 }
48713 arg2 = static_cast< int >(val2);
48714 ecode3 = SWIG_AsVal_int(obj2, &val3);
48715 if (!SWIG_IsOK(ecode3)) {
48716 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48717 }
48718 arg3 = static_cast< int >(val3);
48719 ecode4 = SWIG_AsVal_int(obj3, &val4);
48720 if (!SWIG_IsOK(ecode4)) {
48721 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48722 }
48723 arg4 = static_cast< int >(val4);
48724 ecode5 = SWIG_AsVal_int(obj4, &val5);
48725 if (!SWIG_IsOK(ecode5)) {
48726 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48727 }
48728 arg5 = static_cast< int >(val5);
48729 if (obj5) {
48730 arg6 = obj5;
48731 }
48732 {
48733 PyThreadState* __tstate = wxPyBeginAllowThreads();
48734 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48735 wxPyEndAllowThreads(__tstate);
48736 if (PyErr_Occurred()) SWIG_fail;
48737 }
48738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48739 return resultobj;
48740 fail:
48741 return NULL;
48742 }
48743
48744
48745 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48746 PyObject *resultobj = 0;
48747 wxSizer *arg1 = (wxSizer *) 0 ;
48748 int arg2 ;
48749 int arg3 ;
48750 int arg4 ;
48751 PyObject *arg5 = (PyObject *) NULL ;
48752 wxSizerItem *result = 0 ;
48753 int res1 = 0 ;
48754 int val2 ;
48755 int ecode2 = 0 ;
48756 int val3 ;
48757 int ecode3 = 0 ;
48758 int val4 ;
48759 int ecode4 = 0 ;
48760 PyObject * obj0 = 0 ;
48761 PyObject * obj1 = 0 ;
48762 PyObject * obj2 = 0 ;
48763 PyObject * obj3 = 0 ;
48764 PyObject * obj4 = 0 ;
48765 char * kwnames[] = {
48766 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48767 };
48768
48769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48770 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48771 if (!SWIG_IsOK(res1)) {
48772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48773 }
48774 ecode2 = SWIG_AsVal_int(obj1, &val2);
48775 if (!SWIG_IsOK(ecode2)) {
48776 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48777 }
48778 arg2 = static_cast< int >(val2);
48779 ecode3 = SWIG_AsVal_int(obj2, &val3);
48780 if (!SWIG_IsOK(ecode3)) {
48781 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48782 }
48783 arg3 = static_cast< int >(val3);
48784 ecode4 = SWIG_AsVal_int(obj3, &val4);
48785 if (!SWIG_IsOK(ecode4)) {
48786 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48787 }
48788 arg4 = static_cast< int >(val4);
48789 if (obj4) {
48790 arg5 = obj4;
48791 }
48792 {
48793 PyThreadState* __tstate = wxPyBeginAllowThreads();
48794 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48795 wxPyEndAllowThreads(__tstate);
48796 if (PyErr_Occurred()) SWIG_fail;
48797 }
48798 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48799 return resultobj;
48800 fail:
48801 return NULL;
48802 }
48803
48804
48805 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48806 PyObject *resultobj = 0;
48807 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48808 void *argp1 = 0 ;
48809 int res1 = 0 ;
48810 PyObject *swig_obj[1] ;
48811
48812 if (!args) SWIG_fail;
48813 swig_obj[0] = args;
48814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48815 if (!SWIG_IsOK(res1)) {
48816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48817 }
48818 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48819 {
48820 PyThreadState* __tstate = wxPyBeginAllowThreads();
48821 (arg1)->DeleteWindows();
48822 wxPyEndAllowThreads(__tstate);
48823 if (PyErr_Occurred()) SWIG_fail;
48824 }
48825 resultobj = SWIG_Py_Void();
48826 return resultobj;
48827 fail:
48828 return NULL;
48829 }
48830
48831
48832 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48833 PyObject *resultobj = 0;
48834 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48835 void *argp1 = 0 ;
48836 int res1 = 0 ;
48837 PyObject *swig_obj[1] ;
48838
48839 if (!args) SWIG_fail;
48840 swig_obj[0] = args;
48841 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48842 if (!SWIG_IsOK(res1)) {
48843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48844 }
48845 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48846 {
48847 PyThreadState* __tstate = wxPyBeginAllowThreads();
48848 (arg1)->DetachSizer();
48849 wxPyEndAllowThreads(__tstate);
48850 if (PyErr_Occurred()) SWIG_fail;
48851 }
48852 resultobj = SWIG_Py_Void();
48853 return resultobj;
48854 fail:
48855 return NULL;
48856 }
48857
48858
48859 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48860 PyObject *resultobj = 0;
48861 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48862 wxSize result;
48863 void *argp1 = 0 ;
48864 int res1 = 0 ;
48865 PyObject *swig_obj[1] ;
48866
48867 if (!args) SWIG_fail;
48868 swig_obj[0] = args;
48869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48870 if (!SWIG_IsOK(res1)) {
48871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48872 }
48873 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48874 {
48875 PyThreadState* __tstate = wxPyBeginAllowThreads();
48876 result = (arg1)->GetSize();
48877 wxPyEndAllowThreads(__tstate);
48878 if (PyErr_Occurred()) SWIG_fail;
48879 }
48880 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48881 return resultobj;
48882 fail:
48883 return NULL;
48884 }
48885
48886
48887 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48888 PyObject *resultobj = 0;
48889 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48890 wxSize result;
48891 void *argp1 = 0 ;
48892 int res1 = 0 ;
48893 PyObject *swig_obj[1] ;
48894
48895 if (!args) SWIG_fail;
48896 swig_obj[0] = args;
48897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48898 if (!SWIG_IsOK(res1)) {
48899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48900 }
48901 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48902 {
48903 PyThreadState* __tstate = wxPyBeginAllowThreads();
48904 result = (arg1)->CalcMin();
48905 wxPyEndAllowThreads(__tstate);
48906 if (PyErr_Occurred()) SWIG_fail;
48907 }
48908 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48909 return resultobj;
48910 fail:
48911 return NULL;
48912 }
48913
48914
48915 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48916 PyObject *resultobj = 0;
48917 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48918 wxPoint *arg2 = 0 ;
48919 wxSize *arg3 = 0 ;
48920 void *argp1 = 0 ;
48921 int res1 = 0 ;
48922 wxPoint temp2 ;
48923 wxSize temp3 ;
48924 PyObject * obj0 = 0 ;
48925 PyObject * obj1 = 0 ;
48926 PyObject * obj2 = 0 ;
48927 char * kwnames[] = {
48928 (char *) "self",(char *) "pos",(char *) "size", NULL
48929 };
48930
48931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48933 if (!SWIG_IsOK(res1)) {
48934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48935 }
48936 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48937 {
48938 arg2 = &temp2;
48939 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48940 }
48941 {
48942 arg3 = &temp3;
48943 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48944 }
48945 {
48946 PyThreadState* __tstate = wxPyBeginAllowThreads();
48947 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48948 wxPyEndAllowThreads(__tstate);
48949 if (PyErr_Occurred()) SWIG_fail;
48950 }
48951 resultobj = SWIG_Py_Void();
48952 return resultobj;
48953 fail:
48954 return NULL;
48955 }
48956
48957
48958 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48959 PyObject *resultobj = 0;
48960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48961 wxSize result;
48962 void *argp1 = 0 ;
48963 int res1 = 0 ;
48964 PyObject *swig_obj[1] ;
48965
48966 if (!args) SWIG_fail;
48967 swig_obj[0] = args;
48968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48969 if (!SWIG_IsOK(res1)) {
48970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48971 }
48972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48973 {
48974 PyThreadState* __tstate = wxPyBeginAllowThreads();
48975 result = (arg1)->GetMinSize();
48976 wxPyEndAllowThreads(__tstate);
48977 if (PyErr_Occurred()) SWIG_fail;
48978 }
48979 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48980 return resultobj;
48981 fail:
48982 return NULL;
48983 }
48984
48985
48986 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48987 PyObject *resultobj = 0;
48988 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48989 wxSize result;
48990 void *argp1 = 0 ;
48991 int res1 = 0 ;
48992 PyObject *swig_obj[1] ;
48993
48994 if (!args) SWIG_fail;
48995 swig_obj[0] = args;
48996 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48997 if (!SWIG_IsOK(res1)) {
48998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48999 }
49000 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49001 {
49002 PyThreadState* __tstate = wxPyBeginAllowThreads();
49003 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
49004 wxPyEndAllowThreads(__tstate);
49005 if (PyErr_Occurred()) SWIG_fail;
49006 }
49007 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49008 return resultobj;
49009 fail:
49010 return NULL;
49011 }
49012
49013
49014 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49015 PyObject *resultobj = 0;
49016 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49017 int arg2 ;
49018 int arg3 ;
49019 void *argp1 = 0 ;
49020 int res1 = 0 ;
49021 int val2 ;
49022 int ecode2 = 0 ;
49023 int val3 ;
49024 int ecode3 = 0 ;
49025 PyObject * obj0 = 0 ;
49026 PyObject * obj1 = 0 ;
49027 PyObject * obj2 = 0 ;
49028 char * kwnames[] = {
49029 (char *) "self",(char *) "x",(char *) "y", NULL
49030 };
49031
49032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49034 if (!SWIG_IsOK(res1)) {
49035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49036 }
49037 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49038 ecode2 = SWIG_AsVal_int(obj1, &val2);
49039 if (!SWIG_IsOK(ecode2)) {
49040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
49041 }
49042 arg2 = static_cast< int >(val2);
49043 ecode3 = SWIG_AsVal_int(obj2, &val3);
49044 if (!SWIG_IsOK(ecode3)) {
49045 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
49046 }
49047 arg3 = static_cast< int >(val3);
49048 {
49049 PyThreadState* __tstate = wxPyBeginAllowThreads();
49050 (arg1)->SetInitSize(arg2,arg3);
49051 wxPyEndAllowThreads(__tstate);
49052 if (PyErr_Occurred()) SWIG_fail;
49053 }
49054 resultobj = SWIG_Py_Void();
49055 return resultobj;
49056 fail:
49057 return NULL;
49058 }
49059
49060
49061 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49062 PyObject *resultobj = 0;
49063 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49064 int arg2 ;
49065 int arg3 ;
49066 void *argp1 = 0 ;
49067 int res1 = 0 ;
49068 int val2 ;
49069 int ecode2 = 0 ;
49070 int val3 ;
49071 int ecode3 = 0 ;
49072 PyObject * obj0 = 0 ;
49073 PyObject * obj1 = 0 ;
49074 PyObject * obj2 = 0 ;
49075 char * kwnames[] = {
49076 (char *) "self",(char *) "width",(char *) "height", NULL
49077 };
49078
49079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49081 if (!SWIG_IsOK(res1)) {
49082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49083 }
49084 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49085 ecode2 = SWIG_AsVal_int(obj1, &val2);
49086 if (!SWIG_IsOK(ecode2)) {
49087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
49088 }
49089 arg2 = static_cast< int >(val2);
49090 ecode3 = SWIG_AsVal_int(obj2, &val3);
49091 if (!SWIG_IsOK(ecode3)) {
49092 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
49093 }
49094 arg3 = static_cast< int >(val3);
49095 {
49096 PyThreadState* __tstate = wxPyBeginAllowThreads();
49097 (arg1)->SetRatio(arg2,arg3);
49098 wxPyEndAllowThreads(__tstate);
49099 if (PyErr_Occurred()) SWIG_fail;
49100 }
49101 resultobj = SWIG_Py_Void();
49102 return resultobj;
49103 fail:
49104 return NULL;
49105 }
49106
49107
49108 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49109 PyObject *resultobj = 0;
49110 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49111 wxSize *arg2 = 0 ;
49112 void *argp1 = 0 ;
49113 int res1 = 0 ;
49114 wxSize temp2 ;
49115 PyObject * obj0 = 0 ;
49116 PyObject * obj1 = 0 ;
49117 char * kwnames[] = {
49118 (char *) "self",(char *) "size", NULL
49119 };
49120
49121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
49122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49123 if (!SWIG_IsOK(res1)) {
49124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49125 }
49126 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49127 {
49128 arg2 = &temp2;
49129 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49130 }
49131 {
49132 PyThreadState* __tstate = wxPyBeginAllowThreads();
49133 (arg1)->SetRatio((wxSize const &)*arg2);
49134 wxPyEndAllowThreads(__tstate);
49135 if (PyErr_Occurred()) SWIG_fail;
49136 }
49137 resultobj = SWIG_Py_Void();
49138 return resultobj;
49139 fail:
49140 return NULL;
49141 }
49142
49143
49144 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49145 PyObject *resultobj = 0;
49146 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49147 float arg2 ;
49148 void *argp1 = 0 ;
49149 int res1 = 0 ;
49150 float val2 ;
49151 int ecode2 = 0 ;
49152 PyObject * obj0 = 0 ;
49153 PyObject * obj1 = 0 ;
49154 char * kwnames[] = {
49155 (char *) "self",(char *) "ratio", NULL
49156 };
49157
49158 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
49159 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49160 if (!SWIG_IsOK(res1)) {
49161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49162 }
49163 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49164 ecode2 = SWIG_AsVal_float(obj1, &val2);
49165 if (!SWIG_IsOK(ecode2)) {
49166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49167 }
49168 arg2 = static_cast< float >(val2);
49169 {
49170 PyThreadState* __tstate = wxPyBeginAllowThreads();
49171 (arg1)->SetRatio(arg2);
49172 wxPyEndAllowThreads(__tstate);
49173 if (PyErr_Occurred()) SWIG_fail;
49174 }
49175 resultobj = SWIG_Py_Void();
49176 return resultobj;
49177 fail:
49178 return NULL;
49179 }
49180
49181
49182 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49183 PyObject *resultobj = 0;
49184 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49185 float result;
49186 void *argp1 = 0 ;
49187 int res1 = 0 ;
49188 PyObject *swig_obj[1] ;
49189
49190 if (!args) SWIG_fail;
49191 swig_obj[0] = args;
49192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49193 if (!SWIG_IsOK(res1)) {
49194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49195 }
49196 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49197 {
49198 PyThreadState* __tstate = wxPyBeginAllowThreads();
49199 result = (float)(arg1)->GetRatio();
49200 wxPyEndAllowThreads(__tstate);
49201 if (PyErr_Occurred()) SWIG_fail;
49202 }
49203 resultobj = SWIG_From_float(static_cast< float >(result));
49204 return resultobj;
49205 fail:
49206 return NULL;
49207 }
49208
49209
49210 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49211 PyObject *resultobj = 0;
49212 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49213 wxRect result;
49214 void *argp1 = 0 ;
49215 int res1 = 0 ;
49216 PyObject *swig_obj[1] ;
49217
49218 if (!args) SWIG_fail;
49219 swig_obj[0] = args;
49220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49221 if (!SWIG_IsOK(res1)) {
49222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49223 }
49224 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49225 {
49226 PyThreadState* __tstate = wxPyBeginAllowThreads();
49227 result = (arg1)->GetRect();
49228 wxPyEndAllowThreads(__tstate);
49229 if (PyErr_Occurred()) SWIG_fail;
49230 }
49231 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49232 return resultobj;
49233 fail:
49234 return NULL;
49235 }
49236
49237
49238 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49239 PyObject *resultobj = 0;
49240 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49241 bool result;
49242 void *argp1 = 0 ;
49243 int res1 = 0 ;
49244 PyObject *swig_obj[1] ;
49245
49246 if (!args) SWIG_fail;
49247 swig_obj[0] = args;
49248 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49249 if (!SWIG_IsOK(res1)) {
49250 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49251 }
49252 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49253 {
49254 PyThreadState* __tstate = wxPyBeginAllowThreads();
49255 result = (bool)(arg1)->IsWindow();
49256 wxPyEndAllowThreads(__tstate);
49257 if (PyErr_Occurred()) SWIG_fail;
49258 }
49259 {
49260 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49261 }
49262 return resultobj;
49263 fail:
49264 return NULL;
49265 }
49266
49267
49268 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49269 PyObject *resultobj = 0;
49270 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49271 bool result;
49272 void *argp1 = 0 ;
49273 int res1 = 0 ;
49274 PyObject *swig_obj[1] ;
49275
49276 if (!args) SWIG_fail;
49277 swig_obj[0] = args;
49278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49279 if (!SWIG_IsOK(res1)) {
49280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49281 }
49282 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49283 {
49284 PyThreadState* __tstate = wxPyBeginAllowThreads();
49285 result = (bool)(arg1)->IsSizer();
49286 wxPyEndAllowThreads(__tstate);
49287 if (PyErr_Occurred()) SWIG_fail;
49288 }
49289 {
49290 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49291 }
49292 return resultobj;
49293 fail:
49294 return NULL;
49295 }
49296
49297
49298 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49299 PyObject *resultobj = 0;
49300 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49301 bool result;
49302 void *argp1 = 0 ;
49303 int res1 = 0 ;
49304 PyObject *swig_obj[1] ;
49305
49306 if (!args) SWIG_fail;
49307 swig_obj[0] = args;
49308 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49309 if (!SWIG_IsOK(res1)) {
49310 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49311 }
49312 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49313 {
49314 PyThreadState* __tstate = wxPyBeginAllowThreads();
49315 result = (bool)(arg1)->IsSpacer();
49316 wxPyEndAllowThreads(__tstate);
49317 if (PyErr_Occurred()) SWIG_fail;
49318 }
49319 {
49320 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49321 }
49322 return resultobj;
49323 fail:
49324 return NULL;
49325 }
49326
49327
49328 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49329 PyObject *resultobj = 0;
49330 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49331 int arg2 ;
49332 void *argp1 = 0 ;
49333 int res1 = 0 ;
49334 int val2 ;
49335 int ecode2 = 0 ;
49336 PyObject * obj0 = 0 ;
49337 PyObject * obj1 = 0 ;
49338 char * kwnames[] = {
49339 (char *) "self",(char *) "proportion", NULL
49340 };
49341
49342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49344 if (!SWIG_IsOK(res1)) {
49345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49346 }
49347 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49348 ecode2 = SWIG_AsVal_int(obj1, &val2);
49349 if (!SWIG_IsOK(ecode2)) {
49350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49351 }
49352 arg2 = static_cast< int >(val2);
49353 {
49354 PyThreadState* __tstate = wxPyBeginAllowThreads();
49355 (arg1)->SetProportion(arg2);
49356 wxPyEndAllowThreads(__tstate);
49357 if (PyErr_Occurred()) SWIG_fail;
49358 }
49359 resultobj = SWIG_Py_Void();
49360 return resultobj;
49361 fail:
49362 return NULL;
49363 }
49364
49365
49366 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49367 PyObject *resultobj = 0;
49368 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49369 int result;
49370 void *argp1 = 0 ;
49371 int res1 = 0 ;
49372 PyObject *swig_obj[1] ;
49373
49374 if (!args) SWIG_fail;
49375 swig_obj[0] = args;
49376 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49377 if (!SWIG_IsOK(res1)) {
49378 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49379 }
49380 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49381 {
49382 PyThreadState* __tstate = wxPyBeginAllowThreads();
49383 result = (int)(arg1)->GetProportion();
49384 wxPyEndAllowThreads(__tstate);
49385 if (PyErr_Occurred()) SWIG_fail;
49386 }
49387 resultobj = SWIG_From_int(static_cast< int >(result));
49388 return resultobj;
49389 fail:
49390 return NULL;
49391 }
49392
49393
49394 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49395 PyObject *resultobj = 0;
49396 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49397 int arg2 ;
49398 void *argp1 = 0 ;
49399 int res1 = 0 ;
49400 int val2 ;
49401 int ecode2 = 0 ;
49402 PyObject * obj0 = 0 ;
49403 PyObject * obj1 = 0 ;
49404 char * kwnames[] = {
49405 (char *) "self",(char *) "flag", NULL
49406 };
49407
49408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49410 if (!SWIG_IsOK(res1)) {
49411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49412 }
49413 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49414 ecode2 = SWIG_AsVal_int(obj1, &val2);
49415 if (!SWIG_IsOK(ecode2)) {
49416 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49417 }
49418 arg2 = static_cast< int >(val2);
49419 {
49420 PyThreadState* __tstate = wxPyBeginAllowThreads();
49421 (arg1)->SetFlag(arg2);
49422 wxPyEndAllowThreads(__tstate);
49423 if (PyErr_Occurred()) SWIG_fail;
49424 }
49425 resultobj = SWIG_Py_Void();
49426 return resultobj;
49427 fail:
49428 return NULL;
49429 }
49430
49431
49432 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49433 PyObject *resultobj = 0;
49434 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49435 int result;
49436 void *argp1 = 0 ;
49437 int res1 = 0 ;
49438 PyObject *swig_obj[1] ;
49439
49440 if (!args) SWIG_fail;
49441 swig_obj[0] = args;
49442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49443 if (!SWIG_IsOK(res1)) {
49444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49445 }
49446 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49447 {
49448 PyThreadState* __tstate = wxPyBeginAllowThreads();
49449 result = (int)(arg1)->GetFlag();
49450 wxPyEndAllowThreads(__tstate);
49451 if (PyErr_Occurred()) SWIG_fail;
49452 }
49453 resultobj = SWIG_From_int(static_cast< int >(result));
49454 return resultobj;
49455 fail:
49456 return NULL;
49457 }
49458
49459
49460 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49461 PyObject *resultobj = 0;
49462 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49463 int arg2 ;
49464 void *argp1 = 0 ;
49465 int res1 = 0 ;
49466 int val2 ;
49467 int ecode2 = 0 ;
49468 PyObject * obj0 = 0 ;
49469 PyObject * obj1 = 0 ;
49470 char * kwnames[] = {
49471 (char *) "self",(char *) "border", NULL
49472 };
49473
49474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49476 if (!SWIG_IsOK(res1)) {
49477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49478 }
49479 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49480 ecode2 = SWIG_AsVal_int(obj1, &val2);
49481 if (!SWIG_IsOK(ecode2)) {
49482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49483 }
49484 arg2 = static_cast< int >(val2);
49485 {
49486 PyThreadState* __tstate = wxPyBeginAllowThreads();
49487 (arg1)->SetBorder(arg2);
49488 wxPyEndAllowThreads(__tstate);
49489 if (PyErr_Occurred()) SWIG_fail;
49490 }
49491 resultobj = SWIG_Py_Void();
49492 return resultobj;
49493 fail:
49494 return NULL;
49495 }
49496
49497
49498 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49499 PyObject *resultobj = 0;
49500 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49501 int result;
49502 void *argp1 = 0 ;
49503 int res1 = 0 ;
49504 PyObject *swig_obj[1] ;
49505
49506 if (!args) SWIG_fail;
49507 swig_obj[0] = args;
49508 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49509 if (!SWIG_IsOK(res1)) {
49510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49511 }
49512 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49513 {
49514 PyThreadState* __tstate = wxPyBeginAllowThreads();
49515 result = (int)(arg1)->GetBorder();
49516 wxPyEndAllowThreads(__tstate);
49517 if (PyErr_Occurred()) SWIG_fail;
49518 }
49519 resultobj = SWIG_From_int(static_cast< int >(result));
49520 return resultobj;
49521 fail:
49522 return NULL;
49523 }
49524
49525
49526 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49527 PyObject *resultobj = 0;
49528 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49529 wxWindow *result = 0 ;
49530 void *argp1 = 0 ;
49531 int res1 = 0 ;
49532 PyObject *swig_obj[1] ;
49533
49534 if (!args) SWIG_fail;
49535 swig_obj[0] = args;
49536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49537 if (!SWIG_IsOK(res1)) {
49538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49539 }
49540 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49541 {
49542 PyThreadState* __tstate = wxPyBeginAllowThreads();
49543 result = (wxWindow *)(arg1)->GetWindow();
49544 wxPyEndAllowThreads(__tstate);
49545 if (PyErr_Occurred()) SWIG_fail;
49546 }
49547 {
49548 resultobj = wxPyMake_wxObject(result, 0);
49549 }
49550 return resultobj;
49551 fail:
49552 return NULL;
49553 }
49554
49555
49556 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49557 PyObject *resultobj = 0;
49558 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49559 wxWindow *arg2 = (wxWindow *) 0 ;
49560 void *argp1 = 0 ;
49561 int res1 = 0 ;
49562 void *argp2 = 0 ;
49563 int res2 = 0 ;
49564 PyObject * obj0 = 0 ;
49565 PyObject * obj1 = 0 ;
49566 char * kwnames[] = {
49567 (char *) "self",(char *) "window", NULL
49568 };
49569
49570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49572 if (!SWIG_IsOK(res1)) {
49573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49574 }
49575 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49577 if (!SWIG_IsOK(res2)) {
49578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49579 }
49580 arg2 = reinterpret_cast< wxWindow * >(argp2);
49581 {
49582 PyThreadState* __tstate = wxPyBeginAllowThreads();
49583 (arg1)->SetWindow(arg2);
49584 wxPyEndAllowThreads(__tstate);
49585 if (PyErr_Occurred()) SWIG_fail;
49586 }
49587 resultobj = SWIG_Py_Void();
49588 return resultobj;
49589 fail:
49590 return NULL;
49591 }
49592
49593
49594 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49595 PyObject *resultobj = 0;
49596 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49597 wxSizer *result = 0 ;
49598 void *argp1 = 0 ;
49599 int res1 = 0 ;
49600 PyObject *swig_obj[1] ;
49601
49602 if (!args) SWIG_fail;
49603 swig_obj[0] = args;
49604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49605 if (!SWIG_IsOK(res1)) {
49606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49607 }
49608 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49609 {
49610 PyThreadState* __tstate = wxPyBeginAllowThreads();
49611 result = (wxSizer *)(arg1)->GetSizer();
49612 wxPyEndAllowThreads(__tstate);
49613 if (PyErr_Occurred()) SWIG_fail;
49614 }
49615 {
49616 resultobj = wxPyMake_wxObject(result, (bool)0);
49617 }
49618 return resultobj;
49619 fail:
49620 return NULL;
49621 }
49622
49623
49624 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49625 PyObject *resultobj = 0;
49626 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49627 wxSizer *arg2 = (wxSizer *) 0 ;
49628 void *argp1 = 0 ;
49629 int res1 = 0 ;
49630 int res2 = 0 ;
49631 PyObject * obj0 = 0 ;
49632 PyObject * obj1 = 0 ;
49633 char * kwnames[] = {
49634 (char *) "self",(char *) "sizer", NULL
49635 };
49636
49637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49639 if (!SWIG_IsOK(res1)) {
49640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49641 }
49642 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49643 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49644 if (!SWIG_IsOK(res2)) {
49645 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49646 }
49647 {
49648 PyThreadState* __tstate = wxPyBeginAllowThreads();
49649 (arg1)->SetSizer(arg2);
49650 wxPyEndAllowThreads(__tstate);
49651 if (PyErr_Occurred()) SWIG_fail;
49652 }
49653 resultobj = SWIG_Py_Void();
49654 return resultobj;
49655 fail:
49656 return NULL;
49657 }
49658
49659
49660 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49661 PyObject *resultobj = 0;
49662 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49663 wxSize result;
49664 void *argp1 = 0 ;
49665 int res1 = 0 ;
49666 PyObject *swig_obj[1] ;
49667
49668 if (!args) SWIG_fail;
49669 swig_obj[0] = args;
49670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49671 if (!SWIG_IsOK(res1)) {
49672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49673 }
49674 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49675 {
49676 PyThreadState* __tstate = wxPyBeginAllowThreads();
49677 result = (arg1)->GetSpacer();
49678 wxPyEndAllowThreads(__tstate);
49679 if (PyErr_Occurred()) SWIG_fail;
49680 }
49681 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49682 return resultobj;
49683 fail:
49684 return NULL;
49685 }
49686
49687
49688 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49689 PyObject *resultobj = 0;
49690 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49691 wxSize *arg2 = 0 ;
49692 void *argp1 = 0 ;
49693 int res1 = 0 ;
49694 wxSize temp2 ;
49695 PyObject * obj0 = 0 ;
49696 PyObject * obj1 = 0 ;
49697 char * kwnames[] = {
49698 (char *) "self",(char *) "size", NULL
49699 };
49700
49701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49703 if (!SWIG_IsOK(res1)) {
49704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49705 }
49706 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49707 {
49708 arg2 = &temp2;
49709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49710 }
49711 {
49712 PyThreadState* __tstate = wxPyBeginAllowThreads();
49713 (arg1)->SetSpacer((wxSize const &)*arg2);
49714 wxPyEndAllowThreads(__tstate);
49715 if (PyErr_Occurred()) SWIG_fail;
49716 }
49717 resultobj = SWIG_Py_Void();
49718 return resultobj;
49719 fail:
49720 return NULL;
49721 }
49722
49723
49724 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49725 PyObject *resultobj = 0;
49726 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49727 bool arg2 ;
49728 void *argp1 = 0 ;
49729 int res1 = 0 ;
49730 bool val2 ;
49731 int ecode2 = 0 ;
49732 PyObject * obj0 = 0 ;
49733 PyObject * obj1 = 0 ;
49734 char * kwnames[] = {
49735 (char *) "self",(char *) "show", NULL
49736 };
49737
49738 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49739 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49740 if (!SWIG_IsOK(res1)) {
49741 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49742 }
49743 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49744 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49745 if (!SWIG_IsOK(ecode2)) {
49746 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49747 }
49748 arg2 = static_cast< bool >(val2);
49749 {
49750 PyThreadState* __tstate = wxPyBeginAllowThreads();
49751 (arg1)->Show(arg2);
49752 wxPyEndAllowThreads(__tstate);
49753 if (PyErr_Occurred()) SWIG_fail;
49754 }
49755 resultobj = SWIG_Py_Void();
49756 return resultobj;
49757 fail:
49758 return NULL;
49759 }
49760
49761
49762 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49763 PyObject *resultobj = 0;
49764 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49765 bool result;
49766 void *argp1 = 0 ;
49767 int res1 = 0 ;
49768 PyObject *swig_obj[1] ;
49769
49770 if (!args) SWIG_fail;
49771 swig_obj[0] = args;
49772 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49773 if (!SWIG_IsOK(res1)) {
49774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49775 }
49776 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49777 {
49778 PyThreadState* __tstate = wxPyBeginAllowThreads();
49779 result = (bool)(arg1)->IsShown();
49780 wxPyEndAllowThreads(__tstate);
49781 if (PyErr_Occurred()) SWIG_fail;
49782 }
49783 {
49784 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49785 }
49786 return resultobj;
49787 fail:
49788 return NULL;
49789 }
49790
49791
49792 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49793 PyObject *resultobj = 0;
49794 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49795 wxPoint result;
49796 void *argp1 = 0 ;
49797 int res1 = 0 ;
49798 PyObject *swig_obj[1] ;
49799
49800 if (!args) SWIG_fail;
49801 swig_obj[0] = args;
49802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49803 if (!SWIG_IsOK(res1)) {
49804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49805 }
49806 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49807 {
49808 PyThreadState* __tstate = wxPyBeginAllowThreads();
49809 result = (arg1)->GetPosition();
49810 wxPyEndAllowThreads(__tstate);
49811 if (PyErr_Occurred()) SWIG_fail;
49812 }
49813 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49814 return resultobj;
49815 fail:
49816 return NULL;
49817 }
49818
49819
49820 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49821 PyObject *resultobj = 0;
49822 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49823 PyObject *result = 0 ;
49824 void *argp1 = 0 ;
49825 int res1 = 0 ;
49826 PyObject *swig_obj[1] ;
49827
49828 if (!args) SWIG_fail;
49829 swig_obj[0] = args;
49830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49831 if (!SWIG_IsOK(res1)) {
49832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49833 }
49834 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49835 {
49836 PyThreadState* __tstate = wxPyBeginAllowThreads();
49837 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49838 wxPyEndAllowThreads(__tstate);
49839 if (PyErr_Occurred()) SWIG_fail;
49840 }
49841 resultobj = result;
49842 return resultobj;
49843 fail:
49844 return NULL;
49845 }
49846
49847
49848 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49849 PyObject *resultobj = 0;
49850 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49851 PyObject *arg2 = (PyObject *) 0 ;
49852 void *argp1 = 0 ;
49853 int res1 = 0 ;
49854 PyObject * obj0 = 0 ;
49855 PyObject * obj1 = 0 ;
49856 char * kwnames[] = {
49857 (char *) "self",(char *) "userData", NULL
49858 };
49859
49860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49862 if (!SWIG_IsOK(res1)) {
49863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49864 }
49865 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49866 arg2 = obj1;
49867 {
49868 PyThreadState* __tstate = wxPyBeginAllowThreads();
49869 wxSizerItem_SetUserData(arg1,arg2);
49870 wxPyEndAllowThreads(__tstate);
49871 if (PyErr_Occurred()) SWIG_fail;
49872 }
49873 resultobj = SWIG_Py_Void();
49874 return resultobj;
49875 fail:
49876 return NULL;
49877 }
49878
49879
49880 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49881 PyObject *obj;
49882 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49883 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49884 return SWIG_Py_Void();
49885 }
49886
49887 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49888 return SWIG_Python_InitShadowInstance(args);
49889 }
49890
49891 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49892 PyObject *resultobj = 0;
49893 wxSizer *arg1 = (wxSizer *) 0 ;
49894 void *argp1 = 0 ;
49895 int res1 = 0 ;
49896 PyObject *swig_obj[1] ;
49897
49898 if (!args) SWIG_fail;
49899 swig_obj[0] = args;
49900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49901 if (!SWIG_IsOK(res1)) {
49902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49903 }
49904 arg1 = reinterpret_cast< wxSizer * >(argp1);
49905 {
49906 PyThreadState* __tstate = wxPyBeginAllowThreads();
49907 delete arg1;
49908
49909 wxPyEndAllowThreads(__tstate);
49910 if (PyErr_Occurred()) SWIG_fail;
49911 }
49912 resultobj = SWIG_Py_Void();
49913 return resultobj;
49914 fail:
49915 return NULL;
49916 }
49917
49918
49919 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49920 PyObject *resultobj = 0;
49921 wxSizer *arg1 = (wxSizer *) 0 ;
49922 PyObject *arg2 = (PyObject *) 0 ;
49923 void *argp1 = 0 ;
49924 int res1 = 0 ;
49925 PyObject * obj0 = 0 ;
49926 PyObject * obj1 = 0 ;
49927 char * kwnames[] = {
49928 (char *) "self",(char *) "_self", NULL
49929 };
49930
49931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49933 if (!SWIG_IsOK(res1)) {
49934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49935 }
49936 arg1 = reinterpret_cast< wxSizer * >(argp1);
49937 arg2 = obj1;
49938 {
49939 PyThreadState* __tstate = wxPyBeginAllowThreads();
49940 wxSizer__setOORInfo(arg1,arg2);
49941 wxPyEndAllowThreads(__tstate);
49942 if (PyErr_Occurred()) SWIG_fail;
49943 }
49944 resultobj = SWIG_Py_Void();
49945 return resultobj;
49946 fail:
49947 return NULL;
49948 }
49949
49950
49951 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49952 PyObject *resultobj = 0;
49953 wxSizer *arg1 = (wxSizer *) 0 ;
49954 PyObject *arg2 = (PyObject *) 0 ;
49955 int arg3 = (int) 0 ;
49956 int arg4 = (int) 0 ;
49957 int arg5 = (int) 0 ;
49958 PyObject *arg6 = (PyObject *) NULL ;
49959 wxSizerItem *result = 0 ;
49960 void *argp1 = 0 ;
49961 int res1 = 0 ;
49962 int val3 ;
49963 int ecode3 = 0 ;
49964 int val4 ;
49965 int ecode4 = 0 ;
49966 int val5 ;
49967 int ecode5 = 0 ;
49968 PyObject * obj0 = 0 ;
49969 PyObject * obj1 = 0 ;
49970 PyObject * obj2 = 0 ;
49971 PyObject * obj3 = 0 ;
49972 PyObject * obj4 = 0 ;
49973 PyObject * obj5 = 0 ;
49974 char * kwnames[] = {
49975 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49976 };
49977
49978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49980 if (!SWIG_IsOK(res1)) {
49981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49982 }
49983 arg1 = reinterpret_cast< wxSizer * >(argp1);
49984 arg2 = obj1;
49985 if (obj2) {
49986 ecode3 = SWIG_AsVal_int(obj2, &val3);
49987 if (!SWIG_IsOK(ecode3)) {
49988 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49989 }
49990 arg3 = static_cast< int >(val3);
49991 }
49992 if (obj3) {
49993 ecode4 = SWIG_AsVal_int(obj3, &val4);
49994 if (!SWIG_IsOK(ecode4)) {
49995 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49996 }
49997 arg4 = static_cast< int >(val4);
49998 }
49999 if (obj4) {
50000 ecode5 = SWIG_AsVal_int(obj4, &val5);
50001 if (!SWIG_IsOK(ecode5)) {
50002 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
50003 }
50004 arg5 = static_cast< int >(val5);
50005 }
50006 if (obj5) {
50007 arg6 = obj5;
50008 }
50009 {
50010 PyThreadState* __tstate = wxPyBeginAllowThreads();
50011 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
50012 wxPyEndAllowThreads(__tstate);
50013 if (PyErr_Occurred()) SWIG_fail;
50014 }
50015 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50016 return resultobj;
50017 fail:
50018 return NULL;
50019 }
50020
50021
50022 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50023 PyObject *resultobj = 0;
50024 wxSizer *arg1 = (wxSizer *) 0 ;
50025 int arg2 ;
50026 PyObject *arg3 = (PyObject *) 0 ;
50027 int arg4 = (int) 0 ;
50028 int arg5 = (int) 0 ;
50029 int arg6 = (int) 0 ;
50030 PyObject *arg7 = (PyObject *) NULL ;
50031 wxSizerItem *result = 0 ;
50032 void *argp1 = 0 ;
50033 int res1 = 0 ;
50034 int val2 ;
50035 int ecode2 = 0 ;
50036 int val4 ;
50037 int ecode4 = 0 ;
50038 int val5 ;
50039 int ecode5 = 0 ;
50040 int val6 ;
50041 int ecode6 = 0 ;
50042 PyObject * obj0 = 0 ;
50043 PyObject * obj1 = 0 ;
50044 PyObject * obj2 = 0 ;
50045 PyObject * obj3 = 0 ;
50046 PyObject * obj4 = 0 ;
50047 PyObject * obj5 = 0 ;
50048 PyObject * obj6 = 0 ;
50049 char * kwnames[] = {
50050 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50051 };
50052
50053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50055 if (!SWIG_IsOK(res1)) {
50056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
50057 }
50058 arg1 = reinterpret_cast< wxSizer * >(argp1);
50059 ecode2 = SWIG_AsVal_int(obj1, &val2);
50060 if (!SWIG_IsOK(ecode2)) {
50061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
50062 }
50063 arg2 = static_cast< int >(val2);
50064 arg3 = obj2;
50065 if (obj3) {
50066 ecode4 = SWIG_AsVal_int(obj3, &val4);
50067 if (!SWIG_IsOK(ecode4)) {
50068 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
50069 }
50070 arg4 = static_cast< int >(val4);
50071 }
50072 if (obj4) {
50073 ecode5 = SWIG_AsVal_int(obj4, &val5);
50074 if (!SWIG_IsOK(ecode5)) {
50075 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
50076 }
50077 arg5 = static_cast< int >(val5);
50078 }
50079 if (obj5) {
50080 ecode6 = SWIG_AsVal_int(obj5, &val6);
50081 if (!SWIG_IsOK(ecode6)) {
50082 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
50083 }
50084 arg6 = static_cast< int >(val6);
50085 }
50086 if (obj6) {
50087 arg7 = obj6;
50088 }
50089 {
50090 PyThreadState* __tstate = wxPyBeginAllowThreads();
50091 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
50092 wxPyEndAllowThreads(__tstate);
50093 if (PyErr_Occurred()) SWIG_fail;
50094 }
50095 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50096 return resultobj;
50097 fail:
50098 return NULL;
50099 }
50100
50101
50102 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50103 PyObject *resultobj = 0;
50104 wxSizer *arg1 = (wxSizer *) 0 ;
50105 PyObject *arg2 = (PyObject *) 0 ;
50106 int arg3 = (int) 0 ;
50107 int arg4 = (int) 0 ;
50108 int arg5 = (int) 0 ;
50109 PyObject *arg6 = (PyObject *) NULL ;
50110 wxSizerItem *result = 0 ;
50111 void *argp1 = 0 ;
50112 int res1 = 0 ;
50113 int val3 ;
50114 int ecode3 = 0 ;
50115 int val4 ;
50116 int ecode4 = 0 ;
50117 int val5 ;
50118 int ecode5 = 0 ;
50119 PyObject * obj0 = 0 ;
50120 PyObject * obj1 = 0 ;
50121 PyObject * obj2 = 0 ;
50122 PyObject * obj3 = 0 ;
50123 PyObject * obj4 = 0 ;
50124 PyObject * obj5 = 0 ;
50125 char * kwnames[] = {
50126 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50127 };
50128
50129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50130 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50131 if (!SWIG_IsOK(res1)) {
50132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
50133 }
50134 arg1 = reinterpret_cast< wxSizer * >(argp1);
50135 arg2 = obj1;
50136 if (obj2) {
50137 ecode3 = SWIG_AsVal_int(obj2, &val3);
50138 if (!SWIG_IsOK(ecode3)) {
50139 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
50140 }
50141 arg3 = static_cast< int >(val3);
50142 }
50143 if (obj3) {
50144 ecode4 = SWIG_AsVal_int(obj3, &val4);
50145 if (!SWIG_IsOK(ecode4)) {
50146 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
50147 }
50148 arg4 = static_cast< int >(val4);
50149 }
50150 if (obj4) {
50151 ecode5 = SWIG_AsVal_int(obj4, &val5);
50152 if (!SWIG_IsOK(ecode5)) {
50153 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
50154 }
50155 arg5 = static_cast< int >(val5);
50156 }
50157 if (obj5) {
50158 arg6 = obj5;
50159 }
50160 {
50161 PyThreadState* __tstate = wxPyBeginAllowThreads();
50162 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50163 wxPyEndAllowThreads(__tstate);
50164 if (PyErr_Occurred()) SWIG_fail;
50165 }
50166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50167 return resultobj;
50168 fail:
50169 return NULL;
50170 }
50171
50172
50173 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50174 PyObject *resultobj = 0;
50175 wxSizer *arg1 = (wxSizer *) 0 ;
50176 PyObject *arg2 = (PyObject *) 0 ;
50177 bool result;
50178 void *argp1 = 0 ;
50179 int res1 = 0 ;
50180 PyObject * obj0 = 0 ;
50181 PyObject * obj1 = 0 ;
50182 char * kwnames[] = {
50183 (char *) "self",(char *) "item", NULL
50184 };
50185
50186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50188 if (!SWIG_IsOK(res1)) {
50189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50190 }
50191 arg1 = reinterpret_cast< wxSizer * >(argp1);
50192 arg2 = obj1;
50193 {
50194 PyThreadState* __tstate = wxPyBeginAllowThreads();
50195 result = (bool)wxSizer_Remove(arg1,arg2);
50196 wxPyEndAllowThreads(__tstate);
50197 if (PyErr_Occurred()) SWIG_fail;
50198 }
50199 {
50200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50201 }
50202 return resultobj;
50203 fail:
50204 return NULL;
50205 }
50206
50207
50208 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50209 PyObject *resultobj = 0;
50210 wxSizer *arg1 = (wxSizer *) 0 ;
50211 PyObject *arg2 = (PyObject *) 0 ;
50212 bool result;
50213 void *argp1 = 0 ;
50214 int res1 = 0 ;
50215 PyObject * obj0 = 0 ;
50216 PyObject * obj1 = 0 ;
50217 char * kwnames[] = {
50218 (char *) "self",(char *) "item", NULL
50219 };
50220
50221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50222 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50223 if (!SWIG_IsOK(res1)) {
50224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50225 }
50226 arg1 = reinterpret_cast< wxSizer * >(argp1);
50227 arg2 = obj1;
50228 {
50229 PyThreadState* __tstate = wxPyBeginAllowThreads();
50230 result = (bool)wxSizer_Detach(arg1,arg2);
50231 wxPyEndAllowThreads(__tstate);
50232 if (PyErr_Occurred()) SWIG_fail;
50233 }
50234 {
50235 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50236 }
50237 return resultobj;
50238 fail:
50239 return NULL;
50240 }
50241
50242
50243 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50244 PyObject *resultobj = 0;
50245 wxSizer *arg1 = (wxSizer *) 0 ;
50246 PyObject *arg2 = (PyObject *) 0 ;
50247 wxSizerItem *result = 0 ;
50248 void *argp1 = 0 ;
50249 int res1 = 0 ;
50250 PyObject * obj0 = 0 ;
50251 PyObject * obj1 = 0 ;
50252 char * kwnames[] = {
50253 (char *) "self",(char *) "item", NULL
50254 };
50255
50256 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50257 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50258 if (!SWIG_IsOK(res1)) {
50259 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50260 }
50261 arg1 = reinterpret_cast< wxSizer * >(argp1);
50262 arg2 = obj1;
50263 {
50264 PyThreadState* __tstate = wxPyBeginAllowThreads();
50265 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50266 wxPyEndAllowThreads(__tstate);
50267 if (PyErr_Occurred()) SWIG_fail;
50268 }
50269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50270 return resultobj;
50271 fail:
50272 return NULL;
50273 }
50274
50275
50276 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50277 PyObject *resultobj = 0;
50278 wxSizer *arg1 = (wxSizer *) 0 ;
50279 PyObject *arg2 = (PyObject *) 0 ;
50280 wxSize *arg3 = 0 ;
50281 void *argp1 = 0 ;
50282 int res1 = 0 ;
50283 wxSize temp3 ;
50284 PyObject * obj0 = 0 ;
50285 PyObject * obj1 = 0 ;
50286 PyObject * obj2 = 0 ;
50287 char * kwnames[] = {
50288 (char *) "self",(char *) "item",(char *) "size", NULL
50289 };
50290
50291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50293 if (!SWIG_IsOK(res1)) {
50294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50295 }
50296 arg1 = reinterpret_cast< wxSizer * >(argp1);
50297 arg2 = obj1;
50298 {
50299 arg3 = &temp3;
50300 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50301 }
50302 {
50303 PyThreadState* __tstate = wxPyBeginAllowThreads();
50304 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50305 wxPyEndAllowThreads(__tstate);
50306 if (PyErr_Occurred()) SWIG_fail;
50307 }
50308 resultobj = SWIG_Py_Void();
50309 return resultobj;
50310 fail:
50311 return NULL;
50312 }
50313
50314
50315 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50316 PyObject *resultobj = 0;
50317 wxSizer *arg1 = (wxSizer *) 0 ;
50318 wxWindow *arg2 = (wxWindow *) 0 ;
50319 wxWindow *arg3 = (wxWindow *) 0 ;
50320 bool arg4 = (bool) false ;
50321 bool result;
50322 void *argp1 = 0 ;
50323 int res1 = 0 ;
50324 void *argp2 = 0 ;
50325 int res2 = 0 ;
50326 void *argp3 = 0 ;
50327 int res3 = 0 ;
50328 bool val4 ;
50329 int ecode4 = 0 ;
50330 PyObject * obj0 = 0 ;
50331 PyObject * obj1 = 0 ;
50332 PyObject * obj2 = 0 ;
50333 PyObject * obj3 = 0 ;
50334 char * kwnames[] = {
50335 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50336 };
50337
50338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50340 if (!SWIG_IsOK(res1)) {
50341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50342 }
50343 arg1 = reinterpret_cast< wxSizer * >(argp1);
50344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50345 if (!SWIG_IsOK(res2)) {
50346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50347 }
50348 arg2 = reinterpret_cast< wxWindow * >(argp2);
50349 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50350 if (!SWIG_IsOK(res3)) {
50351 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50352 }
50353 arg3 = reinterpret_cast< wxWindow * >(argp3);
50354 if (obj3) {
50355 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50356 if (!SWIG_IsOK(ecode4)) {
50357 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50358 }
50359 arg4 = static_cast< bool >(val4);
50360 }
50361 {
50362 PyThreadState* __tstate = wxPyBeginAllowThreads();
50363 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50364 wxPyEndAllowThreads(__tstate);
50365 if (PyErr_Occurred()) SWIG_fail;
50366 }
50367 {
50368 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50369 }
50370 return resultobj;
50371 fail:
50372 return NULL;
50373 }
50374
50375
50376 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50377 PyObject *resultobj = 0;
50378 wxSizer *arg1 = (wxSizer *) 0 ;
50379 wxSizer *arg2 = (wxSizer *) 0 ;
50380 wxSizer *arg3 = (wxSizer *) 0 ;
50381 bool arg4 = (bool) false ;
50382 bool result;
50383 void *argp1 = 0 ;
50384 int res1 = 0 ;
50385 void *argp2 = 0 ;
50386 int res2 = 0 ;
50387 void *argp3 = 0 ;
50388 int res3 = 0 ;
50389 bool val4 ;
50390 int ecode4 = 0 ;
50391 PyObject * obj0 = 0 ;
50392 PyObject * obj1 = 0 ;
50393 PyObject * obj2 = 0 ;
50394 PyObject * obj3 = 0 ;
50395 char * kwnames[] = {
50396 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50397 };
50398
50399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50401 if (!SWIG_IsOK(res1)) {
50402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50403 }
50404 arg1 = reinterpret_cast< wxSizer * >(argp1);
50405 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50406 if (!SWIG_IsOK(res2)) {
50407 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50408 }
50409 arg2 = reinterpret_cast< wxSizer * >(argp2);
50410 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50411 if (!SWIG_IsOK(res3)) {
50412 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50413 }
50414 arg3 = reinterpret_cast< wxSizer * >(argp3);
50415 if (obj3) {
50416 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50417 if (!SWIG_IsOK(ecode4)) {
50418 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50419 }
50420 arg4 = static_cast< bool >(val4);
50421 }
50422 {
50423 PyThreadState* __tstate = wxPyBeginAllowThreads();
50424 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50425 wxPyEndAllowThreads(__tstate);
50426 if (PyErr_Occurred()) SWIG_fail;
50427 }
50428 {
50429 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50430 }
50431 return resultobj;
50432 fail:
50433 return NULL;
50434 }
50435
50436
50437 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50438 PyObject *resultobj = 0;
50439 wxSizer *arg1 = (wxSizer *) 0 ;
50440 size_t arg2 ;
50441 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50442 bool result;
50443 void *argp1 = 0 ;
50444 int res1 = 0 ;
50445 size_t val2 ;
50446 int ecode2 = 0 ;
50447 void *argp3 = 0 ;
50448 int res3 = 0 ;
50449 PyObject * obj0 = 0 ;
50450 PyObject * obj1 = 0 ;
50451 PyObject * obj2 = 0 ;
50452 char * kwnames[] = {
50453 (char *) "self",(char *) "index",(char *) "newitem", NULL
50454 };
50455
50456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50458 if (!SWIG_IsOK(res1)) {
50459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50460 }
50461 arg1 = reinterpret_cast< wxSizer * >(argp1);
50462 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50463 if (!SWIG_IsOK(ecode2)) {
50464 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50465 }
50466 arg2 = static_cast< size_t >(val2);
50467 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50468 if (!SWIG_IsOK(res3)) {
50469 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50470 }
50471 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50472 {
50473 PyThreadState* __tstate = wxPyBeginAllowThreads();
50474 result = (bool)(arg1)->Replace(arg2,arg3);
50475 wxPyEndAllowThreads(__tstate);
50476 if (PyErr_Occurred()) SWIG_fail;
50477 }
50478 {
50479 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50480 }
50481 return resultobj;
50482 fail:
50483 return NULL;
50484 }
50485
50486
50487 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50488 PyObject *resultobj = 0;
50489 wxSizer *arg1 = (wxSizer *) 0 ;
50490 wxWindow *arg2 = (wxWindow *) 0 ;
50491 void *argp1 = 0 ;
50492 int res1 = 0 ;
50493 void *argp2 = 0 ;
50494 int res2 = 0 ;
50495 PyObject * obj0 = 0 ;
50496 PyObject * obj1 = 0 ;
50497 char * kwnames[] = {
50498 (char *) "self",(char *) "window", NULL
50499 };
50500
50501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50503 if (!SWIG_IsOK(res1)) {
50504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50505 }
50506 arg1 = reinterpret_cast< wxSizer * >(argp1);
50507 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50508 if (!SWIG_IsOK(res2)) {
50509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50510 }
50511 arg2 = reinterpret_cast< wxWindow * >(argp2);
50512 {
50513 PyThreadState* __tstate = wxPyBeginAllowThreads();
50514 (arg1)->SetContainingWindow(arg2);
50515 wxPyEndAllowThreads(__tstate);
50516 if (PyErr_Occurred()) SWIG_fail;
50517 }
50518 resultobj = SWIG_Py_Void();
50519 return resultobj;
50520 fail:
50521 return NULL;
50522 }
50523
50524
50525 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50526 PyObject *resultobj = 0;
50527 wxSizer *arg1 = (wxSizer *) 0 ;
50528 wxWindow *result = 0 ;
50529 void *argp1 = 0 ;
50530 int res1 = 0 ;
50531 PyObject *swig_obj[1] ;
50532
50533 if (!args) SWIG_fail;
50534 swig_obj[0] = args;
50535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50536 if (!SWIG_IsOK(res1)) {
50537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50538 }
50539 arg1 = reinterpret_cast< wxSizer * >(argp1);
50540 {
50541 PyThreadState* __tstate = wxPyBeginAllowThreads();
50542 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50543 wxPyEndAllowThreads(__tstate);
50544 if (PyErr_Occurred()) SWIG_fail;
50545 }
50546 {
50547 resultobj = wxPyMake_wxObject(result, 0);
50548 }
50549 return resultobj;
50550 fail:
50551 return NULL;
50552 }
50553
50554
50555 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50556 PyObject *resultobj = 0;
50557 wxSizer *arg1 = (wxSizer *) 0 ;
50558 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50559 wxSizerItem *result = 0 ;
50560 void *argp1 = 0 ;
50561 int res1 = 0 ;
50562 int res2 = 0 ;
50563 PyObject * obj0 = 0 ;
50564 PyObject * obj1 = 0 ;
50565 char * kwnames[] = {
50566 (char *) "self",(char *) "item", NULL
50567 };
50568
50569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50571 if (!SWIG_IsOK(res1)) {
50572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50573 }
50574 arg1 = reinterpret_cast< wxSizer * >(argp1);
50575 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50576 if (!SWIG_IsOK(res2)) {
50577 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50578 }
50579 {
50580 PyThreadState* __tstate = wxPyBeginAllowThreads();
50581 result = (wxSizerItem *)(arg1)->Add(arg2);
50582 wxPyEndAllowThreads(__tstate);
50583 if (PyErr_Occurred()) SWIG_fail;
50584 }
50585 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50586 return resultobj;
50587 fail:
50588 return NULL;
50589 }
50590
50591
50592 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50593 PyObject *resultobj = 0;
50594 wxSizer *arg1 = (wxSizer *) 0 ;
50595 size_t arg2 ;
50596 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50597 wxSizerItem *result = 0 ;
50598 void *argp1 = 0 ;
50599 int res1 = 0 ;
50600 size_t val2 ;
50601 int ecode2 = 0 ;
50602 int res3 = 0 ;
50603 PyObject * obj0 = 0 ;
50604 PyObject * obj1 = 0 ;
50605 PyObject * obj2 = 0 ;
50606 char * kwnames[] = {
50607 (char *) "self",(char *) "index",(char *) "item", NULL
50608 };
50609
50610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50612 if (!SWIG_IsOK(res1)) {
50613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50614 }
50615 arg1 = reinterpret_cast< wxSizer * >(argp1);
50616 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50617 if (!SWIG_IsOK(ecode2)) {
50618 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50619 }
50620 arg2 = static_cast< size_t >(val2);
50621 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50622 if (!SWIG_IsOK(res3)) {
50623 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50624 }
50625 {
50626 PyThreadState* __tstate = wxPyBeginAllowThreads();
50627 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50628 wxPyEndAllowThreads(__tstate);
50629 if (PyErr_Occurred()) SWIG_fail;
50630 }
50631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50632 return resultobj;
50633 fail:
50634 return NULL;
50635 }
50636
50637
50638 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50639 PyObject *resultobj = 0;
50640 wxSizer *arg1 = (wxSizer *) 0 ;
50641 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50642 wxSizerItem *result = 0 ;
50643 void *argp1 = 0 ;
50644 int res1 = 0 ;
50645 int res2 = 0 ;
50646 PyObject * obj0 = 0 ;
50647 PyObject * obj1 = 0 ;
50648 char * kwnames[] = {
50649 (char *) "self",(char *) "item", NULL
50650 };
50651
50652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50654 if (!SWIG_IsOK(res1)) {
50655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50656 }
50657 arg1 = reinterpret_cast< wxSizer * >(argp1);
50658 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50659 if (!SWIG_IsOK(res2)) {
50660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50661 }
50662 {
50663 PyThreadState* __tstate = wxPyBeginAllowThreads();
50664 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50665 wxPyEndAllowThreads(__tstate);
50666 if (PyErr_Occurred()) SWIG_fail;
50667 }
50668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50669 return resultobj;
50670 fail:
50671 return NULL;
50672 }
50673
50674
50675 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50676 PyObject *resultobj = 0;
50677 wxSizer *arg1 = (wxSizer *) 0 ;
50678 int arg2 ;
50679 int arg3 ;
50680 int arg4 ;
50681 int arg5 ;
50682 void *argp1 = 0 ;
50683 int res1 = 0 ;
50684 int val2 ;
50685 int ecode2 = 0 ;
50686 int val3 ;
50687 int ecode3 = 0 ;
50688 int val4 ;
50689 int ecode4 = 0 ;
50690 int val5 ;
50691 int ecode5 = 0 ;
50692 PyObject * obj0 = 0 ;
50693 PyObject * obj1 = 0 ;
50694 PyObject * obj2 = 0 ;
50695 PyObject * obj3 = 0 ;
50696 PyObject * obj4 = 0 ;
50697 char * kwnames[] = {
50698 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50699 };
50700
50701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50703 if (!SWIG_IsOK(res1)) {
50704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50705 }
50706 arg1 = reinterpret_cast< wxSizer * >(argp1);
50707 ecode2 = SWIG_AsVal_int(obj1, &val2);
50708 if (!SWIG_IsOK(ecode2)) {
50709 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50710 }
50711 arg2 = static_cast< int >(val2);
50712 ecode3 = SWIG_AsVal_int(obj2, &val3);
50713 if (!SWIG_IsOK(ecode3)) {
50714 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50715 }
50716 arg3 = static_cast< int >(val3);
50717 ecode4 = SWIG_AsVal_int(obj3, &val4);
50718 if (!SWIG_IsOK(ecode4)) {
50719 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50720 }
50721 arg4 = static_cast< int >(val4);
50722 ecode5 = SWIG_AsVal_int(obj4, &val5);
50723 if (!SWIG_IsOK(ecode5)) {
50724 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50725 }
50726 arg5 = static_cast< int >(val5);
50727 {
50728 PyThreadState* __tstate = wxPyBeginAllowThreads();
50729 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50730 wxPyEndAllowThreads(__tstate);
50731 if (PyErr_Occurred()) SWIG_fail;
50732 }
50733 resultobj = SWIG_Py_Void();
50734 return resultobj;
50735 fail:
50736 return NULL;
50737 }
50738
50739
50740 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50741 PyObject *resultobj = 0;
50742 wxSizer *arg1 = (wxSizer *) 0 ;
50743 wxSize *arg2 = 0 ;
50744 void *argp1 = 0 ;
50745 int res1 = 0 ;
50746 wxSize temp2 ;
50747 PyObject * obj0 = 0 ;
50748 PyObject * obj1 = 0 ;
50749 char * kwnames[] = {
50750 (char *) "self",(char *) "size", NULL
50751 };
50752
50753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50755 if (!SWIG_IsOK(res1)) {
50756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50757 }
50758 arg1 = reinterpret_cast< wxSizer * >(argp1);
50759 {
50760 arg2 = &temp2;
50761 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50762 }
50763 {
50764 PyThreadState* __tstate = wxPyBeginAllowThreads();
50765 (arg1)->SetMinSize((wxSize const &)*arg2);
50766 wxPyEndAllowThreads(__tstate);
50767 if (PyErr_Occurred()) SWIG_fail;
50768 }
50769 resultobj = SWIG_Py_Void();
50770 return resultobj;
50771 fail:
50772 return NULL;
50773 }
50774
50775
50776 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50777 PyObject *resultobj = 0;
50778 wxSizer *arg1 = (wxSizer *) 0 ;
50779 wxSize result;
50780 void *argp1 = 0 ;
50781 int res1 = 0 ;
50782 PyObject *swig_obj[1] ;
50783
50784 if (!args) SWIG_fail;
50785 swig_obj[0] = args;
50786 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50787 if (!SWIG_IsOK(res1)) {
50788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50789 }
50790 arg1 = reinterpret_cast< wxSizer * >(argp1);
50791 {
50792 PyThreadState* __tstate = wxPyBeginAllowThreads();
50793 result = (arg1)->GetSize();
50794 wxPyEndAllowThreads(__tstate);
50795 if (PyErr_Occurred()) SWIG_fail;
50796 }
50797 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50798 return resultobj;
50799 fail:
50800 return NULL;
50801 }
50802
50803
50804 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50805 PyObject *resultobj = 0;
50806 wxSizer *arg1 = (wxSizer *) 0 ;
50807 wxPoint result;
50808 void *argp1 = 0 ;
50809 int res1 = 0 ;
50810 PyObject *swig_obj[1] ;
50811
50812 if (!args) SWIG_fail;
50813 swig_obj[0] = args;
50814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50815 if (!SWIG_IsOK(res1)) {
50816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50817 }
50818 arg1 = reinterpret_cast< wxSizer * >(argp1);
50819 {
50820 PyThreadState* __tstate = wxPyBeginAllowThreads();
50821 result = (arg1)->GetPosition();
50822 wxPyEndAllowThreads(__tstate);
50823 if (PyErr_Occurred()) SWIG_fail;
50824 }
50825 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50826 return resultobj;
50827 fail:
50828 return NULL;
50829 }
50830
50831
50832 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50833 PyObject *resultobj = 0;
50834 wxSizer *arg1 = (wxSizer *) 0 ;
50835 wxSize result;
50836 void *argp1 = 0 ;
50837 int res1 = 0 ;
50838 PyObject *swig_obj[1] ;
50839
50840 if (!args) SWIG_fail;
50841 swig_obj[0] = args;
50842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50843 if (!SWIG_IsOK(res1)) {
50844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50845 }
50846 arg1 = reinterpret_cast< wxSizer * >(argp1);
50847 {
50848 PyThreadState* __tstate = wxPyBeginAllowThreads();
50849 result = (arg1)->GetMinSize();
50850 wxPyEndAllowThreads(__tstate);
50851 if (PyErr_Occurred()) SWIG_fail;
50852 }
50853 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50854 return resultobj;
50855 fail:
50856 return NULL;
50857 }
50858
50859
50860 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50861 PyObject *resultobj = 0;
50862 wxSizer *arg1 = (wxSizer *) 0 ;
50863 void *argp1 = 0 ;
50864 int res1 = 0 ;
50865 PyObject *swig_obj[1] ;
50866
50867 if (!args) SWIG_fail;
50868 swig_obj[0] = args;
50869 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50870 if (!SWIG_IsOK(res1)) {
50871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50872 }
50873 arg1 = reinterpret_cast< wxSizer * >(argp1);
50874 {
50875 PyThreadState* __tstate = wxPyBeginAllowThreads();
50876 (arg1)->RecalcSizes();
50877 wxPyEndAllowThreads(__tstate);
50878 if (PyErr_Occurred()) SWIG_fail;
50879 }
50880 resultobj = SWIG_Py_Void();
50881 return resultobj;
50882 fail:
50883 return NULL;
50884 }
50885
50886
50887 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50888 PyObject *resultobj = 0;
50889 wxSizer *arg1 = (wxSizer *) 0 ;
50890 wxSize result;
50891 void *argp1 = 0 ;
50892 int res1 = 0 ;
50893 PyObject *swig_obj[1] ;
50894
50895 if (!args) SWIG_fail;
50896 swig_obj[0] = args;
50897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50898 if (!SWIG_IsOK(res1)) {
50899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50900 }
50901 arg1 = reinterpret_cast< wxSizer * >(argp1);
50902 {
50903 PyThreadState* __tstate = wxPyBeginAllowThreads();
50904 result = (arg1)->CalcMin();
50905 wxPyEndAllowThreads(__tstate);
50906 if (PyErr_Occurred()) SWIG_fail;
50907 }
50908 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50909 return resultobj;
50910 fail:
50911 return NULL;
50912 }
50913
50914
50915 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50916 PyObject *resultobj = 0;
50917 wxSizer *arg1 = (wxSizer *) 0 ;
50918 void *argp1 = 0 ;
50919 int res1 = 0 ;
50920 PyObject *swig_obj[1] ;
50921
50922 if (!args) SWIG_fail;
50923 swig_obj[0] = args;
50924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50925 if (!SWIG_IsOK(res1)) {
50926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50927 }
50928 arg1 = reinterpret_cast< wxSizer * >(argp1);
50929 {
50930 PyThreadState* __tstate = wxPyBeginAllowThreads();
50931 (arg1)->Layout();
50932 wxPyEndAllowThreads(__tstate);
50933 if (PyErr_Occurred()) SWIG_fail;
50934 }
50935 resultobj = SWIG_Py_Void();
50936 return resultobj;
50937 fail:
50938 return NULL;
50939 }
50940
50941
50942 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50943 PyObject *resultobj = 0;
50944 wxSizer *arg1 = (wxSizer *) 0 ;
50945 wxWindow *arg2 = (wxWindow *) 0 ;
50946 wxSize result;
50947 void *argp1 = 0 ;
50948 int res1 = 0 ;
50949 void *argp2 = 0 ;
50950 int res2 = 0 ;
50951 PyObject * obj0 = 0 ;
50952 PyObject * obj1 = 0 ;
50953 char * kwnames[] = {
50954 (char *) "self",(char *) "window", NULL
50955 };
50956
50957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50959 if (!SWIG_IsOK(res1)) {
50960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50961 }
50962 arg1 = reinterpret_cast< wxSizer * >(argp1);
50963 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50964 if (!SWIG_IsOK(res2)) {
50965 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50966 }
50967 arg2 = reinterpret_cast< wxWindow * >(argp2);
50968 {
50969 PyThreadState* __tstate = wxPyBeginAllowThreads();
50970 result = (arg1)->Fit(arg2);
50971 wxPyEndAllowThreads(__tstate);
50972 if (PyErr_Occurred()) SWIG_fail;
50973 }
50974 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50975 return resultobj;
50976 fail:
50977 return NULL;
50978 }
50979
50980
50981 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50982 PyObject *resultobj = 0;
50983 wxSizer *arg1 = (wxSizer *) 0 ;
50984 wxWindow *arg2 = (wxWindow *) 0 ;
50985 void *argp1 = 0 ;
50986 int res1 = 0 ;
50987 void *argp2 = 0 ;
50988 int res2 = 0 ;
50989 PyObject * obj0 = 0 ;
50990 PyObject * obj1 = 0 ;
50991 char * kwnames[] = {
50992 (char *) "self",(char *) "window", NULL
50993 };
50994
50995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50997 if (!SWIG_IsOK(res1)) {
50998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50999 }
51000 arg1 = reinterpret_cast< wxSizer * >(argp1);
51001 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51002 if (!SWIG_IsOK(res2)) {
51003 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
51004 }
51005 arg2 = reinterpret_cast< wxWindow * >(argp2);
51006 {
51007 PyThreadState* __tstate = wxPyBeginAllowThreads();
51008 (arg1)->FitInside(arg2);
51009 wxPyEndAllowThreads(__tstate);
51010 if (PyErr_Occurred()) SWIG_fail;
51011 }
51012 resultobj = SWIG_Py_Void();
51013 return resultobj;
51014 fail:
51015 return NULL;
51016 }
51017
51018
51019 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51020 PyObject *resultobj = 0;
51021 wxSizer *arg1 = (wxSizer *) 0 ;
51022 wxWindow *arg2 = (wxWindow *) 0 ;
51023 void *argp1 = 0 ;
51024 int res1 = 0 ;
51025 void *argp2 = 0 ;
51026 int res2 = 0 ;
51027 PyObject * obj0 = 0 ;
51028 PyObject * obj1 = 0 ;
51029 char * kwnames[] = {
51030 (char *) "self",(char *) "window", NULL
51031 };
51032
51033 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
51034 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51035 if (!SWIG_IsOK(res1)) {
51036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
51037 }
51038 arg1 = reinterpret_cast< wxSizer * >(argp1);
51039 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51040 if (!SWIG_IsOK(res2)) {
51041 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
51042 }
51043 arg2 = reinterpret_cast< wxWindow * >(argp2);
51044 {
51045 PyThreadState* __tstate = wxPyBeginAllowThreads();
51046 (arg1)->SetSizeHints(arg2);
51047 wxPyEndAllowThreads(__tstate);
51048 if (PyErr_Occurred()) SWIG_fail;
51049 }
51050 resultobj = SWIG_Py_Void();
51051 return resultobj;
51052 fail:
51053 return NULL;
51054 }
51055
51056
51057 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51058 PyObject *resultobj = 0;
51059 wxSizer *arg1 = (wxSizer *) 0 ;
51060 wxWindow *arg2 = (wxWindow *) 0 ;
51061 void *argp1 = 0 ;
51062 int res1 = 0 ;
51063 void *argp2 = 0 ;
51064 int res2 = 0 ;
51065 PyObject * obj0 = 0 ;
51066 PyObject * obj1 = 0 ;
51067 char * kwnames[] = {
51068 (char *) "self",(char *) "window", NULL
51069 };
51070
51071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
51072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51073 if (!SWIG_IsOK(res1)) {
51074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
51075 }
51076 arg1 = reinterpret_cast< wxSizer * >(argp1);
51077 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51078 if (!SWIG_IsOK(res2)) {
51079 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
51080 }
51081 arg2 = reinterpret_cast< wxWindow * >(argp2);
51082 {
51083 PyThreadState* __tstate = wxPyBeginAllowThreads();
51084 (arg1)->SetVirtualSizeHints(arg2);
51085 wxPyEndAllowThreads(__tstate);
51086 if (PyErr_Occurred()) SWIG_fail;
51087 }
51088 resultobj = SWIG_Py_Void();
51089 return resultobj;
51090 fail:
51091 return NULL;
51092 }
51093
51094
51095 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51096 PyObject *resultobj = 0;
51097 wxSizer *arg1 = (wxSizer *) 0 ;
51098 bool arg2 = (bool) false ;
51099 void *argp1 = 0 ;
51100 int res1 = 0 ;
51101 bool val2 ;
51102 int ecode2 = 0 ;
51103 PyObject * obj0 = 0 ;
51104 PyObject * obj1 = 0 ;
51105 char * kwnames[] = {
51106 (char *) "self",(char *) "deleteWindows", NULL
51107 };
51108
51109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
51110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51111 if (!SWIG_IsOK(res1)) {
51112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
51113 }
51114 arg1 = reinterpret_cast< wxSizer * >(argp1);
51115 if (obj1) {
51116 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51117 if (!SWIG_IsOK(ecode2)) {
51118 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
51119 }
51120 arg2 = static_cast< bool >(val2);
51121 }
51122 {
51123 PyThreadState* __tstate = wxPyBeginAllowThreads();
51124 (arg1)->Clear(arg2);
51125 wxPyEndAllowThreads(__tstate);
51126 if (PyErr_Occurred()) SWIG_fail;
51127 }
51128 resultobj = SWIG_Py_Void();
51129 return resultobj;
51130 fail:
51131 return NULL;
51132 }
51133
51134
51135 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51136 PyObject *resultobj = 0;
51137 wxSizer *arg1 = (wxSizer *) 0 ;
51138 void *argp1 = 0 ;
51139 int res1 = 0 ;
51140 PyObject *swig_obj[1] ;
51141
51142 if (!args) SWIG_fail;
51143 swig_obj[0] = args;
51144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51145 if (!SWIG_IsOK(res1)) {
51146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
51147 }
51148 arg1 = reinterpret_cast< wxSizer * >(argp1);
51149 {
51150 PyThreadState* __tstate = wxPyBeginAllowThreads();
51151 (arg1)->DeleteWindows();
51152 wxPyEndAllowThreads(__tstate);
51153 if (PyErr_Occurred()) SWIG_fail;
51154 }
51155 resultobj = SWIG_Py_Void();
51156 return resultobj;
51157 fail:
51158 return NULL;
51159 }
51160
51161
51162 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51163 PyObject *resultobj = 0;
51164 wxSizer *arg1 = (wxSizer *) 0 ;
51165 PyObject *result = 0 ;
51166 void *argp1 = 0 ;
51167 int res1 = 0 ;
51168 PyObject *swig_obj[1] ;
51169
51170 if (!args) SWIG_fail;
51171 swig_obj[0] = args;
51172 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51173 if (!SWIG_IsOK(res1)) {
51174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51175 }
51176 arg1 = reinterpret_cast< wxSizer * >(argp1);
51177 {
51178 PyThreadState* __tstate = wxPyBeginAllowThreads();
51179 result = (PyObject *)wxSizer_GetChildren(arg1);
51180 wxPyEndAllowThreads(__tstate);
51181 if (PyErr_Occurred()) SWIG_fail;
51182 }
51183 resultobj = result;
51184 return resultobj;
51185 fail:
51186 return NULL;
51187 }
51188
51189
51190 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51191 PyObject *resultobj = 0;
51192 wxSizer *arg1 = (wxSizer *) 0 ;
51193 PyObject *arg2 = (PyObject *) 0 ;
51194 bool arg3 = (bool) true ;
51195 bool arg4 = (bool) false ;
51196 bool result;
51197 void *argp1 = 0 ;
51198 int res1 = 0 ;
51199 bool val3 ;
51200 int ecode3 = 0 ;
51201 bool val4 ;
51202 int ecode4 = 0 ;
51203 PyObject * obj0 = 0 ;
51204 PyObject * obj1 = 0 ;
51205 PyObject * obj2 = 0 ;
51206 PyObject * obj3 = 0 ;
51207 char * kwnames[] = {
51208 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51209 };
51210
51211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51213 if (!SWIG_IsOK(res1)) {
51214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51215 }
51216 arg1 = reinterpret_cast< wxSizer * >(argp1);
51217 arg2 = obj1;
51218 if (obj2) {
51219 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51220 if (!SWIG_IsOK(ecode3)) {
51221 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51222 }
51223 arg3 = static_cast< bool >(val3);
51224 }
51225 if (obj3) {
51226 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51227 if (!SWIG_IsOK(ecode4)) {
51228 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51229 }
51230 arg4 = static_cast< bool >(val4);
51231 }
51232 {
51233 PyThreadState* __tstate = wxPyBeginAllowThreads();
51234 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51235 wxPyEndAllowThreads(__tstate);
51236 if (PyErr_Occurred()) SWIG_fail;
51237 }
51238 {
51239 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51240 }
51241 return resultobj;
51242 fail:
51243 return NULL;
51244 }
51245
51246
51247 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51248 PyObject *resultobj = 0;
51249 wxSizer *arg1 = (wxSizer *) 0 ;
51250 PyObject *arg2 = (PyObject *) 0 ;
51251 bool result;
51252 void *argp1 = 0 ;
51253 int res1 = 0 ;
51254 PyObject * obj0 = 0 ;
51255 PyObject * obj1 = 0 ;
51256 char * kwnames[] = {
51257 (char *) "self",(char *) "item", NULL
51258 };
51259
51260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51262 if (!SWIG_IsOK(res1)) {
51263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51264 }
51265 arg1 = reinterpret_cast< wxSizer * >(argp1);
51266 arg2 = obj1;
51267 {
51268 PyThreadState* __tstate = wxPyBeginAllowThreads();
51269 result = (bool)wxSizer_IsShown(arg1,arg2);
51270 wxPyEndAllowThreads(__tstate);
51271 if (PyErr_Occurred()) SWIG_fail;
51272 }
51273 {
51274 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51275 }
51276 return resultobj;
51277 fail:
51278 return NULL;
51279 }
51280
51281
51282 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51283 PyObject *resultobj = 0;
51284 wxSizer *arg1 = (wxSizer *) 0 ;
51285 bool arg2 ;
51286 void *argp1 = 0 ;
51287 int res1 = 0 ;
51288 bool val2 ;
51289 int ecode2 = 0 ;
51290 PyObject * obj0 = 0 ;
51291 PyObject * obj1 = 0 ;
51292 char * kwnames[] = {
51293 (char *) "self",(char *) "show", NULL
51294 };
51295
51296 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51297 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51298 if (!SWIG_IsOK(res1)) {
51299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51300 }
51301 arg1 = reinterpret_cast< wxSizer * >(argp1);
51302 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51303 if (!SWIG_IsOK(ecode2)) {
51304 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51305 }
51306 arg2 = static_cast< bool >(val2);
51307 {
51308 PyThreadState* __tstate = wxPyBeginAllowThreads();
51309 (arg1)->ShowItems(arg2);
51310 wxPyEndAllowThreads(__tstate);
51311 if (PyErr_Occurred()) SWIG_fail;
51312 }
51313 resultobj = SWIG_Py_Void();
51314 return resultobj;
51315 fail:
51316 return NULL;
51317 }
51318
51319
51320 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51321 PyObject *obj;
51322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51323 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51324 return SWIG_Py_Void();
51325 }
51326
51327 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51328 PyObject *resultobj = 0;
51329 wxPySizer *result = 0 ;
51330
51331 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51332 {
51333 PyThreadState* __tstate = wxPyBeginAllowThreads();
51334 result = (wxPySizer *)new wxPySizer();
51335 wxPyEndAllowThreads(__tstate);
51336 if (PyErr_Occurred()) SWIG_fail;
51337 }
51338 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51339 return resultobj;
51340 fail:
51341 return NULL;
51342 }
51343
51344
51345 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51346 PyObject *resultobj = 0;
51347 wxPySizer *arg1 = (wxPySizer *) 0 ;
51348 PyObject *arg2 = (PyObject *) 0 ;
51349 PyObject *arg3 = (PyObject *) 0 ;
51350 void *argp1 = 0 ;
51351 int res1 = 0 ;
51352 PyObject * obj0 = 0 ;
51353 PyObject * obj1 = 0 ;
51354 PyObject * obj2 = 0 ;
51355 char * kwnames[] = {
51356 (char *) "self",(char *) "self",(char *) "_class", NULL
51357 };
51358
51359 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51360 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51361 if (!SWIG_IsOK(res1)) {
51362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51363 }
51364 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51365 arg2 = obj1;
51366 arg3 = obj2;
51367 {
51368 PyThreadState* __tstate = wxPyBeginAllowThreads();
51369 (arg1)->_setCallbackInfo(arg2,arg3);
51370 wxPyEndAllowThreads(__tstate);
51371 if (PyErr_Occurred()) SWIG_fail;
51372 }
51373 resultobj = SWIG_Py_Void();
51374 return resultobj;
51375 fail:
51376 return NULL;
51377 }
51378
51379
51380 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51381 PyObject *obj;
51382 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51383 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51384 return SWIG_Py_Void();
51385 }
51386
51387 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51388 return SWIG_Python_InitShadowInstance(args);
51389 }
51390
51391 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51392 PyObject *resultobj = 0;
51393 int arg1 = (int) wxHORIZONTAL ;
51394 wxBoxSizer *result = 0 ;
51395 int val1 ;
51396 int ecode1 = 0 ;
51397 PyObject * obj0 = 0 ;
51398 char * kwnames[] = {
51399 (char *) "orient", NULL
51400 };
51401
51402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51403 if (obj0) {
51404 ecode1 = SWIG_AsVal_int(obj0, &val1);
51405 if (!SWIG_IsOK(ecode1)) {
51406 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51407 }
51408 arg1 = static_cast< int >(val1);
51409 }
51410 {
51411 PyThreadState* __tstate = wxPyBeginAllowThreads();
51412 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51413 wxPyEndAllowThreads(__tstate);
51414 if (PyErr_Occurred()) SWIG_fail;
51415 }
51416 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51417 return resultobj;
51418 fail:
51419 return NULL;
51420 }
51421
51422
51423 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51424 PyObject *resultobj = 0;
51425 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51426 int result;
51427 void *argp1 = 0 ;
51428 int res1 = 0 ;
51429 PyObject *swig_obj[1] ;
51430
51431 if (!args) SWIG_fail;
51432 swig_obj[0] = args;
51433 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51434 if (!SWIG_IsOK(res1)) {
51435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51436 }
51437 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51438 {
51439 PyThreadState* __tstate = wxPyBeginAllowThreads();
51440 result = (int)(arg1)->GetOrientation();
51441 wxPyEndAllowThreads(__tstate);
51442 if (PyErr_Occurred()) SWIG_fail;
51443 }
51444 resultobj = SWIG_From_int(static_cast< int >(result));
51445 return resultobj;
51446 fail:
51447 return NULL;
51448 }
51449
51450
51451 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51452 PyObject *resultobj = 0;
51453 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51454 int arg2 ;
51455 void *argp1 = 0 ;
51456 int res1 = 0 ;
51457 int val2 ;
51458 int ecode2 = 0 ;
51459 PyObject * obj0 = 0 ;
51460 PyObject * obj1 = 0 ;
51461 char * kwnames[] = {
51462 (char *) "self",(char *) "orient", NULL
51463 };
51464
51465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51467 if (!SWIG_IsOK(res1)) {
51468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51469 }
51470 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51471 ecode2 = SWIG_AsVal_int(obj1, &val2);
51472 if (!SWIG_IsOK(ecode2)) {
51473 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51474 }
51475 arg2 = static_cast< int >(val2);
51476 {
51477 PyThreadState* __tstate = wxPyBeginAllowThreads();
51478 (arg1)->SetOrientation(arg2);
51479 wxPyEndAllowThreads(__tstate);
51480 if (PyErr_Occurred()) SWIG_fail;
51481 }
51482 resultobj = SWIG_Py_Void();
51483 return resultobj;
51484 fail:
51485 return NULL;
51486 }
51487
51488
51489 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51490 PyObject *obj;
51491 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51492 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51493 return SWIG_Py_Void();
51494 }
51495
51496 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51497 return SWIG_Python_InitShadowInstance(args);
51498 }
51499
51500 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51501 PyObject *resultobj = 0;
51502 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51503 int arg2 = (int) wxHORIZONTAL ;
51504 wxStaticBoxSizer *result = 0 ;
51505 void *argp1 = 0 ;
51506 int res1 = 0 ;
51507 int val2 ;
51508 int ecode2 = 0 ;
51509 PyObject * obj0 = 0 ;
51510 PyObject * obj1 = 0 ;
51511 char * kwnames[] = {
51512 (char *) "box",(char *) "orient", NULL
51513 };
51514
51515 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51516 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51517 if (!SWIG_IsOK(res1)) {
51518 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51519 }
51520 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51521 if (obj1) {
51522 ecode2 = SWIG_AsVal_int(obj1, &val2);
51523 if (!SWIG_IsOK(ecode2)) {
51524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51525 }
51526 arg2 = static_cast< int >(val2);
51527 }
51528 {
51529 PyThreadState* __tstate = wxPyBeginAllowThreads();
51530 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51531 wxPyEndAllowThreads(__tstate);
51532 if (PyErr_Occurred()) SWIG_fail;
51533 }
51534 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51535 return resultobj;
51536 fail:
51537 return NULL;
51538 }
51539
51540
51541 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51542 PyObject *resultobj = 0;
51543 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51544 wxStaticBox *result = 0 ;
51545 void *argp1 = 0 ;
51546 int res1 = 0 ;
51547 PyObject *swig_obj[1] ;
51548
51549 if (!args) SWIG_fail;
51550 swig_obj[0] = args;
51551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51552 if (!SWIG_IsOK(res1)) {
51553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51554 }
51555 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51556 {
51557 PyThreadState* __tstate = wxPyBeginAllowThreads();
51558 result = (wxStaticBox *)(arg1)->GetStaticBox();
51559 wxPyEndAllowThreads(__tstate);
51560 if (PyErr_Occurred()) SWIG_fail;
51561 }
51562 {
51563 resultobj = wxPyMake_wxObject(result, (bool)0);
51564 }
51565 return resultobj;
51566 fail:
51567 return NULL;
51568 }
51569
51570
51571 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51572 PyObject *obj;
51573 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51574 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51575 return SWIG_Py_Void();
51576 }
51577
51578 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51579 return SWIG_Python_InitShadowInstance(args);
51580 }
51581
51582 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51583 PyObject *resultobj = 0;
51584 int arg1 = (int) 1 ;
51585 int arg2 = (int) 0 ;
51586 int arg3 = (int) 0 ;
51587 int arg4 = (int) 0 ;
51588 wxGridSizer *result = 0 ;
51589 int val1 ;
51590 int ecode1 = 0 ;
51591 int val2 ;
51592 int ecode2 = 0 ;
51593 int val3 ;
51594 int ecode3 = 0 ;
51595 int val4 ;
51596 int ecode4 = 0 ;
51597 PyObject * obj0 = 0 ;
51598 PyObject * obj1 = 0 ;
51599 PyObject * obj2 = 0 ;
51600 PyObject * obj3 = 0 ;
51601 char * kwnames[] = {
51602 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51603 };
51604
51605 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51606 if (obj0) {
51607 ecode1 = SWIG_AsVal_int(obj0, &val1);
51608 if (!SWIG_IsOK(ecode1)) {
51609 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51610 }
51611 arg1 = static_cast< int >(val1);
51612 }
51613 if (obj1) {
51614 ecode2 = SWIG_AsVal_int(obj1, &val2);
51615 if (!SWIG_IsOK(ecode2)) {
51616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51617 }
51618 arg2 = static_cast< int >(val2);
51619 }
51620 if (obj2) {
51621 ecode3 = SWIG_AsVal_int(obj2, &val3);
51622 if (!SWIG_IsOK(ecode3)) {
51623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51624 }
51625 arg3 = static_cast< int >(val3);
51626 }
51627 if (obj3) {
51628 ecode4 = SWIG_AsVal_int(obj3, &val4);
51629 if (!SWIG_IsOK(ecode4)) {
51630 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51631 }
51632 arg4 = static_cast< int >(val4);
51633 }
51634 {
51635 PyThreadState* __tstate = wxPyBeginAllowThreads();
51636 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51637 wxPyEndAllowThreads(__tstate);
51638 if (PyErr_Occurred()) SWIG_fail;
51639 }
51640 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51641 return resultobj;
51642 fail:
51643 return NULL;
51644 }
51645
51646
51647 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51648 PyObject *resultobj = 0;
51649 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51650 int arg2 ;
51651 void *argp1 = 0 ;
51652 int res1 = 0 ;
51653 int val2 ;
51654 int ecode2 = 0 ;
51655 PyObject * obj0 = 0 ;
51656 PyObject * obj1 = 0 ;
51657 char * kwnames[] = {
51658 (char *) "self",(char *) "cols", NULL
51659 };
51660
51661 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51662 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51663 if (!SWIG_IsOK(res1)) {
51664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51665 }
51666 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51667 ecode2 = SWIG_AsVal_int(obj1, &val2);
51668 if (!SWIG_IsOK(ecode2)) {
51669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51670 }
51671 arg2 = static_cast< int >(val2);
51672 {
51673 PyThreadState* __tstate = wxPyBeginAllowThreads();
51674 (arg1)->SetCols(arg2);
51675 wxPyEndAllowThreads(__tstate);
51676 if (PyErr_Occurred()) SWIG_fail;
51677 }
51678 resultobj = SWIG_Py_Void();
51679 return resultobj;
51680 fail:
51681 return NULL;
51682 }
51683
51684
51685 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51686 PyObject *resultobj = 0;
51687 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51688 int arg2 ;
51689 void *argp1 = 0 ;
51690 int res1 = 0 ;
51691 int val2 ;
51692 int ecode2 = 0 ;
51693 PyObject * obj0 = 0 ;
51694 PyObject * obj1 = 0 ;
51695 char * kwnames[] = {
51696 (char *) "self",(char *) "rows", NULL
51697 };
51698
51699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51701 if (!SWIG_IsOK(res1)) {
51702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51703 }
51704 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51705 ecode2 = SWIG_AsVal_int(obj1, &val2);
51706 if (!SWIG_IsOK(ecode2)) {
51707 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51708 }
51709 arg2 = static_cast< int >(val2);
51710 {
51711 PyThreadState* __tstate = wxPyBeginAllowThreads();
51712 (arg1)->SetRows(arg2);
51713 wxPyEndAllowThreads(__tstate);
51714 if (PyErr_Occurred()) SWIG_fail;
51715 }
51716 resultobj = SWIG_Py_Void();
51717 return resultobj;
51718 fail:
51719 return NULL;
51720 }
51721
51722
51723 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51724 PyObject *resultobj = 0;
51725 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51726 int arg2 ;
51727 void *argp1 = 0 ;
51728 int res1 = 0 ;
51729 int val2 ;
51730 int ecode2 = 0 ;
51731 PyObject * obj0 = 0 ;
51732 PyObject * obj1 = 0 ;
51733 char * kwnames[] = {
51734 (char *) "self",(char *) "gap", NULL
51735 };
51736
51737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51739 if (!SWIG_IsOK(res1)) {
51740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51741 }
51742 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51743 ecode2 = SWIG_AsVal_int(obj1, &val2);
51744 if (!SWIG_IsOK(ecode2)) {
51745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51746 }
51747 arg2 = static_cast< int >(val2);
51748 {
51749 PyThreadState* __tstate = wxPyBeginAllowThreads();
51750 (arg1)->SetVGap(arg2);
51751 wxPyEndAllowThreads(__tstate);
51752 if (PyErr_Occurred()) SWIG_fail;
51753 }
51754 resultobj = SWIG_Py_Void();
51755 return resultobj;
51756 fail:
51757 return NULL;
51758 }
51759
51760
51761 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51762 PyObject *resultobj = 0;
51763 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51764 int arg2 ;
51765 void *argp1 = 0 ;
51766 int res1 = 0 ;
51767 int val2 ;
51768 int ecode2 = 0 ;
51769 PyObject * obj0 = 0 ;
51770 PyObject * obj1 = 0 ;
51771 char * kwnames[] = {
51772 (char *) "self",(char *) "gap", NULL
51773 };
51774
51775 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51776 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51777 if (!SWIG_IsOK(res1)) {
51778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51779 }
51780 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51781 ecode2 = SWIG_AsVal_int(obj1, &val2);
51782 if (!SWIG_IsOK(ecode2)) {
51783 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51784 }
51785 arg2 = static_cast< int >(val2);
51786 {
51787 PyThreadState* __tstate = wxPyBeginAllowThreads();
51788 (arg1)->SetHGap(arg2);
51789 wxPyEndAllowThreads(__tstate);
51790 if (PyErr_Occurred()) SWIG_fail;
51791 }
51792 resultobj = SWIG_Py_Void();
51793 return resultobj;
51794 fail:
51795 return NULL;
51796 }
51797
51798
51799 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51800 PyObject *resultobj = 0;
51801 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51802 int result;
51803 void *argp1 = 0 ;
51804 int res1 = 0 ;
51805 PyObject *swig_obj[1] ;
51806
51807 if (!args) SWIG_fail;
51808 swig_obj[0] = args;
51809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51810 if (!SWIG_IsOK(res1)) {
51811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51812 }
51813 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51814 {
51815 PyThreadState* __tstate = wxPyBeginAllowThreads();
51816 result = (int)(arg1)->GetCols();
51817 wxPyEndAllowThreads(__tstate);
51818 if (PyErr_Occurred()) SWIG_fail;
51819 }
51820 resultobj = SWIG_From_int(static_cast< int >(result));
51821 return resultobj;
51822 fail:
51823 return NULL;
51824 }
51825
51826
51827 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51828 PyObject *resultobj = 0;
51829 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51830 int result;
51831 void *argp1 = 0 ;
51832 int res1 = 0 ;
51833 PyObject *swig_obj[1] ;
51834
51835 if (!args) SWIG_fail;
51836 swig_obj[0] = args;
51837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51838 if (!SWIG_IsOK(res1)) {
51839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51840 }
51841 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51842 {
51843 PyThreadState* __tstate = wxPyBeginAllowThreads();
51844 result = (int)(arg1)->GetRows();
51845 wxPyEndAllowThreads(__tstate);
51846 if (PyErr_Occurred()) SWIG_fail;
51847 }
51848 resultobj = SWIG_From_int(static_cast< int >(result));
51849 return resultobj;
51850 fail:
51851 return NULL;
51852 }
51853
51854
51855 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51856 PyObject *resultobj = 0;
51857 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51858 int result;
51859 void *argp1 = 0 ;
51860 int res1 = 0 ;
51861 PyObject *swig_obj[1] ;
51862
51863 if (!args) SWIG_fail;
51864 swig_obj[0] = args;
51865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51866 if (!SWIG_IsOK(res1)) {
51867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51868 }
51869 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51870 {
51871 PyThreadState* __tstate = wxPyBeginAllowThreads();
51872 result = (int)(arg1)->GetVGap();
51873 wxPyEndAllowThreads(__tstate);
51874 if (PyErr_Occurred()) SWIG_fail;
51875 }
51876 resultobj = SWIG_From_int(static_cast< int >(result));
51877 return resultobj;
51878 fail:
51879 return NULL;
51880 }
51881
51882
51883 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51884 PyObject *resultobj = 0;
51885 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51886 int result;
51887 void *argp1 = 0 ;
51888 int res1 = 0 ;
51889 PyObject *swig_obj[1] ;
51890
51891 if (!args) SWIG_fail;
51892 swig_obj[0] = args;
51893 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51894 if (!SWIG_IsOK(res1)) {
51895 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51896 }
51897 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51898 {
51899 PyThreadState* __tstate = wxPyBeginAllowThreads();
51900 result = (int)(arg1)->GetHGap();
51901 wxPyEndAllowThreads(__tstate);
51902 if (PyErr_Occurred()) SWIG_fail;
51903 }
51904 resultobj = SWIG_From_int(static_cast< int >(result));
51905 return resultobj;
51906 fail:
51907 return NULL;
51908 }
51909
51910
51911 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51912 PyObject *obj;
51913 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51914 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51915 return SWIG_Py_Void();
51916 }
51917
51918 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51919 return SWIG_Python_InitShadowInstance(args);
51920 }
51921
51922 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51923 PyObject *resultobj = 0;
51924 int arg1 = (int) 1 ;
51925 int arg2 = (int) 0 ;
51926 int arg3 = (int) 0 ;
51927 int arg4 = (int) 0 ;
51928 wxFlexGridSizer *result = 0 ;
51929 int val1 ;
51930 int ecode1 = 0 ;
51931 int val2 ;
51932 int ecode2 = 0 ;
51933 int val3 ;
51934 int ecode3 = 0 ;
51935 int val4 ;
51936 int ecode4 = 0 ;
51937 PyObject * obj0 = 0 ;
51938 PyObject * obj1 = 0 ;
51939 PyObject * obj2 = 0 ;
51940 PyObject * obj3 = 0 ;
51941 char * kwnames[] = {
51942 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51943 };
51944
51945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51946 if (obj0) {
51947 ecode1 = SWIG_AsVal_int(obj0, &val1);
51948 if (!SWIG_IsOK(ecode1)) {
51949 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51950 }
51951 arg1 = static_cast< int >(val1);
51952 }
51953 if (obj1) {
51954 ecode2 = SWIG_AsVal_int(obj1, &val2);
51955 if (!SWIG_IsOK(ecode2)) {
51956 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51957 }
51958 arg2 = static_cast< int >(val2);
51959 }
51960 if (obj2) {
51961 ecode3 = SWIG_AsVal_int(obj2, &val3);
51962 if (!SWIG_IsOK(ecode3)) {
51963 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51964 }
51965 arg3 = static_cast< int >(val3);
51966 }
51967 if (obj3) {
51968 ecode4 = SWIG_AsVal_int(obj3, &val4);
51969 if (!SWIG_IsOK(ecode4)) {
51970 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51971 }
51972 arg4 = static_cast< int >(val4);
51973 }
51974 {
51975 PyThreadState* __tstate = wxPyBeginAllowThreads();
51976 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51977 wxPyEndAllowThreads(__tstate);
51978 if (PyErr_Occurred()) SWIG_fail;
51979 }
51980 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51981 return resultobj;
51982 fail:
51983 return NULL;
51984 }
51985
51986
51987 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51988 PyObject *resultobj = 0;
51989 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51990 size_t arg2 ;
51991 int arg3 = (int) 0 ;
51992 void *argp1 = 0 ;
51993 int res1 = 0 ;
51994 size_t val2 ;
51995 int ecode2 = 0 ;
51996 int val3 ;
51997 int ecode3 = 0 ;
51998 PyObject * obj0 = 0 ;
51999 PyObject * obj1 = 0 ;
52000 PyObject * obj2 = 0 ;
52001 char * kwnames[] = {
52002 (char *) "self",(char *) "idx",(char *) "proportion", NULL
52003 };
52004
52005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52007 if (!SWIG_IsOK(res1)) {
52008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52009 }
52010 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52011 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52012 if (!SWIG_IsOK(ecode2)) {
52013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
52014 }
52015 arg2 = static_cast< size_t >(val2);
52016 if (obj2) {
52017 ecode3 = SWIG_AsVal_int(obj2, &val3);
52018 if (!SWIG_IsOK(ecode3)) {
52019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
52020 }
52021 arg3 = static_cast< int >(val3);
52022 }
52023 {
52024 PyThreadState* __tstate = wxPyBeginAllowThreads();
52025 (arg1)->AddGrowableRow(arg2,arg3);
52026 wxPyEndAllowThreads(__tstate);
52027 if (PyErr_Occurred()) SWIG_fail;
52028 }
52029 resultobj = SWIG_Py_Void();
52030 return resultobj;
52031 fail:
52032 return NULL;
52033 }
52034
52035
52036 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52037 PyObject *resultobj = 0;
52038 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52039 size_t arg2 ;
52040 void *argp1 = 0 ;
52041 int res1 = 0 ;
52042 size_t val2 ;
52043 int ecode2 = 0 ;
52044 PyObject * obj0 = 0 ;
52045 PyObject * obj1 = 0 ;
52046 char * kwnames[] = {
52047 (char *) "self",(char *) "idx", NULL
52048 };
52049
52050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
52051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52052 if (!SWIG_IsOK(res1)) {
52053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52054 }
52055 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52056 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52057 if (!SWIG_IsOK(ecode2)) {
52058 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
52059 }
52060 arg2 = static_cast< size_t >(val2);
52061 {
52062 PyThreadState* __tstate = wxPyBeginAllowThreads();
52063 (arg1)->RemoveGrowableRow(arg2);
52064 wxPyEndAllowThreads(__tstate);
52065 if (PyErr_Occurred()) SWIG_fail;
52066 }
52067 resultobj = SWIG_Py_Void();
52068 return resultobj;
52069 fail:
52070 return NULL;
52071 }
52072
52073
52074 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52075 PyObject *resultobj = 0;
52076 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52077 size_t arg2 ;
52078 int arg3 = (int) 0 ;
52079 void *argp1 = 0 ;
52080 int res1 = 0 ;
52081 size_t val2 ;
52082 int ecode2 = 0 ;
52083 int val3 ;
52084 int ecode3 = 0 ;
52085 PyObject * obj0 = 0 ;
52086 PyObject * obj1 = 0 ;
52087 PyObject * obj2 = 0 ;
52088 char * kwnames[] = {
52089 (char *) "self",(char *) "idx",(char *) "proportion", NULL
52090 };
52091
52092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52094 if (!SWIG_IsOK(res1)) {
52095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52096 }
52097 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52098 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52099 if (!SWIG_IsOK(ecode2)) {
52100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52101 }
52102 arg2 = static_cast< size_t >(val2);
52103 if (obj2) {
52104 ecode3 = SWIG_AsVal_int(obj2, &val3);
52105 if (!SWIG_IsOK(ecode3)) {
52106 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
52107 }
52108 arg3 = static_cast< int >(val3);
52109 }
52110 {
52111 PyThreadState* __tstate = wxPyBeginAllowThreads();
52112 (arg1)->AddGrowableCol(arg2,arg3);
52113 wxPyEndAllowThreads(__tstate);
52114 if (PyErr_Occurred()) SWIG_fail;
52115 }
52116 resultobj = SWIG_Py_Void();
52117 return resultobj;
52118 fail:
52119 return NULL;
52120 }
52121
52122
52123 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52124 PyObject *resultobj = 0;
52125 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52126 size_t arg2 ;
52127 void *argp1 = 0 ;
52128 int res1 = 0 ;
52129 size_t val2 ;
52130 int ecode2 = 0 ;
52131 PyObject * obj0 = 0 ;
52132 PyObject * obj1 = 0 ;
52133 char * kwnames[] = {
52134 (char *) "self",(char *) "idx", NULL
52135 };
52136
52137 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
52138 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52139 if (!SWIG_IsOK(res1)) {
52140 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52141 }
52142 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52143 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52144 if (!SWIG_IsOK(ecode2)) {
52145 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52146 }
52147 arg2 = static_cast< size_t >(val2);
52148 {
52149 PyThreadState* __tstate = wxPyBeginAllowThreads();
52150 (arg1)->RemoveGrowableCol(arg2);
52151 wxPyEndAllowThreads(__tstate);
52152 if (PyErr_Occurred()) SWIG_fail;
52153 }
52154 resultobj = SWIG_Py_Void();
52155 return resultobj;
52156 fail:
52157 return NULL;
52158 }
52159
52160
52161 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52162 PyObject *resultobj = 0;
52163 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52164 int arg2 ;
52165 void *argp1 = 0 ;
52166 int res1 = 0 ;
52167 int val2 ;
52168 int ecode2 = 0 ;
52169 PyObject * obj0 = 0 ;
52170 PyObject * obj1 = 0 ;
52171 char * kwnames[] = {
52172 (char *) "self",(char *) "direction", NULL
52173 };
52174
52175 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52176 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52177 if (!SWIG_IsOK(res1)) {
52178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52179 }
52180 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52181 ecode2 = SWIG_AsVal_int(obj1, &val2);
52182 if (!SWIG_IsOK(ecode2)) {
52183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52184 }
52185 arg2 = static_cast< int >(val2);
52186 {
52187 PyThreadState* __tstate = wxPyBeginAllowThreads();
52188 (arg1)->SetFlexibleDirection(arg2);
52189 wxPyEndAllowThreads(__tstate);
52190 if (PyErr_Occurred()) SWIG_fail;
52191 }
52192 resultobj = SWIG_Py_Void();
52193 return resultobj;
52194 fail:
52195 return NULL;
52196 }
52197
52198
52199 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52200 PyObject *resultobj = 0;
52201 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52202 int result;
52203 void *argp1 = 0 ;
52204 int res1 = 0 ;
52205 PyObject *swig_obj[1] ;
52206
52207 if (!args) SWIG_fail;
52208 swig_obj[0] = args;
52209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52210 if (!SWIG_IsOK(res1)) {
52211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52212 }
52213 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52214 {
52215 PyThreadState* __tstate = wxPyBeginAllowThreads();
52216 result = (int)(arg1)->GetFlexibleDirection();
52217 wxPyEndAllowThreads(__tstate);
52218 if (PyErr_Occurred()) SWIG_fail;
52219 }
52220 resultobj = SWIG_From_int(static_cast< int >(result));
52221 return resultobj;
52222 fail:
52223 return NULL;
52224 }
52225
52226
52227 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52228 PyObject *resultobj = 0;
52229 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52230 wxFlexSizerGrowMode arg2 ;
52231 void *argp1 = 0 ;
52232 int res1 = 0 ;
52233 int val2 ;
52234 int ecode2 = 0 ;
52235 PyObject * obj0 = 0 ;
52236 PyObject * obj1 = 0 ;
52237 char * kwnames[] = {
52238 (char *) "self",(char *) "mode", NULL
52239 };
52240
52241 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52242 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52243 if (!SWIG_IsOK(res1)) {
52244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52245 }
52246 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52247 ecode2 = SWIG_AsVal_int(obj1, &val2);
52248 if (!SWIG_IsOK(ecode2)) {
52249 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52250 }
52251 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52252 {
52253 PyThreadState* __tstate = wxPyBeginAllowThreads();
52254 (arg1)->SetNonFlexibleGrowMode(arg2);
52255 wxPyEndAllowThreads(__tstate);
52256 if (PyErr_Occurred()) SWIG_fail;
52257 }
52258 resultobj = SWIG_Py_Void();
52259 return resultobj;
52260 fail:
52261 return NULL;
52262 }
52263
52264
52265 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52266 PyObject *resultobj = 0;
52267 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52268 wxFlexSizerGrowMode result;
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_wxFlexGridSizer, 0 | 0 );
52276 if (!SWIG_IsOK(res1)) {
52277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52278 }
52279 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52280 {
52281 PyThreadState* __tstate = wxPyBeginAllowThreads();
52282 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52283 wxPyEndAllowThreads(__tstate);
52284 if (PyErr_Occurred()) SWIG_fail;
52285 }
52286 resultobj = SWIG_From_int(static_cast< int >(result));
52287 return resultobj;
52288 fail:
52289 return NULL;
52290 }
52291
52292
52293 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52294 PyObject *resultobj = 0;
52295 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52296 wxArrayInt *result = 0 ;
52297 void *argp1 = 0 ;
52298 int res1 = 0 ;
52299 PyObject *swig_obj[1] ;
52300
52301 if (!args) SWIG_fail;
52302 swig_obj[0] = args;
52303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52304 if (!SWIG_IsOK(res1)) {
52305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52306 }
52307 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52308 {
52309 PyThreadState* __tstate = wxPyBeginAllowThreads();
52310 {
52311 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52312 result = (wxArrayInt *) &_result_ref;
52313 }
52314 wxPyEndAllowThreads(__tstate);
52315 if (PyErr_Occurred()) SWIG_fail;
52316 }
52317 {
52318 resultobj = wxArrayInt2PyList_helper(*result);
52319 }
52320 return resultobj;
52321 fail:
52322 return NULL;
52323 }
52324
52325
52326 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52327 PyObject *resultobj = 0;
52328 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52329 wxArrayInt *result = 0 ;
52330 void *argp1 = 0 ;
52331 int res1 = 0 ;
52332 PyObject *swig_obj[1] ;
52333
52334 if (!args) SWIG_fail;
52335 swig_obj[0] = args;
52336 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52337 if (!SWIG_IsOK(res1)) {
52338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52339 }
52340 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52341 {
52342 PyThreadState* __tstate = wxPyBeginAllowThreads();
52343 {
52344 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52345 result = (wxArrayInt *) &_result_ref;
52346 }
52347 wxPyEndAllowThreads(__tstate);
52348 if (PyErr_Occurred()) SWIG_fail;
52349 }
52350 {
52351 resultobj = wxArrayInt2PyList_helper(*result);
52352 }
52353 return resultobj;
52354 fail:
52355 return NULL;
52356 }
52357
52358
52359 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52360 PyObject *obj;
52361 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52362 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52363 return SWIG_Py_Void();
52364 }
52365
52366 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52367 return SWIG_Python_InitShadowInstance(args);
52368 }
52369
52370 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52371 PyObject *resultobj = 0;
52372 wxStdDialogButtonSizer *result = 0 ;
52373
52374 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52375 {
52376 PyThreadState* __tstate = wxPyBeginAllowThreads();
52377 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52378 wxPyEndAllowThreads(__tstate);
52379 if (PyErr_Occurred()) SWIG_fail;
52380 }
52381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52382 return resultobj;
52383 fail:
52384 return NULL;
52385 }
52386
52387
52388 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52389 PyObject *resultobj = 0;
52390 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52391 wxButton *arg2 = (wxButton *) 0 ;
52392 void *argp1 = 0 ;
52393 int res1 = 0 ;
52394 void *argp2 = 0 ;
52395 int res2 = 0 ;
52396 PyObject * obj0 = 0 ;
52397 PyObject * obj1 = 0 ;
52398 char * kwnames[] = {
52399 (char *) "self",(char *) "button", NULL
52400 };
52401
52402 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52403 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52404 if (!SWIG_IsOK(res1)) {
52405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52406 }
52407 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52408 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52409 if (!SWIG_IsOK(res2)) {
52410 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52411 }
52412 arg2 = reinterpret_cast< wxButton * >(argp2);
52413 {
52414 PyThreadState* __tstate = wxPyBeginAllowThreads();
52415 (arg1)->AddButton(arg2);
52416 wxPyEndAllowThreads(__tstate);
52417 if (PyErr_Occurred()) SWIG_fail;
52418 }
52419 resultobj = SWIG_Py_Void();
52420 return resultobj;
52421 fail:
52422 return NULL;
52423 }
52424
52425
52426 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52427 PyObject *resultobj = 0;
52428 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52429 void *argp1 = 0 ;
52430 int res1 = 0 ;
52431 PyObject *swig_obj[1] ;
52432
52433 if (!args) SWIG_fail;
52434 swig_obj[0] = args;
52435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52436 if (!SWIG_IsOK(res1)) {
52437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52438 }
52439 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52440 {
52441 PyThreadState* __tstate = wxPyBeginAllowThreads();
52442 (arg1)->Realize();
52443 wxPyEndAllowThreads(__tstate);
52444 if (PyErr_Occurred()) SWIG_fail;
52445 }
52446 resultobj = SWIG_Py_Void();
52447 return resultobj;
52448 fail:
52449 return NULL;
52450 }
52451
52452
52453 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52454 PyObject *resultobj = 0;
52455 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52456 wxButton *arg2 = (wxButton *) 0 ;
52457 void *argp1 = 0 ;
52458 int res1 = 0 ;
52459 void *argp2 = 0 ;
52460 int res2 = 0 ;
52461 PyObject * obj0 = 0 ;
52462 PyObject * obj1 = 0 ;
52463 char * kwnames[] = {
52464 (char *) "self",(char *) "button", NULL
52465 };
52466
52467 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52468 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52469 if (!SWIG_IsOK(res1)) {
52470 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52471 }
52472 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52473 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52474 if (!SWIG_IsOK(res2)) {
52475 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52476 }
52477 arg2 = reinterpret_cast< wxButton * >(argp2);
52478 {
52479 PyThreadState* __tstate = wxPyBeginAllowThreads();
52480 (arg1)->SetAffirmativeButton(arg2);
52481 wxPyEndAllowThreads(__tstate);
52482 if (PyErr_Occurred()) SWIG_fail;
52483 }
52484 resultobj = SWIG_Py_Void();
52485 return resultobj;
52486 fail:
52487 return NULL;
52488 }
52489
52490
52491 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52492 PyObject *resultobj = 0;
52493 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52494 wxButton *arg2 = (wxButton *) 0 ;
52495 void *argp1 = 0 ;
52496 int res1 = 0 ;
52497 void *argp2 = 0 ;
52498 int res2 = 0 ;
52499 PyObject * obj0 = 0 ;
52500 PyObject * obj1 = 0 ;
52501 char * kwnames[] = {
52502 (char *) "self",(char *) "button", NULL
52503 };
52504
52505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52507 if (!SWIG_IsOK(res1)) {
52508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52509 }
52510 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52511 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52512 if (!SWIG_IsOK(res2)) {
52513 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52514 }
52515 arg2 = reinterpret_cast< wxButton * >(argp2);
52516 {
52517 PyThreadState* __tstate = wxPyBeginAllowThreads();
52518 (arg1)->SetNegativeButton(arg2);
52519 wxPyEndAllowThreads(__tstate);
52520 if (PyErr_Occurred()) SWIG_fail;
52521 }
52522 resultobj = SWIG_Py_Void();
52523 return resultobj;
52524 fail:
52525 return NULL;
52526 }
52527
52528
52529 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52530 PyObject *resultobj = 0;
52531 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52532 wxButton *arg2 = (wxButton *) 0 ;
52533 void *argp1 = 0 ;
52534 int res1 = 0 ;
52535 void *argp2 = 0 ;
52536 int res2 = 0 ;
52537 PyObject * obj0 = 0 ;
52538 PyObject * obj1 = 0 ;
52539 char * kwnames[] = {
52540 (char *) "self",(char *) "button", NULL
52541 };
52542
52543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52545 if (!SWIG_IsOK(res1)) {
52546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52547 }
52548 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52549 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52550 if (!SWIG_IsOK(res2)) {
52551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52552 }
52553 arg2 = reinterpret_cast< wxButton * >(argp2);
52554 {
52555 PyThreadState* __tstate = wxPyBeginAllowThreads();
52556 (arg1)->SetCancelButton(arg2);
52557 wxPyEndAllowThreads(__tstate);
52558 if (PyErr_Occurred()) SWIG_fail;
52559 }
52560 resultobj = SWIG_Py_Void();
52561 return resultobj;
52562 fail:
52563 return NULL;
52564 }
52565
52566
52567 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52568 PyObject *resultobj = 0;
52569 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52570 wxButton *result = 0 ;
52571 void *argp1 = 0 ;
52572 int res1 = 0 ;
52573 PyObject *swig_obj[1] ;
52574
52575 if (!args) SWIG_fail;
52576 swig_obj[0] = args;
52577 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52578 if (!SWIG_IsOK(res1)) {
52579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52580 }
52581 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52582 {
52583 PyThreadState* __tstate = wxPyBeginAllowThreads();
52584 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52585 wxPyEndAllowThreads(__tstate);
52586 if (PyErr_Occurred()) SWIG_fail;
52587 }
52588 {
52589 resultobj = wxPyMake_wxObject(result, (bool)0);
52590 }
52591 return resultobj;
52592 fail:
52593 return NULL;
52594 }
52595
52596
52597 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52598 PyObject *resultobj = 0;
52599 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52600 wxButton *result = 0 ;
52601 void *argp1 = 0 ;
52602 int res1 = 0 ;
52603 PyObject *swig_obj[1] ;
52604
52605 if (!args) SWIG_fail;
52606 swig_obj[0] = args;
52607 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52608 if (!SWIG_IsOK(res1)) {
52609 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52610 }
52611 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52612 {
52613 PyThreadState* __tstate = wxPyBeginAllowThreads();
52614 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52615 wxPyEndAllowThreads(__tstate);
52616 if (PyErr_Occurred()) SWIG_fail;
52617 }
52618 {
52619 resultobj = wxPyMake_wxObject(result, (bool)0);
52620 }
52621 return resultobj;
52622 fail:
52623 return NULL;
52624 }
52625
52626
52627 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52628 PyObject *resultobj = 0;
52629 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52630 wxButton *result = 0 ;
52631 void *argp1 = 0 ;
52632 int res1 = 0 ;
52633 PyObject *swig_obj[1] ;
52634
52635 if (!args) SWIG_fail;
52636 swig_obj[0] = args;
52637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52638 if (!SWIG_IsOK(res1)) {
52639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52640 }
52641 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52642 {
52643 PyThreadState* __tstate = wxPyBeginAllowThreads();
52644 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52645 wxPyEndAllowThreads(__tstate);
52646 if (PyErr_Occurred()) SWIG_fail;
52647 }
52648 {
52649 resultobj = wxPyMake_wxObject(result, (bool)0);
52650 }
52651 return resultobj;
52652 fail:
52653 return NULL;
52654 }
52655
52656
52657 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52658 PyObject *resultobj = 0;
52659 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52660 wxButton *result = 0 ;
52661 void *argp1 = 0 ;
52662 int res1 = 0 ;
52663 PyObject *swig_obj[1] ;
52664
52665 if (!args) SWIG_fail;
52666 swig_obj[0] = args;
52667 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52668 if (!SWIG_IsOK(res1)) {
52669 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52670 }
52671 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52672 {
52673 PyThreadState* __tstate = wxPyBeginAllowThreads();
52674 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52675 wxPyEndAllowThreads(__tstate);
52676 if (PyErr_Occurred()) SWIG_fail;
52677 }
52678 {
52679 resultobj = wxPyMake_wxObject(result, (bool)0);
52680 }
52681 return resultobj;
52682 fail:
52683 return NULL;
52684 }
52685
52686
52687 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52688 PyObject *resultobj = 0;
52689 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52690 wxButton *result = 0 ;
52691 void *argp1 = 0 ;
52692 int res1 = 0 ;
52693 PyObject *swig_obj[1] ;
52694
52695 if (!args) SWIG_fail;
52696 swig_obj[0] = args;
52697 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52698 if (!SWIG_IsOK(res1)) {
52699 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52700 }
52701 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52702 {
52703 PyThreadState* __tstate = wxPyBeginAllowThreads();
52704 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52705 wxPyEndAllowThreads(__tstate);
52706 if (PyErr_Occurred()) SWIG_fail;
52707 }
52708 {
52709 resultobj = wxPyMake_wxObject(result, (bool)0);
52710 }
52711 return resultobj;
52712 fail:
52713 return NULL;
52714 }
52715
52716
52717 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52718 PyObject *obj;
52719 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52720 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52721 return SWIG_Py_Void();
52722 }
52723
52724 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52725 return SWIG_Python_InitShadowInstance(args);
52726 }
52727
52728 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52729 PyObject *resultobj = 0;
52730 int arg1 = (int) 0 ;
52731 int arg2 = (int) 0 ;
52732 wxGBPosition *result = 0 ;
52733 int val1 ;
52734 int ecode1 = 0 ;
52735 int val2 ;
52736 int ecode2 = 0 ;
52737 PyObject * obj0 = 0 ;
52738 PyObject * obj1 = 0 ;
52739 char * kwnames[] = {
52740 (char *) "row",(char *) "col", NULL
52741 };
52742
52743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52744 if (obj0) {
52745 ecode1 = SWIG_AsVal_int(obj0, &val1);
52746 if (!SWIG_IsOK(ecode1)) {
52747 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52748 }
52749 arg1 = static_cast< int >(val1);
52750 }
52751 if (obj1) {
52752 ecode2 = SWIG_AsVal_int(obj1, &val2);
52753 if (!SWIG_IsOK(ecode2)) {
52754 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52755 }
52756 arg2 = static_cast< int >(val2);
52757 }
52758 {
52759 PyThreadState* __tstate = wxPyBeginAllowThreads();
52760 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52761 wxPyEndAllowThreads(__tstate);
52762 if (PyErr_Occurred()) SWIG_fail;
52763 }
52764 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52765 return resultobj;
52766 fail:
52767 return NULL;
52768 }
52769
52770
52771 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52772 PyObject *resultobj = 0;
52773 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52774 void *argp1 = 0 ;
52775 int res1 = 0 ;
52776 PyObject *swig_obj[1] ;
52777
52778 if (!args) SWIG_fail;
52779 swig_obj[0] = args;
52780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52781 if (!SWIG_IsOK(res1)) {
52782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52783 }
52784 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52785 {
52786 PyThreadState* __tstate = wxPyBeginAllowThreads();
52787 delete arg1;
52788
52789 wxPyEndAllowThreads(__tstate);
52790 if (PyErr_Occurred()) SWIG_fail;
52791 }
52792 resultobj = SWIG_Py_Void();
52793 return resultobj;
52794 fail:
52795 return NULL;
52796 }
52797
52798
52799 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52800 PyObject *resultobj = 0;
52801 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52802 int result;
52803 void *argp1 = 0 ;
52804 int res1 = 0 ;
52805 PyObject *swig_obj[1] ;
52806
52807 if (!args) SWIG_fail;
52808 swig_obj[0] = args;
52809 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52810 if (!SWIG_IsOK(res1)) {
52811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52812 }
52813 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52814 {
52815 PyThreadState* __tstate = wxPyBeginAllowThreads();
52816 result = (int)((wxGBPosition const *)arg1)->GetRow();
52817 wxPyEndAllowThreads(__tstate);
52818 if (PyErr_Occurred()) SWIG_fail;
52819 }
52820 resultobj = SWIG_From_int(static_cast< int >(result));
52821 return resultobj;
52822 fail:
52823 return NULL;
52824 }
52825
52826
52827 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52828 PyObject *resultobj = 0;
52829 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52830 int result;
52831 void *argp1 = 0 ;
52832 int res1 = 0 ;
52833 PyObject *swig_obj[1] ;
52834
52835 if (!args) SWIG_fail;
52836 swig_obj[0] = args;
52837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52838 if (!SWIG_IsOK(res1)) {
52839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52840 }
52841 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52842 {
52843 PyThreadState* __tstate = wxPyBeginAllowThreads();
52844 result = (int)((wxGBPosition const *)arg1)->GetCol();
52845 wxPyEndAllowThreads(__tstate);
52846 if (PyErr_Occurred()) SWIG_fail;
52847 }
52848 resultobj = SWIG_From_int(static_cast< int >(result));
52849 return resultobj;
52850 fail:
52851 return NULL;
52852 }
52853
52854
52855 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52856 PyObject *resultobj = 0;
52857 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52858 int arg2 ;
52859 void *argp1 = 0 ;
52860 int res1 = 0 ;
52861 int val2 ;
52862 int ecode2 = 0 ;
52863 PyObject * obj0 = 0 ;
52864 PyObject * obj1 = 0 ;
52865 char * kwnames[] = {
52866 (char *) "self",(char *) "row", NULL
52867 };
52868
52869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52871 if (!SWIG_IsOK(res1)) {
52872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52873 }
52874 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52875 ecode2 = SWIG_AsVal_int(obj1, &val2);
52876 if (!SWIG_IsOK(ecode2)) {
52877 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52878 }
52879 arg2 = static_cast< int >(val2);
52880 {
52881 PyThreadState* __tstate = wxPyBeginAllowThreads();
52882 (arg1)->SetRow(arg2);
52883 wxPyEndAllowThreads(__tstate);
52884 if (PyErr_Occurred()) SWIG_fail;
52885 }
52886 resultobj = SWIG_Py_Void();
52887 return resultobj;
52888 fail:
52889 return NULL;
52890 }
52891
52892
52893 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52894 PyObject *resultobj = 0;
52895 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52896 int arg2 ;
52897 void *argp1 = 0 ;
52898 int res1 = 0 ;
52899 int val2 ;
52900 int ecode2 = 0 ;
52901 PyObject * obj0 = 0 ;
52902 PyObject * obj1 = 0 ;
52903 char * kwnames[] = {
52904 (char *) "self",(char *) "col", NULL
52905 };
52906
52907 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52908 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52909 if (!SWIG_IsOK(res1)) {
52910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52911 }
52912 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52913 ecode2 = SWIG_AsVal_int(obj1, &val2);
52914 if (!SWIG_IsOK(ecode2)) {
52915 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52916 }
52917 arg2 = static_cast< int >(val2);
52918 {
52919 PyThreadState* __tstate = wxPyBeginAllowThreads();
52920 (arg1)->SetCol(arg2);
52921 wxPyEndAllowThreads(__tstate);
52922 if (PyErr_Occurred()) SWIG_fail;
52923 }
52924 resultobj = SWIG_Py_Void();
52925 return resultobj;
52926 fail:
52927 return NULL;
52928 }
52929
52930
52931 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52932 PyObject *resultobj = 0;
52933 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52934 PyObject *arg2 = (PyObject *) 0 ;
52935 bool result;
52936 void *argp1 = 0 ;
52937 int res1 = 0 ;
52938 PyObject * obj0 = 0 ;
52939 PyObject * obj1 = 0 ;
52940 char * kwnames[] = {
52941 (char *) "self",(char *) "other", NULL
52942 };
52943
52944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52946 if (!SWIG_IsOK(res1)) {
52947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52948 }
52949 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52950 arg2 = obj1;
52951 {
52952 result = (bool)wxGBPosition___eq__(arg1,arg2);
52953 if (PyErr_Occurred()) SWIG_fail;
52954 }
52955 {
52956 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52957 }
52958 return resultobj;
52959 fail:
52960 return NULL;
52961 }
52962
52963
52964 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52965 PyObject *resultobj = 0;
52966 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52967 PyObject *arg2 = (PyObject *) 0 ;
52968 bool result;
52969 void *argp1 = 0 ;
52970 int res1 = 0 ;
52971 PyObject * obj0 = 0 ;
52972 PyObject * obj1 = 0 ;
52973 char * kwnames[] = {
52974 (char *) "self",(char *) "other", NULL
52975 };
52976
52977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52979 if (!SWIG_IsOK(res1)) {
52980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52981 }
52982 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52983 arg2 = obj1;
52984 {
52985 result = (bool)wxGBPosition___ne__(arg1,arg2);
52986 if (PyErr_Occurred()) SWIG_fail;
52987 }
52988 {
52989 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52990 }
52991 return resultobj;
52992 fail:
52993 return NULL;
52994 }
52995
52996
52997 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52998 PyObject *resultobj = 0;
52999 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53000 int arg2 = (int) 0 ;
53001 int arg3 = (int) 0 ;
53002 void *argp1 = 0 ;
53003 int res1 = 0 ;
53004 int val2 ;
53005 int ecode2 = 0 ;
53006 int val3 ;
53007 int ecode3 = 0 ;
53008 PyObject * obj0 = 0 ;
53009 PyObject * obj1 = 0 ;
53010 PyObject * obj2 = 0 ;
53011 char * kwnames[] = {
53012 (char *) "self",(char *) "row",(char *) "col", NULL
53013 };
53014
53015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53017 if (!SWIG_IsOK(res1)) {
53018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53019 }
53020 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53021 if (obj1) {
53022 ecode2 = SWIG_AsVal_int(obj1, &val2);
53023 if (!SWIG_IsOK(ecode2)) {
53024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
53025 }
53026 arg2 = static_cast< int >(val2);
53027 }
53028 if (obj2) {
53029 ecode3 = SWIG_AsVal_int(obj2, &val3);
53030 if (!SWIG_IsOK(ecode3)) {
53031 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
53032 }
53033 arg3 = static_cast< int >(val3);
53034 }
53035 {
53036 PyThreadState* __tstate = wxPyBeginAllowThreads();
53037 wxGBPosition_Set(arg1,arg2,arg3);
53038 wxPyEndAllowThreads(__tstate);
53039 if (PyErr_Occurred()) SWIG_fail;
53040 }
53041 resultobj = SWIG_Py_Void();
53042 return resultobj;
53043 fail:
53044 return NULL;
53045 }
53046
53047
53048 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53049 PyObject *resultobj = 0;
53050 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53051 PyObject *result = 0 ;
53052 void *argp1 = 0 ;
53053 int res1 = 0 ;
53054 PyObject *swig_obj[1] ;
53055
53056 if (!args) SWIG_fail;
53057 swig_obj[0] = args;
53058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53059 if (!SWIG_IsOK(res1)) {
53060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53061 }
53062 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53063 {
53064 PyThreadState* __tstate = wxPyBeginAllowThreads();
53065 result = (PyObject *)wxGBPosition_Get(arg1);
53066 wxPyEndAllowThreads(__tstate);
53067 if (PyErr_Occurred()) SWIG_fail;
53068 }
53069 resultobj = result;
53070 return resultobj;
53071 fail:
53072 return NULL;
53073 }
53074
53075
53076 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53077 PyObject *obj;
53078 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53079 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
53080 return SWIG_Py_Void();
53081 }
53082
53083 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53084 return SWIG_Python_InitShadowInstance(args);
53085 }
53086
53087 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53088 PyObject *resultobj = 0;
53089 int arg1 = (int) 1 ;
53090 int arg2 = (int) 1 ;
53091 wxGBSpan *result = 0 ;
53092 int val1 ;
53093 int ecode1 = 0 ;
53094 int val2 ;
53095 int ecode2 = 0 ;
53096 PyObject * obj0 = 0 ;
53097 PyObject * obj1 = 0 ;
53098 char * kwnames[] = {
53099 (char *) "rowspan",(char *) "colspan", NULL
53100 };
53101
53102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53103 if (obj0) {
53104 ecode1 = SWIG_AsVal_int(obj0, &val1);
53105 if (!SWIG_IsOK(ecode1)) {
53106 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
53107 }
53108 arg1 = static_cast< int >(val1);
53109 }
53110 if (obj1) {
53111 ecode2 = SWIG_AsVal_int(obj1, &val2);
53112 if (!SWIG_IsOK(ecode2)) {
53113 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
53114 }
53115 arg2 = static_cast< int >(val2);
53116 }
53117 {
53118 PyThreadState* __tstate = wxPyBeginAllowThreads();
53119 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
53120 wxPyEndAllowThreads(__tstate);
53121 if (PyErr_Occurred()) SWIG_fail;
53122 }
53123 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
53124 return resultobj;
53125 fail:
53126 return NULL;
53127 }
53128
53129
53130 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53131 PyObject *resultobj = 0;
53132 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53133 void *argp1 = 0 ;
53134 int res1 = 0 ;
53135 PyObject *swig_obj[1] ;
53136
53137 if (!args) SWIG_fail;
53138 swig_obj[0] = args;
53139 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
53140 if (!SWIG_IsOK(res1)) {
53141 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53142 }
53143 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53144 {
53145 PyThreadState* __tstate = wxPyBeginAllowThreads();
53146 delete arg1;
53147
53148 wxPyEndAllowThreads(__tstate);
53149 if (PyErr_Occurred()) SWIG_fail;
53150 }
53151 resultobj = SWIG_Py_Void();
53152 return resultobj;
53153 fail:
53154 return NULL;
53155 }
53156
53157
53158 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53159 PyObject *resultobj = 0;
53160 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53161 int result;
53162 void *argp1 = 0 ;
53163 int res1 = 0 ;
53164 PyObject *swig_obj[1] ;
53165
53166 if (!args) SWIG_fail;
53167 swig_obj[0] = args;
53168 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53169 if (!SWIG_IsOK(res1)) {
53170 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53171 }
53172 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53173 {
53174 PyThreadState* __tstate = wxPyBeginAllowThreads();
53175 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53176 wxPyEndAllowThreads(__tstate);
53177 if (PyErr_Occurred()) SWIG_fail;
53178 }
53179 resultobj = SWIG_From_int(static_cast< int >(result));
53180 return resultobj;
53181 fail:
53182 return NULL;
53183 }
53184
53185
53186 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53187 PyObject *resultobj = 0;
53188 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53189 int result;
53190 void *argp1 = 0 ;
53191 int res1 = 0 ;
53192 PyObject *swig_obj[1] ;
53193
53194 if (!args) SWIG_fail;
53195 swig_obj[0] = args;
53196 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53197 if (!SWIG_IsOK(res1)) {
53198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53199 }
53200 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53201 {
53202 PyThreadState* __tstate = wxPyBeginAllowThreads();
53203 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53204 wxPyEndAllowThreads(__tstate);
53205 if (PyErr_Occurred()) SWIG_fail;
53206 }
53207 resultobj = SWIG_From_int(static_cast< int >(result));
53208 return resultobj;
53209 fail:
53210 return NULL;
53211 }
53212
53213
53214 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53215 PyObject *resultobj = 0;
53216 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53217 int arg2 ;
53218 void *argp1 = 0 ;
53219 int res1 = 0 ;
53220 int val2 ;
53221 int ecode2 = 0 ;
53222 PyObject * obj0 = 0 ;
53223 PyObject * obj1 = 0 ;
53224 char * kwnames[] = {
53225 (char *) "self",(char *) "rowspan", NULL
53226 };
53227
53228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53230 if (!SWIG_IsOK(res1)) {
53231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53232 }
53233 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53234 ecode2 = SWIG_AsVal_int(obj1, &val2);
53235 if (!SWIG_IsOK(ecode2)) {
53236 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53237 }
53238 arg2 = static_cast< int >(val2);
53239 {
53240 PyThreadState* __tstate = wxPyBeginAllowThreads();
53241 (arg1)->SetRowspan(arg2);
53242 wxPyEndAllowThreads(__tstate);
53243 if (PyErr_Occurred()) SWIG_fail;
53244 }
53245 resultobj = SWIG_Py_Void();
53246 return resultobj;
53247 fail:
53248 return NULL;
53249 }
53250
53251
53252 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53253 PyObject *resultobj = 0;
53254 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53255 int arg2 ;
53256 void *argp1 = 0 ;
53257 int res1 = 0 ;
53258 int val2 ;
53259 int ecode2 = 0 ;
53260 PyObject * obj0 = 0 ;
53261 PyObject * obj1 = 0 ;
53262 char * kwnames[] = {
53263 (char *) "self",(char *) "colspan", NULL
53264 };
53265
53266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53268 if (!SWIG_IsOK(res1)) {
53269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53270 }
53271 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53272 ecode2 = SWIG_AsVal_int(obj1, &val2);
53273 if (!SWIG_IsOK(ecode2)) {
53274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53275 }
53276 arg2 = static_cast< int >(val2);
53277 {
53278 PyThreadState* __tstate = wxPyBeginAllowThreads();
53279 (arg1)->SetColspan(arg2);
53280 wxPyEndAllowThreads(__tstate);
53281 if (PyErr_Occurred()) SWIG_fail;
53282 }
53283 resultobj = SWIG_Py_Void();
53284 return resultobj;
53285 fail:
53286 return NULL;
53287 }
53288
53289
53290 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53291 PyObject *resultobj = 0;
53292 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53293 PyObject *arg2 = (PyObject *) 0 ;
53294 bool result;
53295 void *argp1 = 0 ;
53296 int res1 = 0 ;
53297 PyObject * obj0 = 0 ;
53298 PyObject * obj1 = 0 ;
53299 char * kwnames[] = {
53300 (char *) "self",(char *) "other", NULL
53301 };
53302
53303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53304 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53305 if (!SWIG_IsOK(res1)) {
53306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53307 }
53308 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53309 arg2 = obj1;
53310 {
53311 result = (bool)wxGBSpan___eq__(arg1,arg2);
53312 if (PyErr_Occurred()) SWIG_fail;
53313 }
53314 {
53315 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53316 }
53317 return resultobj;
53318 fail:
53319 return NULL;
53320 }
53321
53322
53323 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53324 PyObject *resultobj = 0;
53325 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53326 PyObject *arg2 = (PyObject *) 0 ;
53327 bool result;
53328 void *argp1 = 0 ;
53329 int res1 = 0 ;
53330 PyObject * obj0 = 0 ;
53331 PyObject * obj1 = 0 ;
53332 char * kwnames[] = {
53333 (char *) "self",(char *) "other", NULL
53334 };
53335
53336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53337 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53338 if (!SWIG_IsOK(res1)) {
53339 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53340 }
53341 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53342 arg2 = obj1;
53343 {
53344 result = (bool)wxGBSpan___ne__(arg1,arg2);
53345 if (PyErr_Occurred()) SWIG_fail;
53346 }
53347 {
53348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53349 }
53350 return resultobj;
53351 fail:
53352 return NULL;
53353 }
53354
53355
53356 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53357 PyObject *resultobj = 0;
53358 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53359 int arg2 = (int) 1 ;
53360 int arg3 = (int) 1 ;
53361 void *argp1 = 0 ;
53362 int res1 = 0 ;
53363 int val2 ;
53364 int ecode2 = 0 ;
53365 int val3 ;
53366 int ecode3 = 0 ;
53367 PyObject * obj0 = 0 ;
53368 PyObject * obj1 = 0 ;
53369 PyObject * obj2 = 0 ;
53370 char * kwnames[] = {
53371 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53372 };
53373
53374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53375 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53376 if (!SWIG_IsOK(res1)) {
53377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53378 }
53379 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53380 if (obj1) {
53381 ecode2 = SWIG_AsVal_int(obj1, &val2);
53382 if (!SWIG_IsOK(ecode2)) {
53383 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53384 }
53385 arg2 = static_cast< int >(val2);
53386 }
53387 if (obj2) {
53388 ecode3 = SWIG_AsVal_int(obj2, &val3);
53389 if (!SWIG_IsOK(ecode3)) {
53390 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53391 }
53392 arg3 = static_cast< int >(val3);
53393 }
53394 {
53395 PyThreadState* __tstate = wxPyBeginAllowThreads();
53396 wxGBSpan_Set(arg1,arg2,arg3);
53397 wxPyEndAllowThreads(__tstate);
53398 if (PyErr_Occurred()) SWIG_fail;
53399 }
53400 resultobj = SWIG_Py_Void();
53401 return resultobj;
53402 fail:
53403 return NULL;
53404 }
53405
53406
53407 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53408 PyObject *resultobj = 0;
53409 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53410 PyObject *result = 0 ;
53411 void *argp1 = 0 ;
53412 int res1 = 0 ;
53413 PyObject *swig_obj[1] ;
53414
53415 if (!args) SWIG_fail;
53416 swig_obj[0] = args;
53417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53418 if (!SWIG_IsOK(res1)) {
53419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53420 }
53421 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53422 {
53423 PyThreadState* __tstate = wxPyBeginAllowThreads();
53424 result = (PyObject *)wxGBSpan_Get(arg1);
53425 wxPyEndAllowThreads(__tstate);
53426 if (PyErr_Occurred()) SWIG_fail;
53427 }
53428 resultobj = result;
53429 return resultobj;
53430 fail:
53431 return NULL;
53432 }
53433
53434
53435 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53436 PyObject *obj;
53437 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53438 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53439 return SWIG_Py_Void();
53440 }
53441
53442 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53443 return SWIG_Python_InitShadowInstance(args);
53444 }
53445
53446 SWIGINTERN int DefaultSpan_set(PyObject *) {
53447 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53448 return 1;
53449 }
53450
53451
53452 SWIGINTERN PyObject *DefaultSpan_get(void) {
53453 PyObject *pyobj = 0;
53454
53455 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53456 return pyobj;
53457 }
53458
53459
53460 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53461 PyObject *resultobj = 0;
53462 wxGBSizerItem *result = 0 ;
53463
53464 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53465 {
53466 PyThreadState* __tstate = wxPyBeginAllowThreads();
53467 result = (wxGBSizerItem *)new wxGBSizerItem();
53468 wxPyEndAllowThreads(__tstate);
53469 if (PyErr_Occurred()) SWIG_fail;
53470 }
53471 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53472 return resultobj;
53473 fail:
53474 return NULL;
53475 }
53476
53477
53478 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53479 PyObject *resultobj = 0;
53480 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53481 void *argp1 = 0 ;
53482 int res1 = 0 ;
53483 PyObject *swig_obj[1] ;
53484
53485 if (!args) SWIG_fail;
53486 swig_obj[0] = args;
53487 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53488 if (!SWIG_IsOK(res1)) {
53489 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53490 }
53491 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53492 {
53493 PyThreadState* __tstate = wxPyBeginAllowThreads();
53494 delete arg1;
53495
53496 wxPyEndAllowThreads(__tstate);
53497 if (PyErr_Occurred()) SWIG_fail;
53498 }
53499 resultobj = SWIG_Py_Void();
53500 return resultobj;
53501 fail:
53502 return NULL;
53503 }
53504
53505
53506 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53507 PyObject *resultobj = 0;
53508 wxWindow *arg1 = (wxWindow *) 0 ;
53509 wxGBPosition *arg2 = 0 ;
53510 wxGBSpan *arg3 = 0 ;
53511 int arg4 ;
53512 int arg5 ;
53513 PyObject *arg6 = (PyObject *) NULL ;
53514 wxGBSizerItem *result = 0 ;
53515 void *argp1 = 0 ;
53516 int res1 = 0 ;
53517 wxGBPosition temp2 ;
53518 wxGBSpan temp3 ;
53519 int val4 ;
53520 int ecode4 = 0 ;
53521 int val5 ;
53522 int ecode5 = 0 ;
53523 PyObject * obj0 = 0 ;
53524 PyObject * obj1 = 0 ;
53525 PyObject * obj2 = 0 ;
53526 PyObject * obj3 = 0 ;
53527 PyObject * obj4 = 0 ;
53528 PyObject * obj5 = 0 ;
53529 char * kwnames[] = {
53530 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53531 };
53532
53533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53535 if (!SWIG_IsOK(res1)) {
53536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53537 }
53538 arg1 = reinterpret_cast< wxWindow * >(argp1);
53539 {
53540 arg2 = &temp2;
53541 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53542 }
53543 {
53544 arg3 = &temp3;
53545 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53546 }
53547 ecode4 = SWIG_AsVal_int(obj3, &val4);
53548 if (!SWIG_IsOK(ecode4)) {
53549 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53550 }
53551 arg4 = static_cast< int >(val4);
53552 ecode5 = SWIG_AsVal_int(obj4, &val5);
53553 if (!SWIG_IsOK(ecode5)) {
53554 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53555 }
53556 arg5 = static_cast< int >(val5);
53557 if (obj5) {
53558 arg6 = obj5;
53559 }
53560 {
53561 PyThreadState* __tstate = wxPyBeginAllowThreads();
53562 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53563 wxPyEndAllowThreads(__tstate);
53564 if (PyErr_Occurred()) SWIG_fail;
53565 }
53566 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53567 return resultobj;
53568 fail:
53569 return NULL;
53570 }
53571
53572
53573 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53574 PyObject *resultobj = 0;
53575 wxSizer *arg1 = (wxSizer *) 0 ;
53576 wxGBPosition *arg2 = 0 ;
53577 wxGBSpan *arg3 = 0 ;
53578 int arg4 ;
53579 int arg5 ;
53580 PyObject *arg6 = (PyObject *) NULL ;
53581 wxGBSizerItem *result = 0 ;
53582 int res1 = 0 ;
53583 wxGBPosition temp2 ;
53584 wxGBSpan temp3 ;
53585 int val4 ;
53586 int ecode4 = 0 ;
53587 int val5 ;
53588 int ecode5 = 0 ;
53589 PyObject * obj0 = 0 ;
53590 PyObject * obj1 = 0 ;
53591 PyObject * obj2 = 0 ;
53592 PyObject * obj3 = 0 ;
53593 PyObject * obj4 = 0 ;
53594 PyObject * obj5 = 0 ;
53595 char * kwnames[] = {
53596 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53597 };
53598
53599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53600 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53601 if (!SWIG_IsOK(res1)) {
53602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53603 }
53604 {
53605 arg2 = &temp2;
53606 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53607 }
53608 {
53609 arg3 = &temp3;
53610 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53611 }
53612 ecode4 = SWIG_AsVal_int(obj3, &val4);
53613 if (!SWIG_IsOK(ecode4)) {
53614 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53615 }
53616 arg4 = static_cast< int >(val4);
53617 ecode5 = SWIG_AsVal_int(obj4, &val5);
53618 if (!SWIG_IsOK(ecode5)) {
53619 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53620 }
53621 arg5 = static_cast< int >(val5);
53622 if (obj5) {
53623 arg6 = obj5;
53624 }
53625 {
53626 PyThreadState* __tstate = wxPyBeginAllowThreads();
53627 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53628 wxPyEndAllowThreads(__tstate);
53629 if (PyErr_Occurred()) SWIG_fail;
53630 }
53631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53632 return resultobj;
53633 fail:
53634 return NULL;
53635 }
53636
53637
53638 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53639 PyObject *resultobj = 0;
53640 int arg1 ;
53641 int arg2 ;
53642 wxGBPosition *arg3 = 0 ;
53643 wxGBSpan *arg4 = 0 ;
53644 int arg5 ;
53645 int arg6 ;
53646 PyObject *arg7 = (PyObject *) NULL ;
53647 wxGBSizerItem *result = 0 ;
53648 int val1 ;
53649 int ecode1 = 0 ;
53650 int val2 ;
53651 int ecode2 = 0 ;
53652 wxGBPosition temp3 ;
53653 wxGBSpan temp4 ;
53654 int val5 ;
53655 int ecode5 = 0 ;
53656 int val6 ;
53657 int ecode6 = 0 ;
53658 PyObject * obj0 = 0 ;
53659 PyObject * obj1 = 0 ;
53660 PyObject * obj2 = 0 ;
53661 PyObject * obj3 = 0 ;
53662 PyObject * obj4 = 0 ;
53663 PyObject * obj5 = 0 ;
53664 PyObject * obj6 = 0 ;
53665 char * kwnames[] = {
53666 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53667 };
53668
53669 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53670 ecode1 = SWIG_AsVal_int(obj0, &val1);
53671 if (!SWIG_IsOK(ecode1)) {
53672 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53673 }
53674 arg1 = static_cast< int >(val1);
53675 ecode2 = SWIG_AsVal_int(obj1, &val2);
53676 if (!SWIG_IsOK(ecode2)) {
53677 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53678 }
53679 arg2 = static_cast< int >(val2);
53680 {
53681 arg3 = &temp3;
53682 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53683 }
53684 {
53685 arg4 = &temp4;
53686 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53687 }
53688 ecode5 = SWIG_AsVal_int(obj4, &val5);
53689 if (!SWIG_IsOK(ecode5)) {
53690 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53691 }
53692 arg5 = static_cast< int >(val5);
53693 ecode6 = SWIG_AsVal_int(obj5, &val6);
53694 if (!SWIG_IsOK(ecode6)) {
53695 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53696 }
53697 arg6 = static_cast< int >(val6);
53698 if (obj6) {
53699 arg7 = obj6;
53700 }
53701 {
53702 PyThreadState* __tstate = wxPyBeginAllowThreads();
53703 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53704 wxPyEndAllowThreads(__tstate);
53705 if (PyErr_Occurred()) SWIG_fail;
53706 }
53707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53708 return resultobj;
53709 fail:
53710 return NULL;
53711 }
53712
53713
53714 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53715 PyObject *resultobj = 0;
53716 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53717 wxGBPosition result;
53718 void *argp1 = 0 ;
53719 int res1 = 0 ;
53720 PyObject *swig_obj[1] ;
53721
53722 if (!args) SWIG_fail;
53723 swig_obj[0] = args;
53724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53725 if (!SWIG_IsOK(res1)) {
53726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53727 }
53728 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53729 {
53730 PyThreadState* __tstate = wxPyBeginAllowThreads();
53731 result = ((wxGBSizerItem const *)arg1)->GetPos();
53732 wxPyEndAllowThreads(__tstate);
53733 if (PyErr_Occurred()) SWIG_fail;
53734 }
53735 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53736 return resultobj;
53737 fail:
53738 return NULL;
53739 }
53740
53741
53742 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53743 PyObject *resultobj = 0;
53744 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53745 wxGBSpan result;
53746 void *argp1 = 0 ;
53747 int res1 = 0 ;
53748 PyObject *swig_obj[1] ;
53749
53750 if (!args) SWIG_fail;
53751 swig_obj[0] = args;
53752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53753 if (!SWIG_IsOK(res1)) {
53754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53755 }
53756 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53757 {
53758 PyThreadState* __tstate = wxPyBeginAllowThreads();
53759 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53760 wxPyEndAllowThreads(__tstate);
53761 if (PyErr_Occurred()) SWIG_fail;
53762 }
53763 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53764 return resultobj;
53765 fail:
53766 return NULL;
53767 }
53768
53769
53770 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53771 PyObject *resultobj = 0;
53772 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53773 wxGBPosition *arg2 = 0 ;
53774 bool result;
53775 void *argp1 = 0 ;
53776 int res1 = 0 ;
53777 wxGBPosition temp2 ;
53778 PyObject * obj0 = 0 ;
53779 PyObject * obj1 = 0 ;
53780 char * kwnames[] = {
53781 (char *) "self",(char *) "pos", NULL
53782 };
53783
53784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53786 if (!SWIG_IsOK(res1)) {
53787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53788 }
53789 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53790 {
53791 arg2 = &temp2;
53792 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53793 }
53794 {
53795 PyThreadState* __tstate = wxPyBeginAllowThreads();
53796 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53797 wxPyEndAllowThreads(__tstate);
53798 if (PyErr_Occurred()) SWIG_fail;
53799 }
53800 {
53801 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53802 }
53803 return resultobj;
53804 fail:
53805 return NULL;
53806 }
53807
53808
53809 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53810 PyObject *resultobj = 0;
53811 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53812 wxGBSpan *arg2 = 0 ;
53813 bool result;
53814 void *argp1 = 0 ;
53815 int res1 = 0 ;
53816 wxGBSpan temp2 ;
53817 PyObject * obj0 = 0 ;
53818 PyObject * obj1 = 0 ;
53819 char * kwnames[] = {
53820 (char *) "self",(char *) "span", NULL
53821 };
53822
53823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53825 if (!SWIG_IsOK(res1)) {
53826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53827 }
53828 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53829 {
53830 arg2 = &temp2;
53831 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53832 }
53833 {
53834 PyThreadState* __tstate = wxPyBeginAllowThreads();
53835 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53836 wxPyEndAllowThreads(__tstate);
53837 if (PyErr_Occurred()) SWIG_fail;
53838 }
53839 {
53840 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53841 }
53842 return resultobj;
53843 fail:
53844 return NULL;
53845 }
53846
53847
53848 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53849 PyObject *resultobj = 0;
53850 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53851 wxGBSizerItem *arg2 = 0 ;
53852 bool result;
53853 void *argp1 = 0 ;
53854 int res1 = 0 ;
53855 void *argp2 = 0 ;
53856 int res2 = 0 ;
53857 PyObject * obj0 = 0 ;
53858 PyObject * obj1 = 0 ;
53859 char * kwnames[] = {
53860 (char *) "self",(char *) "other", NULL
53861 };
53862
53863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53865 if (!SWIG_IsOK(res1)) {
53866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53867 }
53868 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53869 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53870 if (!SWIG_IsOK(res2)) {
53871 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53872 }
53873 if (!argp2) {
53874 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53875 }
53876 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53877 {
53878 PyThreadState* __tstate = wxPyBeginAllowThreads();
53879 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53880 wxPyEndAllowThreads(__tstate);
53881 if (PyErr_Occurred()) SWIG_fail;
53882 }
53883 {
53884 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53885 }
53886 return resultobj;
53887 fail:
53888 return NULL;
53889 }
53890
53891
53892 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53893 PyObject *resultobj = 0;
53894 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53895 wxGBPosition *arg2 = 0 ;
53896 wxGBSpan *arg3 = 0 ;
53897 bool result;
53898 void *argp1 = 0 ;
53899 int res1 = 0 ;
53900 wxGBPosition temp2 ;
53901 wxGBSpan temp3 ;
53902 PyObject * obj0 = 0 ;
53903 PyObject * obj1 = 0 ;
53904 PyObject * obj2 = 0 ;
53905 char * kwnames[] = {
53906 (char *) "self",(char *) "pos",(char *) "span", NULL
53907 };
53908
53909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53911 if (!SWIG_IsOK(res1)) {
53912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53913 }
53914 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53915 {
53916 arg2 = &temp2;
53917 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53918 }
53919 {
53920 arg3 = &temp3;
53921 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53922 }
53923 {
53924 PyThreadState* __tstate = wxPyBeginAllowThreads();
53925 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53926 wxPyEndAllowThreads(__tstate);
53927 if (PyErr_Occurred()) SWIG_fail;
53928 }
53929 {
53930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53931 }
53932 return resultobj;
53933 fail:
53934 return NULL;
53935 }
53936
53937
53938 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53939 PyObject *resultobj = 0;
53940 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53941 wxGBPosition result;
53942 void *argp1 = 0 ;
53943 int res1 = 0 ;
53944 PyObject *swig_obj[1] ;
53945
53946 if (!args) SWIG_fail;
53947 swig_obj[0] = args;
53948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53949 if (!SWIG_IsOK(res1)) {
53950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53951 }
53952 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53953 {
53954 PyThreadState* __tstate = wxPyBeginAllowThreads();
53955 result = wxGBSizerItem_GetEndPos(arg1);
53956 wxPyEndAllowThreads(__tstate);
53957 if (PyErr_Occurred()) SWIG_fail;
53958 }
53959 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53960 return resultobj;
53961 fail:
53962 return NULL;
53963 }
53964
53965
53966 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53967 PyObject *resultobj = 0;
53968 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53969 wxGridBagSizer *result = 0 ;
53970 void *argp1 = 0 ;
53971 int res1 = 0 ;
53972 PyObject *swig_obj[1] ;
53973
53974 if (!args) SWIG_fail;
53975 swig_obj[0] = args;
53976 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53977 if (!SWIG_IsOK(res1)) {
53978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53979 }
53980 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53981 {
53982 PyThreadState* __tstate = wxPyBeginAllowThreads();
53983 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53984 wxPyEndAllowThreads(__tstate);
53985 if (PyErr_Occurred()) SWIG_fail;
53986 }
53987 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53988 return resultobj;
53989 fail:
53990 return NULL;
53991 }
53992
53993
53994 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53995 PyObject *resultobj = 0;
53996 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53997 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53998 void *argp1 = 0 ;
53999 int res1 = 0 ;
54000 void *argp2 = 0 ;
54001 int res2 = 0 ;
54002 PyObject * obj0 = 0 ;
54003 PyObject * obj1 = 0 ;
54004 char * kwnames[] = {
54005 (char *) "self",(char *) "sizer", NULL
54006 };
54007
54008 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
54009 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54010 if (!SWIG_IsOK(res1)) {
54011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
54012 }
54013 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
54014 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54015 if (!SWIG_IsOK(res2)) {
54016 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
54017 }
54018 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
54019 {
54020 PyThreadState* __tstate = wxPyBeginAllowThreads();
54021 (arg1)->SetGBSizer(arg2);
54022 wxPyEndAllowThreads(__tstate);
54023 if (PyErr_Occurred()) SWIG_fail;
54024 }
54025 resultobj = SWIG_Py_Void();
54026 return resultobj;
54027 fail:
54028 return NULL;
54029 }
54030
54031
54032 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54033 PyObject *obj;
54034 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54035 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
54036 return SWIG_Py_Void();
54037 }
54038
54039 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54040 return SWIG_Python_InitShadowInstance(args);
54041 }
54042
54043 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54044 PyObject *resultobj = 0;
54045 int arg1 = (int) 0 ;
54046 int arg2 = (int) 0 ;
54047 wxGridBagSizer *result = 0 ;
54048 int val1 ;
54049 int ecode1 = 0 ;
54050 int val2 ;
54051 int ecode2 = 0 ;
54052 PyObject * obj0 = 0 ;
54053 PyObject * obj1 = 0 ;
54054 char * kwnames[] = {
54055 (char *) "vgap",(char *) "hgap", NULL
54056 };
54057
54058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
54059 if (obj0) {
54060 ecode1 = SWIG_AsVal_int(obj0, &val1);
54061 if (!SWIG_IsOK(ecode1)) {
54062 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
54063 }
54064 arg1 = static_cast< int >(val1);
54065 }
54066 if (obj1) {
54067 ecode2 = SWIG_AsVal_int(obj1, &val2);
54068 if (!SWIG_IsOK(ecode2)) {
54069 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
54070 }
54071 arg2 = static_cast< int >(val2);
54072 }
54073 {
54074 PyThreadState* __tstate = wxPyBeginAllowThreads();
54075 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
54076 wxPyEndAllowThreads(__tstate);
54077 if (PyErr_Occurred()) SWIG_fail;
54078 }
54079 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
54080 return resultobj;
54081 fail:
54082 return NULL;
54083 }
54084
54085
54086 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54087 PyObject *resultobj = 0;
54088 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54089 PyObject *arg2 = (PyObject *) 0 ;
54090 wxGBPosition *arg3 = 0 ;
54091 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
54092 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
54093 int arg5 = (int) 0 ;
54094 int arg6 = (int) 0 ;
54095 PyObject *arg7 = (PyObject *) NULL ;
54096 wxGBSizerItem *result = 0 ;
54097 void *argp1 = 0 ;
54098 int res1 = 0 ;
54099 wxGBPosition temp3 ;
54100 wxGBSpan temp4 ;
54101 int val5 ;
54102 int ecode5 = 0 ;
54103 int val6 ;
54104 int ecode6 = 0 ;
54105 PyObject * obj0 = 0 ;
54106 PyObject * obj1 = 0 ;
54107 PyObject * obj2 = 0 ;
54108 PyObject * obj3 = 0 ;
54109 PyObject * obj4 = 0 ;
54110 PyObject * obj5 = 0 ;
54111 PyObject * obj6 = 0 ;
54112 char * kwnames[] = {
54113 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54114 };
54115
54116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54118 if (!SWIG_IsOK(res1)) {
54119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54120 }
54121 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54122 arg2 = obj1;
54123 {
54124 arg3 = &temp3;
54125 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54126 }
54127 if (obj3) {
54128 {
54129 arg4 = &temp4;
54130 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54131 }
54132 }
54133 if (obj4) {
54134 ecode5 = SWIG_AsVal_int(obj4, &val5);
54135 if (!SWIG_IsOK(ecode5)) {
54136 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
54137 }
54138 arg5 = static_cast< int >(val5);
54139 }
54140 if (obj5) {
54141 ecode6 = SWIG_AsVal_int(obj5, &val6);
54142 if (!SWIG_IsOK(ecode6)) {
54143 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
54144 }
54145 arg6 = static_cast< int >(val6);
54146 }
54147 if (obj6) {
54148 arg7 = obj6;
54149 }
54150 {
54151 PyThreadState* __tstate = wxPyBeginAllowThreads();
54152 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54153 wxPyEndAllowThreads(__tstate);
54154 if (PyErr_Occurred()) SWIG_fail;
54155 }
54156 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54157 return resultobj;
54158 fail:
54159 return NULL;
54160 }
54161
54162
54163 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54164 PyObject *resultobj = 0;
54165 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54166 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54167 wxGBSizerItem *result = 0 ;
54168 void *argp1 = 0 ;
54169 int res1 = 0 ;
54170 int res2 = 0 ;
54171 PyObject * obj0 = 0 ;
54172 PyObject * obj1 = 0 ;
54173 char * kwnames[] = {
54174 (char *) "self",(char *) "item", NULL
54175 };
54176
54177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54179 if (!SWIG_IsOK(res1)) {
54180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54181 }
54182 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54183 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54184 if (!SWIG_IsOK(res2)) {
54185 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54186 }
54187 {
54188 PyThreadState* __tstate = wxPyBeginAllowThreads();
54189 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54190 wxPyEndAllowThreads(__tstate);
54191 if (PyErr_Occurred()) SWIG_fail;
54192 }
54193 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54194 return resultobj;
54195 fail:
54196 return NULL;
54197 }
54198
54199
54200 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54201 PyObject *resultobj = 0;
54202 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54203 int arg2 ;
54204 int arg3 ;
54205 wxSize result;
54206 void *argp1 = 0 ;
54207 int res1 = 0 ;
54208 int val2 ;
54209 int ecode2 = 0 ;
54210 int val3 ;
54211 int ecode3 = 0 ;
54212 PyObject * obj0 = 0 ;
54213 PyObject * obj1 = 0 ;
54214 PyObject * obj2 = 0 ;
54215 char * kwnames[] = {
54216 (char *) "self",(char *) "row",(char *) "col", NULL
54217 };
54218
54219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54220 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54221 if (!SWIG_IsOK(res1)) {
54222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54223 }
54224 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54225 ecode2 = SWIG_AsVal_int(obj1, &val2);
54226 if (!SWIG_IsOK(ecode2)) {
54227 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54228 }
54229 arg2 = static_cast< int >(val2);
54230 ecode3 = SWIG_AsVal_int(obj2, &val3);
54231 if (!SWIG_IsOK(ecode3)) {
54232 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54233 }
54234 arg3 = static_cast< int >(val3);
54235 {
54236 PyThreadState* __tstate = wxPyBeginAllowThreads();
54237 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54238 wxPyEndAllowThreads(__tstate);
54239 if (PyErr_Occurred()) SWIG_fail;
54240 }
54241 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54242 return resultobj;
54243 fail:
54244 return NULL;
54245 }
54246
54247
54248 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54249 PyObject *resultobj = 0;
54250 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54251 wxSize result;
54252 void *argp1 = 0 ;
54253 int res1 = 0 ;
54254 PyObject *swig_obj[1] ;
54255
54256 if (!args) SWIG_fail;
54257 swig_obj[0] = args;
54258 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54259 if (!SWIG_IsOK(res1)) {
54260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54261 }
54262 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54263 {
54264 PyThreadState* __tstate = wxPyBeginAllowThreads();
54265 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54266 wxPyEndAllowThreads(__tstate);
54267 if (PyErr_Occurred()) SWIG_fail;
54268 }
54269 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54270 return resultobj;
54271 fail:
54272 return NULL;
54273 }
54274
54275
54276 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54277 PyObject *resultobj = 0;
54278 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54279 wxSize *arg2 = 0 ;
54280 void *argp1 = 0 ;
54281 int res1 = 0 ;
54282 wxSize temp2 ;
54283 PyObject * obj0 = 0 ;
54284 PyObject * obj1 = 0 ;
54285 char * kwnames[] = {
54286 (char *) "self",(char *) "sz", NULL
54287 };
54288
54289 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54290 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54291 if (!SWIG_IsOK(res1)) {
54292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54293 }
54294 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54295 {
54296 arg2 = &temp2;
54297 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54298 }
54299 {
54300 PyThreadState* __tstate = wxPyBeginAllowThreads();
54301 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54302 wxPyEndAllowThreads(__tstate);
54303 if (PyErr_Occurred()) SWIG_fail;
54304 }
54305 resultobj = SWIG_Py_Void();
54306 return resultobj;
54307 fail:
54308 return NULL;
54309 }
54310
54311
54312 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54313 PyObject *resultobj = 0;
54314 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54315 wxWindow *arg2 = (wxWindow *) 0 ;
54316 wxGBPosition result;
54317 void *argp1 = 0 ;
54318 int res1 = 0 ;
54319 void *argp2 = 0 ;
54320 int res2 = 0 ;
54321
54322 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54323 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54324 if (!SWIG_IsOK(res1)) {
54325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54326 }
54327 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54328 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54329 if (!SWIG_IsOK(res2)) {
54330 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54331 }
54332 arg2 = reinterpret_cast< wxWindow * >(argp2);
54333 {
54334 PyThreadState* __tstate = wxPyBeginAllowThreads();
54335 result = (arg1)->GetItemPosition(arg2);
54336 wxPyEndAllowThreads(__tstate);
54337 if (PyErr_Occurred()) SWIG_fail;
54338 }
54339 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54340 return resultobj;
54341 fail:
54342 return NULL;
54343 }
54344
54345
54346 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54347 PyObject *resultobj = 0;
54348 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54349 wxSizer *arg2 = (wxSizer *) 0 ;
54350 wxGBPosition result;
54351 void *argp1 = 0 ;
54352 int res1 = 0 ;
54353 void *argp2 = 0 ;
54354 int res2 = 0 ;
54355
54356 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54358 if (!SWIG_IsOK(res1)) {
54359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54360 }
54361 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54362 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54363 if (!SWIG_IsOK(res2)) {
54364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54365 }
54366 arg2 = reinterpret_cast< wxSizer * >(argp2);
54367 {
54368 PyThreadState* __tstate = wxPyBeginAllowThreads();
54369 result = (arg1)->GetItemPosition(arg2);
54370 wxPyEndAllowThreads(__tstate);
54371 if (PyErr_Occurred()) SWIG_fail;
54372 }
54373 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54374 return resultobj;
54375 fail:
54376 return NULL;
54377 }
54378
54379
54380 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54381 PyObject *resultobj = 0;
54382 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54383 size_t arg2 ;
54384 wxGBPosition result;
54385 void *argp1 = 0 ;
54386 int res1 = 0 ;
54387 size_t val2 ;
54388 int ecode2 = 0 ;
54389
54390 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54392 if (!SWIG_IsOK(res1)) {
54393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54394 }
54395 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54396 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54397 if (!SWIG_IsOK(ecode2)) {
54398 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54399 }
54400 arg2 = static_cast< size_t >(val2);
54401 {
54402 PyThreadState* __tstate = wxPyBeginAllowThreads();
54403 result = (arg1)->GetItemPosition(arg2);
54404 wxPyEndAllowThreads(__tstate);
54405 if (PyErr_Occurred()) SWIG_fail;
54406 }
54407 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54408 return resultobj;
54409 fail:
54410 return NULL;
54411 }
54412
54413
54414 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54415 int argc;
54416 PyObject *argv[3];
54417
54418 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54419 --argc;
54420 if (argc == 2) {
54421 int _v = 0;
54422 {
54423 void *vptr = 0;
54424 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54425 _v = SWIG_CheckState(res);
54426 }
54427 if (!_v) goto check_1;
54428 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54429 }
54430 check_1:
54431
54432 if (argc == 2) {
54433 int _v = 0;
54434 {
54435 void *vptr = 0;
54436 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54437 _v = SWIG_CheckState(res);
54438 }
54439 if (!_v) goto check_2;
54440 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54441 }
54442 check_2:
54443
54444 if (argc == 2) {
54445 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54446 }
54447
54448 fail:
54449 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54450 return NULL;
54451 }
54452
54453
54454 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54455 PyObject *resultobj = 0;
54456 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54457 wxWindow *arg2 = (wxWindow *) 0 ;
54458 wxGBPosition *arg3 = 0 ;
54459 bool result;
54460 void *argp1 = 0 ;
54461 int res1 = 0 ;
54462 void *argp2 = 0 ;
54463 int res2 = 0 ;
54464 wxGBPosition temp3 ;
54465
54466 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54468 if (!SWIG_IsOK(res1)) {
54469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54470 }
54471 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54472 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54473 if (!SWIG_IsOK(res2)) {
54474 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54475 }
54476 arg2 = reinterpret_cast< wxWindow * >(argp2);
54477 {
54478 arg3 = &temp3;
54479 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54480 }
54481 {
54482 PyThreadState* __tstate = wxPyBeginAllowThreads();
54483 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54484 wxPyEndAllowThreads(__tstate);
54485 if (PyErr_Occurred()) SWIG_fail;
54486 }
54487 {
54488 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54489 }
54490 return resultobj;
54491 fail:
54492 return NULL;
54493 }
54494
54495
54496 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54497 PyObject *resultobj = 0;
54498 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54499 wxSizer *arg2 = (wxSizer *) 0 ;
54500 wxGBPosition *arg3 = 0 ;
54501 bool result;
54502 void *argp1 = 0 ;
54503 int res1 = 0 ;
54504 void *argp2 = 0 ;
54505 int res2 = 0 ;
54506 wxGBPosition temp3 ;
54507
54508 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54510 if (!SWIG_IsOK(res1)) {
54511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54512 }
54513 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54514 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54515 if (!SWIG_IsOK(res2)) {
54516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54517 }
54518 arg2 = reinterpret_cast< wxSizer * >(argp2);
54519 {
54520 arg3 = &temp3;
54521 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54522 }
54523 {
54524 PyThreadState* __tstate = wxPyBeginAllowThreads();
54525 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54526 wxPyEndAllowThreads(__tstate);
54527 if (PyErr_Occurred()) SWIG_fail;
54528 }
54529 {
54530 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54531 }
54532 return resultobj;
54533 fail:
54534 return NULL;
54535 }
54536
54537
54538 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54539 PyObject *resultobj = 0;
54540 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54541 size_t arg2 ;
54542 wxGBPosition *arg3 = 0 ;
54543 bool result;
54544 void *argp1 = 0 ;
54545 int res1 = 0 ;
54546 size_t val2 ;
54547 int ecode2 = 0 ;
54548 wxGBPosition temp3 ;
54549
54550 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54552 if (!SWIG_IsOK(res1)) {
54553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54554 }
54555 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54556 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54557 if (!SWIG_IsOK(ecode2)) {
54558 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54559 }
54560 arg2 = static_cast< size_t >(val2);
54561 {
54562 arg3 = &temp3;
54563 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54564 }
54565 {
54566 PyThreadState* __tstate = wxPyBeginAllowThreads();
54567 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54568 wxPyEndAllowThreads(__tstate);
54569 if (PyErr_Occurred()) SWIG_fail;
54570 }
54571 {
54572 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54573 }
54574 return resultobj;
54575 fail:
54576 return NULL;
54577 }
54578
54579
54580 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54581 int argc;
54582 PyObject *argv[4];
54583
54584 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54585 --argc;
54586 if (argc == 3) {
54587 int _v = 0;
54588 {
54589 void *vptr = 0;
54590 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54591 _v = SWIG_CheckState(res);
54592 }
54593 if (!_v) goto check_1;
54594 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54595 }
54596 check_1:
54597
54598 if (argc == 3) {
54599 int _v = 0;
54600 {
54601 void *vptr = 0;
54602 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54603 _v = SWIG_CheckState(res);
54604 }
54605 if (!_v) goto check_2;
54606 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54607 }
54608 check_2:
54609
54610 if (argc == 3) {
54611 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54612 }
54613
54614 fail:
54615 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54616 return NULL;
54617 }
54618
54619
54620 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54621 PyObject *resultobj = 0;
54622 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54623 wxWindow *arg2 = (wxWindow *) 0 ;
54624 wxGBSpan result;
54625 void *argp1 = 0 ;
54626 int res1 = 0 ;
54627 void *argp2 = 0 ;
54628 int res2 = 0 ;
54629
54630 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54631 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54632 if (!SWIG_IsOK(res1)) {
54633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54634 }
54635 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54636 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54637 if (!SWIG_IsOK(res2)) {
54638 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54639 }
54640 arg2 = reinterpret_cast< wxWindow * >(argp2);
54641 {
54642 PyThreadState* __tstate = wxPyBeginAllowThreads();
54643 result = (arg1)->GetItemSpan(arg2);
54644 wxPyEndAllowThreads(__tstate);
54645 if (PyErr_Occurred()) SWIG_fail;
54646 }
54647 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54648 return resultobj;
54649 fail:
54650 return NULL;
54651 }
54652
54653
54654 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54655 PyObject *resultobj = 0;
54656 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54657 wxSizer *arg2 = (wxSizer *) 0 ;
54658 wxGBSpan result;
54659 void *argp1 = 0 ;
54660 int res1 = 0 ;
54661 void *argp2 = 0 ;
54662 int res2 = 0 ;
54663
54664 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54666 if (!SWIG_IsOK(res1)) {
54667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54668 }
54669 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54670 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54671 if (!SWIG_IsOK(res2)) {
54672 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54673 }
54674 arg2 = reinterpret_cast< wxSizer * >(argp2);
54675 {
54676 PyThreadState* __tstate = wxPyBeginAllowThreads();
54677 result = (arg1)->GetItemSpan(arg2);
54678 wxPyEndAllowThreads(__tstate);
54679 if (PyErr_Occurred()) SWIG_fail;
54680 }
54681 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54682 return resultobj;
54683 fail:
54684 return NULL;
54685 }
54686
54687
54688 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54689 PyObject *resultobj = 0;
54690 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54691 size_t arg2 ;
54692 wxGBSpan result;
54693 void *argp1 = 0 ;
54694 int res1 = 0 ;
54695 size_t val2 ;
54696 int ecode2 = 0 ;
54697
54698 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54700 if (!SWIG_IsOK(res1)) {
54701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54702 }
54703 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54704 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54705 if (!SWIG_IsOK(ecode2)) {
54706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54707 }
54708 arg2 = static_cast< size_t >(val2);
54709 {
54710 PyThreadState* __tstate = wxPyBeginAllowThreads();
54711 result = (arg1)->GetItemSpan(arg2);
54712 wxPyEndAllowThreads(__tstate);
54713 if (PyErr_Occurred()) SWIG_fail;
54714 }
54715 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54716 return resultobj;
54717 fail:
54718 return NULL;
54719 }
54720
54721
54722 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54723 int argc;
54724 PyObject *argv[3];
54725
54726 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54727 --argc;
54728 if (argc == 2) {
54729 int _v = 0;
54730 {
54731 void *vptr = 0;
54732 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54733 _v = SWIG_CheckState(res);
54734 }
54735 if (!_v) goto check_1;
54736 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54737 }
54738 check_1:
54739
54740 if (argc == 2) {
54741 int _v = 0;
54742 {
54743 void *vptr = 0;
54744 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54745 _v = SWIG_CheckState(res);
54746 }
54747 if (!_v) goto check_2;
54748 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54749 }
54750 check_2:
54751
54752 if (argc == 2) {
54753 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54754 }
54755
54756 fail:
54757 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54758 return NULL;
54759 }
54760
54761
54762 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54763 PyObject *resultobj = 0;
54764 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54765 wxWindow *arg2 = (wxWindow *) 0 ;
54766 wxGBSpan *arg3 = 0 ;
54767 bool result;
54768 void *argp1 = 0 ;
54769 int res1 = 0 ;
54770 void *argp2 = 0 ;
54771 int res2 = 0 ;
54772 wxGBSpan temp3 ;
54773
54774 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54776 if (!SWIG_IsOK(res1)) {
54777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54778 }
54779 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54780 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54781 if (!SWIG_IsOK(res2)) {
54782 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54783 }
54784 arg2 = reinterpret_cast< wxWindow * >(argp2);
54785 {
54786 arg3 = &temp3;
54787 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54788 }
54789 {
54790 PyThreadState* __tstate = wxPyBeginAllowThreads();
54791 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54792 wxPyEndAllowThreads(__tstate);
54793 if (PyErr_Occurred()) SWIG_fail;
54794 }
54795 {
54796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54797 }
54798 return resultobj;
54799 fail:
54800 return NULL;
54801 }
54802
54803
54804 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54805 PyObject *resultobj = 0;
54806 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54807 wxSizer *arg2 = (wxSizer *) 0 ;
54808 wxGBSpan *arg3 = 0 ;
54809 bool result;
54810 void *argp1 = 0 ;
54811 int res1 = 0 ;
54812 void *argp2 = 0 ;
54813 int res2 = 0 ;
54814 wxGBSpan temp3 ;
54815
54816 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54817 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54818 if (!SWIG_IsOK(res1)) {
54819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54820 }
54821 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54822 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54823 if (!SWIG_IsOK(res2)) {
54824 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54825 }
54826 arg2 = reinterpret_cast< wxSizer * >(argp2);
54827 {
54828 arg3 = &temp3;
54829 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54830 }
54831 {
54832 PyThreadState* __tstate = wxPyBeginAllowThreads();
54833 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54834 wxPyEndAllowThreads(__tstate);
54835 if (PyErr_Occurred()) SWIG_fail;
54836 }
54837 {
54838 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54839 }
54840 return resultobj;
54841 fail:
54842 return NULL;
54843 }
54844
54845
54846 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54847 PyObject *resultobj = 0;
54848 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54849 size_t arg2 ;
54850 wxGBSpan *arg3 = 0 ;
54851 bool result;
54852 void *argp1 = 0 ;
54853 int res1 = 0 ;
54854 size_t val2 ;
54855 int ecode2 = 0 ;
54856 wxGBSpan temp3 ;
54857
54858 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54860 if (!SWIG_IsOK(res1)) {
54861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54862 }
54863 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54864 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54865 if (!SWIG_IsOK(ecode2)) {
54866 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54867 }
54868 arg2 = static_cast< size_t >(val2);
54869 {
54870 arg3 = &temp3;
54871 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54872 }
54873 {
54874 PyThreadState* __tstate = wxPyBeginAllowThreads();
54875 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54876 wxPyEndAllowThreads(__tstate);
54877 if (PyErr_Occurred()) SWIG_fail;
54878 }
54879 {
54880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54881 }
54882 return resultobj;
54883 fail:
54884 return NULL;
54885 }
54886
54887
54888 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54889 int argc;
54890 PyObject *argv[4];
54891
54892 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54893 --argc;
54894 if (argc == 3) {
54895 int _v = 0;
54896 {
54897 void *vptr = 0;
54898 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54899 _v = SWIG_CheckState(res);
54900 }
54901 if (!_v) goto check_1;
54902 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54903 }
54904 check_1:
54905
54906 if (argc == 3) {
54907 int _v = 0;
54908 {
54909 void *vptr = 0;
54910 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54911 _v = SWIG_CheckState(res);
54912 }
54913 if (!_v) goto check_2;
54914 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54915 }
54916 check_2:
54917
54918 if (argc == 3) {
54919 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54920 }
54921
54922 fail:
54923 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54924 return NULL;
54925 }
54926
54927
54928 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54929 PyObject *resultobj = 0;
54930 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54931 wxWindow *arg2 = (wxWindow *) 0 ;
54932 wxGBSizerItem *result = 0 ;
54933 void *argp1 = 0 ;
54934 int res1 = 0 ;
54935 void *argp2 = 0 ;
54936 int res2 = 0 ;
54937
54938 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54940 if (!SWIG_IsOK(res1)) {
54941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54942 }
54943 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54944 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54945 if (!SWIG_IsOK(res2)) {
54946 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54947 }
54948 arg2 = reinterpret_cast< wxWindow * >(argp2);
54949 {
54950 PyThreadState* __tstate = wxPyBeginAllowThreads();
54951 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54952 wxPyEndAllowThreads(__tstate);
54953 if (PyErr_Occurred()) SWIG_fail;
54954 }
54955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54956 return resultobj;
54957 fail:
54958 return NULL;
54959 }
54960
54961
54962 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54963 PyObject *resultobj = 0;
54964 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54965 wxSizer *arg2 = (wxSizer *) 0 ;
54966 wxGBSizerItem *result = 0 ;
54967 void *argp1 = 0 ;
54968 int res1 = 0 ;
54969 void *argp2 = 0 ;
54970 int res2 = 0 ;
54971
54972 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54973 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54974 if (!SWIG_IsOK(res1)) {
54975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54976 }
54977 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54978 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54979 if (!SWIG_IsOK(res2)) {
54980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54981 }
54982 arg2 = reinterpret_cast< wxSizer * >(argp2);
54983 {
54984 PyThreadState* __tstate = wxPyBeginAllowThreads();
54985 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54986 wxPyEndAllowThreads(__tstate);
54987 if (PyErr_Occurred()) SWIG_fail;
54988 }
54989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54990 return resultobj;
54991 fail:
54992 return NULL;
54993 }
54994
54995
54996 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54997 int argc;
54998 PyObject *argv[3];
54999
55000 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
55001 --argc;
55002 if (argc == 2) {
55003 int _v = 0;
55004 {
55005 void *vptr = 0;
55006 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
55007 _v = SWIG_CheckState(res);
55008 }
55009 if (!_v) goto check_1;
55010 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
55011 }
55012 check_1:
55013
55014 if (argc == 2) {
55015 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
55016 }
55017
55018 fail:
55019 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
55020 return NULL;
55021 }
55022
55023
55024 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55025 PyObject *resultobj = 0;
55026 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55027 wxGBPosition *arg2 = 0 ;
55028 wxGBSizerItem *result = 0 ;
55029 void *argp1 = 0 ;
55030 int res1 = 0 ;
55031 wxGBPosition temp2 ;
55032 PyObject * obj0 = 0 ;
55033 PyObject * obj1 = 0 ;
55034 char * kwnames[] = {
55035 (char *) "self",(char *) "pos", NULL
55036 };
55037
55038 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
55039 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55040 if (!SWIG_IsOK(res1)) {
55041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55042 }
55043 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55044 {
55045 arg2 = &temp2;
55046 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55047 }
55048 {
55049 PyThreadState* __tstate = wxPyBeginAllowThreads();
55050 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
55051 wxPyEndAllowThreads(__tstate);
55052 if (PyErr_Occurred()) SWIG_fail;
55053 }
55054 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55055 return resultobj;
55056 fail:
55057 return NULL;
55058 }
55059
55060
55061 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55062 PyObject *resultobj = 0;
55063 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55064 wxPoint *arg2 = 0 ;
55065 wxGBSizerItem *result = 0 ;
55066 void *argp1 = 0 ;
55067 int res1 = 0 ;
55068 wxPoint temp2 ;
55069 PyObject * obj0 = 0 ;
55070 PyObject * obj1 = 0 ;
55071 char * kwnames[] = {
55072 (char *) "self",(char *) "pt", NULL
55073 };
55074
55075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
55076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55077 if (!SWIG_IsOK(res1)) {
55078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55079 }
55080 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55081 {
55082 arg2 = &temp2;
55083 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
55084 }
55085 {
55086 PyThreadState* __tstate = wxPyBeginAllowThreads();
55087 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
55088 wxPyEndAllowThreads(__tstate);
55089 if (PyErr_Occurred()) SWIG_fail;
55090 }
55091 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55092 return resultobj;
55093 fail:
55094 return NULL;
55095 }
55096
55097
55098 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55099 PyObject *resultobj = 0;
55100 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55101 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55102 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
55103 bool result;
55104 void *argp1 = 0 ;
55105 int res1 = 0 ;
55106 void *argp2 = 0 ;
55107 int res2 = 0 ;
55108 void *argp3 = 0 ;
55109 int res3 = 0 ;
55110 PyObject * obj0 = 0 ;
55111 PyObject * obj1 = 0 ;
55112 PyObject * obj2 = 0 ;
55113 char * kwnames[] = {
55114 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
55115 };
55116
55117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55119 if (!SWIG_IsOK(res1)) {
55120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55121 }
55122 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55123 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55124 if (!SWIG_IsOK(res2)) {
55125 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55126 }
55127 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55128 if (obj2) {
55129 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55130 if (!SWIG_IsOK(res3)) {
55131 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
55132 }
55133 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
55134 }
55135 {
55136 PyThreadState* __tstate = wxPyBeginAllowThreads();
55137 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
55138 wxPyEndAllowThreads(__tstate);
55139 if (PyErr_Occurred()) SWIG_fail;
55140 }
55141 {
55142 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55143 }
55144 return resultobj;
55145 fail:
55146 return NULL;
55147 }
55148
55149
55150 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55151 PyObject *resultobj = 0;
55152 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55153 wxGBPosition *arg2 = 0 ;
55154 wxGBSpan *arg3 = 0 ;
55155 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
55156 bool result;
55157 void *argp1 = 0 ;
55158 int res1 = 0 ;
55159 wxGBPosition temp2 ;
55160 wxGBSpan temp3 ;
55161 void *argp4 = 0 ;
55162 int res4 = 0 ;
55163 PyObject * obj0 = 0 ;
55164 PyObject * obj1 = 0 ;
55165 PyObject * obj2 = 0 ;
55166 PyObject * obj3 = 0 ;
55167 char * kwnames[] = {
55168 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55169 };
55170
55171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55172 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55173 if (!SWIG_IsOK(res1)) {
55174 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55175 }
55176 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55177 {
55178 arg2 = &temp2;
55179 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55180 }
55181 {
55182 arg3 = &temp3;
55183 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55184 }
55185 if (obj3) {
55186 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55187 if (!SWIG_IsOK(res4)) {
55188 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55189 }
55190 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55191 }
55192 {
55193 PyThreadState* __tstate = wxPyBeginAllowThreads();
55194 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55195 wxPyEndAllowThreads(__tstate);
55196 if (PyErr_Occurred()) SWIG_fail;
55197 }
55198 {
55199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55200 }
55201 return resultobj;
55202 fail:
55203 return NULL;
55204 }
55205
55206
55207 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55208 PyObject *obj;
55209 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55210 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55211 return SWIG_Py_Void();
55212 }
55213
55214 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55215 return SWIG_Python_InitShadowInstance(args);
55216 }
55217
55218 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55219 PyObject *resultobj = 0;
55220 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55221 wxRelationship arg2 ;
55222 wxWindow *arg3 = (wxWindow *) 0 ;
55223 wxEdge arg4 ;
55224 int arg5 = (int) 0 ;
55225 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55226 void *argp1 = 0 ;
55227 int res1 = 0 ;
55228 int val2 ;
55229 int ecode2 = 0 ;
55230 void *argp3 = 0 ;
55231 int res3 = 0 ;
55232 int val4 ;
55233 int ecode4 = 0 ;
55234 int val5 ;
55235 int ecode5 = 0 ;
55236 int val6 ;
55237 int ecode6 = 0 ;
55238 PyObject * obj0 = 0 ;
55239 PyObject * obj1 = 0 ;
55240 PyObject * obj2 = 0 ;
55241 PyObject * obj3 = 0 ;
55242 PyObject * obj4 = 0 ;
55243 PyObject * obj5 = 0 ;
55244 char * kwnames[] = {
55245 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55246 };
55247
55248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55249 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55250 if (!SWIG_IsOK(res1)) {
55251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55252 }
55253 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55254 ecode2 = SWIG_AsVal_int(obj1, &val2);
55255 if (!SWIG_IsOK(ecode2)) {
55256 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55257 }
55258 arg2 = static_cast< wxRelationship >(val2);
55259 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55260 if (!SWIG_IsOK(res3)) {
55261 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55262 }
55263 arg3 = reinterpret_cast< wxWindow * >(argp3);
55264 ecode4 = SWIG_AsVal_int(obj3, &val4);
55265 if (!SWIG_IsOK(ecode4)) {
55266 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55267 }
55268 arg4 = static_cast< wxEdge >(val4);
55269 if (obj4) {
55270 ecode5 = SWIG_AsVal_int(obj4, &val5);
55271 if (!SWIG_IsOK(ecode5)) {
55272 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55273 }
55274 arg5 = static_cast< int >(val5);
55275 }
55276 if (obj5) {
55277 ecode6 = SWIG_AsVal_int(obj5, &val6);
55278 if (!SWIG_IsOK(ecode6)) {
55279 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55280 }
55281 arg6 = static_cast< int >(val6);
55282 }
55283 {
55284 PyThreadState* __tstate = wxPyBeginAllowThreads();
55285 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55286 wxPyEndAllowThreads(__tstate);
55287 if (PyErr_Occurred()) SWIG_fail;
55288 }
55289 resultobj = SWIG_Py_Void();
55290 return resultobj;
55291 fail:
55292 return NULL;
55293 }
55294
55295
55296 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55297 PyObject *resultobj = 0;
55298 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55299 wxWindow *arg2 = (wxWindow *) 0 ;
55300 int arg3 = (int) 0 ;
55301 void *argp1 = 0 ;
55302 int res1 = 0 ;
55303 void *argp2 = 0 ;
55304 int res2 = 0 ;
55305 int val3 ;
55306 int ecode3 = 0 ;
55307 PyObject * obj0 = 0 ;
55308 PyObject * obj1 = 0 ;
55309 PyObject * obj2 = 0 ;
55310 char * kwnames[] = {
55311 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55312 };
55313
55314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55316 if (!SWIG_IsOK(res1)) {
55317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55318 }
55319 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55320 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55321 if (!SWIG_IsOK(res2)) {
55322 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55323 }
55324 arg2 = reinterpret_cast< wxWindow * >(argp2);
55325 if (obj2) {
55326 ecode3 = SWIG_AsVal_int(obj2, &val3);
55327 if (!SWIG_IsOK(ecode3)) {
55328 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55329 }
55330 arg3 = static_cast< int >(val3);
55331 }
55332 {
55333 PyThreadState* __tstate = wxPyBeginAllowThreads();
55334 (arg1)->LeftOf(arg2,arg3);
55335 wxPyEndAllowThreads(__tstate);
55336 if (PyErr_Occurred()) SWIG_fail;
55337 }
55338 resultobj = SWIG_Py_Void();
55339 return resultobj;
55340 fail:
55341 return NULL;
55342 }
55343
55344
55345 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55346 PyObject *resultobj = 0;
55347 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55348 wxWindow *arg2 = (wxWindow *) 0 ;
55349 int arg3 = (int) 0 ;
55350 void *argp1 = 0 ;
55351 int res1 = 0 ;
55352 void *argp2 = 0 ;
55353 int res2 = 0 ;
55354 int val3 ;
55355 int ecode3 = 0 ;
55356 PyObject * obj0 = 0 ;
55357 PyObject * obj1 = 0 ;
55358 PyObject * obj2 = 0 ;
55359 char * kwnames[] = {
55360 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55361 };
55362
55363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55365 if (!SWIG_IsOK(res1)) {
55366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55367 }
55368 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55369 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55370 if (!SWIG_IsOK(res2)) {
55371 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55372 }
55373 arg2 = reinterpret_cast< wxWindow * >(argp2);
55374 if (obj2) {
55375 ecode3 = SWIG_AsVal_int(obj2, &val3);
55376 if (!SWIG_IsOK(ecode3)) {
55377 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55378 }
55379 arg3 = static_cast< int >(val3);
55380 }
55381 {
55382 PyThreadState* __tstate = wxPyBeginAllowThreads();
55383 (arg1)->RightOf(arg2,arg3);
55384 wxPyEndAllowThreads(__tstate);
55385 if (PyErr_Occurred()) SWIG_fail;
55386 }
55387 resultobj = SWIG_Py_Void();
55388 return resultobj;
55389 fail:
55390 return NULL;
55391 }
55392
55393
55394 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55395 PyObject *resultobj = 0;
55396 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55397 wxWindow *arg2 = (wxWindow *) 0 ;
55398 int arg3 = (int) 0 ;
55399 void *argp1 = 0 ;
55400 int res1 = 0 ;
55401 void *argp2 = 0 ;
55402 int res2 = 0 ;
55403 int val3 ;
55404 int ecode3 = 0 ;
55405 PyObject * obj0 = 0 ;
55406 PyObject * obj1 = 0 ;
55407 PyObject * obj2 = 0 ;
55408 char * kwnames[] = {
55409 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55410 };
55411
55412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55414 if (!SWIG_IsOK(res1)) {
55415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55416 }
55417 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55418 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55419 if (!SWIG_IsOK(res2)) {
55420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55421 }
55422 arg2 = reinterpret_cast< wxWindow * >(argp2);
55423 if (obj2) {
55424 ecode3 = SWIG_AsVal_int(obj2, &val3);
55425 if (!SWIG_IsOK(ecode3)) {
55426 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55427 }
55428 arg3 = static_cast< int >(val3);
55429 }
55430 {
55431 PyThreadState* __tstate = wxPyBeginAllowThreads();
55432 (arg1)->Above(arg2,arg3);
55433 wxPyEndAllowThreads(__tstate);
55434 if (PyErr_Occurred()) SWIG_fail;
55435 }
55436 resultobj = SWIG_Py_Void();
55437 return resultobj;
55438 fail:
55439 return NULL;
55440 }
55441
55442
55443 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55444 PyObject *resultobj = 0;
55445 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55446 wxWindow *arg2 = (wxWindow *) 0 ;
55447 int arg3 = (int) 0 ;
55448 void *argp1 = 0 ;
55449 int res1 = 0 ;
55450 void *argp2 = 0 ;
55451 int res2 = 0 ;
55452 int val3 ;
55453 int ecode3 = 0 ;
55454 PyObject * obj0 = 0 ;
55455 PyObject * obj1 = 0 ;
55456 PyObject * obj2 = 0 ;
55457 char * kwnames[] = {
55458 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55459 };
55460
55461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55463 if (!SWIG_IsOK(res1)) {
55464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55465 }
55466 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55467 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55468 if (!SWIG_IsOK(res2)) {
55469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55470 }
55471 arg2 = reinterpret_cast< wxWindow * >(argp2);
55472 if (obj2) {
55473 ecode3 = SWIG_AsVal_int(obj2, &val3);
55474 if (!SWIG_IsOK(ecode3)) {
55475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55476 }
55477 arg3 = static_cast< int >(val3);
55478 }
55479 {
55480 PyThreadState* __tstate = wxPyBeginAllowThreads();
55481 (arg1)->Below(arg2,arg3);
55482 wxPyEndAllowThreads(__tstate);
55483 if (PyErr_Occurred()) SWIG_fail;
55484 }
55485 resultobj = SWIG_Py_Void();
55486 return resultobj;
55487 fail:
55488 return NULL;
55489 }
55490
55491
55492 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55493 PyObject *resultobj = 0;
55494 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55495 wxWindow *arg2 = (wxWindow *) 0 ;
55496 wxEdge arg3 ;
55497 int arg4 = (int) 0 ;
55498 void *argp1 = 0 ;
55499 int res1 = 0 ;
55500 void *argp2 = 0 ;
55501 int res2 = 0 ;
55502 int val3 ;
55503 int ecode3 = 0 ;
55504 int val4 ;
55505 int ecode4 = 0 ;
55506 PyObject * obj0 = 0 ;
55507 PyObject * obj1 = 0 ;
55508 PyObject * obj2 = 0 ;
55509 PyObject * obj3 = 0 ;
55510 char * kwnames[] = {
55511 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55512 };
55513
55514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55516 if (!SWIG_IsOK(res1)) {
55517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55518 }
55519 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55520 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55521 if (!SWIG_IsOK(res2)) {
55522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55523 }
55524 arg2 = reinterpret_cast< wxWindow * >(argp2);
55525 ecode3 = SWIG_AsVal_int(obj2, &val3);
55526 if (!SWIG_IsOK(ecode3)) {
55527 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55528 }
55529 arg3 = static_cast< wxEdge >(val3);
55530 if (obj3) {
55531 ecode4 = SWIG_AsVal_int(obj3, &val4);
55532 if (!SWIG_IsOK(ecode4)) {
55533 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55534 }
55535 arg4 = static_cast< int >(val4);
55536 }
55537 {
55538 PyThreadState* __tstate = wxPyBeginAllowThreads();
55539 (arg1)->SameAs(arg2,arg3,arg4);
55540 wxPyEndAllowThreads(__tstate);
55541 if (PyErr_Occurred()) SWIG_fail;
55542 }
55543 resultobj = SWIG_Py_Void();
55544 return resultobj;
55545 fail:
55546 return NULL;
55547 }
55548
55549
55550 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55551 PyObject *resultobj = 0;
55552 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55553 wxWindow *arg2 = (wxWindow *) 0 ;
55554 wxEdge arg3 ;
55555 int arg4 ;
55556 void *argp1 = 0 ;
55557 int res1 = 0 ;
55558 void *argp2 = 0 ;
55559 int res2 = 0 ;
55560 int val3 ;
55561 int ecode3 = 0 ;
55562 int val4 ;
55563 int ecode4 = 0 ;
55564 PyObject * obj0 = 0 ;
55565 PyObject * obj1 = 0 ;
55566 PyObject * obj2 = 0 ;
55567 PyObject * obj3 = 0 ;
55568 char * kwnames[] = {
55569 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55570 };
55571
55572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55574 if (!SWIG_IsOK(res1)) {
55575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55576 }
55577 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55579 if (!SWIG_IsOK(res2)) {
55580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55581 }
55582 arg2 = reinterpret_cast< wxWindow * >(argp2);
55583 ecode3 = SWIG_AsVal_int(obj2, &val3);
55584 if (!SWIG_IsOK(ecode3)) {
55585 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55586 }
55587 arg3 = static_cast< wxEdge >(val3);
55588 ecode4 = SWIG_AsVal_int(obj3, &val4);
55589 if (!SWIG_IsOK(ecode4)) {
55590 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55591 }
55592 arg4 = static_cast< int >(val4);
55593 {
55594 PyThreadState* __tstate = wxPyBeginAllowThreads();
55595 (arg1)->PercentOf(arg2,arg3,arg4);
55596 wxPyEndAllowThreads(__tstate);
55597 if (PyErr_Occurred()) SWIG_fail;
55598 }
55599 resultobj = SWIG_Py_Void();
55600 return resultobj;
55601 fail:
55602 return NULL;
55603 }
55604
55605
55606 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55607 PyObject *resultobj = 0;
55608 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55609 int arg2 ;
55610 void *argp1 = 0 ;
55611 int res1 = 0 ;
55612 int val2 ;
55613 int ecode2 = 0 ;
55614 PyObject * obj0 = 0 ;
55615 PyObject * obj1 = 0 ;
55616 char * kwnames[] = {
55617 (char *) "self",(char *) "val", NULL
55618 };
55619
55620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55622 if (!SWIG_IsOK(res1)) {
55623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55624 }
55625 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55626 ecode2 = SWIG_AsVal_int(obj1, &val2);
55627 if (!SWIG_IsOK(ecode2)) {
55628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55629 }
55630 arg2 = static_cast< int >(val2);
55631 {
55632 PyThreadState* __tstate = wxPyBeginAllowThreads();
55633 (arg1)->Absolute(arg2);
55634 wxPyEndAllowThreads(__tstate);
55635 if (PyErr_Occurred()) SWIG_fail;
55636 }
55637 resultobj = SWIG_Py_Void();
55638 return resultobj;
55639 fail:
55640 return NULL;
55641 }
55642
55643
55644 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55645 PyObject *resultobj = 0;
55646 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55647 void *argp1 = 0 ;
55648 int res1 = 0 ;
55649 PyObject *swig_obj[1] ;
55650
55651 if (!args) SWIG_fail;
55652 swig_obj[0] = args;
55653 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55654 if (!SWIG_IsOK(res1)) {
55655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55656 }
55657 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55658 {
55659 PyThreadState* __tstate = wxPyBeginAllowThreads();
55660 (arg1)->Unconstrained();
55661 wxPyEndAllowThreads(__tstate);
55662 if (PyErr_Occurred()) SWIG_fail;
55663 }
55664 resultobj = SWIG_Py_Void();
55665 return resultobj;
55666 fail:
55667 return NULL;
55668 }
55669
55670
55671 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55672 PyObject *resultobj = 0;
55673 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55674 void *argp1 = 0 ;
55675 int res1 = 0 ;
55676 PyObject *swig_obj[1] ;
55677
55678 if (!args) SWIG_fail;
55679 swig_obj[0] = args;
55680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55681 if (!SWIG_IsOK(res1)) {
55682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55683 }
55684 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55685 {
55686 PyThreadState* __tstate = wxPyBeginAllowThreads();
55687 (arg1)->AsIs();
55688 wxPyEndAllowThreads(__tstate);
55689 if (PyErr_Occurred()) SWIG_fail;
55690 }
55691 resultobj = SWIG_Py_Void();
55692 return resultobj;
55693 fail:
55694 return NULL;
55695 }
55696
55697
55698 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55699 PyObject *resultobj = 0;
55700 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55701 wxWindow *result = 0 ;
55702 void *argp1 = 0 ;
55703 int res1 = 0 ;
55704 PyObject *swig_obj[1] ;
55705
55706 if (!args) SWIG_fail;
55707 swig_obj[0] = args;
55708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55709 if (!SWIG_IsOK(res1)) {
55710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55711 }
55712 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55713 {
55714 PyThreadState* __tstate = wxPyBeginAllowThreads();
55715 result = (wxWindow *)(arg1)->GetOtherWindow();
55716 wxPyEndAllowThreads(__tstate);
55717 if (PyErr_Occurred()) SWIG_fail;
55718 }
55719 {
55720 resultobj = wxPyMake_wxObject(result, 0);
55721 }
55722 return resultobj;
55723 fail:
55724 return NULL;
55725 }
55726
55727
55728 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55729 PyObject *resultobj = 0;
55730 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55731 wxEdge result;
55732 void *argp1 = 0 ;
55733 int res1 = 0 ;
55734 PyObject *swig_obj[1] ;
55735
55736 if (!args) SWIG_fail;
55737 swig_obj[0] = args;
55738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55739 if (!SWIG_IsOK(res1)) {
55740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55741 }
55742 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55743 {
55744 PyThreadState* __tstate = wxPyBeginAllowThreads();
55745 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55746 wxPyEndAllowThreads(__tstate);
55747 if (PyErr_Occurred()) SWIG_fail;
55748 }
55749 resultobj = SWIG_From_int(static_cast< int >(result));
55750 return resultobj;
55751 fail:
55752 return NULL;
55753 }
55754
55755
55756 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55757 PyObject *resultobj = 0;
55758 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55759 wxEdge arg2 ;
55760 void *argp1 = 0 ;
55761 int res1 = 0 ;
55762 int val2 ;
55763 int ecode2 = 0 ;
55764 PyObject * obj0 = 0 ;
55765 PyObject * obj1 = 0 ;
55766 char * kwnames[] = {
55767 (char *) "self",(char *) "which", NULL
55768 };
55769
55770 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55771 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55772 if (!SWIG_IsOK(res1)) {
55773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55774 }
55775 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55776 ecode2 = SWIG_AsVal_int(obj1, &val2);
55777 if (!SWIG_IsOK(ecode2)) {
55778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55779 }
55780 arg2 = static_cast< wxEdge >(val2);
55781 {
55782 PyThreadState* __tstate = wxPyBeginAllowThreads();
55783 (arg1)->SetEdge(arg2);
55784 wxPyEndAllowThreads(__tstate);
55785 if (PyErr_Occurred()) SWIG_fail;
55786 }
55787 resultobj = SWIG_Py_Void();
55788 return resultobj;
55789 fail:
55790 return NULL;
55791 }
55792
55793
55794 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55795 PyObject *resultobj = 0;
55796 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55797 int arg2 ;
55798 void *argp1 = 0 ;
55799 int res1 = 0 ;
55800 int val2 ;
55801 int ecode2 = 0 ;
55802 PyObject * obj0 = 0 ;
55803 PyObject * obj1 = 0 ;
55804 char * kwnames[] = {
55805 (char *) "self",(char *) "v", NULL
55806 };
55807
55808 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55809 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55810 if (!SWIG_IsOK(res1)) {
55811 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55812 }
55813 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55814 ecode2 = SWIG_AsVal_int(obj1, &val2);
55815 if (!SWIG_IsOK(ecode2)) {
55816 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55817 }
55818 arg2 = static_cast< int >(val2);
55819 {
55820 PyThreadState* __tstate = wxPyBeginAllowThreads();
55821 (arg1)->SetValue(arg2);
55822 wxPyEndAllowThreads(__tstate);
55823 if (PyErr_Occurred()) SWIG_fail;
55824 }
55825 resultobj = SWIG_Py_Void();
55826 return resultobj;
55827 fail:
55828 return NULL;
55829 }
55830
55831
55832 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55833 PyObject *resultobj = 0;
55834 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55835 int result;
55836 void *argp1 = 0 ;
55837 int res1 = 0 ;
55838 PyObject *swig_obj[1] ;
55839
55840 if (!args) SWIG_fail;
55841 swig_obj[0] = args;
55842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55843 if (!SWIG_IsOK(res1)) {
55844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55845 }
55846 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55847 {
55848 PyThreadState* __tstate = wxPyBeginAllowThreads();
55849 result = (int)(arg1)->GetMargin();
55850 wxPyEndAllowThreads(__tstate);
55851 if (PyErr_Occurred()) SWIG_fail;
55852 }
55853 resultobj = SWIG_From_int(static_cast< int >(result));
55854 return resultobj;
55855 fail:
55856 return NULL;
55857 }
55858
55859
55860 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55861 PyObject *resultobj = 0;
55862 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55863 int arg2 ;
55864 void *argp1 = 0 ;
55865 int res1 = 0 ;
55866 int val2 ;
55867 int ecode2 = 0 ;
55868 PyObject * obj0 = 0 ;
55869 PyObject * obj1 = 0 ;
55870 char * kwnames[] = {
55871 (char *) "self",(char *) "m", NULL
55872 };
55873
55874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55876 if (!SWIG_IsOK(res1)) {
55877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55878 }
55879 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55880 ecode2 = SWIG_AsVal_int(obj1, &val2);
55881 if (!SWIG_IsOK(ecode2)) {
55882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55883 }
55884 arg2 = static_cast< int >(val2);
55885 {
55886 PyThreadState* __tstate = wxPyBeginAllowThreads();
55887 (arg1)->SetMargin(arg2);
55888 wxPyEndAllowThreads(__tstate);
55889 if (PyErr_Occurred()) SWIG_fail;
55890 }
55891 resultobj = SWIG_Py_Void();
55892 return resultobj;
55893 fail:
55894 return NULL;
55895 }
55896
55897
55898 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55899 PyObject *resultobj = 0;
55900 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55901 int result;
55902 void *argp1 = 0 ;
55903 int res1 = 0 ;
55904 PyObject *swig_obj[1] ;
55905
55906 if (!args) SWIG_fail;
55907 swig_obj[0] = args;
55908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55909 if (!SWIG_IsOK(res1)) {
55910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55911 }
55912 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55913 {
55914 PyThreadState* __tstate = wxPyBeginAllowThreads();
55915 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55916 wxPyEndAllowThreads(__tstate);
55917 if (PyErr_Occurred()) SWIG_fail;
55918 }
55919 resultobj = SWIG_From_int(static_cast< int >(result));
55920 return resultobj;
55921 fail:
55922 return NULL;
55923 }
55924
55925
55926 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55927 PyObject *resultobj = 0;
55928 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55929 int result;
55930 void *argp1 = 0 ;
55931 int res1 = 0 ;
55932 PyObject *swig_obj[1] ;
55933
55934 if (!args) SWIG_fail;
55935 swig_obj[0] = args;
55936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55937 if (!SWIG_IsOK(res1)) {
55938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55939 }
55940 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55941 {
55942 PyThreadState* __tstate = wxPyBeginAllowThreads();
55943 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55944 wxPyEndAllowThreads(__tstate);
55945 if (PyErr_Occurred()) SWIG_fail;
55946 }
55947 resultobj = SWIG_From_int(static_cast< int >(result));
55948 return resultobj;
55949 fail:
55950 return NULL;
55951 }
55952
55953
55954 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55955 PyObject *resultobj = 0;
55956 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55957 int result;
55958 void *argp1 = 0 ;
55959 int res1 = 0 ;
55960 PyObject *swig_obj[1] ;
55961
55962 if (!args) SWIG_fail;
55963 swig_obj[0] = args;
55964 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55965 if (!SWIG_IsOK(res1)) {
55966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55967 }
55968 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55969 {
55970 PyThreadState* __tstate = wxPyBeginAllowThreads();
55971 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55972 wxPyEndAllowThreads(__tstate);
55973 if (PyErr_Occurred()) SWIG_fail;
55974 }
55975 resultobj = SWIG_From_int(static_cast< int >(result));
55976 return resultobj;
55977 fail:
55978 return NULL;
55979 }
55980
55981
55982 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55983 PyObject *resultobj = 0;
55984 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55985 bool result;
55986 void *argp1 = 0 ;
55987 int res1 = 0 ;
55988 PyObject *swig_obj[1] ;
55989
55990 if (!args) SWIG_fail;
55991 swig_obj[0] = args;
55992 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55993 if (!SWIG_IsOK(res1)) {
55994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55995 }
55996 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55997 {
55998 PyThreadState* __tstate = wxPyBeginAllowThreads();
55999 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
56000 wxPyEndAllowThreads(__tstate);
56001 if (PyErr_Occurred()) SWIG_fail;
56002 }
56003 {
56004 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56005 }
56006 return resultobj;
56007 fail:
56008 return NULL;
56009 }
56010
56011
56012 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56013 PyObject *resultobj = 0;
56014 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56015 bool arg2 ;
56016 void *argp1 = 0 ;
56017 int res1 = 0 ;
56018 bool val2 ;
56019 int ecode2 = 0 ;
56020 PyObject * obj0 = 0 ;
56021 PyObject * obj1 = 0 ;
56022 char * kwnames[] = {
56023 (char *) "self",(char *) "d", NULL
56024 };
56025
56026 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
56027 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56028 if (!SWIG_IsOK(res1)) {
56029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56030 }
56031 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56032 ecode2 = SWIG_AsVal_bool(obj1, &val2);
56033 if (!SWIG_IsOK(ecode2)) {
56034 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
56035 }
56036 arg2 = static_cast< bool >(val2);
56037 {
56038 PyThreadState* __tstate = wxPyBeginAllowThreads();
56039 (arg1)->SetDone(arg2);
56040 wxPyEndAllowThreads(__tstate);
56041 if (PyErr_Occurred()) SWIG_fail;
56042 }
56043 resultobj = SWIG_Py_Void();
56044 return resultobj;
56045 fail:
56046 return NULL;
56047 }
56048
56049
56050 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56051 PyObject *resultobj = 0;
56052 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56053 wxRelationship result;
56054 void *argp1 = 0 ;
56055 int res1 = 0 ;
56056 PyObject *swig_obj[1] ;
56057
56058 if (!args) SWIG_fail;
56059 swig_obj[0] = args;
56060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56061 if (!SWIG_IsOK(res1)) {
56062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56063 }
56064 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56065 {
56066 PyThreadState* __tstate = wxPyBeginAllowThreads();
56067 result = (wxRelationship)(arg1)->GetRelationship();
56068 wxPyEndAllowThreads(__tstate);
56069 if (PyErr_Occurred()) SWIG_fail;
56070 }
56071 resultobj = SWIG_From_int(static_cast< int >(result));
56072 return resultobj;
56073 fail:
56074 return NULL;
56075 }
56076
56077
56078 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56079 PyObject *resultobj = 0;
56080 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56081 wxRelationship arg2 ;
56082 void *argp1 = 0 ;
56083 int res1 = 0 ;
56084 int val2 ;
56085 int ecode2 = 0 ;
56086 PyObject * obj0 = 0 ;
56087 PyObject * obj1 = 0 ;
56088 char * kwnames[] = {
56089 (char *) "self",(char *) "r", NULL
56090 };
56091
56092 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
56093 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56094 if (!SWIG_IsOK(res1)) {
56095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56096 }
56097 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56098 ecode2 = SWIG_AsVal_int(obj1, &val2);
56099 if (!SWIG_IsOK(ecode2)) {
56100 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
56101 }
56102 arg2 = static_cast< wxRelationship >(val2);
56103 {
56104 PyThreadState* __tstate = wxPyBeginAllowThreads();
56105 (arg1)->SetRelationship(arg2);
56106 wxPyEndAllowThreads(__tstate);
56107 if (PyErr_Occurred()) SWIG_fail;
56108 }
56109 resultobj = SWIG_Py_Void();
56110 return resultobj;
56111 fail:
56112 return NULL;
56113 }
56114
56115
56116 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56117 PyObject *resultobj = 0;
56118 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56119 wxWindow *arg2 = (wxWindow *) 0 ;
56120 bool result;
56121 void *argp1 = 0 ;
56122 int res1 = 0 ;
56123 void *argp2 = 0 ;
56124 int res2 = 0 ;
56125 PyObject * obj0 = 0 ;
56126 PyObject * obj1 = 0 ;
56127 char * kwnames[] = {
56128 (char *) "self",(char *) "otherW", NULL
56129 };
56130
56131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
56132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56133 if (!SWIG_IsOK(res1)) {
56134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56135 }
56136 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56137 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56138 if (!SWIG_IsOK(res2)) {
56139 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
56140 }
56141 arg2 = reinterpret_cast< wxWindow * >(argp2);
56142 {
56143 PyThreadState* __tstate = wxPyBeginAllowThreads();
56144 result = (bool)(arg1)->ResetIfWin(arg2);
56145 wxPyEndAllowThreads(__tstate);
56146 if (PyErr_Occurred()) SWIG_fail;
56147 }
56148 {
56149 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56150 }
56151 return resultobj;
56152 fail:
56153 return NULL;
56154 }
56155
56156
56157 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56158 PyObject *resultobj = 0;
56159 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56160 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56161 wxWindow *arg3 = (wxWindow *) 0 ;
56162 bool result;
56163 void *argp1 = 0 ;
56164 int res1 = 0 ;
56165 void *argp2 = 0 ;
56166 int res2 = 0 ;
56167 void *argp3 = 0 ;
56168 int res3 = 0 ;
56169 PyObject * obj0 = 0 ;
56170 PyObject * obj1 = 0 ;
56171 PyObject * obj2 = 0 ;
56172 char * kwnames[] = {
56173 (char *) "self",(char *) "constraints",(char *) "win", NULL
56174 };
56175
56176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56178 if (!SWIG_IsOK(res1)) {
56179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56180 }
56181 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56182 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56183 if (!SWIG_IsOK(res2)) {
56184 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56185 }
56186 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56187 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56188 if (!SWIG_IsOK(res3)) {
56189 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56190 }
56191 arg3 = reinterpret_cast< wxWindow * >(argp3);
56192 {
56193 PyThreadState* __tstate = wxPyBeginAllowThreads();
56194 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56195 wxPyEndAllowThreads(__tstate);
56196 if (PyErr_Occurred()) SWIG_fail;
56197 }
56198 {
56199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56200 }
56201 return resultobj;
56202 fail:
56203 return NULL;
56204 }
56205
56206
56207 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56208 PyObject *resultobj = 0;
56209 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56210 wxEdge arg2 ;
56211 wxWindow *arg3 = (wxWindow *) 0 ;
56212 wxWindow *arg4 = (wxWindow *) 0 ;
56213 int result;
56214 void *argp1 = 0 ;
56215 int res1 = 0 ;
56216 int val2 ;
56217 int ecode2 = 0 ;
56218 void *argp3 = 0 ;
56219 int res3 = 0 ;
56220 void *argp4 = 0 ;
56221 int res4 = 0 ;
56222 PyObject * obj0 = 0 ;
56223 PyObject * obj1 = 0 ;
56224 PyObject * obj2 = 0 ;
56225 PyObject * obj3 = 0 ;
56226 char * kwnames[] = {
56227 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56228 };
56229
56230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56232 if (!SWIG_IsOK(res1)) {
56233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56234 }
56235 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56236 ecode2 = SWIG_AsVal_int(obj1, &val2);
56237 if (!SWIG_IsOK(ecode2)) {
56238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56239 }
56240 arg2 = static_cast< wxEdge >(val2);
56241 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56242 if (!SWIG_IsOK(res3)) {
56243 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56244 }
56245 arg3 = reinterpret_cast< wxWindow * >(argp3);
56246 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56247 if (!SWIG_IsOK(res4)) {
56248 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56249 }
56250 arg4 = reinterpret_cast< wxWindow * >(argp4);
56251 {
56252 PyThreadState* __tstate = wxPyBeginAllowThreads();
56253 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56254 wxPyEndAllowThreads(__tstate);
56255 if (PyErr_Occurred()) SWIG_fail;
56256 }
56257 resultobj = SWIG_From_int(static_cast< int >(result));
56258 return resultobj;
56259 fail:
56260 return NULL;
56261 }
56262
56263
56264 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56265 PyObject *obj;
56266 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56267 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56268 return SWIG_Py_Void();
56269 }
56270
56271 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56272 PyObject *resultobj = 0;
56273 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56274 wxIndividualLayoutConstraint *result = 0 ;
56275 void *argp1 = 0 ;
56276 int res1 = 0 ;
56277 PyObject *swig_obj[1] ;
56278
56279 if (!args) SWIG_fail;
56280 swig_obj[0] = args;
56281 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56282 if (!SWIG_IsOK(res1)) {
56283 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56284 }
56285 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56286 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56287 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56288 return resultobj;
56289 fail:
56290 return NULL;
56291 }
56292
56293
56294 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56295 PyObject *resultobj = 0;
56296 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56297 wxIndividualLayoutConstraint *result = 0 ;
56298 void *argp1 = 0 ;
56299 int res1 = 0 ;
56300 PyObject *swig_obj[1] ;
56301
56302 if (!args) SWIG_fail;
56303 swig_obj[0] = args;
56304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56305 if (!SWIG_IsOK(res1)) {
56306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56307 }
56308 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56309 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56311 return resultobj;
56312 fail:
56313 return NULL;
56314 }
56315
56316
56317 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56318 PyObject *resultobj = 0;
56319 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56320 wxIndividualLayoutConstraint *result = 0 ;
56321 void *argp1 = 0 ;
56322 int res1 = 0 ;
56323 PyObject *swig_obj[1] ;
56324
56325 if (!args) SWIG_fail;
56326 swig_obj[0] = args;
56327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56328 if (!SWIG_IsOK(res1)) {
56329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56330 }
56331 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56332 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56334 return resultobj;
56335 fail:
56336 return NULL;
56337 }
56338
56339
56340 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56341 PyObject *resultobj = 0;
56342 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56343 wxIndividualLayoutConstraint *result = 0 ;
56344 void *argp1 = 0 ;
56345 int res1 = 0 ;
56346 PyObject *swig_obj[1] ;
56347
56348 if (!args) SWIG_fail;
56349 swig_obj[0] = args;
56350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56351 if (!SWIG_IsOK(res1)) {
56352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56353 }
56354 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56355 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56356 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56357 return resultobj;
56358 fail:
56359 return NULL;
56360 }
56361
56362
56363 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56364 PyObject *resultobj = 0;
56365 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56366 wxIndividualLayoutConstraint *result = 0 ;
56367 void *argp1 = 0 ;
56368 int res1 = 0 ;
56369 PyObject *swig_obj[1] ;
56370
56371 if (!args) SWIG_fail;
56372 swig_obj[0] = args;
56373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56374 if (!SWIG_IsOK(res1)) {
56375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56376 }
56377 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56378 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56379 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56380 return resultobj;
56381 fail:
56382 return NULL;
56383 }
56384
56385
56386 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56387 PyObject *resultobj = 0;
56388 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56389 wxIndividualLayoutConstraint *result = 0 ;
56390 void *argp1 = 0 ;
56391 int res1 = 0 ;
56392 PyObject *swig_obj[1] ;
56393
56394 if (!args) SWIG_fail;
56395 swig_obj[0] = args;
56396 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56397 if (!SWIG_IsOK(res1)) {
56398 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56399 }
56400 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56401 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56402 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56403 return resultobj;
56404 fail:
56405 return NULL;
56406 }
56407
56408
56409 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56410 PyObject *resultobj = 0;
56411 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56412 wxIndividualLayoutConstraint *result = 0 ;
56413 void *argp1 = 0 ;
56414 int res1 = 0 ;
56415 PyObject *swig_obj[1] ;
56416
56417 if (!args) SWIG_fail;
56418 swig_obj[0] = args;
56419 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56420 if (!SWIG_IsOK(res1)) {
56421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56422 }
56423 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56424 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56426 return resultobj;
56427 fail:
56428 return NULL;
56429 }
56430
56431
56432 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56433 PyObject *resultobj = 0;
56434 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56435 wxIndividualLayoutConstraint *result = 0 ;
56436 void *argp1 = 0 ;
56437 int res1 = 0 ;
56438 PyObject *swig_obj[1] ;
56439
56440 if (!args) SWIG_fail;
56441 swig_obj[0] = args;
56442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56443 if (!SWIG_IsOK(res1)) {
56444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56445 }
56446 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56447 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56448 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56449 return resultobj;
56450 fail:
56451 return NULL;
56452 }
56453
56454
56455 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56456 PyObject *resultobj = 0;
56457 wxLayoutConstraints *result = 0 ;
56458
56459 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56460 {
56461 PyThreadState* __tstate = wxPyBeginAllowThreads();
56462 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56463 wxPyEndAllowThreads(__tstate);
56464 if (PyErr_Occurred()) SWIG_fail;
56465 }
56466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56467 return resultobj;
56468 fail:
56469 return NULL;
56470 }
56471
56472
56473 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56474 PyObject *resultobj = 0;
56475 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56476 void *argp1 = 0 ;
56477 int res1 = 0 ;
56478 PyObject *swig_obj[1] ;
56479
56480 if (!args) SWIG_fail;
56481 swig_obj[0] = args;
56482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56483 if (!SWIG_IsOK(res1)) {
56484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56485 }
56486 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56487 {
56488 PyThreadState* __tstate = wxPyBeginAllowThreads();
56489 delete arg1;
56490
56491 wxPyEndAllowThreads(__tstate);
56492 if (PyErr_Occurred()) SWIG_fail;
56493 }
56494 resultobj = SWIG_Py_Void();
56495 return resultobj;
56496 fail:
56497 return NULL;
56498 }
56499
56500
56501 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56502 PyObject *resultobj = 0;
56503 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56504 wxWindow *arg2 = (wxWindow *) 0 ;
56505 int *arg3 = (int *) 0 ;
56506 bool result;
56507 void *argp1 = 0 ;
56508 int res1 = 0 ;
56509 void *argp2 = 0 ;
56510 int res2 = 0 ;
56511 int temp3 ;
56512 int res3 = SWIG_TMPOBJ ;
56513 PyObject * obj0 = 0 ;
56514 PyObject * obj1 = 0 ;
56515 char * kwnames[] = {
56516 (char *) "self",(char *) "win", NULL
56517 };
56518
56519 arg3 = &temp3;
56520 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56521 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56522 if (!SWIG_IsOK(res1)) {
56523 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56524 }
56525 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56526 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56527 if (!SWIG_IsOK(res2)) {
56528 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56529 }
56530 arg2 = reinterpret_cast< wxWindow * >(argp2);
56531 {
56532 PyThreadState* __tstate = wxPyBeginAllowThreads();
56533 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56534 wxPyEndAllowThreads(__tstate);
56535 if (PyErr_Occurred()) SWIG_fail;
56536 }
56537 {
56538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56539 }
56540 if (SWIG_IsTmpObj(res3)) {
56541 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56542 } else {
56543 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56545 }
56546 return resultobj;
56547 fail:
56548 return NULL;
56549 }
56550
56551
56552 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56553 PyObject *resultobj = 0;
56554 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56555 bool result;
56556 void *argp1 = 0 ;
56557 int res1 = 0 ;
56558 PyObject *swig_obj[1] ;
56559
56560 if (!args) SWIG_fail;
56561 swig_obj[0] = args;
56562 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56563 if (!SWIG_IsOK(res1)) {
56564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56565 }
56566 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56567 {
56568 PyThreadState* __tstate = wxPyBeginAllowThreads();
56569 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56570 wxPyEndAllowThreads(__tstate);
56571 if (PyErr_Occurred()) SWIG_fail;
56572 }
56573 {
56574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56575 }
56576 return resultobj;
56577 fail:
56578 return NULL;
56579 }
56580
56581
56582 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56583 PyObject *obj;
56584 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56585 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56586 return SWIG_Py_Void();
56587 }
56588
56589 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56590 return SWIG_Python_InitShadowInstance(args);
56591 }
56592
56593 static PyMethodDef SwigMethods[] = {
56594 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56595 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56596 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56597 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56598 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56599 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56600 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56601 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56602 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56603 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56604 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56605 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56610 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56611 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56612 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56613 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56614 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56615 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56616 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56618 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56619 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56620 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56622 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56623 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56624 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56625 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56626 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56627 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56628 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56630 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56633 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56634 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56636 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56637 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56638 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56639 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56640 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56641 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56642 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56644 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56646 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56647 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56649 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56650 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56651 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56652 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56653 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56654 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56655 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56656 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56657 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56658 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56659 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56660 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56662 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56663 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56664 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56665 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56666 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56667 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56668 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56670 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56672 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56673 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56675 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56677 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56678 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56679 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56680 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56681 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56682 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56683 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56684 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56685 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56686 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56687 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56688 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56689 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56694 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56695 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56696 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56697 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56698 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56704 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56705 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56706 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56707 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56708 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56709 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56710 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56711 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56712 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56713 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56714 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56715 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56717 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56718 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56719 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56720 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56721 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56722 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56723 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56724 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56727 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56730 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56731 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56733 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56736 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56738 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56739 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56740 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56741 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56742 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56743 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56744 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56745 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56747 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56748 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56749 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56750 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56753 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56754 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56756 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56759 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56762 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56765 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56768 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56769 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56770 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56771 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56772 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56773 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56774 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56775 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56777 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56778 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56779 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56780 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56781 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56782 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56783 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56784 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56789 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56790 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56791 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56792 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56793 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56794 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56795 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56796 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56797 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56798 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56799 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56800 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56801 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56802 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56803 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56804 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56805 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56806 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56807 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56808 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56809 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56810 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56811 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56812 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56813 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56814 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56815 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56816 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56817 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56818 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56819 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56820 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56823 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56824 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56825 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56826 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56827 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56828 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56829 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56830 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56831 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56832 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56833 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56834 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56835 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56836 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56837 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56838 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56839 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56840 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56841 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56842 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56845 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56846 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56847 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56850 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56851 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56852 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56853 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56854 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56855 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56857 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56858 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56860 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56862 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56863 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56864 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56865 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56866 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56867 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56868 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56869 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56870 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56871 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56872 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56873 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56875 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56876 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56877 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56878 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56879 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56880 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56881 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56883 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56885 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56886 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56887 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56888 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56889 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56890 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56891 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56892 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56893 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56894 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56895 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56896 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56897 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56898 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56899 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56900 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56901 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56902 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56903 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56904 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56905 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56906 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56907 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56908 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56910 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56911 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56912 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56913 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56914 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56915 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56916 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56917 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56918 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56919 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56920 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56921 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56922 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56923 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56924 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56925 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56926 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56927 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56928 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56929 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56930 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56931 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56933 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56934 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56935 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56936 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56937 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56940 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56942 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56944 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56945 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56946 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56947 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56948 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56949 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56950 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56951 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56952 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56953 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56955 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56956 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56957 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56959 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56960 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56961 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56962 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56963 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56965 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56966 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56967 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56968 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56969 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56970 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56971 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56972 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56973 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56974 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56975 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56976 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56977 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56978 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56979 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56980 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56981 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56982 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56983 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56984 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56985 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56986 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56987 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56988 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56989 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56990 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56991 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56992 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56993 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56994 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56995 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56996 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56997 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56998 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56999 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
57000 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57001 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
57002 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
57003 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
57004 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
57005 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
57006 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
57007 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
57008 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
57009 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
57010 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57011 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57012 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57013 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
57014 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
57015 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57016 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57017 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
57018 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
57019 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
57020 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
57021 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
57022 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
57023 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
57024 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
57025 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
57026 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
57027 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
57028 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
57029 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
57030 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
57031 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
57032 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
57033 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
57034 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
57035 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
57036 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
57037 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
57038 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
57039 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
57040 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
57041 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
57042 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
57043 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
57044 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
57045 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
57046 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
57047 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
57048 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
57049 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
57050 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
57051 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
57052 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
57053 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
57054 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
57055 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
57056 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
57057 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
57058 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
57059 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
57060 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
57061 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
57062 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
57063 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
57064 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57065 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57066 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
57067 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57068 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57069 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57070 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
57071 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
57072 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
57073 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57074 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
57075 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
57076 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
57077 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
57078 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
57079 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
57080 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
57081 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
57082 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
57083 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
57084 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
57085 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57086 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
57087 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
57088 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
57089 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
57090 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
57091 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
57092 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
57093 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
57094 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
57095 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
57096 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
57097 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
57098 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
57099 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
57100 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
57101 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
57102 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57103 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
57104 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57105 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
57106 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
57107 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
57108 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
57110 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
57111 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
57112 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
57113 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
57115 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
57116 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
57117 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57118 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
57119 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
57120 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
57121 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
57122 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
57123 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57124 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
57125 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
57126 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57127 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57128 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
57129 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
57130 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57131 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
57132 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
57133 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57134 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57135 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
57136 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
57137 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57138 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
57139 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
57140 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
57141 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
57142 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
57143 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
57144 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
57145 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
57146 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
57147 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
57148 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
57149 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
57150 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
57151 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
57152 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
57153 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
57154 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
57155 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
57156 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
57157 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
57158 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
57159 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57160 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57161 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57162 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57163 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57164 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57165 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57166 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57167 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57168 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57169 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57170 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57171 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57172 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57173 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
57174 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57175 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57176 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57177 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57178 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57179 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57180 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57181 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57182 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57183 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57184 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57185 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57186 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57187 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57188 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57189 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57190 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57191 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57192 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57193 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57194 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57195 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57196 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57197 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57198 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57199 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57200 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57201 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57202 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57203 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57204 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57205 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57206 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57207 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57208 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57209 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57210 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57211 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57212 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57213 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57214 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57215 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57216 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57217 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57218 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57219 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57220 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57221 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57222 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57223 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57224 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57225 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57226 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57227 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57228 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57229 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57230 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57231 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57232 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57233 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57234 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57235 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57236 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57237 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57238 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57239 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57240 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57241 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57242 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57243 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57244 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57245 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57246 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57247 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57248 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57249 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57250 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57251 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57252 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57253 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57254 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57255 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57256 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57257 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57258 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57259 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57260 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57261 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57262 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57263 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57264 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57265 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57266 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57267 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57268 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57269 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57270 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57271 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57272 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57273 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57275 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57276 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57277 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57278 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57279 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57280 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57281 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57282 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57283 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57284 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57285 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57286 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57287 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57288 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57289 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57290 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57291 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57292 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57293 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57294 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57295 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57296 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57297 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57298 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57299 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57300 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57301 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57302 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57303 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57304 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57305 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57306 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57307 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57308 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57309 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57311 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57312 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57313 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57315 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57316 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57317 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57318 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57319 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57320 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57321 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57322 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57323 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57324 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57325 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57326 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57327 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57328 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57329 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57330 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57331 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57332 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57333 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57334 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57335 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57336 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57337 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57339 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57340 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57341 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57342 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57343 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57344 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57345 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57346 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57347 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57348 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57349 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57350 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57351 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57352 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57353 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57354 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57355 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57356 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57357 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57358 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57359 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57360 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57361 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57362 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57363 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57364 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57365 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57366 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57367 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57368 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57369 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57370 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57372 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57374 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57375 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57377 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57378 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57379 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57380 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57382 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57383 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57384 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57386 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57387 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57388 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57389 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57390 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57392 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57393 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57394 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57395 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57396 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57397 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57398 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57399 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57400 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57401 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57402 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57403 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57404 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57406 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57408 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57409 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57410 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57411 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57412 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57413 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57414 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57415 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57416 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57417 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57418 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57419 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57420 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57421 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
57423 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
57425 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
57426 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57427 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57428 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57429 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57430 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57431 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57432 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57433 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57434 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57435 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57436 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57437 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57438 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57439 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57440 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57441 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57442 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57443 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57444 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57445 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57446 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57447 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57448 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57449 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57450 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57451 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57453 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57455 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57456 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57457 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57458 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57459 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57460 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57461 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57462 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57463 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57464 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57465 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57466 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57468 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57469 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57470 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57471 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57472 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57473 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57474 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57475 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57476 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57477 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57478 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57479 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57480 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57481 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57482 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57484 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57485 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57486 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57487 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57488 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57489 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57490 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57491 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57492 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57493 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57494 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57495 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57496 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57497 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57498 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57499 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57500 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57501 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57503 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57504 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57505 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57506 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57507 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57508 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57510 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57511 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57512 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57513 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57514 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57515 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57516 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57517 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57518 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57519 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57520 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57521 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57522 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57523 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57524 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57525 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57526 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57527 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57529 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57530 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57531 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57532 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57533 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57534 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57535 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57536 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57537 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57538 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57539 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57540 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57541 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57542 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57543 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57544 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57545 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57546 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57547 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57548 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57549 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57551 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57554 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57555 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57556 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57557 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57560 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57561 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57562 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57563 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57564 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57565 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57566 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57567 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57568 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57569 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57570 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57571 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57572 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57573 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57574 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57575 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57577 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57578 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57579 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57580 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57581 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57582 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57584 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57586 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57587 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57590 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57591 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57592 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57593 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57594 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57595 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57596 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57597 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
57598 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57599 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57600 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57601 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57602 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57603 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57604 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57605 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57606 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57608 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57609 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57610 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57613 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57615 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57616 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57617 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57618 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57619 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57620 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57621 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57625 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57626 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57627 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57628 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57631 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57632 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57633 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57634 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57635 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57637 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57638 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57639 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57640 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57641 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57642 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57643 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57644 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57645 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57647 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57649 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57655 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57656 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57657 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57658 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57659 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57660 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57661 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57663 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57664 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57665 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57666 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57667 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57668 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57669 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57670 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57671 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57675 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57679 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57681 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57682 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57683 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57684 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57686 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57687 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57689 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57692 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57694 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57695 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57696 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57697 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57698 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57699 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57701 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57703 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57705 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57706 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57708 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57709 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57710 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57711 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57712 { (char *)"Window_OnPaint", (PyCFunction) _wrap_Window_OnPaint, METH_VARARGS | METH_KEYWORDS, NULL},
57713 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57714 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57717 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57719 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57720 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57721 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57722 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57723 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57724 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57725 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57726 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57727 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57730 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57731 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57732 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57733 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57734 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57735 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57736 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57738 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57740 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57741 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57742 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57744 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57745 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57746 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57747 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57748 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57749 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57751 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57752 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57756 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57757 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57758 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57759 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57761 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57762 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57763 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57765 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57767 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57768 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57769 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57771 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57772 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57774 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57775 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57783 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57788 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57790 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57792 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57793 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57795 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57797 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57798 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57800 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57801 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57802 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57806 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57812 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57815 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57817 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57819 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57820 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57822 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57824 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57825 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57826 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57827 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57828 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57829 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57831 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57832 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57833 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57835 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57836 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57838 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57839 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57840 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57842 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57843 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57845 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57848 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57849 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57851 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57852 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57853 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57855 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57856 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57858 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57859 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57860 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57862 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57863 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57864 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57866 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57867 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57868 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57869 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57870 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57871 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57872 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57873 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57874 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57875 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57876 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57877 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57878 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57879 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57880 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57881 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57882 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57883 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57884 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57885 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57886 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57887 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57888 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57889 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57891 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57892 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57893 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57895 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57896 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57897 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57898 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57899 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57900 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57901 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57902 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57903 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57904 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57905 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57906 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57907 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57908 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57909 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57910 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57911 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57914 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57915 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57916 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57917 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57919 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57920 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57923 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57924 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57925 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57926 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57927 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57928 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57929 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57930 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57931 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57932 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57933 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57934 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57935 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57936 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57937 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57938 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57940 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57941 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57942 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57943 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57944 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57945 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57946 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57947 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57948 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57949 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57950 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57952 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57953 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57954 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57955 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57956 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57958 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57959 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57960 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57961 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57962 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57963 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57965 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57967 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57968 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57969 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57970 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57971 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57972 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57973 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57974 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57975 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57976 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57977 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57978 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57979 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57980 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57984 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57985 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57986 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57987 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57988 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57989 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57990 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57992 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57993 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57994 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57995 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57996 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57997 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57998 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57999 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
58000 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
58001 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
58002 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58003 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
58004 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
58005 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
58006 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
58007 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
58008 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
58009 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
58010 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
58011 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
58012 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
58013 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
58014 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
58015 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58016 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
58017 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
58018 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
58019 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
58020 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58021 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
58022 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
58023 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
58024 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58025 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
58026 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
58027 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
58028 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
58029 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
58030 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
58031 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
58032 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
58033 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
58034 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
58035 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58036 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
58037 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
58038 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
58039 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
58040 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58041 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
58042 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
58043 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
58044 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
58045 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
58046 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
58047 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
58048 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
58049 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
58050 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
58051 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
58052 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
58053 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
58054 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
58055 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
58056 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
58057 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
58058 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
58059 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
58060 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
58061 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58062 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
58063 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
58064 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
58065 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58066 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58067 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58069 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58070 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
58071 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
58072 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
58073 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
58074 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
58075 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
58076 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
58077 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
58078 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
58079 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58080 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58081 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58082 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
58083 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
58084 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
58085 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
58086 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
58087 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58088 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58089 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
58090 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
58091 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
58092 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
58093 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
58094 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58095 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
58096 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
58097 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
58098 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58099 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
58100 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
58101 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58102 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
58103 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
58104 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
58105 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
58106 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
58107 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
58108 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
58109 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
58110 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
58111 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
58112 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58113 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58114 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58115 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
58116 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
58117 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
58118 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58119 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
58120 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
58121 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
58122 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
58123 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58124 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
58125 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
58126 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
58127 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
58128 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
58129 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
58130 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
58131 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
58132 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
58133 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
58134 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
58135 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
58136 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
58137 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
58138 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
58139 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
58140 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
58141 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
58142 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
58143 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
58144 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
58145 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
58146 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
58147 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
58148 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
58149 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
58150 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
58151 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
58152 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
58153 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
58154 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
58155 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58156 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
58157 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
58158 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
58159 { NULL, NULL, 0, NULL }
58160 };
58161
58162
58163 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
58164
58165 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58166 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58167 }
58168 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58169 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58170 }
58171 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58172 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58173 }
58174 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58175 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58176 }
58177 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58178 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58179 }
58180 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58181 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58182 }
58183 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58184 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58185 }
58186 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58187 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58188 }
58189 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58190 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58191 }
58192 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58193 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58194 }
58195 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58196 return (void *)((wxEvent *) ((wxPyEvent *) x));
58197 }
58198 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58199 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58200 }
58201 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58202 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58203 }
58204 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58205 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58206 }
58207 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58208 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58209 }
58210 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58211 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58212 }
58213 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58214 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58215 }
58216 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58217 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58218 }
58219 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58220 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58221 }
58222 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58223 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58224 }
58225 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58226 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58227 }
58228 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58229 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58230 }
58231 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58232 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58233 }
58234 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58235 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58236 }
58237 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58238 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58239 }
58240 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58241 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58242 }
58243 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58244 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58245 }
58246 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58247 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58248 }
58249 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58250 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58251 }
58252 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58253 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58254 }
58255 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58256 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58257 }
58258 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58259 return (void *)((wxEvent *) ((wxShowEvent *) x));
58260 }
58261 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58262 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58263 }
58264 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58265 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58266 }
58267 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58268 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58269 }
58270 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58271 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58272 }
58273 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58274 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58275 }
58276 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58277 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58278 }
58279 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58280 return (void *)((wxValidator *) ((wxPyValidator *) x));
58281 }
58282 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58283 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58284 }
58285 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
58286 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
58287 }
58288 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58289 return (void *)((wxObject *) ((wxSizerItem *) x));
58290 }
58291 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58292 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58293 }
58294 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58295 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58296 }
58297 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58298 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58299 }
58300 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58301 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58302 }
58303 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58304 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58305 }
58306 static void *_p_wxSizerTo_p_wxObject(void *x) {
58307 return (void *)((wxObject *) ((wxSizer *) x));
58308 }
58309 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58310 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58311 }
58312 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58313 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58314 }
58315 static void *_p_wxEventTo_p_wxObject(void *x) {
58316 return (void *)((wxObject *) ((wxEvent *) x));
58317 }
58318 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58319 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58320 }
58321 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58322 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58323 }
58324 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58325 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58326 }
58327 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58328 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58329 }
58330 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58331 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58332 }
58333 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58334 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58335 }
58336 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58337 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58338 }
58339 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58340 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58341 }
58342 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58343 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58344 }
58345 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58346 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58347 }
58348 static void *_p_wxControlTo_p_wxObject(void *x) {
58349 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58350 }
58351 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58352 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58353 }
58354 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58355 return (void *)((wxObject *) ((wxFSFile *) x));
58356 }
58357 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58358 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58359 }
58360 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58361 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58362 }
58363 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58364 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58365 }
58366 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58367 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58368 }
58369 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58370 return (void *)((wxObject *) ((wxMenuItem *) x));
58371 }
58372 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58373 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58374 }
58375 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58376 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58377 }
58378 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58379 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58380 }
58381 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58382 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58383 }
58384 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58385 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58386 }
58387 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58388 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58389 }
58390 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58391 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58392 }
58393 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58395 }
58396 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58398 }
58399 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58401 }
58402 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58404 }
58405 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58407 }
58408 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58410 }
58411 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58413 }
58414 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58416 }
58417 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58419 }
58420 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58422 }
58423 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58425 }
58426 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58428 }
58429 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) ((wxImageHandler *) x));
58431 }
58432 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58434 }
58435 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58437 }
58438 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58439 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58440 }
58441 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58442 return (void *)((wxObject *) ((wxEvtHandler *) x));
58443 }
58444 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58445 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58446 }
58447 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58448 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58449 }
58450 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58451 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58452 }
58453 static void *_p_wxImageTo_p_wxObject(void *x) {
58454 return (void *)((wxObject *) ((wxImage *) x));
58455 }
58456 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58457 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58458 }
58459 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58460 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58461 }
58462 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58463 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58464 }
58465 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58466 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58467 }
58468 static void *_p_wxWindowTo_p_wxObject(void *x) {
58469 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58470 }
58471 static void *_p_wxMenuTo_p_wxObject(void *x) {
58472 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58473 }
58474 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58475 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58476 }
58477 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58478 return (void *)((wxObject *) ((wxFileSystem *) x));
58479 }
58480 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58481 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58482 }
58483 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58484 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58485 }
58486 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58487 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58488 }
58489 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58490 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58491 }
58492 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58493 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58494 }
58495 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58496 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58497 }
58498 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58499 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58500 }
58501 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58502 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58503 }
58504 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58505 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58506 }
58507 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58508 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58509 }
58510 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58511 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58512 }
58513 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58514 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58515 }
58516 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58517 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58518 }
58519 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58520 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58521 }
58522 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58523 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58524 }
58525 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58526 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58527 }
58528 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58529 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58530 }
58531 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58532 return (void *)((wxControl *) ((wxControlWithItems *) x));
58533 }
58534 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58535 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58536 }
58537 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58538 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58539 }
58540 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58541 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58542 }
58543 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58544 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58545 }
58546 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58547 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58548 }
58549 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58550 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58551 }
58552 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58553 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58554 }
58555 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58556 return (void *)((wxSizer *) ((wxGridSizer *) x));
58557 }
58558 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58559 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58560 }
58561 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58562 return (void *)((wxSizer *) ((wxPySizer *) x));
58563 }
58564 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
58565 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
58566 }
58567 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58568 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58569 }
58570 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58571 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58572 }
58573 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58574 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58575 }
58576 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58577 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58578 }
58579 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58580 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58581 }
58582 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58583 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58584 }
58585 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58586 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58587 }
58588 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58589 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58590 }
58591 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58592 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58593 }
58594 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58595 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58596 }
58597 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58598 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58599 }
58600 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58601 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58602 }
58603 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58604 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58605 }
58606 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58607 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58608 }
58609 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58610 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58611 }
58612 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58613 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58614 }
58615 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58616 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58617 }
58618 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58619 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58620 }
58621 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58622 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58623 }
58624 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58625 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58626 }
58627 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58628 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58629 }
58630 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58631 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58632 }
58633 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58634 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58635 }
58636 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58637 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58638 }
58639 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58640 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58641 }
58642 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58643 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58644 }
58645 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58646 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58647 }
58648 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58649 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58650 }
58651 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58652 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58653 }
58654 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58655 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58656 }
58657 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
58658 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
58659 }
58660 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58661 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58662 }
58663 static void *_p_wxControlTo_p_wxWindow(void *x) {
58664 return (void *)((wxWindow *) ((wxControl *) x));
58665 }
58666 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58667 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58668 }
58669 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58670 return (void *)((wxWindow *) ((wxMenuBar *) x));
58671 }
58672 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58673 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58674 }
58675 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58676 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58677 }
58678 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58679 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58680 }
58681 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58682 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58683 }
58684 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58685 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58686 }
58687 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58688 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58689 }
58690 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58691 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58692 }
58693 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58694 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58695 }
58696 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58697 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58698 }
58699 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58700 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58701 }
58702 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58703 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58704 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};
58705 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58706 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58707 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58708 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58709 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58710 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58711 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58712 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58713 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58714 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58715 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58716 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58717 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58718 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58719 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58720 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58721 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58722 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58723 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58724 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58725 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58726 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58727 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58728 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58729 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58730 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58731 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58732 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58733 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58734 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58735 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58736 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58737 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58738 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58739 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58740 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
58741 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58742 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58743 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58744 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58745 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58746 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58747 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58748 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58749 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58750 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58751 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58752 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58753 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58754 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58755 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58756 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58757 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58758 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58759 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58760 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58761 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58762 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58763 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58764 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58765 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58766 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58767 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58768 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58769 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58770 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58771 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58772 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58773 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58774 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58775 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58776 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58777 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58778 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58779 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58780 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58781 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58782 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58783 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58784 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58785 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58786 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58787 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58788 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58789 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58790 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58791 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58792 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58793 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58794 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58795 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58796 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58797 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58798 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58799 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58800 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58801 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58802 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58803 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58804 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58805 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58806 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58807 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58808 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58809 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58810 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58811 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58812 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58813 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58814 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58815 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58816 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58817 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58818 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58819 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58820 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58821 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58822 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58823 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58824 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58825 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58826 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58827 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58828 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58829 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58830 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58831 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58832 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58833 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58834 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58835 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58836 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58837 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58838
58839 static swig_type_info *swig_type_initial[] = {
58840 &_swigt__p_buffer,
58841 &_swigt__p_char,
58842 &_swigt__p_form_ops_t,
58843 &_swigt__p_int,
58844 &_swigt__p_long,
58845 &_swigt__p_unsigned_char,
58846 &_swigt__p_unsigned_int,
58847 &_swigt__p_unsigned_long,
58848 &_swigt__p_wxANIHandler,
58849 &_swigt__p_wxAcceleratorEntry,
58850 &_swigt__p_wxAcceleratorTable,
58851 &_swigt__p_wxActivateEvent,
58852 &_swigt__p_wxAppTraits,
58853 &_swigt__p_wxArrayString,
58854 &_swigt__p_wxBMPHandler,
58855 &_swigt__p_wxBitmap,
58856 &_swigt__p_wxBoxSizer,
58857 &_swigt__p_wxButton,
58858 &_swigt__p_wxCURHandler,
58859 &_swigt__p_wxCaret,
58860 &_swigt__p_wxChildFocusEvent,
58861 &_swigt__p_wxClipboardTextEvent,
58862 &_swigt__p_wxCloseEvent,
58863 &_swigt__p_wxColour,
58864 &_swigt__p_wxCommandEvent,
58865 &_swigt__p_wxContextMenuEvent,
58866 &_swigt__p_wxControl,
58867 &_swigt__p_wxControlWithItems,
58868 &_swigt__p_wxCursor,
58869 &_swigt__p_wxDC,
58870 &_swigt__p_wxDateEvent,
58871 &_swigt__p_wxDateTime,
58872 &_swigt__p_wxDisplayChangedEvent,
58873 &_swigt__p_wxDouble,
58874 &_swigt__p_wxDropFilesEvent,
58875 &_swigt__p_wxDuplexMode,
58876 &_swigt__p_wxEraseEvent,
58877 &_swigt__p_wxEvent,
58878 &_swigt__p_wxEventBlocker,
58879 &_swigt__p_wxEventLoop,
58880 &_swigt__p_wxEventLoopActivator,
58881 &_swigt__p_wxEvtHandler,
58882 &_swigt__p_wxFSFile,
58883 &_swigt__p_wxFileSystem,
58884 &_swigt__p_wxFileSystemHandler,
58885 &_swigt__p_wxFlexGridSizer,
58886 &_swigt__p_wxFocusEvent,
58887 &_swigt__p_wxFont,
58888 &_swigt__p_wxFrame,
58889 &_swigt__p_wxGBPosition,
58890 &_swigt__p_wxGBSizerItem,
58891 &_swigt__p_wxGBSpan,
58892 &_swigt__p_wxGIFHandler,
58893 &_swigt__p_wxGridBagSizer,
58894 &_swigt__p_wxGridSizer,
58895 &_swigt__p_wxHelpEvent__Origin,
58896 &_swigt__p_wxICOHandler,
58897 &_swigt__p_wxIconizeEvent,
58898 &_swigt__p_wxIdleEvent,
58899 &_swigt__p_wxImage,
58900 &_swigt__p_wxImageHandler,
58901 &_swigt__p_wxImageHistogram,
58902 &_swigt__p_wxImage_HSVValue,
58903 &_swigt__p_wxImage_RGBValue,
58904 &_swigt__p_wxIndividualLayoutConstraint,
58905 &_swigt__p_wxInitDialogEvent,
58906 &_swigt__p_wxInputStream,
58907 &_swigt__p_wxInternetFSHandler,
58908 &_swigt__p_wxItemContainer,
58909 &_swigt__p_wxJPEGHandler,
58910 &_swigt__p_wxKeyEvent,
58911 &_swigt__p_wxLayoutConstraints,
58912 &_swigt__p_wxMaximizeEvent,
58913 &_swigt__p_wxMemoryFSHandler,
58914 &_swigt__p_wxMenu,
58915 &_swigt__p_wxMenuBar,
58916 &_swigt__p_wxMenuBarBase,
58917 &_swigt__p_wxMenuEvent,
58918 &_swigt__p_wxMenuItem,
58919 &_swigt__p_wxMouseCaptureChangedEvent,
58920 &_swigt__p_wxMouseCaptureLostEvent,
58921 &_swigt__p_wxMouseEvent,
58922 &_swigt__p_wxMoveEvent,
58923 &_swigt__p_wxNavigationKeyEvent,
58924 &_swigt__p_wxNcPaintEvent,
58925 &_swigt__p_wxNotifyEvent,
58926 &_swigt__p_wxObject,
58927 &_swigt__p_wxOutputStream,
58928 &_swigt__p_wxPCXHandler,
58929 &_swigt__p_wxPNGHandler,
58930 &_swigt__p_wxPNMHandler,
58931 &_swigt__p_wxPaintEvent,
58932 &_swigt__p_wxPaletteChangedEvent,
58933 &_swigt__p_wxPaperSize,
58934 &_swigt__p_wxPoint,
58935 &_swigt__p_wxPoint2D,
58936 &_swigt__p_wxPropagateOnce,
58937 &_swigt__p_wxPropagationDisabler,
58938 &_swigt__p_wxPyApp,
58939 &_swigt__p_wxPyCommandEvent,
58940 &_swigt__p_wxPyDropTarget,
58941 &_swigt__p_wxPyEvent,
58942 &_swigt__p_wxPyFileSystemHandler,
58943 &_swigt__p_wxPyImageHandler,
58944 &_swigt__p_wxPyInputStream,
58945 &_swigt__p_wxPySizer,
58946 &_swigt__p_wxPyValidator,
58947 &_swigt__p_wxQuantize,
58948 &_swigt__p_wxQueryNewPaletteEvent,
58949 &_swigt__p_wxRealPoint,
58950 &_swigt__p_wxRect,
58951 &_swigt__p_wxRect2D,
58952 &_swigt__p_wxRegion,
58953 &_swigt__p_wxScrollEvent,
58954 &_swigt__p_wxScrollWinEvent,
58955 &_swigt__p_wxSetCursorEvent,
58956 &_swigt__p_wxShowEvent,
58957 &_swigt__p_wxSize,
58958 &_swigt__p_wxSizeEvent,
58959 &_swigt__p_wxSizer,
58960 &_swigt__p_wxSizerItem,
58961 &_swigt__p_wxStaticBox,
58962 &_swigt__p_wxStaticBoxSizer,
58963 &_swigt__p_wxStdDialogButtonSizer,
58964 &_swigt__p_wxSysColourChangedEvent,
58965 &_swigt__p_wxTGAHandler,
58966 &_swigt__p_wxTIFFHandler,
58967 &_swigt__p_wxToolTip,
58968 &_swigt__p_wxUpdateUIEvent,
58969 &_swigt__p_wxValidator,
58970 &_swigt__p_wxVisualAttributes,
58971 &_swigt__p_wxWindow,
58972 &_swigt__p_wxWindowCreateEvent,
58973 &_swigt__p_wxWindowDestroyEvent,
58974 &_swigt__p_wxXPMHandler,
58975 &_swigt__p_wxZipFSHandler,
58976 };
58977
58978 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58979 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58980 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58981 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58982 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58983 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58984 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58985 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58986 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58987 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58988 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58989 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58990 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58991 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58992 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}};
58993 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58994 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}};
58995 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58996 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}};
58997 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58998 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58999 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
59000 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
59001 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
59002 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}};
59003 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
59004 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}};
59005 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
59006 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
59007 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
59008 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
59009 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
59010 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59011 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
59012 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
59013 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
59014 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
59015 static swig_cast_info _swigc__p_wxEvent[] = { {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxEvent, 0, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMaximizeEvent, _p_wxMaximizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxIconizeEvent, _p_wxIconizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxActivateEvent, _p_wxActivateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSizeEvent, _p_wxSizeEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDateEvent, _p_wxDateEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMoveEvent, _p_wxMoveEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxEvent, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxEvent, 0, 0},{0, 0, 0, 0}};
59016 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
59017 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
59018 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
59019 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}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
59020 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
59021 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
59022 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}};
59023 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}};
59024 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
59025 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
59026 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
59027 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
59028 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
59029 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
59030 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
59031 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
59032 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}};
59033 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
59034 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}};
59035 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59036 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
59037 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
59038 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_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}, {&_swigt__p_wxTGAHandler, _p_wxTGAHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxImageHandler, 0, 0, 0},{0, 0, 0, 0}};
59039 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
59040 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
59041 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
59042 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
59043 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
59044 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
59045 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59046 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}};
59047 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
59048 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
59049 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
59050 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59051 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59052 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
59053 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
59054 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
59055 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
59056 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
59057 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59058 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
59059 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
59060 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
59061 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
59062 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
59063 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
59064 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_p_wxObject, 0, 0}, {&_swigt__p_wxEventBlocker, _p_wxEventBlockerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizerItem, _p_wxSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxGBSizerItem, _p_wxGBSizerItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollEvent, _p_wxScrollEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIndividualLayoutConstraint, _p_wxIndividualLayoutConstraintTo_p_wxObject, 0, 0}, {&_swigt__p_wxStaticBoxSizer, _p_wxStaticBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBoxSizer, _p_wxBoxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxSizer, _p_wxSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridBagSizer, _p_wxGridBagSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxUpdateUIEvent, _p_wxUpdateUIEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvent, _p_wxEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFlexGridSizer, _p_wxFlexGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGridSizer, _p_wxGridSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxInitDialogEvent, _p_wxInitDialogEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaintEvent, _p_wxPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNcPaintEvent, _p_wxNcPaintEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxClipboardTextEvent, _p_wxClipboardTextEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPaletteChangedEvent, _p_wxPaletteChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDisplayChangedEvent, _p_wxDisplayChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureChangedEvent, _p_wxMouseCaptureChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxSysColourChangedEvent, _p_wxSysColourChangedEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControl, _p_wxControlTo_p_wxObject, 0, 0}, {&_swigt__p_wxSetCursorEvent, _p_wxSetCursorEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFSFile, _p_wxFSFileTo_p_wxObject, 0, 0}, {&_swigt__p_wxPySizer, _p_wxPySizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxNotifyEvent, _p_wxNotifyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyEvent, _p_wxPyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxShowEvent, _p_wxShowEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuItem, _p_wxMenuItemTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowCreateEvent, _p_wxWindowCreateEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxIdleEvent, _p_wxIdleEventTo_p_wxObject, 0, 0}, {&_swigt__p_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_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_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_wxTGAHandler, _p_wxTGAHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_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_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyCommandEvent, _p_wxPyCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxCommandEvent, _p_wxCommandEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxDropFilesEvent, _p_wxDropFilesEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxFocusEvent, _p_wxFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxChildFocusEvent, _p_wxChildFocusEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxObject, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxObject, 0, 0},{0, 0, 0, 0}};
59065 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
59066 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
59067 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
59068 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
59069 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
59070 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59071 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
59072 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
59073 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
59074 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
59075 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
59076 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
59077 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
59078 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
59079 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
59080 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
59081 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
59082 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
59083 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
59084 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
59085 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
59086 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
59087 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
59088 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
59089 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
59090 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
59091 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
59092 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
59093 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
59094 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
59095 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
59096 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59097 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}};
59098 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}};
59099 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
59100 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
59101 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
59102 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59103 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
59104 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
59105 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
59106 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
59107 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}};
59108 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
59109 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}};
59110 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
59111 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
59112 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
59113 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59114
59115 static swig_cast_info *swig_cast_initial[] = {
59116 _swigc__p_buffer,
59117 _swigc__p_char,
59118 _swigc__p_form_ops_t,
59119 _swigc__p_int,
59120 _swigc__p_long,
59121 _swigc__p_unsigned_char,
59122 _swigc__p_unsigned_int,
59123 _swigc__p_unsigned_long,
59124 _swigc__p_wxANIHandler,
59125 _swigc__p_wxAcceleratorEntry,
59126 _swigc__p_wxAcceleratorTable,
59127 _swigc__p_wxActivateEvent,
59128 _swigc__p_wxAppTraits,
59129 _swigc__p_wxArrayString,
59130 _swigc__p_wxBMPHandler,
59131 _swigc__p_wxBitmap,
59132 _swigc__p_wxBoxSizer,
59133 _swigc__p_wxButton,
59134 _swigc__p_wxCURHandler,
59135 _swigc__p_wxCaret,
59136 _swigc__p_wxChildFocusEvent,
59137 _swigc__p_wxClipboardTextEvent,
59138 _swigc__p_wxCloseEvent,
59139 _swigc__p_wxColour,
59140 _swigc__p_wxCommandEvent,
59141 _swigc__p_wxContextMenuEvent,
59142 _swigc__p_wxControl,
59143 _swigc__p_wxControlWithItems,
59144 _swigc__p_wxCursor,
59145 _swigc__p_wxDC,
59146 _swigc__p_wxDateEvent,
59147 _swigc__p_wxDateTime,
59148 _swigc__p_wxDisplayChangedEvent,
59149 _swigc__p_wxDouble,
59150 _swigc__p_wxDropFilesEvent,
59151 _swigc__p_wxDuplexMode,
59152 _swigc__p_wxEraseEvent,
59153 _swigc__p_wxEvent,
59154 _swigc__p_wxEventBlocker,
59155 _swigc__p_wxEventLoop,
59156 _swigc__p_wxEventLoopActivator,
59157 _swigc__p_wxEvtHandler,
59158 _swigc__p_wxFSFile,
59159 _swigc__p_wxFileSystem,
59160 _swigc__p_wxFileSystemHandler,
59161 _swigc__p_wxFlexGridSizer,
59162 _swigc__p_wxFocusEvent,
59163 _swigc__p_wxFont,
59164 _swigc__p_wxFrame,
59165 _swigc__p_wxGBPosition,
59166 _swigc__p_wxGBSizerItem,
59167 _swigc__p_wxGBSpan,
59168 _swigc__p_wxGIFHandler,
59169 _swigc__p_wxGridBagSizer,
59170 _swigc__p_wxGridSizer,
59171 _swigc__p_wxHelpEvent__Origin,
59172 _swigc__p_wxICOHandler,
59173 _swigc__p_wxIconizeEvent,
59174 _swigc__p_wxIdleEvent,
59175 _swigc__p_wxImage,
59176 _swigc__p_wxImageHandler,
59177 _swigc__p_wxImageHistogram,
59178 _swigc__p_wxImage_HSVValue,
59179 _swigc__p_wxImage_RGBValue,
59180 _swigc__p_wxIndividualLayoutConstraint,
59181 _swigc__p_wxInitDialogEvent,
59182 _swigc__p_wxInputStream,
59183 _swigc__p_wxInternetFSHandler,
59184 _swigc__p_wxItemContainer,
59185 _swigc__p_wxJPEGHandler,
59186 _swigc__p_wxKeyEvent,
59187 _swigc__p_wxLayoutConstraints,
59188 _swigc__p_wxMaximizeEvent,
59189 _swigc__p_wxMemoryFSHandler,
59190 _swigc__p_wxMenu,
59191 _swigc__p_wxMenuBar,
59192 _swigc__p_wxMenuBarBase,
59193 _swigc__p_wxMenuEvent,
59194 _swigc__p_wxMenuItem,
59195 _swigc__p_wxMouseCaptureChangedEvent,
59196 _swigc__p_wxMouseCaptureLostEvent,
59197 _swigc__p_wxMouseEvent,
59198 _swigc__p_wxMoveEvent,
59199 _swigc__p_wxNavigationKeyEvent,
59200 _swigc__p_wxNcPaintEvent,
59201 _swigc__p_wxNotifyEvent,
59202 _swigc__p_wxObject,
59203 _swigc__p_wxOutputStream,
59204 _swigc__p_wxPCXHandler,
59205 _swigc__p_wxPNGHandler,
59206 _swigc__p_wxPNMHandler,
59207 _swigc__p_wxPaintEvent,
59208 _swigc__p_wxPaletteChangedEvent,
59209 _swigc__p_wxPaperSize,
59210 _swigc__p_wxPoint,
59211 _swigc__p_wxPoint2D,
59212 _swigc__p_wxPropagateOnce,
59213 _swigc__p_wxPropagationDisabler,
59214 _swigc__p_wxPyApp,
59215 _swigc__p_wxPyCommandEvent,
59216 _swigc__p_wxPyDropTarget,
59217 _swigc__p_wxPyEvent,
59218 _swigc__p_wxPyFileSystemHandler,
59219 _swigc__p_wxPyImageHandler,
59220 _swigc__p_wxPyInputStream,
59221 _swigc__p_wxPySizer,
59222 _swigc__p_wxPyValidator,
59223 _swigc__p_wxQuantize,
59224 _swigc__p_wxQueryNewPaletteEvent,
59225 _swigc__p_wxRealPoint,
59226 _swigc__p_wxRect,
59227 _swigc__p_wxRect2D,
59228 _swigc__p_wxRegion,
59229 _swigc__p_wxScrollEvent,
59230 _swigc__p_wxScrollWinEvent,
59231 _swigc__p_wxSetCursorEvent,
59232 _swigc__p_wxShowEvent,
59233 _swigc__p_wxSize,
59234 _swigc__p_wxSizeEvent,
59235 _swigc__p_wxSizer,
59236 _swigc__p_wxSizerItem,
59237 _swigc__p_wxStaticBox,
59238 _swigc__p_wxStaticBoxSizer,
59239 _swigc__p_wxStdDialogButtonSizer,
59240 _swigc__p_wxSysColourChangedEvent,
59241 _swigc__p_wxTGAHandler,
59242 _swigc__p_wxTIFFHandler,
59243 _swigc__p_wxToolTip,
59244 _swigc__p_wxUpdateUIEvent,
59245 _swigc__p_wxValidator,
59246 _swigc__p_wxVisualAttributes,
59247 _swigc__p_wxWindow,
59248 _swigc__p_wxWindowCreateEvent,
59249 _swigc__p_wxWindowDestroyEvent,
59250 _swigc__p_wxXPMHandler,
59251 _swigc__p_wxZipFSHandler,
59252 };
59253
59254
59255 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59256
59257 static swig_const_info swig_const_table[] = {
59258 {0, 0, 0, 0.0, 0, 0}};
59259
59260 #ifdef __cplusplus
59261 }
59262 #endif
59263 /* -----------------------------------------------------------------------------
59264 * Type initialization:
59265 * This problem is tough by the requirement that no dynamic
59266 * memory is used. Also, since swig_type_info structures store pointers to
59267 * swig_cast_info structures and swig_cast_info structures store pointers back
59268 * to swig_type_info structures, we need some lookup code at initialization.
59269 * The idea is that swig generates all the structures that are needed.
59270 * The runtime then collects these partially filled structures.
59271 * The SWIG_InitializeModule function takes these initial arrays out of
59272 * swig_module, and does all the lookup, filling in the swig_module.types
59273 * array with the correct data and linking the correct swig_cast_info
59274 * structures together.
59275 *
59276 * The generated swig_type_info structures are assigned staticly to an initial
59277 * array. We just loop though that array, and handle each type individually.
59278 * First we lookup if this type has been already loaded, and if so, use the
59279 * loaded structure instead of the generated one. Then we have to fill in the
59280 * cast linked list. The cast data is initially stored in something like a
59281 * two-dimensional array. Each row corresponds to a type (there are the same
59282 * number of rows as there are in the swig_type_initial array). Each entry in
59283 * a column is one of the swig_cast_info structures for that type.
59284 * The cast_initial array is actually an array of arrays, because each row has
59285 * a variable number of columns. So to actually build the cast linked list,
59286 * we find the array of casts associated with the type, and loop through it
59287 * adding the casts to the list. The one last trick we need to do is making
59288 * sure the type pointer in the swig_cast_info struct is correct.
59289 *
59290 * First off, we lookup the cast->type name to see if it is already loaded.
59291 * There are three cases to handle:
59292 * 1) If the cast->type has already been loaded AND the type we are adding
59293 * casting info to has not been loaded (it is in this module), THEN we
59294 * replace the cast->type pointer with the type pointer that has already
59295 * been loaded.
59296 * 2) If BOTH types (the one we are adding casting info to, and the
59297 * cast->type) are loaded, THEN the cast info has already been loaded by
59298 * the previous module so we just ignore it.
59299 * 3) Finally, if cast->type has not already been loaded, then we add that
59300 * swig_cast_info to the linked list (because the cast->type) pointer will
59301 * be correct.
59302 * ----------------------------------------------------------------------------- */
59303
59304 #ifdef __cplusplus
59305 extern "C" {
59306 #if 0
59307 } /* c-mode */
59308 #endif
59309 #endif
59310
59311 #if 0
59312 #define SWIGRUNTIME_DEBUG
59313 #endif
59314
59315 SWIGRUNTIME void
59316 SWIG_InitializeModule(void *clientdata) {
59317 size_t i;
59318 swig_module_info *module_head;
59319 static int init_run = 0;
59320
59321 clientdata = clientdata;
59322
59323 if (init_run) return;
59324 init_run = 1;
59325
59326 /* Initialize the swig_module */
59327 swig_module.type_initial = swig_type_initial;
59328 swig_module.cast_initial = swig_cast_initial;
59329
59330 /* Try and load any already created modules */
59331 module_head = SWIG_GetModule(clientdata);
59332 if (module_head) {
59333 swig_module.next = module_head->next;
59334 module_head->next = &swig_module;
59335 } else {
59336 /* This is the first module loaded */
59337 swig_module.next = &swig_module;
59338 SWIG_SetModule(clientdata, &swig_module);
59339 }
59340
59341 /* Now work on filling in swig_module.types */
59342 #ifdef SWIGRUNTIME_DEBUG
59343 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59344 #endif
59345 for (i = 0; i < swig_module.size; ++i) {
59346 swig_type_info *type = 0;
59347 swig_type_info *ret;
59348 swig_cast_info *cast;
59349
59350 #ifdef SWIGRUNTIME_DEBUG
59351 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59352 #endif
59353
59354 /* if there is another module already loaded */
59355 if (swig_module.next != &swig_module) {
59356 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59357 }
59358 if (type) {
59359 /* Overwrite clientdata field */
59360 #ifdef SWIGRUNTIME_DEBUG
59361 printf("SWIG_InitializeModule: found type %s\n", type->name);
59362 #endif
59363 if (swig_module.type_initial[i]->clientdata) {
59364 type->clientdata = swig_module.type_initial[i]->clientdata;
59365 #ifdef SWIGRUNTIME_DEBUG
59366 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59367 #endif
59368 }
59369 } else {
59370 type = swig_module.type_initial[i];
59371 }
59372
59373 /* Insert casting types */
59374 cast = swig_module.cast_initial[i];
59375 while (cast->type) {
59376 /* Don't need to add information already in the list */
59377 ret = 0;
59378 #ifdef SWIGRUNTIME_DEBUG
59379 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59380 #endif
59381 if (swig_module.next != &swig_module) {
59382 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59383 #ifdef SWIGRUNTIME_DEBUG
59384 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59385 #endif
59386 }
59387 if (ret) {
59388 if (type == swig_module.type_initial[i]) {
59389 #ifdef SWIGRUNTIME_DEBUG
59390 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59391 #endif
59392 cast->type = ret;
59393 ret = 0;
59394 } else {
59395 /* Check for casting already in the list */
59396 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59397 #ifdef SWIGRUNTIME_DEBUG
59398 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59399 #endif
59400 if (!ocast) ret = 0;
59401 }
59402 }
59403
59404 if (!ret) {
59405 #ifdef SWIGRUNTIME_DEBUG
59406 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59407 #endif
59408 if (type->cast) {
59409 type->cast->prev = cast;
59410 cast->next = type->cast;
59411 }
59412 type->cast = cast;
59413 }
59414 cast++;
59415 }
59416 /* Set entry in modules->types array equal to the type */
59417 swig_module.types[i] = type;
59418 }
59419 swig_module.types[i] = 0;
59420
59421 #ifdef SWIGRUNTIME_DEBUG
59422 printf("**** SWIG_InitializeModule: Cast List ******\n");
59423 for (i = 0; i < swig_module.size; ++i) {
59424 int j = 0;
59425 swig_cast_info *cast = swig_module.cast_initial[i];
59426 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59427 while (cast->type) {
59428 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59429 cast++;
59430 ++j;
59431 }
59432 printf("---- Total casts: %d\n",j);
59433 }
59434 printf("**** SWIG_InitializeModule: Cast List ******\n");
59435 #endif
59436 }
59437
59438 /* This function will propagate the clientdata field of type to
59439 * any new swig_type_info structures that have been added into the list
59440 * of equivalent types. It is like calling
59441 * SWIG_TypeClientData(type, clientdata) a second time.
59442 */
59443 SWIGRUNTIME void
59444 SWIG_PropagateClientData(void) {
59445 size_t i;
59446 swig_cast_info *equiv;
59447 static int init_run = 0;
59448
59449 if (init_run) return;
59450 init_run = 1;
59451
59452 for (i = 0; i < swig_module.size; i++) {
59453 if (swig_module.types[i]->clientdata) {
59454 equiv = swig_module.types[i]->cast;
59455 while (equiv) {
59456 if (!equiv->converter) {
59457 if (equiv->type && !equiv->type->clientdata)
59458 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59459 }
59460 equiv = equiv->next;
59461 }
59462 }
59463 }
59464 }
59465
59466 #ifdef __cplusplus
59467 #if 0
59468 {
59469 /* c-mode */
59470 #endif
59471 }
59472 #endif
59473
59474
59475
59476 #ifdef __cplusplus
59477 extern "C" {
59478 #endif
59479
59480 /* Python-specific SWIG API */
59481 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59482 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59483 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59484
59485 /* -----------------------------------------------------------------------------
59486 * global variable support code.
59487 * ----------------------------------------------------------------------------- */
59488
59489 typedef struct swig_globalvar {
59490 char *name; /* Name of global variable */
59491 PyObject *(*get_attr)(void); /* Return the current value */
59492 int (*set_attr)(PyObject *); /* Set the value */
59493 struct swig_globalvar *next;
59494 } swig_globalvar;
59495
59496 typedef struct swig_varlinkobject {
59497 PyObject_HEAD
59498 swig_globalvar *vars;
59499 } swig_varlinkobject;
59500
59501 SWIGINTERN PyObject *
59502 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59503 return PyString_FromString("<Swig global variables>");
59504 }
59505
59506 SWIGINTERN PyObject *
59507 swig_varlink_str(swig_varlinkobject *v) {
59508 PyObject *str = PyString_FromString("(");
59509 swig_globalvar *var;
59510 for (var = v->vars; var; var=var->next) {
59511 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59512 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59513 }
59514 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59515 return str;
59516 }
59517
59518 SWIGINTERN int
59519 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59520 PyObject *str = swig_varlink_str(v);
59521 fprintf(fp,"Swig global variables ");
59522 fprintf(fp,"%s\n", PyString_AsString(str));
59523 Py_DECREF(str);
59524 return 0;
59525 }
59526
59527 SWIGINTERN void
59528 swig_varlink_dealloc(swig_varlinkobject *v) {
59529 swig_globalvar *var = v->vars;
59530 while (var) {
59531 swig_globalvar *n = var->next;
59532 free(var->name);
59533 free(var);
59534 var = n;
59535 }
59536 }
59537
59538 SWIGINTERN PyObject *
59539 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59540 PyObject *res = NULL;
59541 swig_globalvar *var = v->vars;
59542 while (var) {
59543 if (strcmp(var->name,n) == 0) {
59544 res = (*var->get_attr)();
59545 break;
59546 }
59547 var = var->next;
59548 }
59549 if (res == NULL && !PyErr_Occurred()) {
59550 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59551 }
59552 return res;
59553 }
59554
59555 SWIGINTERN int
59556 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59557 int res = 1;
59558 swig_globalvar *var = v->vars;
59559 while (var) {
59560 if (strcmp(var->name,n) == 0) {
59561 res = (*var->set_attr)(p);
59562 break;
59563 }
59564 var = var->next;
59565 }
59566 if (res == 1 && !PyErr_Occurred()) {
59567 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59568 }
59569 return res;
59570 }
59571
59572 SWIGINTERN PyTypeObject*
59573 swig_varlink_type(void) {
59574 static char varlink__doc__[] = "Swig var link object";
59575 static PyTypeObject varlink_type;
59576 static int type_init = 0;
59577 if (!type_init) {
59578 const PyTypeObject tmp
59579 = {
59580 PyObject_HEAD_INIT(NULL)
59581 0, /* Number of items in variable part (ob_size) */
59582 (char *)"swigvarlink", /* Type name (tp_name) */
59583 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59584 0, /* Itemsize (tp_itemsize) */
59585 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59586 (printfunc) swig_varlink_print, /* Print (tp_print) */
59587 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59588 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59589 0, /* tp_compare */
59590 (reprfunc) swig_varlink_repr, /* tp_repr */
59591 0, /* tp_as_number */
59592 0, /* tp_as_sequence */
59593 0, /* tp_as_mapping */
59594 0, /* tp_hash */
59595 0, /* tp_call */
59596 (reprfunc)swig_varlink_str, /* tp_str */
59597 0, /* tp_getattro */
59598 0, /* tp_setattro */
59599 0, /* tp_as_buffer */
59600 0, /* tp_flags */
59601 varlink__doc__, /* tp_doc */
59602 0, /* tp_traverse */
59603 0, /* tp_clear */
59604 0, /* tp_richcompare */
59605 0, /* tp_weaklistoffset */
59606 #if PY_VERSION_HEX >= 0x02020000
59607 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59608 #endif
59609 #if PY_VERSION_HEX >= 0x02030000
59610 0, /* tp_del */
59611 #endif
59612 #ifdef COUNT_ALLOCS
59613 0,0,0,0 /* tp_alloc -> tp_next */
59614 #endif
59615 };
59616 varlink_type = tmp;
59617 varlink_type.ob_type = &PyType_Type;
59618 type_init = 1;
59619 }
59620 return &varlink_type;
59621 }
59622
59623 /* Create a variable linking object for use later */
59624 SWIGINTERN PyObject *
59625 SWIG_Python_newvarlink(void) {
59626 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59627 if (result) {
59628 result->vars = 0;
59629 }
59630 return ((PyObject*) result);
59631 }
59632
59633 SWIGINTERN void
59634 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59635 swig_varlinkobject *v = (swig_varlinkobject *) p;
59636 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59637 if (gv) {
59638 size_t size = strlen(name)+1;
59639 gv->name = (char *)malloc(size);
59640 if (gv->name) {
59641 strncpy(gv->name,name,size);
59642 gv->get_attr = get_attr;
59643 gv->set_attr = set_attr;
59644 gv->next = v->vars;
59645 }
59646 }
59647 v->vars = gv;
59648 }
59649
59650 SWIGINTERN PyObject *
59651 SWIG_globals() {
59652 static PyObject *_SWIG_globals = 0;
59653 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59654 return _SWIG_globals;
59655 }
59656
59657 /* -----------------------------------------------------------------------------
59658 * constants/methods manipulation
59659 * ----------------------------------------------------------------------------- */
59660
59661 /* Install Constants */
59662 SWIGINTERN void
59663 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59664 PyObject *obj = 0;
59665 size_t i;
59666 for (i = 0; constants[i].type; ++i) {
59667 switch(constants[i].type) {
59668 case SWIG_PY_POINTER:
59669 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59670 break;
59671 case SWIG_PY_BINARY:
59672 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59673 break;
59674 default:
59675 obj = 0;
59676 break;
59677 }
59678 if (obj) {
59679 PyDict_SetItemString(d, constants[i].name, obj);
59680 Py_DECREF(obj);
59681 }
59682 }
59683 }
59684
59685 /* -----------------------------------------------------------------------------*/
59686 /* Fix SwigMethods to carry the callback ptrs when needed */
59687 /* -----------------------------------------------------------------------------*/
59688
59689 SWIGINTERN void
59690 SWIG_Python_FixMethods(PyMethodDef *methods,
59691 swig_const_info *const_table,
59692 swig_type_info **types,
59693 swig_type_info **types_initial) {
59694 size_t i;
59695 for (i = 0; methods[i].ml_name; ++i) {
59696 const char *c = methods[i].ml_doc;
59697 if (c && (c = strstr(c, "swig_ptr: "))) {
59698 int j;
59699 swig_const_info *ci = 0;
59700 const char *name = c + 10;
59701 for (j = 0; const_table[j].type; ++j) {
59702 if (strncmp(const_table[j].name, name,
59703 strlen(const_table[j].name)) == 0) {
59704 ci = &(const_table[j]);
59705 break;
59706 }
59707 }
59708 if (ci) {
59709 size_t shift = (ci->ptype) - types;
59710 swig_type_info *ty = types_initial[shift];
59711 size_t ldoc = (c - methods[i].ml_doc);
59712 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59713 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59714 if (ndoc) {
59715 char *buff = ndoc;
59716 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59717 if (ptr) {
59718 strncpy(buff, methods[i].ml_doc, ldoc);
59719 buff += ldoc;
59720 strncpy(buff, "swig_ptr: ", 10);
59721 buff += 10;
59722 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59723 methods[i].ml_doc = ndoc;
59724 }
59725 }
59726 }
59727 }
59728 }
59729 }
59730
59731 #ifdef __cplusplus
59732 }
59733 #endif
59734
59735 /* -----------------------------------------------------------------------------*
59736 * Partial Init method
59737 * -----------------------------------------------------------------------------*/
59738
59739 #ifdef __cplusplus
59740 extern "C"
59741 #endif
59742 SWIGEXPORT void SWIG_init(void) {
59743 PyObject *m, *d;
59744
59745 /* Fix SwigMethods to carry the callback ptrs when needed */
59746 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59747
59748 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59749 d = PyModule_GetDict(m);
59750
59751 SWIG_InitializeModule(0);
59752 SWIG_InstallConstants(d,swig_const_table);
59753
59754
59755
59756 #ifndef wxPyUSE_EXPORT
59757 // Make our API structure a CObject so other modules can import it
59758 // from this module.
59759 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59760 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59761 Py_XDECREF(cobj);
59762 #endif
59763
59764 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59765 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59766 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59767 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59768 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59769 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59770 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59771 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59772 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59773 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59774 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59775 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59776 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59777 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59778 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59779 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59780 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59781 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59782 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59783 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59784 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59785 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59786 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59787 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59788 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59789 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59790 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59791 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59792 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59793 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59794 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59795 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59796 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59797 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59798 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59799 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59800 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59801 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59802 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59803 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59804 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59805 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59806 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59807 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59808 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59809 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59810 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59811 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59812 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59813 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59814 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59815 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59816 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59817 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59818 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59819 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59820 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59821 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59822 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59823 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59824 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59825 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59826 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59827 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59828 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59829 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59830 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59831 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59832 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59833 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59834 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59835 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59836 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59837 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59838 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59839 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59840 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59841 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59842 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59843 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59844 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59845 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59846 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59847 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59848 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59849 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59850 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59851 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59852 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59853 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59854 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59855 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59856 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59857 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59858 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59859 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59860 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59861 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59862 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59863 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59864 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59865 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59866 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59867 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59868 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59869 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59870 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59871 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59872 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59873 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59874 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59875 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59876 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59877 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59878 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59879 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59880 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59881 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59882 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59883 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59884 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59885 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59886 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59887 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59888 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59889 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59890 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59891 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59892 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59893 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59894 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59895 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59896 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59897 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59898 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59899 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59900 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59901 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59902 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59903 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59904 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59905 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59906 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59907 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59908 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59909 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59910 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59911 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59912 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59913 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59914 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59915 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59916 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59917 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59918 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59919 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59920 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59921 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59922 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59923 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59924 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59925 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59926 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59927 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59928 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59929 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59930 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59931 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59932 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59933 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59934 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59935 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59936 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59937 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59938 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59939 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59940 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59941 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59942 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59943 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59944 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59945 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59946 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59947 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59948 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59949 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59950 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59951 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59952 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59953 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59954 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59955 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59956 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59957 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59958 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59959 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59960 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59961 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59962 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59963 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59964 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59965 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59966 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59967 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59968 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59969 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59970 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59971 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59972 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59973 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59974 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59975 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59976 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59977 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59978 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59979 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59980 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59981 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59982 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59983 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59984 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59985 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59986 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59987 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59988 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59989 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59990 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59991 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59992 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59993 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59994 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59995 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59996 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59997 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59998 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59999 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
60000 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
60001 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
60002 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
60003 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
60004 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
60005 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
60006 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
60007 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
60008 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
60009 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
60010 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
60011 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
60012 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
60013 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
60014 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
60015 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
60016 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
60017 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
60018 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
60019 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
60020 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
60021 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
60022 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
60023 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
60024 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
60025 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
60026 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
60027 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
60028 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
60029 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
60030 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
60031 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
60032 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
60033 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
60034 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
60035 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
60036 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
60037 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
60038 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
60039 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
60040 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
60041 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
60042 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
60043 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
60044 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
60045 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
60046 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
60047 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
60048 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
60049 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
60050 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
60051 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
60052 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
60053 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
60054 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
60055 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
60056 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
60057 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
60058 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
60059 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
60060 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
60061 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
60062 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
60063 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
60064 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
60065 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
60066 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
60067 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
60068 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
60069 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
60070 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
60071 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
60072 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
60073 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
60074 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
60075 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
60076 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
60077 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
60078 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
60079 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
60080 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
60081 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
60082 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
60083 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
60084 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
60085 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
60086 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
60087 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
60088 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
60089 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
60090 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
60091 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
60092 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
60093 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
60094 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
60095 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
60096 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
60097 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
60098 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
60099 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
60100 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
60101 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
60102 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
60103 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
60104 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
60105 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
60106 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
60107 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
60108 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
60109 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
60110 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
60111 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
60112 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
60113 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
60114 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
60115 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
60116 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
60117 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
60118 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
60119 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
60120 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
60121 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
60122 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
60123 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
60124 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
60125 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
60126 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
60127 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
60128 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
60129 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
60130 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
60131 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
60132 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
60133 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
60134 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
60135 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
60136 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
60137 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
60138 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
60139 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
60140 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
60141 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
60142 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
60143 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
60144 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
60145 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
60146 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
60147 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
60148 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
60149 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
60150 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
60151 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
60152 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
60153 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
60154 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
60155 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
60156 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
60157 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
60158 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
60159 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
60160 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
60161 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
60162 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
60163 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
60164 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
60165 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
60166 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
60167 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
60168 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
60169 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
60170 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
60171 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
60172 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
60173 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
60174 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
60175 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
60176 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
60177 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
60178 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
60179 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
60180 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
60181 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
60182 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
60183 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
60184 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
60185 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
60186 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60187 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60188 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60189 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60190 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60191 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60192 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60193 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60194 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60195 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60196 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60197 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60198 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60199 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60200 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60201 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60202 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60203 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60204 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60205 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60206 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60207 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60208 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60209 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60210 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60211 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60212 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60213 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60214 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60215 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60216 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60217 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60218 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60219 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60220 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60221 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60222 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60223 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60224 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60225 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60226 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60227 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60228 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60229 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60230 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60231 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60232 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60233 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60234 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60235 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60236 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60237 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60238 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60239 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60240 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60241 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60242 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60243 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60244 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60245 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60246 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60247 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60248 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60249 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60250 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60251 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60252 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60253 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60254 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60255 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60256 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60257 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60258 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60259 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60260 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60261 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60262 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60263 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60264 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60265 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60266 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60267 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60268 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60269 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60270 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60271 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60272 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60273 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60274 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60275 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60276 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60277 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60278 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60279 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60280 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60281 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60282 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60283 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60284 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60285 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60286 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60287 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60288 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60289 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60290 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60291 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60292 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60293 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60294 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60295 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60296 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60297 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60298 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60299 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60300 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60301 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60302 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60303 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60304 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60305 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60306 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60307 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60308 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60309 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60310 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60311 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60312 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60313 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60314 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60315 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60316 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60317 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60318 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60319 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60320 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60321 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60322 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60323 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60324 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60325 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60326 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60327 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60328 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60329 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60330 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60331 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60332 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60333 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60334 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60335 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60336 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60337 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60338 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60339 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60340 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60341 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60342 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60343 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60344 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60345 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60346 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60347 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60348 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60349 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60350 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60351 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60352 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60353 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60354 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60355 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60356 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60357 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60358 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60359 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60360 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60361 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60362 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60363 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60364 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60365 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60366 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60367 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60368 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60369 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60370 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60371 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60372 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60373 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60374 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60375 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60376 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60377 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60378 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60379 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60380 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60381 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60382 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60383 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60384 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60385 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60386 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60387 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60388 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60389 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60390 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60391 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60392 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60393 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60394 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60395 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60396 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60397 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60398 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60399 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60400 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60401 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60402 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60403 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60404 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60405 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60406 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60407 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60408 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60409 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60410 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60411 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60412 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60413 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60414 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60415 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60416 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60417 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60418 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60419 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60420 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60421 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60422 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60423 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60424 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60425 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60426 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60427 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60428 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60429
60430 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60431
60432
60433 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60434
60435 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60436 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60437 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60438 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60439 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60440 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60441 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60442 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60443 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60444 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60445 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60446 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60447 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60448 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60449 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60450 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60451 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60452 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60453 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60454 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60455 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60456 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60457 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60458 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60459 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60460 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60461 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60462 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60463 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60464 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60465 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60466 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60467 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60468 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60469 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60470 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60471 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60472 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60473 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60474 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
60475 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60476 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60477 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60478 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60479 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60480 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60481 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60482 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60483 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60484 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60485 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60486 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60487 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60488 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60489 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60490 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60491 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60492 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60493 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60494 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60495 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60496 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60497 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60498 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60499 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60500 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60501 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60502 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60503 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60504 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60505 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60506 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60507 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60508 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60509 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60510 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60511 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60512 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60513 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60514 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60515 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60516 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60517 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60518 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60519 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60520 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60521 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60522 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60523 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60524 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60525 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60526 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60527 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60528 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60529 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60530 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60531 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60532 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60533 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60534 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60535 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60536 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60537 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60538 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60539 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60540 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60541 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60542 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60543 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60544 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60545 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60546 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60547 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60548 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60549 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60550 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60551 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60552 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60553 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60554 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60555 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60556 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60557 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60558 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60559 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60560 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60561 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60562 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60563 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60564 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60565 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60566 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60567 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60568 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60569 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60570 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60571 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60572 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60573 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60574 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60575 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60576 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60577 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60578 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60579 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60580 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60581 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60582 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60583 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60584 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60585 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60586 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60587 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60588 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60589 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60590 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60591 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60592 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60593 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60594 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60595 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60596 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60597 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60598 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60599 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60600 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60601 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60602 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60603 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60604 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60605 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60606 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60607 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60608 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60609 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60610 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60611 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60612 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60613 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60614 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60615 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60616 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60617 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60618 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60619 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60620 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60621 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60622 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60623 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60624 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60625 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60626 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60627 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60628 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60629 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60630 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60631 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60632 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60633 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60634 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60635 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60636 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60637 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60638 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60639 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60640 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60641 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60642 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60643 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60644 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60645 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60646 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60647 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60648 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60649 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60650
60651 // Initialize threading, some globals and such
60652 __wxPyPreStart(d);
60653
60654
60655 // Although these are defined in __version__ they need to be here too so
60656 // that an assert can be done to ensure that the wxPython and the wxWindows
60657 // versions match.
60658 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60659 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60660 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60661
60662 }
60663
wxWidgets (Impactor)