]> git.saurik.com Git - wxWidgets.git/blob - wxPython/src/mac/_core_wrap.cpp
projects / wxWidgets.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
reSWIGged
[wxWidgets.git] / wxPython / src / mac / _core_wrap.cpp
1 /* ----------------------------------------------------------------------------
2 * This file was automatically generated by SWIG (http://www.swig.org).
3 * Version 1.3.29
4 *
5 * This file is not intended to be easily readable and contains a number of
6 * coding conventions designed to improve portability and efficiency. Do not make
7 * changes to this file unless you know what you are doing--modify the SWIG
8 * interface file instead.
9 * ----------------------------------------------------------------------------- */
10
11 #define SWIGPYTHON
12 #define SWIG_PYTHON_DIRECTOR_NO_VTABLE
13
14 #ifdef __cplusplus
15 template<class T> class SwigValueWrapper {
16 T *tt;
17 public:
18 SwigValueWrapper() : tt(0) { }
19 SwigValueWrapper(const SwigValueWrapper<T>& rhs) : tt(new T(*rhs.tt)) { }
20 SwigValueWrapper(const T& t) : tt(new T(t)) { }
21 ~SwigValueWrapper() { delete tt; }
22 SwigValueWrapper& operator=(const T& t) { delete tt; tt = new T(t); return *this; }
23 operator T&() const { return *tt; }
24 T *operator&() { return tt; }
25 private:
26 SwigValueWrapper& operator=(const SwigValueWrapper<T>& rhs);
27 };
28 #endif
29
30 /* -----------------------------------------------------------------------------
31 * This section contains generic SWIG labels for method/variable
32 * declarations/attributes, and other compiler dependent labels.
33 * ----------------------------------------------------------------------------- */
34
35 /* template workaround for compilers that cannot correctly implement the C++ standard */
36 #ifndef SWIGTEMPLATEDISAMBIGUATOR
37 # if defined(__SUNPRO_CC)
38 # if (__SUNPRO_CC <= 0x560)
39 # define SWIGTEMPLATEDISAMBIGUATOR template
40 # else
41 # define SWIGTEMPLATEDISAMBIGUATOR
42 # endif
43 # else
44 # define SWIGTEMPLATEDISAMBIGUATOR
45 # endif
46 #endif
47
48 /* inline attribute */
49 #ifndef SWIGINLINE
50 # if defined(__cplusplus) || (defined(__GNUC__) && !defined(__STRICT_ANSI__))
51 # define SWIGINLINE inline
52 # else
53 # define SWIGINLINE
54 # endif
55 #endif
56
57 /* attribute recognised by some compilers to avoid 'unused' warnings */
58 #ifndef SWIGUNUSED
59 # if defined(__GNUC__)
60 # if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
61 # define SWIGUNUSED __attribute__ ((__unused__))
62 # else
63 # define SWIGUNUSED
64 # endif
65 # elif defined(__ICC)
66 # define SWIGUNUSED __attribute__ ((__unused__))
67 # else
68 # define SWIGUNUSED
69 # endif
70 #endif
71
72 #ifndef SWIGUNUSEDPARM
73 # ifdef __cplusplus
74 # define SWIGUNUSEDPARM(p)
75 # else
76 # define SWIGUNUSEDPARM(p) p SWIGUNUSED
77 # endif
78 #endif
79
80 /* internal SWIG method */
81 #ifndef SWIGINTERN
82 # define SWIGINTERN static SWIGUNUSED
83 #endif
84
85 /* internal inline SWIG method */
86 #ifndef SWIGINTERNINLINE
87 # define SWIGINTERNINLINE SWIGINTERN SWIGINLINE
88 #endif
89
90 /* exporting methods */
91 #if (__GNUC__ >= 4) || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)
92 # ifndef GCC_HASCLASSVISIBILITY
93 # define GCC_HASCLASSVISIBILITY
94 # endif
95 #endif
96
97 #ifndef SWIGEXPORT
98 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
99 # if defined(STATIC_LINKED)
100 # define SWIGEXPORT
101 # else
102 # define SWIGEXPORT __declspec(dllexport)
103 # endif
104 # else
105 # if defined(__GNUC__) && defined(GCC_HASCLASSVISIBILITY)
106 # define SWIGEXPORT __attribute__ ((visibility("default")))
107 # else
108 # define SWIGEXPORT
109 # endif
110 # endif
111 #endif
112
113 /* calling conventions for Windows */
114 #ifndef SWIGSTDCALL
115 # if defined(_WIN32) || defined(__WIN32__) || defined(__CYGWIN__)
116 # define SWIGSTDCALL __stdcall
117 # else
118 # define SWIGSTDCALL
119 # endif
120 #endif
121
122 /* Deal with Microsoft's attempt at deprecating C standard runtime functions */
123 #if !defined(SWIG_NO_CRT_SECURE_NO_DEPRECATE) && defined(_MSC_VER)
124 # define _CRT_SECURE_NO_DEPRECATE
125 #endif
126
127
128 /* Python.h has to appear first */
129 #include <Python.h>
130
131 /* -----------------------------------------------------------------------------
132 * swigrun.swg
133 *
134 * This file contains generic CAPI SWIG runtime support for pointer
135 * type checking.
136 * ----------------------------------------------------------------------------- */
137
138 /* This should only be incremented when either the layout of swig_type_info changes,
139 or for whatever reason, the runtime changes incompatibly */
140 #define SWIG_RUNTIME_VERSION "2"
141
142 /* define SWIG_TYPE_TABLE_NAME as "SWIG_TYPE_TABLE" */
143 #ifdef SWIG_TYPE_TABLE
144 # define SWIG_QUOTE_STRING(x) #x
145 # define SWIG_EXPAND_AND_QUOTE_STRING(x) SWIG_QUOTE_STRING(x)
146 # define SWIG_TYPE_TABLE_NAME SWIG_EXPAND_AND_QUOTE_STRING(SWIG_TYPE_TABLE)
147 #else
148 # define SWIG_TYPE_TABLE_NAME
149 #endif
150
151 /*
152 You can use the SWIGRUNTIME and SWIGRUNTIMEINLINE macros for
153 creating a static or dynamic library from the swig runtime code.
154 In 99.9% of the cases, swig just needs to declare them as 'static'.
155
156 But only do this if is strictly necessary, ie, if you have problems
157 with your compiler or so.
158 */
159
160 #ifndef SWIGRUNTIME
161 # define SWIGRUNTIME SWIGINTERN
162 #endif
163
164 #ifndef SWIGRUNTIMEINLINE
165 # define SWIGRUNTIMEINLINE SWIGRUNTIME SWIGINLINE
166 #endif
167
168 /* Generic buffer size */
169 #ifndef SWIG_BUFFER_SIZE
170 # define SWIG_BUFFER_SIZE 1024
171 #endif
172
173 /* Flags for pointer conversions */
174 #define SWIG_POINTER_DISOWN 0x1
175
176 /* Flags for new pointer objects */
177 #define SWIG_POINTER_OWN 0x1
178
179
180 /*
181 Flags/methods for returning states.
182
183 The swig conversion methods, as ConvertPtr, return and integer
184 that tells if the conversion was successful or not. And if not,
185 an error code can be returned (see swigerrors.swg for the codes).
186
187 Use the following macros/flags to set or process the returning
188 states.
189
190 In old swig versions, you usually write code as:
191
192 if (SWIG_ConvertPtr(obj,vptr,ty.flags) != -1) {
193 // success code
194 } else {
195 //fail code
196 }
197
198 Now you can be more explicit as:
199
200 int res = SWIG_ConvertPtr(obj,vptr,ty.flags);
201 if (SWIG_IsOK(res)) {
202 // success code
203 } else {
204 // fail code
205 }
206
207 that seems to be the same, but now you can also do
208
209 Type *ptr;
210 int res = SWIG_ConvertPtr(obj,(void **)(&ptr),ty.flags);
211 if (SWIG_IsOK(res)) {
212 // success code
213 if (SWIG_IsNewObj(res) {
214 ...
215 delete *ptr;
216 } else {
217 ...
218 }
219 } else {
220 // fail code
221 }
222
223 I.e., now SWIG_ConvertPtr can return new objects and you can
224 identify the case and take care of the deallocation. Of course that
225 requires also to SWIG_ConvertPtr to return new result values, as
226
227 int SWIG_ConvertPtr(obj, ptr,...) {
228 if (<obj is ok>) {
229 if (<need new object>) {
230 *ptr = <ptr to new allocated object>;
231 return SWIG_NEWOBJ;
232 } else {
233 *ptr = <ptr to old object>;
234 return SWIG_OLDOBJ;
235 }
236 } else {
237 return SWIG_BADOBJ;
238 }
239 }
240
241 Of course, returning the plain '0(success)/-1(fail)' still works, but you can be
242 more explicit by returning SWIG_BADOBJ, SWIG_ERROR or any of the
243 swig errors code.
244
245 Finally, if the SWIG_CASTRANK_MODE is enabled, the result code
246 allows to return the 'cast rank', for example, if you have this
247
248 int food(double)
249 int fooi(int);
250
251 and you call
252
253 food(1) // cast rank '1' (1 -> 1.0)
254 fooi(1) // cast rank '0'
255
256 just use the SWIG_AddCast()/SWIG_CheckState()
257
258
259 */
260 #define SWIG_OK (0)
261 #define SWIG_ERROR (-1)
262 #define SWIG_IsOK(r) (r >= 0)
263 #define SWIG_ArgError(r) ((r != SWIG_ERROR) ? r : SWIG_TypeError)
264
265 /* The CastRankLimit says how many bits are used for the cast rank */
266 #define SWIG_CASTRANKLIMIT (1 << 8)
267 /* The NewMask denotes the object was created (using new/malloc) */
268 #define SWIG_NEWOBJMASK (SWIG_CASTRANKLIMIT << 1)
269 /* The TmpMask is for in/out typemaps that use temporal objects */
270 #define SWIG_TMPOBJMASK (SWIG_NEWOBJMASK << 1)
271 /* Simple returning values */
272 #define SWIG_BADOBJ (SWIG_ERROR)
273 #define SWIG_OLDOBJ (SWIG_OK)
274 #define SWIG_NEWOBJ (SWIG_OK | SWIG_NEWOBJMASK)
275 #define SWIG_TMPOBJ (SWIG_OK | SWIG_TMPOBJMASK)
276 /* Check, add and del mask methods */
277 #define SWIG_AddNewMask(r) (SWIG_IsOK(r) ? (r | SWIG_NEWOBJMASK) : r)
278 #define SWIG_DelNewMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_NEWOBJMASK) : r)
279 #define SWIG_IsNewObj(r) (SWIG_IsOK(r) && (r & SWIG_NEWOBJMASK))
280 #define SWIG_AddTmpMask(r) (SWIG_IsOK(r) ? (r | SWIG_TMPOBJMASK) : r)
281 #define SWIG_DelTmpMask(r) (SWIG_IsOK(r) ? (r & ~SWIG_TMPOBJMASK) : r)
282 #define SWIG_IsTmpObj(r) (SWIG_IsOK(r) && (r & SWIG_TMPOBJMASK))
283
284
285 /* Cast-Rank Mode */
286 #if defined(SWIG_CASTRANK_MODE)
287 # ifndef SWIG_TypeRank
288 # define SWIG_TypeRank unsigned long
289 # endif
290 # ifndef SWIG_MAXCASTRANK /* Default cast allowed */
291 # define SWIG_MAXCASTRANK (2)
292 # endif
293 # define SWIG_CASTRANKMASK ((SWIG_CASTRANKLIMIT) -1)
294 # define SWIG_CastRank(r) (r & SWIG_CASTRANKMASK)
295 SWIGINTERNINLINE int SWIG_AddCast(int r) {
296 return SWIG_IsOK(r) ? ((SWIG_CastRank(r) < SWIG_MAXCASTRANK) ? (r + 1) : SWIG_ERROR) : r;
297 }
298 SWIGINTERNINLINE int SWIG_CheckState(int r) {
299 return SWIG_IsOK(r) ? SWIG_CastRank(r) + 1 : 0;
300 }
301 #else /* no cast-rank mode */
302 # define SWIG_AddCast
303 # define SWIG_CheckState(r) (SWIG_IsOK(r) ? 1 : 0)
304 #endif
305
306
307
308
309 #include <string.h>
310
311 #ifdef __cplusplus
312 extern "C" {
313 #endif
314
315 typedef void *(*swig_converter_func)(void *);
316 typedef struct swig_type_info *(*swig_dycast_func)(void **);
317
318 /* Structure to store inforomation on one type */
319 typedef struct swig_type_info {
320 const char *name; /* mangled name of this type */
321 const char *str; /* human readable name of this type */
322 swig_dycast_func dcast; /* dynamic cast function down a hierarchy */
323 struct swig_cast_info *cast; /* linked list of types that can cast into this type */
324 void *clientdata; /* language specific type data */
325 int owndata; /* flag if the structure owns the clientdata */
326 } swig_type_info;
327
328 /* Structure to store a type and conversion function used for casting */
329 typedef struct swig_cast_info {
330 swig_type_info *type; /* pointer to type that is equivalent to this type */
331 swig_converter_func converter; /* function to cast the void pointers */
332 struct swig_cast_info *next; /* pointer to next cast in linked list */
333 struct swig_cast_info *prev; /* pointer to the previous cast */
334 } swig_cast_info;
335
336 /* Structure used to store module information
337 * Each module generates one structure like this, and the runtime collects
338 * all of these structures and stores them in a circularly linked list.*/
339 typedef struct swig_module_info {
340 swig_type_info **types; /* Array of pointers to swig_type_info structures that are in this module */
341 size_t size; /* Number of types in this module */
342 struct swig_module_info *next; /* Pointer to next element in circularly linked list */
343 swig_type_info **type_initial; /* Array of initially generated type structures */
344 swig_cast_info **cast_initial; /* Array of initially generated casting structures */
345 void *clientdata; /* Language specific module data */
346 } swig_module_info;
347
348 /*
349 Compare two type names skipping the space characters, therefore
350 "char*" == "char *" and "Class<int>" == "Class<int >", etc.
351
352 Return 0 when the two name types are equivalent, as in
353 strncmp, but skipping ' '.
354 */
355 SWIGRUNTIME int
356 SWIG_TypeNameComp(const char *f1, const char *l1,
357 const char *f2, const char *l2) {
358 for (;(f1 != l1) && (f2 != l2); ++f1, ++f2) {
359 while ((*f1 == ' ') && (f1 != l1)) ++f1;
360 while ((*f2 == ' ') && (f2 != l2)) ++f2;
361 if (*f1 != *f2) return (*f1 > *f2) ? 1 : -1;
362 }
363 return (l1 - f1) - (l2 - f2);
364 }
365
366 /*
367 Check type equivalence in a name list like <name1>|<name2>|...
368 Return 0 if not equal, 1 if equal
369 */
370 SWIGRUNTIME int
371 SWIG_TypeEquiv(const char *nb, const char *tb) {
372 int equiv = 0;
373 const char* te = tb + strlen(tb);
374 const char* ne = nb;
375 while (!equiv && *ne) {
376 for (nb = ne; *ne; ++ne) {
377 if (*ne == '|') break;
378 }
379 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
380 if (*ne) ++ne;
381 }
382 return equiv;
383 }
384
385 /*
386 Check type equivalence in a name list like <name1>|<name2>|...
387 Return 0 if equal, -1 if nb < tb, 1 if nb > tb
388 */
389 SWIGRUNTIME int
390 SWIG_TypeCompare(const char *nb, const char *tb) {
391 int equiv = 0;
392 const char* te = tb + strlen(tb);
393 const char* ne = nb;
394 while (!equiv && *ne) {
395 for (nb = ne; *ne; ++ne) {
396 if (*ne == '|') break;
397 }
398 equiv = (SWIG_TypeNameComp(nb, ne, tb, te) == 0) ? 1 : 0;
399 if (*ne) ++ne;
400 }
401 return equiv;
402 }
403
404
405 /* think of this as a c++ template<> or a scheme macro */
406 #define SWIG_TypeCheck_Template(comparison, ty) \
407 if (ty) { \
408 swig_cast_info *iter = ty->cast; \
409 while (iter) { \
410 if (comparison) { \
411 if (iter == ty->cast) return iter; \
412 /* Move iter to the top of the linked list */ \
413 iter->prev->next = iter->next; \
414 if (iter->next) \
415 iter->next->prev = iter->prev; \
416 iter->next = ty->cast; \
417 iter->prev = 0; \
418 if (ty->cast) ty->cast->prev = iter; \
419 ty->cast = iter; \
420 return iter; \
421 } \
422 iter = iter->next; \
423 } \
424 } \
425 return 0
426
427 /*
428 Check the typename
429 */
430 SWIGRUNTIME swig_cast_info *
431 SWIG_TypeCheck(const char *c, swig_type_info *ty) {
432 SWIG_TypeCheck_Template(strcmp(iter->type->name, c) == 0, ty);
433 }
434
435 /* Same as previous function, except strcmp is replaced with a pointer comparison */
436 SWIGRUNTIME swig_cast_info *
437 SWIG_TypeCheckStruct(swig_type_info *from, swig_type_info *into) {
438 SWIG_TypeCheck_Template(iter->type == from, into);
439 }
440
441 /*
442 Cast a pointer up an inheritance hierarchy
443 */
444 SWIGRUNTIMEINLINE void *
445 SWIG_TypeCast(swig_cast_info *ty, void *ptr) {
446 return ((!ty) || (!ty->converter)) ? ptr : (*ty->converter)(ptr);
447 }
448
449 /*
450 Dynamic pointer casting. Down an inheritance hierarchy
451 */
452 SWIGRUNTIME swig_type_info *
453 SWIG_TypeDynamicCast(swig_type_info *ty, void **ptr) {
454 swig_type_info *lastty = ty;
455 if (!ty || !ty->dcast) return ty;
456 while (ty && (ty->dcast)) {
457 ty = (*ty->dcast)(ptr);
458 if (ty) lastty = ty;
459 }
460 return lastty;
461 }
462
463 /*
464 Return the name associated with this type
465 */
466 SWIGRUNTIMEINLINE const char *
467 SWIG_TypeName(const swig_type_info *ty) {
468 return ty->name;
469 }
470
471 /*
472 Return the pretty name associated with this type,
473 that is an unmangled type name in a form presentable to the user.
474 */
475 SWIGRUNTIME const char *
476 SWIG_TypePrettyName(const swig_type_info *type) {
477 /* The "str" field contains the equivalent pretty names of the
478 type, separated by vertical-bar characters. We choose
479 to print the last name, as it is often (?) the most
480 specific. */
481 if (!type) return NULL;
482 if (type->str != NULL) {
483 const char *last_name = type->str;
484 const char *s;
485 for (s = type->str; *s; s++)
486 if (*s == '|') last_name = s+1;
487 return last_name;
488 }
489 else
490 return type->name;
491 }
492
493 /*
494 Set the clientdata field for a type
495 */
496 SWIGRUNTIME void
497 SWIG_TypeClientData(swig_type_info *ti, void *clientdata) {
498 swig_cast_info *cast = ti->cast;
499 /* if (ti->clientdata == clientdata) return; */
500 ti->clientdata = clientdata;
501
502 while (cast) {
503 if (!cast->converter) {
504 swig_type_info *tc = cast->type;
505 if (!tc->clientdata) {
506 SWIG_TypeClientData(tc, clientdata);
507 }
508 }
509 cast = cast->next;
510 }
511 }
512 SWIGRUNTIME void
513 SWIG_TypeNewClientData(swig_type_info *ti, void *clientdata) {
514 SWIG_TypeClientData(ti, clientdata);
515 ti->owndata = 1;
516 }
517
518 /*
519 Search for a swig_type_info structure only by mangled name
520 Search is a O(log #types)
521
522 We start searching at module start, and finish searching when start == end.
523 Note: if start == end at the beginning of the function, we go all the way around
524 the circular list.
525 */
526 SWIGRUNTIME swig_type_info *
527 SWIG_MangledTypeQueryModule(swig_module_info *start,
528 swig_module_info *end,
529 const char *name) {
530 swig_module_info *iter = start;
531 do {
532 if (iter->size) {
533 register size_t l = 0;
534 register size_t r = iter->size - 1;
535 do {
536 /* since l+r >= 0, we can (>> 1) instead (/ 2) */
537 register size_t i = (l + r) >> 1;
538 const char *iname = iter->types[i]->name;
539 if (iname) {
540 register int compare = strcmp(name, iname);
541 if (compare == 0) {
542 return iter->types[i];
543 } else if (compare < 0) {
544 if (i) {
545 r = i - 1;
546 } else {
547 break;
548 }
549 } else if (compare > 0) {
550 l = i + 1;
551 }
552 } else {
553 break; /* should never happen */
554 }
555 } while (l <= r);
556 }
557 iter = iter->next;
558 } while (iter != end);
559 return 0;
560 }
561
562 /*
563 Search for a swig_type_info structure for either a mangled name or a human readable name.
564 It first searches the mangled names of the types, which is a O(log #types)
565 If a type is not found it then searches the human readable names, which is O(#types).
566
567 We start searching at module start, and finish searching when start == end.
568 Note: if start == end at the beginning of the function, we go all the way around
569 the circular list.
570 */
571 SWIGRUNTIME swig_type_info *
572 SWIG_TypeQueryModule(swig_module_info *start,
573 swig_module_info *end,
574 const char *name) {
575 /* STEP 1: Search the name field using binary search */
576 swig_type_info *ret = SWIG_MangledTypeQueryModule(start, end, name);
577 if (ret) {
578 return ret;
579 } else {
580 /* STEP 2: If the type hasn't been found, do a complete search
581 of the str field (the human readable name) */
582 swig_module_info *iter = start;
583 do {
584 register size_t i = 0;
585 for (; i < iter->size; ++i) {
586 if (iter->types[i]->str && (SWIG_TypeEquiv(iter->types[i]->str, name)))
587 return iter->types[i];
588 }
589 iter = iter->next;
590 } while (iter != end);
591 }
592
593 /* neither found a match */
594 return 0;
595 }
596
597 /*
598 Pack binary data into a string
599 */
600 SWIGRUNTIME char *
601 SWIG_PackData(char *c, void *ptr, size_t sz) {
602 static const char hex[17] = "0123456789abcdef";
603 register const unsigned char *u = (unsigned char *) ptr;
604 register const unsigned char *eu = u + sz;
605 for (; u != eu; ++u) {
606 register unsigned char uu = *u;
607 *(c++) = hex[(uu & 0xf0) >> 4];
608 *(c++) = hex[uu & 0xf];
609 }
610 return c;
611 }
612
613 /*
614 Unpack binary data from a string
615 */
616 SWIGRUNTIME const char *
617 SWIG_UnpackData(const char *c, void *ptr, size_t sz) {
618 register unsigned char *u = (unsigned char *) ptr;
619 register const unsigned char *eu = u + sz;
620 for (; u != eu; ++u) {
621 register char d = *(c++);
622 register unsigned char uu;
623 if ((d >= '0') && (d <= '9'))
624 uu = ((d - '0') << 4);
625 else if ((d >= 'a') && (d <= 'f'))
626 uu = ((d - ('a'-10)) << 4);
627 else
628 return (char *) 0;
629 d = *(c++);
630 if ((d >= '0') && (d <= '9'))
631 uu |= (d - '0');
632 else if ((d >= 'a') && (d <= 'f'))
633 uu |= (d - ('a'-10));
634 else
635 return (char *) 0;
636 *u = uu;
637 }
638 return c;
639 }
640
641 /*
642 Pack 'void *' into a string buffer.
643 */
644 SWIGRUNTIME char *
645 SWIG_PackVoidPtr(char *buff, void *ptr, const char *name, size_t bsz) {
646 char *r = buff;
647 if ((2*sizeof(void *) + 2) > bsz) return 0;
648 *(r++) = '_';
649 r = SWIG_PackData(r,&ptr,sizeof(void *));
650 if (strlen(name) + 1 > (bsz - (r - buff))) return 0;
651 strcpy(r,name);
652 return buff;
653 }
654
655 SWIGRUNTIME const char *
656 SWIG_UnpackVoidPtr(const char *c, void **ptr, const char *name) {
657 if (*c != '_') {
658 if (strcmp(c,"NULL") == 0) {
659 *ptr = (void *) 0;
660 return name;
661 } else {
662 return 0;
663 }
664 }
665 return SWIG_UnpackData(++c,ptr,sizeof(void *));
666 }
667
668 SWIGRUNTIME char *
669 SWIG_PackDataName(char *buff, void *ptr, size_t sz, const char *name, size_t bsz) {
670 char *r = buff;
671 size_t lname = (name ? strlen(name) : 0);
672 if ((2*sz + 2 + lname) > bsz) return 0;
673 *(r++) = '_';
674 r = SWIG_PackData(r,ptr,sz);
675 if (lname) {
676 strncpy(r,name,lname+1);
677 } else {
678 *r = 0;
679 }
680 return buff;
681 }
682
683 SWIGRUNTIME const char *
684 SWIG_UnpackDataName(const char *c, void *ptr, size_t sz, const char *name) {
685 if (*c != '_') {
686 if (strcmp(c,"NULL") == 0) {
687 memset(ptr,0,sz);
688 return name;
689 } else {
690 return 0;
691 }
692 }
693 return SWIG_UnpackData(++c,ptr,sz);
694 }
695
696 #ifdef __cplusplus
697 }
698 #endif
699
700 /* Errors in SWIG */
701 #define SWIG_UnknownError -1
702 #define SWIG_IOError -2
703 #define SWIG_RuntimeError -3
704 #define SWIG_IndexError -4
705 #define SWIG_TypeError -5
706 #define SWIG_DivisionByZero -6
707 #define SWIG_OverflowError -7
708 #define SWIG_SyntaxError -8
709 #define SWIG_ValueError -9
710 #define SWIG_SystemError -10
711 #define SWIG_AttributeError -11
712 #define SWIG_MemoryError -12
713 #define SWIG_NullReferenceError -13
714
715
716
717 /* Python.h has to appear first */
718 #include <Python.h>
719
720 /* Add PyOS_snprintf for old Pythons */
721 #if PY_VERSION_HEX < 0x02020000
722 # if defined(_MSC_VER) || defined(__BORLANDC__) || defined(_WATCOM)
723 # define PyOS_snprintf _snprintf
724 # else
725 # define PyOS_snprintf snprintf
726 # endif
727 #endif
728
729 /* A crude PyString_FromFormat implementation for old Pythons */
730 #if PY_VERSION_HEX < 0x02020000
731
732 #ifndef SWIG_PYBUFFER_SIZE
733 # define SWIG_PYBUFFER_SIZE 1024
734 #endif
735
736 static PyObject *
737 PyString_FromFormat(const char *fmt, ...) {
738 va_list ap;
739 char buf[SWIG_PYBUFFER_SIZE * 2];
740 int res;
741 va_start(ap, fmt);
742 res = vsnprintf(buf, sizeof(buf), fmt, ap);
743 va_end(ap);
744 return (res < 0 || res >= (int)sizeof(buf)) ? 0 : PyString_FromString(buf);
745 }
746 #endif
747
748 /* Add PyObject_Del for old Pythons */
749 #if PY_VERSION_HEX < 0x01060000
750 # define PyObject_Del(op) PyMem_DEL((op))
751 #endif
752 #ifndef PyObject_DEL
753 # define PyObject_DEL PyObject_Del
754 #endif
755
756 /* A crude PyExc_StopIteration exception for old Pythons */
757 #if PY_VERSION_HEX < 0x02020000
758 # ifndef PyExc_StopIteration
759 # define PyExc_StopIteration PyExc_RuntimeError
760 # endif
761 # ifndef PyObject_GenericGetAttr
762 # define PyObject_GenericGetAttr 0
763 # endif
764 #endif
765 /* Py_NotImplemented is defined in 2.1 and up. */
766 #if PY_VERSION_HEX < 0x02010000
767 # ifndef Py_NotImplemented
768 # define Py_NotImplemented PyExc_RuntimeError
769 # endif
770 #endif
771
772
773 /* A crude PyString_AsStringAndSize implementation for old Pythons */
774 #if PY_VERSION_HEX < 0x02010000
775 # ifndef PyString_AsStringAndSize
776 # define PyString_AsStringAndSize(obj, s, len) {*s = PyString_AsString(obj); *len = *s ? strlen(*s) : 0;}
777 # endif
778 #endif
779
780 /* PySequence_Size for old Pythons */
781 #if PY_VERSION_HEX < 0x02000000
782 # ifndef PySequence_Size
783 # define PySequence_Size PySequence_Length
784 # endif
785 #endif
786
787
788 /* PyBool_FromLong for old Pythons */
789 #if PY_VERSION_HEX < 0x02030000
790 static
791 PyObject *PyBool_FromLong(long ok)
792 {
793 PyObject *result = ok ? Py_True : Py_False;
794 Py_INCREF(result);
795 return result;
796 }
797 #endif
798
799
800 /* -----------------------------------------------------------------------------
801 * error manipulation
802 * ----------------------------------------------------------------------------- */
803
804 SWIGRUNTIME PyObject*
805 SWIG_Python_ErrorType(int code) {
806 PyObject* type = 0;
807 switch(code) {
808 case SWIG_MemoryError:
809 type = PyExc_MemoryError;
810 break;
811 case SWIG_IOError:
812 type = PyExc_IOError;
813 break;
814 case SWIG_RuntimeError:
815 type = PyExc_RuntimeError;
816 break;
817 case SWIG_IndexError:
818 type = PyExc_IndexError;
819 break;
820 case SWIG_TypeError:
821 type = PyExc_TypeError;
822 break;
823 case SWIG_DivisionByZero:
824 type = PyExc_ZeroDivisionError;
825 break;
826 case SWIG_OverflowError:
827 type = PyExc_OverflowError;
828 break;
829 case SWIG_SyntaxError:
830 type = PyExc_SyntaxError;
831 break;
832 case SWIG_ValueError:
833 type = PyExc_ValueError;
834 break;
835 case SWIG_SystemError:
836 type = PyExc_SystemError;
837 break;
838 case SWIG_AttributeError:
839 type = PyExc_AttributeError;
840 break;
841 default:
842 type = PyExc_RuntimeError;
843 }
844 return type;
845 }
846
847
848 SWIGRUNTIME void
849 SWIG_Python_AddErrorMsg(const char* mesg)
850 {
851 PyObject *type = 0;
852 PyObject *value = 0;
853 PyObject *traceback = 0;
854
855 if (PyErr_Occurred()) PyErr_Fetch(&type, &value, &traceback);
856 if (value) {
857 PyObject *old_str = PyObject_Str(value);
858 PyErr_Clear();
859 Py_XINCREF(type);
860 PyErr_Format(type, "%s %s", PyString_AsString(old_str), mesg);
861 Py_DECREF(old_str);
862 Py_DECREF(value);
863 } else {
864 PyErr_Format(PyExc_RuntimeError, mesg);
865 }
866 }
867
868
869
870 #if defined(SWIG_PYTHON_NO_THREADS)
871 # if defined(SWIG_PYTHON_THREADS)
872 # undef SWIG_PYTHON_THREADS
873 # endif
874 #endif
875 #if defined(SWIG_PYTHON_THREADS) /* Threading support is enabled */
876 # if !defined(SWIG_PYTHON_USE_GIL) && !defined(SWIG_PYTHON_NO_USE_GIL)
877 # if (PY_VERSION_HEX >= 0x02030000) /* For 2.3 or later, use the PyGILState calls */
878 # define SWIG_PYTHON_USE_GIL
879 # endif
880 # endif
881 # if defined(SWIG_PYTHON_USE_GIL) /* Use PyGILState threads calls */
882 # ifndef SWIG_PYTHON_INITIALIZE_THREADS
883 # define SWIG_PYTHON_INITIALIZE_THREADS PyEval_InitThreads()
884 # endif
885 # ifdef __cplusplus /* C++ code */
886 class SWIG_Python_Thread_Block {
887 bool status;
888 PyGILState_STATE state;
889 public:
890 void end() { if (status) { PyGILState_Release(state); status = false;} }
891 SWIG_Python_Thread_Block() : status(true), state(PyGILState_Ensure()) {}
892 ~SWIG_Python_Thread_Block() { end(); }
893 };
894 class SWIG_Python_Thread_Allow {
895 bool status;
896 PyThreadState *save;
897 public:
898 void end() { if (status) { PyEval_RestoreThread(save); status = false; }}
899 SWIG_Python_Thread_Allow() : status(true), save(PyEval_SaveThread()) {}
900 ~SWIG_Python_Thread_Allow() { end(); }
901 };
902 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK SWIG_Python_Thread_Block _swig_thread_block
903 # define SWIG_PYTHON_THREAD_END_BLOCK _swig_thread_block.end()
904 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW SWIG_Python_Thread_Allow _swig_thread_allow
905 # define SWIG_PYTHON_THREAD_END_ALLOW _swig_thread_allow.end()
906 # else /* C code */
907 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK PyGILState_STATE _swig_thread_block = PyGILState_Ensure()
908 # define SWIG_PYTHON_THREAD_END_BLOCK PyGILState_Release(_swig_thread_block)
909 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW PyThreadState *_swig_thread_allow = PyEval_SaveThread()
910 # define SWIG_PYTHON_THREAD_END_ALLOW PyEval_RestoreThread(_swig_thread_allow)
911 # endif
912 # else /* Old thread way, not implemented, user must provide it */
913 # if !defined(SWIG_PYTHON_INITIALIZE_THREADS)
914 # define SWIG_PYTHON_INITIALIZE_THREADS
915 # endif
916 # if !defined(SWIG_PYTHON_THREAD_BEGIN_BLOCK)
917 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
918 # endif
919 # if !defined(SWIG_PYTHON_THREAD_END_BLOCK)
920 # define SWIG_PYTHON_THREAD_END_BLOCK
921 # endif
922 # if !defined(SWIG_PYTHON_THREAD_BEGIN_ALLOW)
923 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
924 # endif
925 # if !defined(SWIG_PYTHON_THREAD_END_ALLOW)
926 # define SWIG_PYTHON_THREAD_END_ALLOW
927 # endif
928 # endif
929 #else /* No thread support */
930 # define SWIG_PYTHON_INITIALIZE_THREADS
931 # define SWIG_PYTHON_THREAD_BEGIN_BLOCK
932 # define SWIG_PYTHON_THREAD_END_BLOCK
933 # define SWIG_PYTHON_THREAD_BEGIN_ALLOW
934 # define SWIG_PYTHON_THREAD_END_ALLOW
935 #endif
936
937 /* -----------------------------------------------------------------------------
938 * Python API portion that goes into the runtime
939 * ----------------------------------------------------------------------------- */
940
941 #ifdef __cplusplus
942 extern "C" {
943 #if 0
944 } /* cc-mode */
945 #endif
946 #endif
947
948 /* -----------------------------------------------------------------------------
949 * Constant declarations
950 * ----------------------------------------------------------------------------- */
951
952 /* Constant Types */
953 #define SWIG_PY_POINTER 4
954 #define SWIG_PY_BINARY 5
955
956 /* Constant information structure */
957 typedef struct swig_const_info {
958 int type;
959 char *name;
960 long lvalue;
961 double dvalue;
962 void *pvalue;
963 swig_type_info **ptype;
964 } swig_const_info;
965
966 #ifdef __cplusplus
967 #if 0
968 { /* cc-mode */
969 #endif
970 }
971 #endif
972
973
974 /* -----------------------------------------------------------------------------
975 * See the LICENSE file for information on copyright, usage and redistribution
976 * of SWIG, and the README file for authors - http://www.swig.org/release.html.
977 *
978 * pyrun.swg
979 *
980 * This file contains the runtime support for Python modules
981 * and includes code for managing global variables and pointer
982 * type checking.
983 *
984 * ----------------------------------------------------------------------------- */
985
986 /* Common SWIG API */
987
988 #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 int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3835 SWIGINTERN bool wxPyApp_IsDisplayAvailable(){
3836 return wxPyTestDisplayAvailable();
3837 }
3838
3839 void wxApp_CleanUp() {
3840 __wxPyCleanup();
3841 }
3842
3843
3844 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3845
3846
3847
3848
3849
3850 SWIGINTERNINLINE PyObject *
3851 SWIG_FromCharPtr(const char *cptr)
3852 {
3853 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3854 }
3855
3856
3857 #if 0 // #ifdef __WXMAC__
3858
3859 // A dummy class that raises an exception if used...
3860 class wxEventLoop
3861 {
3862 public:
3863 wxEventLoop() { wxPyRaiseNotImplemented(); }
3864 int Run() { return 0; }
3865 void Exit(int rc = 0) {}
3866 bool Pending() const { return false; }
3867 bool Dispatch() { return false; }
3868 bool IsRunning() const { return false; }
3869 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3870 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3871 };
3872
3873 #else
3874
3875 #include <wx/evtloop.h>
3876
3877 #endif
3878
3879
3880
3881 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3882 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3883 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3884 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3885 wxWindowList& list = self->GetChildren();
3886 return wxPy_ConvertList(&list);
3887 }
3888 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3889 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3890 #if wxUSE_HOTKEY
3891 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3892 #else
3893 return false;
3894 #endif
3895 }
3896 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3897
3898
3899
3900 return false;
3901
3902 }
3903 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3904 return wxPyGetWinHandle(self);
3905 }
3906 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3907 self->AssociateHandle((WXWidget)handle);
3908 }
3909 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3910
3911 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3912 return wxWindow::FindWindowById(id, parent);
3913 }
3914
3915 wxWindow* wxFindWindowByName( const wxString& name,
3916 const wxWindow *parent = NULL ) {
3917 return wxWindow::FindWindowByName(name, parent);
3918 }
3919
3920 wxWindow* wxFindWindowByLabel( const wxString& label,
3921 const wxWindow *parent = NULL ) {
3922 return wxWindow::FindWindowByLabel(label, parent);
3923 }
3924
3925
3926 #ifdef __WXMSW__
3927 #include <wx/msw/private.h> // to get wxGetWindowId
3928 #endif
3929
3930
3931 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3932 #ifdef __WXMSW__
3933 WXHWND hWnd = (WXHWND)_hWnd;
3934 long id = wxGetWindowId(hWnd);
3935 wxWindow* win = new wxWindow;
3936 if (parent)
3937 parent->AddChild(win);
3938 win->SetEventHandler(win);
3939 win->SetHWND(hWnd);
3940 win->SetId(id);
3941 win->SubclassWin(hWnd);
3942 win->AdoptAttributesFromHWND();
3943 win->SetupColours();
3944 return win;
3945 #else
3946 wxPyRaiseNotImplemented();
3947 return NULL;
3948 #endif
3949 }
3950
3951
3952 PyObject* GetTopLevelWindows() {
3953 return wxPy_ConvertList(&wxTopLevelWindows);
3954 }
3955
3956
3957 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3958 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3959 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3960
3961 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3962
3963
3964 SWIGINTERNINLINE int
3965 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3966 {
3967 unsigned long v;
3968 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3969 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3970 return res;
3971 }
3972
3973 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3974 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3975 wxMenuItemList& list = self->GetMenuItems();
3976 return wxPy_ConvertList(&list);
3977 }
3978 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3979 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3980 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3981 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3982 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3983 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3984 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3985 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3986 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3987 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3988 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3989 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3990 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3991 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3992 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3993 static const wxString wxPyControlNameStr(wxControlNameStr);
3994 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3995 if (clientData) {
3996 wxPyClientData* data = new wxPyClientData(clientData);
3997 return self->Append(item, data);
3998 } else
3999 return self->Append(item);
4000 }
4001 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,int pos,PyObject *clientData=NULL){
4002 if (clientData) {
4003 wxPyClientData* data = new wxPyClientData(clientData);
4004 return self->Insert(item, pos, data);
4005 } else
4006 return self->Insert(item, pos);
4007 }
4008 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,int n){
4009 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
4010 if (data) {
4011 Py_INCREF(data->m_obj);
4012 return data->m_obj;
4013 } else {
4014 Py_INCREF(Py_None);
4015 return Py_None;
4016 }
4017 }
4018 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,int n,PyObject *clientData){
4019 wxPyClientData* data = new wxPyClientData(clientData);
4020 self->SetClientObject(n, data);
4021 }
4022
4023
4024 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
4025 wxPyUserData* data = NULL;
4026 if ( userData ) {
4027 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4028 data = new wxPyUserData(userData);
4029 wxPyEndBlockThreads(blocked);
4030 }
4031 return new wxSizerItem(window, proportion, flag, border, data);
4032 }
4033 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
4034 wxPyUserData* data = NULL;
4035 if ( userData ) {
4036 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4037 data = new wxPyUserData(userData);
4038 wxPyEndBlockThreads(blocked);
4039 }
4040 return new wxSizerItem(width, height, proportion, flag, border, data);
4041 }
4042 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
4043 wxPyUserData* data = NULL;
4044 if ( userData ) {
4045 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4046 data = new wxPyUserData(userData);
4047 wxPyEndBlockThreads(blocked);
4048 }
4049 return new wxSizerItem(sizer, proportion, flag, border, data);
4050 }
4051
4052 SWIGINTERNINLINE PyObject *
4053 SWIG_From_float (float value)
4054 {
4055 return SWIG_From_double (value);
4056 }
4057
4058 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
4059 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
4060 if (data) {
4061 Py_INCREF(data->m_obj);
4062 return data->m_obj;
4063 } else {
4064 Py_INCREF(Py_None);
4065 return Py_None;
4066 }
4067 }
4068 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4069 wxPyUserData* data = NULL;
4070 if ( userData ) {
4071 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4072 data = new wxPyUserData(userData);
4073 wxPyEndBlockThreads(blocked);
4074 }
4075 self->SetUserData(data);
4076 }
4077
4078 // Figure out the type of the sizer item
4079
4080 struct wxPySizerItemInfo {
4081 wxPySizerItemInfo()
4082 : window(NULL), sizer(NULL), gotSize(false),
4083 size(wxDefaultSize), gotPos(false), pos(-1)
4084 {}
4085
4086 wxWindow* window;
4087 wxSizer* sizer;
4088 bool gotSize;
4089 wxSize size;
4090 bool gotPos;
4091 int pos;
4092 };
4093
4094 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4095
4096 wxPySizerItemInfo info;
4097 wxSize size;
4098 wxSize* sizePtr = &size;
4099
4100 // Find out what the type of the item is
4101 // try wxWindow
4102 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4103 PyErr_Clear();
4104 info.window = NULL;
4105
4106 // try wxSizer
4107 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4108 PyErr_Clear();
4109 info.sizer = NULL;
4110
4111 // try wxSize or (w,h)
4112 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4113 info.size = *sizePtr;
4114 info.gotSize = true;
4115 }
4116
4117 // or a single int
4118 if (checkIdx && PyInt_Check(item)) {
4119 info.pos = PyInt_AsLong(item);
4120 info.gotPos = true;
4121 }
4122 }
4123 }
4124
4125 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4126 // no expected type, figure out what kind of error message to generate
4127 if ( !checkSize && !checkIdx )
4128 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4129 else if ( checkSize && !checkIdx )
4130 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4131 else if ( !checkSize && checkIdx)
4132 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4133 else
4134 // can this one happen?
4135 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4136 }
4137
4138 return info;
4139 }
4140
4141 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4142 if (!self->GetClientObject())
4143 self->SetClientObject(new wxPyOORClientData(_self));
4144 }
4145 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4146
4147 wxPyUserData* data = NULL;
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4150 if ( userData && (info.window || info.sizer || info.gotSize) )
4151 data = new wxPyUserData(userData);
4152 if ( info.sizer )
4153 PyObject_SetAttrString(item,"thisown",Py_False);
4154 wxPyEndBlockThreads(blocked);
4155
4156 // Now call the real Add method if a valid item type was found
4157 if ( info.window )
4158 return self->Add(info.window, proportion, flag, border, data);
4159 else if ( info.sizer )
4160 return self->Add(info.sizer, proportion, flag, border, data);
4161 else if (info.gotSize)
4162 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4163 proportion, flag, border, data);
4164 else
4165 return NULL;
4166 }
4167 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4168
4169 wxPyUserData* data = NULL;
4170 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4171 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4172 if ( userData && (info.window || info.sizer || info.gotSize) )
4173 data = new wxPyUserData(userData);
4174 if ( info.sizer )
4175 PyObject_SetAttrString(item,"thisown",Py_False);
4176 wxPyEndBlockThreads(blocked);
4177
4178 // Now call the real Insert method if a valid item type was found
4179 if ( info.window )
4180 return self->Insert(before, info.window, proportion, flag, border, data);
4181 else if ( info.sizer )
4182 return self->Insert(before, info.sizer, proportion, flag, border, data);
4183 else if (info.gotSize)
4184 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4185 proportion, flag, border, data);
4186 else
4187 return NULL;
4188 }
4189 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4190
4191 wxPyUserData* data = NULL;
4192 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4193 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4194 if ( userData && (info.window || info.sizer || info.gotSize) )
4195 data = new wxPyUserData(userData);
4196 if ( info.sizer )
4197 PyObject_SetAttrString(item,"thisown",Py_False);
4198 wxPyEndBlockThreads(blocked);
4199
4200 // Now call the real Prepend method if a valid item type was found
4201 if ( info.window )
4202 return self->Prepend(info.window, proportion, flag, border, data);
4203 else if ( info.sizer )
4204 return self->Prepend(info.sizer, proportion, flag, border, data);
4205 else if (info.gotSize)
4206 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4207 proportion, flag, border, data);
4208 else
4209 return NULL;
4210 }
4211 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4212 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4213 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4214 wxPyEndBlockThreads(blocked);
4215 if ( info.window )
4216 return self->Remove(info.window);
4217 else if ( info.sizer )
4218 return self->Remove(info.sizer);
4219 else if ( info.gotPos )
4220 return self->Remove(info.pos);
4221 else
4222 return false;
4223 }
4224 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4225 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4226 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4227 wxPyEndBlockThreads(blocked);
4228 if ( info.window )
4229 return self->Detach(info.window);
4230 else if ( info.sizer )
4231 return self->Detach(info.sizer);
4232 else if ( info.gotPos )
4233 return self->Detach(info.pos);
4234 else
4235 return false;
4236 }
4237 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4238 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4239 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4240 wxPyEndBlockThreads(blocked);
4241 if ( info.window )
4242 return self->GetItem(info.window);
4243 else if ( info.sizer )
4244 return self->GetItem(info.sizer);
4245 else if ( info.gotPos )
4246 return self->GetItem(info.pos);
4247 else
4248 return NULL;
4249 }
4250 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4251 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4252 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4253 wxPyEndBlockThreads(blocked);
4254 if ( info.window )
4255 self->SetItemMinSize(info.window, size);
4256 else if ( info.sizer )
4257 self->SetItemMinSize(info.sizer, size);
4258 else if ( info.gotPos )
4259 self->SetItemMinSize(info.pos, size);
4260 }
4261 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4262 wxSizerItemList& list = self->GetChildren();
4263 return wxPy_ConvertList(&list);
4264 }
4265 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4266 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4267 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4268 wxPyEndBlockThreads(blocked);
4269 if ( info.window )
4270 return self->Show(info.window, show, recursive);
4271 else if ( info.sizer )
4272 return self->Show(info.sizer, show, recursive);
4273 else if ( info.gotPos )
4274 return self->Show(info.pos, show);
4275 else
4276 return false;
4277 }
4278 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4279 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4280 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4281 wxPyEndBlockThreads(blocked);
4282 if ( info.window )
4283 return self->IsShown(info.window);
4284 else if ( info.sizer )
4285 return self->IsShown(info.sizer);
4286 else if ( info.gotPos )
4287 return self->IsShown(info.pos);
4288 else
4289 return false;
4290 }
4291
4292 // See pyclasses.h
4293 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4294 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4295 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4296
4297
4298
4299
4300 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4301 {
4302 if (source == Py_None) {
4303 **obj = wxGBPosition(-1,-1);
4304 return true;
4305 }
4306 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4307 }
4308
4309 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4310 {
4311 if (source == Py_None) {
4312 **obj = wxGBSpan(-1,-1);
4313 return true;
4314 }
4315 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4316 }
4317
4318
4319 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4320 wxGBPosition temp, *obj = &temp;
4321 if ( other == Py_None ) return false;
4322 if ( ! wxGBPosition_helper(other, &obj) ) {
4323 PyErr_Clear();
4324 return false;
4325 }
4326 return self->operator==(*obj);
4327 }
4328 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4329 wxGBPosition temp, *obj = &temp;
4330 if ( other == Py_None ) return true;
4331 if ( ! wxGBPosition_helper(other, &obj)) {
4332 PyErr_Clear();
4333 return true;
4334 }
4335 return self->operator!=(*obj);
4336 }
4337 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4338 self->SetRow(row);
4339 self->SetCol(col);
4340 }
4341 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4342 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4343 PyObject* tup = PyTuple_New(2);
4344 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4345 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4346 wxPyEndBlockThreads(blocked);
4347 return tup;
4348 }
4349 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4350 wxGBSpan temp, *obj = &temp;
4351 if ( other == Py_None ) return false;
4352 if ( ! wxGBSpan_helper(other, &obj) ) {
4353 PyErr_Clear();
4354 return false;
4355 }
4356 return self->operator==(*obj);
4357 }
4358 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4359 wxGBSpan temp, *obj = &temp;
4360 if ( other == Py_None ) return true;
4361 if ( ! wxGBSpan_helper(other, &obj)) {
4362 PyErr_Clear();
4363 return true;
4364 }
4365 return self->operator!=(*obj);
4366 }
4367 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4368 self->SetRowspan(rowspan);
4369 self->SetColspan(colspan);
4370 }
4371 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4372 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4373 PyObject* tup = PyTuple_New(2);
4374 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4375 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4376 wxPyEndBlockThreads(blocked);
4377 return tup;
4378 }
4379 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4380 wxPyUserData* data = NULL;
4381 if ( userData ) {
4382 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4383 data = new wxPyUserData(userData);
4384 wxPyEndBlockThreads(blocked);
4385 }
4386 return new wxGBSizerItem(window, pos, span, flag, border, data);
4387 }
4388 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4389 wxPyUserData* data = NULL;
4390 if ( userData ) {
4391 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4392 data = new wxPyUserData(userData);
4393 wxPyEndBlockThreads(blocked);
4394 }
4395 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4396 }
4397 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4398 wxPyUserData* data = NULL;
4399 if ( userData ) {
4400 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4401 data = new wxPyUserData(userData);
4402 wxPyEndBlockThreads(blocked);
4403 }
4404 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4405 }
4406 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4407 int row, col;
4408 self->GetEndPos(row, col);
4409 return wxGBPosition(row, col);
4410 }
4411 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4412
4413 wxPyUserData* data = NULL;
4414 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4415 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4416 if ( userData && (info.window || info.sizer || info.gotSize) )
4417 data = new wxPyUserData(userData);
4418 if ( info.sizer )
4419 PyObject_SetAttrString(item,"thisown",Py_False);
4420 wxPyEndBlockThreads(blocked);
4421
4422 // Now call the real Add method if a valid item type was found
4423 if ( info.window )
4424 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4425 else if ( info.sizer )
4426 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4427 else if (info.gotSize)
4428 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4429 pos, span, flag, border, data);
4430 return NULL;
4431 }
4432
4433
4434 #ifdef __cplusplus
4435 extern "C" {
4436 #endif
4437 SWIGINTERN int EmptyString_set(PyObject *) {
4438 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4439 return 1;
4440 }
4441
4442
4443 SWIGINTERN PyObject *EmptyString_get(void) {
4444 PyObject *pyobj = 0;
4445
4446 {
4447 #if wxUSE_UNICODE
4448 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4449 #else
4450 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4451 #endif
4452 }
4453 return pyobj;
4454 }
4455
4456
4457 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4458 PyObject *resultobj = 0;
4459 wxObject *arg1 = (wxObject *) 0 ;
4460 wxString result;
4461 void *argp1 = 0 ;
4462 int res1 = 0 ;
4463 PyObject *swig_obj[1] ;
4464
4465 if (!args) SWIG_fail;
4466 swig_obj[0] = args;
4467 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4468 if (!SWIG_IsOK(res1)) {
4469 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4470 }
4471 arg1 = reinterpret_cast< wxObject * >(argp1);
4472 {
4473 PyThreadState* __tstate = wxPyBeginAllowThreads();
4474 result = wxObject_GetClassName(arg1);
4475 wxPyEndAllowThreads(__tstate);
4476 if (PyErr_Occurred()) SWIG_fail;
4477 }
4478 {
4479 #if wxUSE_UNICODE
4480 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4481 #else
4482 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4483 #endif
4484 }
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxObject *arg1 = (wxObject *) 0 ;
4494 void *argp1 = 0 ;
4495 int res1 = 0 ;
4496 PyObject *swig_obj[1] ;
4497
4498 if (!args) SWIG_fail;
4499 swig_obj[0] = args;
4500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4501 if (!SWIG_IsOK(res1)) {
4502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4503 }
4504 arg1 = reinterpret_cast< wxObject * >(argp1);
4505 {
4506 PyThreadState* __tstate = wxPyBeginAllowThreads();
4507 wxObject_Destroy(arg1);
4508 wxPyEndAllowThreads(__tstate);
4509 if (PyErr_Occurred()) SWIG_fail;
4510 }
4511 resultobj = SWIG_Py_Void();
4512 return resultobj;
4513 fail:
4514 return NULL;
4515 }
4516
4517
4518 SWIGINTERN PyObject *_wrap_Object_IsSameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4519 PyObject *resultobj = 0;
4520 wxObject *arg1 = (wxObject *) 0 ;
4521 wxObject *arg2 = 0 ;
4522 bool result;
4523 void *argp1 = 0 ;
4524 int res1 = 0 ;
4525 void *argp2 = 0 ;
4526 int res2 = 0 ;
4527 PyObject * obj0 = 0 ;
4528 PyObject * obj1 = 0 ;
4529 char * kwnames[] = {
4530 (char *) "self",(char *) "p", NULL
4531 };
4532
4533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Object_IsSameAs",kwnames,&obj0,&obj1)) SWIG_fail;
4534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4535 if (!SWIG_IsOK(res1)) {
4536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_IsSameAs" "', expected argument " "1"" of type '" "wxObject const *""'");
4537 }
4538 arg1 = reinterpret_cast< wxObject * >(argp1);
4539 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxObject, 0 | 0);
4540 if (!SWIG_IsOK(res2)) {
4541 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4542 }
4543 if (!argp2) {
4544 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Object_IsSameAs" "', expected argument " "2"" of type '" "wxObject const &""'");
4545 }
4546 arg2 = reinterpret_cast< wxObject * >(argp2);
4547 {
4548 PyThreadState* __tstate = wxPyBeginAllowThreads();
4549 result = (bool)((wxObject const *)arg1)->IsSameAs((wxObject const &)*arg2);
4550 wxPyEndAllowThreads(__tstate);
4551 if (PyErr_Occurred()) SWIG_fail;
4552 }
4553 {
4554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4555 }
4556 return resultobj;
4557 fail:
4558 return NULL;
4559 }
4560
4561
4562 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4563 PyObject *obj;
4564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4565 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4566 return SWIG_Py_Void();
4567 }
4568
4569 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4570 PyObject *resultobj = 0;
4571 wxSize *arg1 = (wxSize *) 0 ;
4572 int arg2 ;
4573 void *argp1 = 0 ;
4574 int res1 = 0 ;
4575 int val2 ;
4576 int ecode2 = 0 ;
4577 PyObject *swig_obj[2] ;
4578
4579 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4581 if (!SWIG_IsOK(res1)) {
4582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4583 }
4584 arg1 = reinterpret_cast< wxSize * >(argp1);
4585 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4586 if (!SWIG_IsOK(ecode2)) {
4587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4588 }
4589 arg2 = static_cast< int >(val2);
4590 if (arg1) (arg1)->x = arg2;
4591
4592 resultobj = SWIG_Py_Void();
4593 return resultobj;
4594 fail:
4595 return NULL;
4596 }
4597
4598
4599 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4600 PyObject *resultobj = 0;
4601 wxSize *arg1 = (wxSize *) 0 ;
4602 int result;
4603 void *argp1 = 0 ;
4604 int res1 = 0 ;
4605 PyObject *swig_obj[1] ;
4606
4607 if (!args) SWIG_fail;
4608 swig_obj[0] = args;
4609 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4610 if (!SWIG_IsOK(res1)) {
4611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4612 }
4613 arg1 = reinterpret_cast< wxSize * >(argp1);
4614 result = (int) ((arg1)->x);
4615 resultobj = SWIG_From_int(static_cast< int >(result));
4616 return resultobj;
4617 fail:
4618 return NULL;
4619 }
4620
4621
4622 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4623 PyObject *resultobj = 0;
4624 wxSize *arg1 = (wxSize *) 0 ;
4625 int arg2 ;
4626 void *argp1 = 0 ;
4627 int res1 = 0 ;
4628 int val2 ;
4629 int ecode2 = 0 ;
4630 PyObject *swig_obj[2] ;
4631
4632 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4633 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4634 if (!SWIG_IsOK(res1)) {
4635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4636 }
4637 arg1 = reinterpret_cast< wxSize * >(argp1);
4638 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4639 if (!SWIG_IsOK(ecode2)) {
4640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4641 }
4642 arg2 = static_cast< int >(val2);
4643 if (arg1) (arg1)->y = arg2;
4644
4645 resultobj = SWIG_Py_Void();
4646 return resultobj;
4647 fail:
4648 return NULL;
4649 }
4650
4651
4652 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4653 PyObject *resultobj = 0;
4654 wxSize *arg1 = (wxSize *) 0 ;
4655 int result;
4656 void *argp1 = 0 ;
4657 int res1 = 0 ;
4658 PyObject *swig_obj[1] ;
4659
4660 if (!args) SWIG_fail;
4661 swig_obj[0] = args;
4662 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4663 if (!SWIG_IsOK(res1)) {
4664 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4665 }
4666 arg1 = reinterpret_cast< wxSize * >(argp1);
4667 result = (int) ((arg1)->y);
4668 resultobj = SWIG_From_int(static_cast< int >(result));
4669 return resultobj;
4670 fail:
4671 return NULL;
4672 }
4673
4674
4675 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4676 PyObject *resultobj = 0;
4677 int arg1 = (int) 0 ;
4678 int arg2 = (int) 0 ;
4679 wxSize *result = 0 ;
4680 int val1 ;
4681 int ecode1 = 0 ;
4682 int val2 ;
4683 int ecode2 = 0 ;
4684 PyObject * obj0 = 0 ;
4685 PyObject * obj1 = 0 ;
4686 char * kwnames[] = {
4687 (char *) "w",(char *) "h", NULL
4688 };
4689
4690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4691 if (obj0) {
4692 ecode1 = SWIG_AsVal_int(obj0, &val1);
4693 if (!SWIG_IsOK(ecode1)) {
4694 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4695 }
4696 arg1 = static_cast< int >(val1);
4697 }
4698 if (obj1) {
4699 ecode2 = SWIG_AsVal_int(obj1, &val2);
4700 if (!SWIG_IsOK(ecode2)) {
4701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4702 }
4703 arg2 = static_cast< int >(val2);
4704 }
4705 {
4706 result = (wxSize *)new wxSize(arg1,arg2);
4707 if (PyErr_Occurred()) SWIG_fail;
4708 }
4709 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4710 return resultobj;
4711 fail:
4712 return NULL;
4713 }
4714
4715
4716 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4717 PyObject *resultobj = 0;
4718 wxSize *arg1 = (wxSize *) 0 ;
4719 void *argp1 = 0 ;
4720 int res1 = 0 ;
4721 PyObject *swig_obj[1] ;
4722
4723 if (!args) SWIG_fail;
4724 swig_obj[0] = args;
4725 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4726 if (!SWIG_IsOK(res1)) {
4727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4728 }
4729 arg1 = reinterpret_cast< wxSize * >(argp1);
4730 {
4731 delete arg1;
4732
4733 if (PyErr_Occurred()) SWIG_fail;
4734 }
4735 resultobj = SWIG_Py_Void();
4736 return resultobj;
4737 fail:
4738 return NULL;
4739 }
4740
4741
4742 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4743 PyObject *resultobj = 0;
4744 wxSize *arg1 = (wxSize *) 0 ;
4745 PyObject *arg2 = (PyObject *) 0 ;
4746 bool result;
4747 void *argp1 = 0 ;
4748 int res1 = 0 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "self",(char *) "other", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4757 if (!SWIG_IsOK(res1)) {
4758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4759 }
4760 arg1 = reinterpret_cast< wxSize * >(argp1);
4761 arg2 = obj1;
4762 {
4763 result = (bool)wxSize___eq__(arg1,arg2);
4764 if (PyErr_Occurred()) SWIG_fail;
4765 }
4766 {
4767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4768 }
4769 return resultobj;
4770 fail:
4771 return NULL;
4772 }
4773
4774
4775 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4776 PyObject *resultobj = 0;
4777 wxSize *arg1 = (wxSize *) 0 ;
4778 PyObject *arg2 = (PyObject *) 0 ;
4779 bool result;
4780 void *argp1 = 0 ;
4781 int res1 = 0 ;
4782 PyObject * obj0 = 0 ;
4783 PyObject * obj1 = 0 ;
4784 char * kwnames[] = {
4785 (char *) "self",(char *) "other", NULL
4786 };
4787
4788 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4789 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4790 if (!SWIG_IsOK(res1)) {
4791 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4792 }
4793 arg1 = reinterpret_cast< wxSize * >(argp1);
4794 arg2 = obj1;
4795 {
4796 result = (bool)wxSize___ne__(arg1,arg2);
4797 if (PyErr_Occurred()) SWIG_fail;
4798 }
4799 {
4800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4801 }
4802 return resultobj;
4803 fail:
4804 return NULL;
4805 }
4806
4807
4808 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4809 PyObject *resultobj = 0;
4810 wxSize *arg1 = (wxSize *) 0 ;
4811 wxSize *arg2 = 0 ;
4812 wxSize result;
4813 void *argp1 = 0 ;
4814 int res1 = 0 ;
4815 wxSize temp2 ;
4816 PyObject * obj0 = 0 ;
4817 PyObject * obj1 = 0 ;
4818 char * kwnames[] = {
4819 (char *) "self",(char *) "sz", NULL
4820 };
4821
4822 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4824 if (!SWIG_IsOK(res1)) {
4825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4826 }
4827 arg1 = reinterpret_cast< wxSize * >(argp1);
4828 {
4829 arg2 = &temp2;
4830 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4831 }
4832 {
4833 result = (arg1)->operator +((wxSize const &)*arg2);
4834 if (PyErr_Occurred()) SWIG_fail;
4835 }
4836 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4837 return resultobj;
4838 fail:
4839 return NULL;
4840 }
4841
4842
4843 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4844 PyObject *resultobj = 0;
4845 wxSize *arg1 = (wxSize *) 0 ;
4846 wxSize *arg2 = 0 ;
4847 wxSize result;
4848 void *argp1 = 0 ;
4849 int res1 = 0 ;
4850 wxSize temp2 ;
4851 PyObject * obj0 = 0 ;
4852 PyObject * obj1 = 0 ;
4853 char * kwnames[] = {
4854 (char *) "self",(char *) "sz", NULL
4855 };
4856
4857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
4858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4859 if (!SWIG_IsOK(res1)) {
4860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4861 }
4862 arg1 = reinterpret_cast< wxSize * >(argp1);
4863 {
4864 arg2 = &temp2;
4865 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4866 }
4867 {
4868 result = (arg1)->operator -((wxSize const &)*arg2);
4869 if (PyErr_Occurred()) SWIG_fail;
4870 }
4871 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4872 return resultobj;
4873 fail:
4874 return NULL;
4875 }
4876
4877
4878 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4879 PyObject *resultobj = 0;
4880 wxSize *arg1 = (wxSize *) 0 ;
4881 wxSize *arg2 = 0 ;
4882 void *argp1 = 0 ;
4883 int res1 = 0 ;
4884 wxSize temp2 ;
4885 PyObject * obj0 = 0 ;
4886 PyObject * obj1 = 0 ;
4887 char * kwnames[] = {
4888 (char *) "self",(char *) "sz", NULL
4889 };
4890
4891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4893 if (!SWIG_IsOK(res1)) {
4894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4895 }
4896 arg1 = reinterpret_cast< wxSize * >(argp1);
4897 {
4898 arg2 = &temp2;
4899 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4900 }
4901 {
4902 (arg1)->IncTo((wxSize const &)*arg2);
4903 if (PyErr_Occurred()) SWIG_fail;
4904 }
4905 resultobj = SWIG_Py_Void();
4906 return resultobj;
4907 fail:
4908 return NULL;
4909 }
4910
4911
4912 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4913 PyObject *resultobj = 0;
4914 wxSize *arg1 = (wxSize *) 0 ;
4915 wxSize *arg2 = 0 ;
4916 void *argp1 = 0 ;
4917 int res1 = 0 ;
4918 wxSize temp2 ;
4919 PyObject * obj0 = 0 ;
4920 PyObject * obj1 = 0 ;
4921 char * kwnames[] = {
4922 (char *) "self",(char *) "sz", NULL
4923 };
4924
4925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4927 if (!SWIG_IsOK(res1)) {
4928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4929 }
4930 arg1 = reinterpret_cast< wxSize * >(argp1);
4931 {
4932 arg2 = &temp2;
4933 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4934 }
4935 {
4936 (arg1)->DecTo((wxSize const &)*arg2);
4937 if (PyErr_Occurred()) SWIG_fail;
4938 }
4939 resultobj = SWIG_Py_Void();
4940 return resultobj;
4941 fail:
4942 return NULL;
4943 }
4944
4945
4946 SWIGINTERN PyObject *_wrap_Size_IncBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4947 PyObject *resultobj = 0;
4948 wxSize *arg1 = (wxSize *) 0 ;
4949 int arg2 ;
4950 int arg3 ;
4951 void *argp1 = 0 ;
4952 int res1 = 0 ;
4953 int val2 ;
4954 int ecode2 = 0 ;
4955 int val3 ;
4956 int ecode3 = 0 ;
4957 PyObject * obj0 = 0 ;
4958 PyObject * obj1 = 0 ;
4959 PyObject * obj2 = 0 ;
4960 char * kwnames[] = {
4961 (char *) "self",(char *) "dx",(char *) "dy", NULL
4962 };
4963
4964 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_IncBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4965 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4966 if (!SWIG_IsOK(res1)) {
4967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncBy" "', expected argument " "1"" of type '" "wxSize *""'");
4968 }
4969 arg1 = reinterpret_cast< wxSize * >(argp1);
4970 ecode2 = SWIG_AsVal_int(obj1, &val2);
4971 if (!SWIG_IsOK(ecode2)) {
4972 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_IncBy" "', expected argument " "2"" of type '" "int""'");
4973 }
4974 arg2 = static_cast< int >(val2);
4975 ecode3 = SWIG_AsVal_int(obj2, &val3);
4976 if (!SWIG_IsOK(ecode3)) {
4977 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_IncBy" "', expected argument " "3"" of type '" "int""'");
4978 }
4979 arg3 = static_cast< int >(val3);
4980 {
4981 (arg1)->IncBy(arg2,arg3);
4982 if (PyErr_Occurred()) SWIG_fail;
4983 }
4984 resultobj = SWIG_Py_Void();
4985 return resultobj;
4986 fail:
4987 return NULL;
4988 }
4989
4990
4991 SWIGINTERN PyObject *_wrap_Size_DecBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4992 PyObject *resultobj = 0;
4993 wxSize *arg1 = (wxSize *) 0 ;
4994 int arg2 ;
4995 int arg3 ;
4996 void *argp1 = 0 ;
4997 int res1 = 0 ;
4998 int val2 ;
4999 int ecode2 = 0 ;
5000 int val3 ;
5001 int ecode3 = 0 ;
5002 PyObject * obj0 = 0 ;
5003 PyObject * obj1 = 0 ;
5004 PyObject * obj2 = 0 ;
5005 char * kwnames[] = {
5006 (char *) "self",(char *) "dx",(char *) "dy", NULL
5007 };
5008
5009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_DecBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5011 if (!SWIG_IsOK(res1)) {
5012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecBy" "', expected argument " "1"" of type '" "wxSize *""'");
5013 }
5014 arg1 = reinterpret_cast< wxSize * >(argp1);
5015 ecode2 = SWIG_AsVal_int(obj1, &val2);
5016 if (!SWIG_IsOK(ecode2)) {
5017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_DecBy" "', expected argument " "2"" of type '" "int""'");
5018 }
5019 arg2 = static_cast< int >(val2);
5020 ecode3 = SWIG_AsVal_int(obj2, &val3);
5021 if (!SWIG_IsOK(ecode3)) {
5022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_DecBy" "', expected argument " "3"" of type '" "int""'");
5023 }
5024 arg3 = static_cast< int >(val3);
5025 {
5026 (arg1)->DecBy(arg2,arg3);
5027 if (PyErr_Occurred()) SWIG_fail;
5028 }
5029 resultobj = SWIG_Py_Void();
5030 return resultobj;
5031 fail:
5032 return NULL;
5033 }
5034
5035
5036 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5037 PyObject *resultobj = 0;
5038 wxSize *arg1 = (wxSize *) 0 ;
5039 float arg2 ;
5040 float arg3 ;
5041 void *argp1 = 0 ;
5042 int res1 = 0 ;
5043 float val2 ;
5044 int ecode2 = 0 ;
5045 float val3 ;
5046 int ecode3 = 0 ;
5047 PyObject * obj0 = 0 ;
5048 PyObject * obj1 = 0 ;
5049 PyObject * obj2 = 0 ;
5050 char * kwnames[] = {
5051 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
5052 };
5053
5054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5055 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5056 if (!SWIG_IsOK(res1)) {
5057 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
5058 }
5059 arg1 = reinterpret_cast< wxSize * >(argp1);
5060 ecode2 = SWIG_AsVal_float(obj1, &val2);
5061 if (!SWIG_IsOK(ecode2)) {
5062 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
5063 }
5064 arg2 = static_cast< float >(val2);
5065 ecode3 = SWIG_AsVal_float(obj2, &val3);
5066 if (!SWIG_IsOK(ecode3)) {
5067 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
5068 }
5069 arg3 = static_cast< float >(val3);
5070 {
5071 (arg1)->Scale(arg2,arg3);
5072 if (PyErr_Occurred()) SWIG_fail;
5073 }
5074 resultobj = SWIG_Py_Void();
5075 return resultobj;
5076 fail:
5077 return NULL;
5078 }
5079
5080
5081 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5082 PyObject *resultobj = 0;
5083 wxSize *arg1 = (wxSize *) 0 ;
5084 int arg2 ;
5085 int arg3 ;
5086 void *argp1 = 0 ;
5087 int res1 = 0 ;
5088 int val2 ;
5089 int ecode2 = 0 ;
5090 int val3 ;
5091 int ecode3 = 0 ;
5092 PyObject * obj0 = 0 ;
5093 PyObject * obj1 = 0 ;
5094 PyObject * obj2 = 0 ;
5095 char * kwnames[] = {
5096 (char *) "self",(char *) "w",(char *) "h", NULL
5097 };
5098
5099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5101 if (!SWIG_IsOK(res1)) {
5102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
5103 }
5104 arg1 = reinterpret_cast< wxSize * >(argp1);
5105 ecode2 = SWIG_AsVal_int(obj1, &val2);
5106 if (!SWIG_IsOK(ecode2)) {
5107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
5108 }
5109 arg2 = static_cast< int >(val2);
5110 ecode3 = SWIG_AsVal_int(obj2, &val3);
5111 if (!SWIG_IsOK(ecode3)) {
5112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
5113 }
5114 arg3 = static_cast< int >(val3);
5115 {
5116 (arg1)->Set(arg2,arg3);
5117 if (PyErr_Occurred()) SWIG_fail;
5118 }
5119 resultobj = SWIG_Py_Void();
5120 return resultobj;
5121 fail:
5122 return NULL;
5123 }
5124
5125
5126 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5127 PyObject *resultobj = 0;
5128 wxSize *arg1 = (wxSize *) 0 ;
5129 int arg2 ;
5130 void *argp1 = 0 ;
5131 int res1 = 0 ;
5132 int val2 ;
5133 int ecode2 = 0 ;
5134 PyObject * obj0 = 0 ;
5135 PyObject * obj1 = 0 ;
5136 char * kwnames[] = {
5137 (char *) "self",(char *) "w", NULL
5138 };
5139
5140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
5141 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5142 if (!SWIG_IsOK(res1)) {
5143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
5144 }
5145 arg1 = reinterpret_cast< wxSize * >(argp1);
5146 ecode2 = SWIG_AsVal_int(obj1, &val2);
5147 if (!SWIG_IsOK(ecode2)) {
5148 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
5149 }
5150 arg2 = static_cast< int >(val2);
5151 {
5152 (arg1)->SetWidth(arg2);
5153 if (PyErr_Occurred()) SWIG_fail;
5154 }
5155 resultobj = SWIG_Py_Void();
5156 return resultobj;
5157 fail:
5158 return NULL;
5159 }
5160
5161
5162 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5163 PyObject *resultobj = 0;
5164 wxSize *arg1 = (wxSize *) 0 ;
5165 int arg2 ;
5166 void *argp1 = 0 ;
5167 int res1 = 0 ;
5168 int val2 ;
5169 int ecode2 = 0 ;
5170 PyObject * obj0 = 0 ;
5171 PyObject * obj1 = 0 ;
5172 char * kwnames[] = {
5173 (char *) "self",(char *) "h", NULL
5174 };
5175
5176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
5177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5178 if (!SWIG_IsOK(res1)) {
5179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5180 }
5181 arg1 = reinterpret_cast< wxSize * >(argp1);
5182 ecode2 = SWIG_AsVal_int(obj1, &val2);
5183 if (!SWIG_IsOK(ecode2)) {
5184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5185 }
5186 arg2 = static_cast< int >(val2);
5187 {
5188 (arg1)->SetHeight(arg2);
5189 if (PyErr_Occurred()) SWIG_fail;
5190 }
5191 resultobj = SWIG_Py_Void();
5192 return resultobj;
5193 fail:
5194 return NULL;
5195 }
5196
5197
5198 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5199 PyObject *resultobj = 0;
5200 wxSize *arg1 = (wxSize *) 0 ;
5201 int result;
5202 void *argp1 = 0 ;
5203 int res1 = 0 ;
5204 PyObject *swig_obj[1] ;
5205
5206 if (!args) SWIG_fail;
5207 swig_obj[0] = args;
5208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5209 if (!SWIG_IsOK(res1)) {
5210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5211 }
5212 arg1 = reinterpret_cast< wxSize * >(argp1);
5213 {
5214 result = (int)((wxSize const *)arg1)->GetWidth();
5215 if (PyErr_Occurred()) SWIG_fail;
5216 }
5217 resultobj = SWIG_From_int(static_cast< int >(result));
5218 return resultobj;
5219 fail:
5220 return NULL;
5221 }
5222
5223
5224 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5225 PyObject *resultobj = 0;
5226 wxSize *arg1 = (wxSize *) 0 ;
5227 int result;
5228 void *argp1 = 0 ;
5229 int res1 = 0 ;
5230 PyObject *swig_obj[1] ;
5231
5232 if (!args) SWIG_fail;
5233 swig_obj[0] = args;
5234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5235 if (!SWIG_IsOK(res1)) {
5236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5237 }
5238 arg1 = reinterpret_cast< wxSize * >(argp1);
5239 {
5240 result = (int)((wxSize const *)arg1)->GetHeight();
5241 if (PyErr_Occurred()) SWIG_fail;
5242 }
5243 resultobj = SWIG_From_int(static_cast< int >(result));
5244 return resultobj;
5245 fail:
5246 return NULL;
5247 }
5248
5249
5250 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5251 PyObject *resultobj = 0;
5252 wxSize *arg1 = (wxSize *) 0 ;
5253 bool result;
5254 void *argp1 = 0 ;
5255 int res1 = 0 ;
5256 PyObject *swig_obj[1] ;
5257
5258 if (!args) SWIG_fail;
5259 swig_obj[0] = args;
5260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5261 if (!SWIG_IsOK(res1)) {
5262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5263 }
5264 arg1 = reinterpret_cast< wxSize * >(argp1);
5265 {
5266 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5267 if (PyErr_Occurred()) SWIG_fail;
5268 }
5269 {
5270 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5271 }
5272 return resultobj;
5273 fail:
5274 return NULL;
5275 }
5276
5277
5278 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5279 PyObject *resultobj = 0;
5280 wxSize *arg1 = (wxSize *) 0 ;
5281 wxSize *arg2 = 0 ;
5282 void *argp1 = 0 ;
5283 int res1 = 0 ;
5284 wxSize temp2 ;
5285 PyObject * obj0 = 0 ;
5286 PyObject * obj1 = 0 ;
5287 char * kwnames[] = {
5288 (char *) "self",(char *) "size", NULL
5289 };
5290
5291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5293 if (!SWIG_IsOK(res1)) {
5294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5295 }
5296 arg1 = reinterpret_cast< wxSize * >(argp1);
5297 {
5298 arg2 = &temp2;
5299 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5300 }
5301 {
5302 (arg1)->SetDefaults((wxSize const &)*arg2);
5303 if (PyErr_Occurred()) SWIG_fail;
5304 }
5305 resultobj = SWIG_Py_Void();
5306 return resultobj;
5307 fail:
5308 return NULL;
5309 }
5310
5311
5312 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5313 PyObject *resultobj = 0;
5314 wxSize *arg1 = (wxSize *) 0 ;
5315 PyObject *result = 0 ;
5316 void *argp1 = 0 ;
5317 int res1 = 0 ;
5318 PyObject *swig_obj[1] ;
5319
5320 if (!args) SWIG_fail;
5321 swig_obj[0] = args;
5322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5323 if (!SWIG_IsOK(res1)) {
5324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5325 }
5326 arg1 = reinterpret_cast< wxSize * >(argp1);
5327 {
5328 result = (PyObject *)wxSize_Get(arg1);
5329 if (PyErr_Occurred()) SWIG_fail;
5330 }
5331 resultobj = result;
5332 return resultobj;
5333 fail:
5334 return NULL;
5335 }
5336
5337
5338 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5339 PyObject *obj;
5340 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5341 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5342 return SWIG_Py_Void();
5343 }
5344
5345 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5346 return SWIG_Python_InitShadowInstance(args);
5347 }
5348
5349 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5350 PyObject *resultobj = 0;
5351 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5352 double arg2 ;
5353 void *argp1 = 0 ;
5354 int res1 = 0 ;
5355 double val2 ;
5356 int ecode2 = 0 ;
5357 PyObject *swig_obj[2] ;
5358
5359 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5360 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5361 if (!SWIG_IsOK(res1)) {
5362 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5363 }
5364 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5365 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5366 if (!SWIG_IsOK(ecode2)) {
5367 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5368 }
5369 arg2 = static_cast< double >(val2);
5370 if (arg1) (arg1)->x = arg2;
5371
5372 resultobj = SWIG_Py_Void();
5373 return resultobj;
5374 fail:
5375 return NULL;
5376 }
5377
5378
5379 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5380 PyObject *resultobj = 0;
5381 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5382 double result;
5383 void *argp1 = 0 ;
5384 int res1 = 0 ;
5385 PyObject *swig_obj[1] ;
5386
5387 if (!args) SWIG_fail;
5388 swig_obj[0] = args;
5389 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5390 if (!SWIG_IsOK(res1)) {
5391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5392 }
5393 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5394 result = (double) ((arg1)->x);
5395 resultobj = SWIG_From_double(static_cast< double >(result));
5396 return resultobj;
5397 fail:
5398 return NULL;
5399 }
5400
5401
5402 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5403 PyObject *resultobj = 0;
5404 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5405 double arg2 ;
5406 void *argp1 = 0 ;
5407 int res1 = 0 ;
5408 double val2 ;
5409 int ecode2 = 0 ;
5410 PyObject *swig_obj[2] ;
5411
5412 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5413 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5414 if (!SWIG_IsOK(res1)) {
5415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5416 }
5417 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5418 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5419 if (!SWIG_IsOK(ecode2)) {
5420 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5421 }
5422 arg2 = static_cast< double >(val2);
5423 if (arg1) (arg1)->y = arg2;
5424
5425 resultobj = SWIG_Py_Void();
5426 return resultobj;
5427 fail:
5428 return NULL;
5429 }
5430
5431
5432 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5433 PyObject *resultobj = 0;
5434 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5435 double result;
5436 void *argp1 = 0 ;
5437 int res1 = 0 ;
5438 PyObject *swig_obj[1] ;
5439
5440 if (!args) SWIG_fail;
5441 swig_obj[0] = args;
5442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5443 if (!SWIG_IsOK(res1)) {
5444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5445 }
5446 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5447 result = (double) ((arg1)->y);
5448 resultobj = SWIG_From_double(static_cast< double >(result));
5449 return resultobj;
5450 fail:
5451 return NULL;
5452 }
5453
5454
5455 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5456 PyObject *resultobj = 0;
5457 double arg1 = (double) 0.0 ;
5458 double arg2 = (double) 0.0 ;
5459 wxRealPoint *result = 0 ;
5460 double val1 ;
5461 int ecode1 = 0 ;
5462 double val2 ;
5463 int ecode2 = 0 ;
5464 PyObject * obj0 = 0 ;
5465 PyObject * obj1 = 0 ;
5466 char * kwnames[] = {
5467 (char *) "x",(char *) "y", NULL
5468 };
5469
5470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5471 if (obj0) {
5472 ecode1 = SWIG_AsVal_double(obj0, &val1);
5473 if (!SWIG_IsOK(ecode1)) {
5474 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5475 }
5476 arg1 = static_cast< double >(val1);
5477 }
5478 if (obj1) {
5479 ecode2 = SWIG_AsVal_double(obj1, &val2);
5480 if (!SWIG_IsOK(ecode2)) {
5481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5482 }
5483 arg2 = static_cast< double >(val2);
5484 }
5485 {
5486 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5487 if (PyErr_Occurred()) SWIG_fail;
5488 }
5489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5490 return resultobj;
5491 fail:
5492 return NULL;
5493 }
5494
5495
5496 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5497 PyObject *resultobj = 0;
5498 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5499 void *argp1 = 0 ;
5500 int res1 = 0 ;
5501 PyObject *swig_obj[1] ;
5502
5503 if (!args) SWIG_fail;
5504 swig_obj[0] = args;
5505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5506 if (!SWIG_IsOK(res1)) {
5507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5508 }
5509 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5510 {
5511 delete arg1;
5512
5513 if (PyErr_Occurred()) SWIG_fail;
5514 }
5515 resultobj = SWIG_Py_Void();
5516 return resultobj;
5517 fail:
5518 return NULL;
5519 }
5520
5521
5522 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5523 PyObject *resultobj = 0;
5524 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5525 PyObject *arg2 = (PyObject *) 0 ;
5526 bool result;
5527 void *argp1 = 0 ;
5528 int res1 = 0 ;
5529 PyObject * obj0 = 0 ;
5530 PyObject * obj1 = 0 ;
5531 char * kwnames[] = {
5532 (char *) "self",(char *) "other", NULL
5533 };
5534
5535 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5536 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5537 if (!SWIG_IsOK(res1)) {
5538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5539 }
5540 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5541 arg2 = obj1;
5542 {
5543 result = (bool)wxRealPoint___eq__(arg1,arg2);
5544 if (PyErr_Occurred()) SWIG_fail;
5545 }
5546 {
5547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5548 }
5549 return resultobj;
5550 fail:
5551 return NULL;
5552 }
5553
5554
5555 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5556 PyObject *resultobj = 0;
5557 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5558 PyObject *arg2 = (PyObject *) 0 ;
5559 bool result;
5560 void *argp1 = 0 ;
5561 int res1 = 0 ;
5562 PyObject * obj0 = 0 ;
5563 PyObject * obj1 = 0 ;
5564 char * kwnames[] = {
5565 (char *) "self",(char *) "other", NULL
5566 };
5567
5568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5569 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5570 if (!SWIG_IsOK(res1)) {
5571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5572 }
5573 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5574 arg2 = obj1;
5575 {
5576 result = (bool)wxRealPoint___ne__(arg1,arg2);
5577 if (PyErr_Occurred()) SWIG_fail;
5578 }
5579 {
5580 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5581 }
5582 return resultobj;
5583 fail:
5584 return NULL;
5585 }
5586
5587
5588 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5589 PyObject *resultobj = 0;
5590 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5591 wxRealPoint *arg2 = 0 ;
5592 wxRealPoint result;
5593 void *argp1 = 0 ;
5594 int res1 = 0 ;
5595 wxRealPoint temp2 ;
5596 PyObject * obj0 = 0 ;
5597 PyObject * obj1 = 0 ;
5598 char * kwnames[] = {
5599 (char *) "self",(char *) "pt", NULL
5600 };
5601
5602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5604 if (!SWIG_IsOK(res1)) {
5605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5606 }
5607 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5608 {
5609 arg2 = &temp2;
5610 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5611 }
5612 {
5613 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5614 if (PyErr_Occurred()) SWIG_fail;
5615 }
5616 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5617 return resultobj;
5618 fail:
5619 return NULL;
5620 }
5621
5622
5623 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5624 PyObject *resultobj = 0;
5625 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5626 wxRealPoint *arg2 = 0 ;
5627 wxRealPoint result;
5628 void *argp1 = 0 ;
5629 int res1 = 0 ;
5630 wxRealPoint temp2 ;
5631 PyObject * obj0 = 0 ;
5632 PyObject * obj1 = 0 ;
5633 char * kwnames[] = {
5634 (char *) "self",(char *) "pt", NULL
5635 };
5636
5637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5639 if (!SWIG_IsOK(res1)) {
5640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5641 }
5642 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5643 {
5644 arg2 = &temp2;
5645 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5646 }
5647 {
5648 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5649 if (PyErr_Occurred()) SWIG_fail;
5650 }
5651 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5652 return resultobj;
5653 fail:
5654 return NULL;
5655 }
5656
5657
5658 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5659 PyObject *resultobj = 0;
5660 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5661 double arg2 ;
5662 double arg3 ;
5663 void *argp1 = 0 ;
5664 int res1 = 0 ;
5665 double val2 ;
5666 int ecode2 = 0 ;
5667 double val3 ;
5668 int ecode3 = 0 ;
5669 PyObject * obj0 = 0 ;
5670 PyObject * obj1 = 0 ;
5671 PyObject * obj2 = 0 ;
5672 char * kwnames[] = {
5673 (char *) "self",(char *) "x",(char *) "y", NULL
5674 };
5675
5676 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5677 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5678 if (!SWIG_IsOK(res1)) {
5679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5682 ecode2 = SWIG_AsVal_double(obj1, &val2);
5683 if (!SWIG_IsOK(ecode2)) {
5684 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5685 }
5686 arg2 = static_cast< double >(val2);
5687 ecode3 = SWIG_AsVal_double(obj2, &val3);
5688 if (!SWIG_IsOK(ecode3)) {
5689 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5690 }
5691 arg3 = static_cast< double >(val3);
5692 {
5693 wxRealPoint_Set(arg1,arg2,arg3);
5694 if (PyErr_Occurred()) SWIG_fail;
5695 }
5696 resultobj = SWIG_Py_Void();
5697 return resultobj;
5698 fail:
5699 return NULL;
5700 }
5701
5702
5703 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5704 PyObject *resultobj = 0;
5705 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5706 PyObject *result = 0 ;
5707 void *argp1 = 0 ;
5708 int res1 = 0 ;
5709 PyObject *swig_obj[1] ;
5710
5711 if (!args) SWIG_fail;
5712 swig_obj[0] = args;
5713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5714 if (!SWIG_IsOK(res1)) {
5715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5716 }
5717 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5718 {
5719 result = (PyObject *)wxRealPoint_Get(arg1);
5720 if (PyErr_Occurred()) SWIG_fail;
5721 }
5722 resultobj = result;
5723 return resultobj;
5724 fail:
5725 return NULL;
5726 }
5727
5728
5729 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5730 PyObject *obj;
5731 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5732 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5733 return SWIG_Py_Void();
5734 }
5735
5736 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5737 return SWIG_Python_InitShadowInstance(args);
5738 }
5739
5740 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5741 PyObject *resultobj = 0;
5742 wxPoint *arg1 = (wxPoint *) 0 ;
5743 int arg2 ;
5744 void *argp1 = 0 ;
5745 int res1 = 0 ;
5746 int val2 ;
5747 int ecode2 = 0 ;
5748 PyObject *swig_obj[2] ;
5749
5750 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5751 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5752 if (!SWIG_IsOK(res1)) {
5753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5754 }
5755 arg1 = reinterpret_cast< wxPoint * >(argp1);
5756 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5757 if (!SWIG_IsOK(ecode2)) {
5758 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5759 }
5760 arg2 = static_cast< int >(val2);
5761 if (arg1) (arg1)->x = arg2;
5762
5763 resultobj = SWIG_Py_Void();
5764 return resultobj;
5765 fail:
5766 return NULL;
5767 }
5768
5769
5770 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5771 PyObject *resultobj = 0;
5772 wxPoint *arg1 = (wxPoint *) 0 ;
5773 int result;
5774 void *argp1 = 0 ;
5775 int res1 = 0 ;
5776 PyObject *swig_obj[1] ;
5777
5778 if (!args) SWIG_fail;
5779 swig_obj[0] = args;
5780 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5781 if (!SWIG_IsOK(res1)) {
5782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5783 }
5784 arg1 = reinterpret_cast< wxPoint * >(argp1);
5785 result = (int) ((arg1)->x);
5786 resultobj = SWIG_From_int(static_cast< int >(result));
5787 return resultobj;
5788 fail:
5789 return NULL;
5790 }
5791
5792
5793 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5794 PyObject *resultobj = 0;
5795 wxPoint *arg1 = (wxPoint *) 0 ;
5796 int arg2 ;
5797 void *argp1 = 0 ;
5798 int res1 = 0 ;
5799 int val2 ;
5800 int ecode2 = 0 ;
5801 PyObject *swig_obj[2] ;
5802
5803 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5805 if (!SWIG_IsOK(res1)) {
5806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5807 }
5808 arg1 = reinterpret_cast< wxPoint * >(argp1);
5809 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5810 if (!SWIG_IsOK(ecode2)) {
5811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5812 }
5813 arg2 = static_cast< int >(val2);
5814 if (arg1) (arg1)->y = arg2;
5815
5816 resultobj = SWIG_Py_Void();
5817 return resultobj;
5818 fail:
5819 return NULL;
5820 }
5821
5822
5823 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5824 PyObject *resultobj = 0;
5825 wxPoint *arg1 = (wxPoint *) 0 ;
5826 int result;
5827 void *argp1 = 0 ;
5828 int res1 = 0 ;
5829 PyObject *swig_obj[1] ;
5830
5831 if (!args) SWIG_fail;
5832 swig_obj[0] = args;
5833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5834 if (!SWIG_IsOK(res1)) {
5835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5836 }
5837 arg1 = reinterpret_cast< wxPoint * >(argp1);
5838 result = (int) ((arg1)->y);
5839 resultobj = SWIG_From_int(static_cast< int >(result));
5840 return resultobj;
5841 fail:
5842 return NULL;
5843 }
5844
5845
5846 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5847 PyObject *resultobj = 0;
5848 int arg1 = (int) 0 ;
5849 int arg2 = (int) 0 ;
5850 wxPoint *result = 0 ;
5851 int val1 ;
5852 int ecode1 = 0 ;
5853 int val2 ;
5854 int ecode2 = 0 ;
5855 PyObject * obj0 = 0 ;
5856 PyObject * obj1 = 0 ;
5857 char * kwnames[] = {
5858 (char *) "x",(char *) "y", NULL
5859 };
5860
5861 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5862 if (obj0) {
5863 ecode1 = SWIG_AsVal_int(obj0, &val1);
5864 if (!SWIG_IsOK(ecode1)) {
5865 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5866 }
5867 arg1 = static_cast< int >(val1);
5868 }
5869 if (obj1) {
5870 ecode2 = SWIG_AsVal_int(obj1, &val2);
5871 if (!SWIG_IsOK(ecode2)) {
5872 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5873 }
5874 arg2 = static_cast< int >(val2);
5875 }
5876 {
5877 result = (wxPoint *)new wxPoint(arg1,arg2);
5878 if (PyErr_Occurred()) SWIG_fail;
5879 }
5880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5881 return resultobj;
5882 fail:
5883 return NULL;
5884 }
5885
5886
5887 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5888 PyObject *resultobj = 0;
5889 wxPoint *arg1 = (wxPoint *) 0 ;
5890 void *argp1 = 0 ;
5891 int res1 = 0 ;
5892 PyObject *swig_obj[1] ;
5893
5894 if (!args) SWIG_fail;
5895 swig_obj[0] = args;
5896 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5897 if (!SWIG_IsOK(res1)) {
5898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5899 }
5900 arg1 = reinterpret_cast< wxPoint * >(argp1);
5901 {
5902 delete arg1;
5903
5904 if (PyErr_Occurred()) SWIG_fail;
5905 }
5906 resultobj = SWIG_Py_Void();
5907 return resultobj;
5908 fail:
5909 return NULL;
5910 }
5911
5912
5913 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5914 PyObject *resultobj = 0;
5915 wxPoint *arg1 = (wxPoint *) 0 ;
5916 PyObject *arg2 = (PyObject *) 0 ;
5917 bool result;
5918 void *argp1 = 0 ;
5919 int res1 = 0 ;
5920 PyObject * obj0 = 0 ;
5921 PyObject * obj1 = 0 ;
5922 char * kwnames[] = {
5923 (char *) "self",(char *) "other", NULL
5924 };
5925
5926 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5927 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5928 if (!SWIG_IsOK(res1)) {
5929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5930 }
5931 arg1 = reinterpret_cast< wxPoint * >(argp1);
5932 arg2 = obj1;
5933 {
5934 result = (bool)wxPoint___eq__(arg1,arg2);
5935 if (PyErr_Occurred()) SWIG_fail;
5936 }
5937 {
5938 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5939 }
5940 return resultobj;
5941 fail:
5942 return NULL;
5943 }
5944
5945
5946 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5947 PyObject *resultobj = 0;
5948 wxPoint *arg1 = (wxPoint *) 0 ;
5949 PyObject *arg2 = (PyObject *) 0 ;
5950 bool result;
5951 void *argp1 = 0 ;
5952 int res1 = 0 ;
5953 PyObject * obj0 = 0 ;
5954 PyObject * obj1 = 0 ;
5955 char * kwnames[] = {
5956 (char *) "self",(char *) "other", NULL
5957 };
5958
5959 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5960 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5961 if (!SWIG_IsOK(res1)) {
5962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5963 }
5964 arg1 = reinterpret_cast< wxPoint * >(argp1);
5965 arg2 = obj1;
5966 {
5967 result = (bool)wxPoint___ne__(arg1,arg2);
5968 if (PyErr_Occurred()) SWIG_fail;
5969 }
5970 {
5971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5972 }
5973 return resultobj;
5974 fail:
5975 return NULL;
5976 }
5977
5978
5979 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5980 PyObject *resultobj = 0;
5981 wxPoint *arg1 = (wxPoint *) 0 ;
5982 wxPoint *arg2 = 0 ;
5983 wxPoint result;
5984 void *argp1 = 0 ;
5985 int res1 = 0 ;
5986 wxPoint temp2 ;
5987 PyObject * obj0 = 0 ;
5988 PyObject * obj1 = 0 ;
5989 char * kwnames[] = {
5990 (char *) "self",(char *) "pt", NULL
5991 };
5992
5993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5995 if (!SWIG_IsOK(res1)) {
5996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5997 }
5998 arg1 = reinterpret_cast< wxPoint * >(argp1);
5999 {
6000 arg2 = &temp2;
6001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6002 }
6003 {
6004 result = (arg1)->operator +((wxPoint const &)*arg2);
6005 if (PyErr_Occurred()) SWIG_fail;
6006 }
6007 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6008 return resultobj;
6009 fail:
6010 return NULL;
6011 }
6012
6013
6014 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6015 PyObject *resultobj = 0;
6016 wxPoint *arg1 = (wxPoint *) 0 ;
6017 wxPoint *arg2 = 0 ;
6018 wxPoint result;
6019 void *argp1 = 0 ;
6020 int res1 = 0 ;
6021 wxPoint temp2 ;
6022 PyObject * obj0 = 0 ;
6023 PyObject * obj1 = 0 ;
6024 char * kwnames[] = {
6025 (char *) "self",(char *) "pt", NULL
6026 };
6027
6028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
6029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6030 if (!SWIG_IsOK(res1)) {
6031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6032 }
6033 arg1 = reinterpret_cast< wxPoint * >(argp1);
6034 {
6035 arg2 = &temp2;
6036 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6037 }
6038 {
6039 result = (arg1)->operator -((wxPoint const &)*arg2);
6040 if (PyErr_Occurred()) SWIG_fail;
6041 }
6042 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6043 return resultobj;
6044 fail:
6045 return NULL;
6046 }
6047
6048
6049 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6050 PyObject *resultobj = 0;
6051 wxPoint *arg1 = (wxPoint *) 0 ;
6052 wxPoint *arg2 = 0 ;
6053 wxPoint *result = 0 ;
6054 void *argp1 = 0 ;
6055 int res1 = 0 ;
6056 wxPoint temp2 ;
6057 PyObject * obj0 = 0 ;
6058 PyObject * obj1 = 0 ;
6059 char * kwnames[] = {
6060 (char *) "self",(char *) "pt", NULL
6061 };
6062
6063 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
6064 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6065 if (!SWIG_IsOK(res1)) {
6066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
6067 }
6068 arg1 = reinterpret_cast< wxPoint * >(argp1);
6069 {
6070 arg2 = &temp2;
6071 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6072 }
6073 {
6074 {
6075 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
6076 result = (wxPoint *) &_result_ref;
6077 }
6078 if (PyErr_Occurred()) SWIG_fail;
6079 }
6080 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6081 return resultobj;
6082 fail:
6083 return NULL;
6084 }
6085
6086
6087 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6088 PyObject *resultobj = 0;
6089 wxPoint *arg1 = (wxPoint *) 0 ;
6090 wxPoint *arg2 = 0 ;
6091 wxPoint *result = 0 ;
6092 void *argp1 = 0 ;
6093 int res1 = 0 ;
6094 wxPoint temp2 ;
6095 PyObject * obj0 = 0 ;
6096 PyObject * obj1 = 0 ;
6097 char * kwnames[] = {
6098 (char *) "self",(char *) "pt", NULL
6099 };
6100
6101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
6102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
6103 if (!SWIG_IsOK(res1)) {
6104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
6105 }
6106 arg1 = reinterpret_cast< wxPoint * >(argp1);
6107 {
6108 arg2 = &temp2;
6109 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6110 }
6111 {
6112 {
6113 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
6114 result = (wxPoint *) &_result_ref;
6115 }
6116 if (PyErr_Occurred()) SWIG_fail;
6117 }
6118 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6119 return resultobj;
6120 fail:
6121 return NULL;
6122 }
6123
6124
6125 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6126 PyObject *resultobj = 0;
6127 wxPoint *arg1 = (wxPoint *) 0 ;
6128 long arg2 ;
6129 long arg3 ;
6130 void *argp1 = 0 ;
6131 int res1 = 0 ;
6132 long val2 ;
6133 int ecode2 = 0 ;
6134 long val3 ;
6135 int ecode3 = 0 ;
6136 PyObject * obj0 = 0 ;
6137 PyObject * obj1 = 0 ;
6138 PyObject * obj2 = 0 ;
6139 char * kwnames[] = {
6140 (char *) "self",(char *) "x",(char *) "y", NULL
6141 };
6142
6143 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6144 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6145 if (!SWIG_IsOK(res1)) {
6146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6147 }
6148 arg1 = reinterpret_cast< wxPoint * >(argp1);
6149 ecode2 = SWIG_AsVal_long(obj1, &val2);
6150 if (!SWIG_IsOK(ecode2)) {
6151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6152 }
6153 arg2 = static_cast< long >(val2);
6154 ecode3 = SWIG_AsVal_long(obj2, &val3);
6155 if (!SWIG_IsOK(ecode3)) {
6156 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6157 }
6158 arg3 = static_cast< long >(val3);
6159 {
6160 wxPoint_Set(arg1,arg2,arg3);
6161 if (PyErr_Occurred()) SWIG_fail;
6162 }
6163 resultobj = SWIG_Py_Void();
6164 return resultobj;
6165 fail:
6166 return NULL;
6167 }
6168
6169
6170 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6171 PyObject *resultobj = 0;
6172 wxPoint *arg1 = (wxPoint *) 0 ;
6173 PyObject *result = 0 ;
6174 void *argp1 = 0 ;
6175 int res1 = 0 ;
6176 PyObject *swig_obj[1] ;
6177
6178 if (!args) SWIG_fail;
6179 swig_obj[0] = args;
6180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6181 if (!SWIG_IsOK(res1)) {
6182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6183 }
6184 arg1 = reinterpret_cast< wxPoint * >(argp1);
6185 {
6186 result = (PyObject *)wxPoint_Get(arg1);
6187 if (PyErr_Occurred()) SWIG_fail;
6188 }
6189 resultobj = result;
6190 return resultobj;
6191 fail:
6192 return NULL;
6193 }
6194
6195
6196 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6197 PyObject *obj;
6198 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6199 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6200 return SWIG_Py_Void();
6201 }
6202
6203 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6204 return SWIG_Python_InitShadowInstance(args);
6205 }
6206
6207 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6208 PyObject *resultobj = 0;
6209 int arg1 = (int) 0 ;
6210 int arg2 = (int) 0 ;
6211 int arg3 = (int) 0 ;
6212 int arg4 = (int) 0 ;
6213 wxRect *result = 0 ;
6214 int val1 ;
6215 int ecode1 = 0 ;
6216 int val2 ;
6217 int ecode2 = 0 ;
6218 int val3 ;
6219 int ecode3 = 0 ;
6220 int val4 ;
6221 int ecode4 = 0 ;
6222 PyObject * obj0 = 0 ;
6223 PyObject * obj1 = 0 ;
6224 PyObject * obj2 = 0 ;
6225 PyObject * obj3 = 0 ;
6226 char * kwnames[] = {
6227 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6228 };
6229
6230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6231 if (obj0) {
6232 ecode1 = SWIG_AsVal_int(obj0, &val1);
6233 if (!SWIG_IsOK(ecode1)) {
6234 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6235 }
6236 arg1 = static_cast< int >(val1);
6237 }
6238 if (obj1) {
6239 ecode2 = SWIG_AsVal_int(obj1, &val2);
6240 if (!SWIG_IsOK(ecode2)) {
6241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6242 }
6243 arg2 = static_cast< int >(val2);
6244 }
6245 if (obj2) {
6246 ecode3 = SWIG_AsVal_int(obj2, &val3);
6247 if (!SWIG_IsOK(ecode3)) {
6248 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6249 }
6250 arg3 = static_cast< int >(val3);
6251 }
6252 if (obj3) {
6253 ecode4 = SWIG_AsVal_int(obj3, &val4);
6254 if (!SWIG_IsOK(ecode4)) {
6255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6256 }
6257 arg4 = static_cast< int >(val4);
6258 }
6259 {
6260 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6261 if (PyErr_Occurred()) SWIG_fail;
6262 }
6263 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6264 return resultobj;
6265 fail:
6266 return NULL;
6267 }
6268
6269
6270 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6271 PyObject *resultobj = 0;
6272 wxPoint *arg1 = 0 ;
6273 wxPoint *arg2 = 0 ;
6274 wxRect *result = 0 ;
6275 wxPoint temp1 ;
6276 wxPoint temp2 ;
6277 PyObject * obj0 = 0 ;
6278 PyObject * obj1 = 0 ;
6279 char * kwnames[] = {
6280 (char *) "topLeft",(char *) "bottomRight", NULL
6281 };
6282
6283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6284 {
6285 arg1 = &temp1;
6286 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6287 }
6288 {
6289 arg2 = &temp2;
6290 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6291 }
6292 {
6293 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6294 if (PyErr_Occurred()) SWIG_fail;
6295 }
6296 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6297 return resultobj;
6298 fail:
6299 return NULL;
6300 }
6301
6302
6303 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6304 PyObject *resultobj = 0;
6305 wxPoint *arg1 = 0 ;
6306 wxSize *arg2 = 0 ;
6307 wxRect *result = 0 ;
6308 wxPoint temp1 ;
6309 wxSize temp2 ;
6310 PyObject * obj0 = 0 ;
6311 PyObject * obj1 = 0 ;
6312 char * kwnames[] = {
6313 (char *) "pos",(char *) "size", NULL
6314 };
6315
6316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6317 {
6318 arg1 = &temp1;
6319 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6320 }
6321 {
6322 arg2 = &temp2;
6323 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6324 }
6325 {
6326 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6327 if (PyErr_Occurred()) SWIG_fail;
6328 }
6329 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6330 return resultobj;
6331 fail:
6332 return NULL;
6333 }
6334
6335
6336 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6337 PyObject *resultobj = 0;
6338 wxSize *arg1 = 0 ;
6339 wxRect *result = 0 ;
6340 wxSize temp1 ;
6341 PyObject * obj0 = 0 ;
6342 char * kwnames[] = {
6343 (char *) "size", NULL
6344 };
6345
6346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6347 {
6348 arg1 = &temp1;
6349 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6350 }
6351 {
6352 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6353 if (PyErr_Occurred()) SWIG_fail;
6354 }
6355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6356 return resultobj;
6357 fail:
6358 return NULL;
6359 }
6360
6361
6362 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6363 PyObject *resultobj = 0;
6364 wxRect *arg1 = (wxRect *) 0 ;
6365 void *argp1 = 0 ;
6366 int res1 = 0 ;
6367 PyObject *swig_obj[1] ;
6368
6369 if (!args) SWIG_fail;
6370 swig_obj[0] = args;
6371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6372 if (!SWIG_IsOK(res1)) {
6373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6374 }
6375 arg1 = reinterpret_cast< wxRect * >(argp1);
6376 {
6377 delete arg1;
6378
6379 if (PyErr_Occurred()) SWIG_fail;
6380 }
6381 resultobj = SWIG_Py_Void();
6382 return resultobj;
6383 fail:
6384 return NULL;
6385 }
6386
6387
6388 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6389 PyObject *resultobj = 0;
6390 wxRect *arg1 = (wxRect *) 0 ;
6391 int result;
6392 void *argp1 = 0 ;
6393 int res1 = 0 ;
6394 PyObject *swig_obj[1] ;
6395
6396 if (!args) SWIG_fail;
6397 swig_obj[0] = args;
6398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6399 if (!SWIG_IsOK(res1)) {
6400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6401 }
6402 arg1 = reinterpret_cast< wxRect * >(argp1);
6403 {
6404 result = (int)((wxRect const *)arg1)->GetX();
6405 if (PyErr_Occurred()) SWIG_fail;
6406 }
6407 resultobj = SWIG_From_int(static_cast< int >(result));
6408 return resultobj;
6409 fail:
6410 return NULL;
6411 }
6412
6413
6414 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6415 PyObject *resultobj = 0;
6416 wxRect *arg1 = (wxRect *) 0 ;
6417 int arg2 ;
6418 void *argp1 = 0 ;
6419 int res1 = 0 ;
6420 int val2 ;
6421 int ecode2 = 0 ;
6422 PyObject * obj0 = 0 ;
6423 PyObject * obj1 = 0 ;
6424 char * kwnames[] = {
6425 (char *) "self",(char *) "x", NULL
6426 };
6427
6428 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6429 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6430 if (!SWIG_IsOK(res1)) {
6431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6432 }
6433 arg1 = reinterpret_cast< wxRect * >(argp1);
6434 ecode2 = SWIG_AsVal_int(obj1, &val2);
6435 if (!SWIG_IsOK(ecode2)) {
6436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6437 }
6438 arg2 = static_cast< int >(val2);
6439 {
6440 (arg1)->SetX(arg2);
6441 if (PyErr_Occurred()) SWIG_fail;
6442 }
6443 resultobj = SWIG_Py_Void();
6444 return resultobj;
6445 fail:
6446 return NULL;
6447 }
6448
6449
6450 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6451 PyObject *resultobj = 0;
6452 wxRect *arg1 = (wxRect *) 0 ;
6453 int result;
6454 void *argp1 = 0 ;
6455 int res1 = 0 ;
6456 PyObject *swig_obj[1] ;
6457
6458 if (!args) SWIG_fail;
6459 swig_obj[0] = args;
6460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6461 if (!SWIG_IsOK(res1)) {
6462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6463 }
6464 arg1 = reinterpret_cast< wxRect * >(argp1);
6465 {
6466 result = (int)(arg1)->GetY();
6467 if (PyErr_Occurred()) SWIG_fail;
6468 }
6469 resultobj = SWIG_From_int(static_cast< int >(result));
6470 return resultobj;
6471 fail:
6472 return NULL;
6473 }
6474
6475
6476 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6477 PyObject *resultobj = 0;
6478 wxRect *arg1 = (wxRect *) 0 ;
6479 int arg2 ;
6480 void *argp1 = 0 ;
6481 int res1 = 0 ;
6482 int val2 ;
6483 int ecode2 = 0 ;
6484 PyObject * obj0 = 0 ;
6485 PyObject * obj1 = 0 ;
6486 char * kwnames[] = {
6487 (char *) "self",(char *) "y", NULL
6488 };
6489
6490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6492 if (!SWIG_IsOK(res1)) {
6493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6494 }
6495 arg1 = reinterpret_cast< wxRect * >(argp1);
6496 ecode2 = SWIG_AsVal_int(obj1, &val2);
6497 if (!SWIG_IsOK(ecode2)) {
6498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6499 }
6500 arg2 = static_cast< int >(val2);
6501 {
6502 (arg1)->SetY(arg2);
6503 if (PyErr_Occurred()) SWIG_fail;
6504 }
6505 resultobj = SWIG_Py_Void();
6506 return resultobj;
6507 fail:
6508 return NULL;
6509 }
6510
6511
6512 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6513 PyObject *resultobj = 0;
6514 wxRect *arg1 = (wxRect *) 0 ;
6515 int result;
6516 void *argp1 = 0 ;
6517 int res1 = 0 ;
6518 PyObject *swig_obj[1] ;
6519
6520 if (!args) SWIG_fail;
6521 swig_obj[0] = args;
6522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6523 if (!SWIG_IsOK(res1)) {
6524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6525 }
6526 arg1 = reinterpret_cast< wxRect * >(argp1);
6527 {
6528 result = (int)((wxRect const *)arg1)->GetWidth();
6529 if (PyErr_Occurred()) SWIG_fail;
6530 }
6531 resultobj = SWIG_From_int(static_cast< int >(result));
6532 return resultobj;
6533 fail:
6534 return NULL;
6535 }
6536
6537
6538 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6539 PyObject *resultobj = 0;
6540 wxRect *arg1 = (wxRect *) 0 ;
6541 int arg2 ;
6542 void *argp1 = 0 ;
6543 int res1 = 0 ;
6544 int val2 ;
6545 int ecode2 = 0 ;
6546 PyObject * obj0 = 0 ;
6547 PyObject * obj1 = 0 ;
6548 char * kwnames[] = {
6549 (char *) "self",(char *) "w", NULL
6550 };
6551
6552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6554 if (!SWIG_IsOK(res1)) {
6555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6556 }
6557 arg1 = reinterpret_cast< wxRect * >(argp1);
6558 ecode2 = SWIG_AsVal_int(obj1, &val2);
6559 if (!SWIG_IsOK(ecode2)) {
6560 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6561 }
6562 arg2 = static_cast< int >(val2);
6563 {
6564 (arg1)->SetWidth(arg2);
6565 if (PyErr_Occurred()) SWIG_fail;
6566 }
6567 resultobj = SWIG_Py_Void();
6568 return resultobj;
6569 fail:
6570 return NULL;
6571 }
6572
6573
6574 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6575 PyObject *resultobj = 0;
6576 wxRect *arg1 = (wxRect *) 0 ;
6577 int result;
6578 void *argp1 = 0 ;
6579 int res1 = 0 ;
6580 PyObject *swig_obj[1] ;
6581
6582 if (!args) SWIG_fail;
6583 swig_obj[0] = args;
6584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6585 if (!SWIG_IsOK(res1)) {
6586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6587 }
6588 arg1 = reinterpret_cast< wxRect * >(argp1);
6589 {
6590 result = (int)((wxRect const *)arg1)->GetHeight();
6591 if (PyErr_Occurred()) SWIG_fail;
6592 }
6593 resultobj = SWIG_From_int(static_cast< int >(result));
6594 return resultobj;
6595 fail:
6596 return NULL;
6597 }
6598
6599
6600 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6601 PyObject *resultobj = 0;
6602 wxRect *arg1 = (wxRect *) 0 ;
6603 int arg2 ;
6604 void *argp1 = 0 ;
6605 int res1 = 0 ;
6606 int val2 ;
6607 int ecode2 = 0 ;
6608 PyObject * obj0 = 0 ;
6609 PyObject * obj1 = 0 ;
6610 char * kwnames[] = {
6611 (char *) "self",(char *) "h", NULL
6612 };
6613
6614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6616 if (!SWIG_IsOK(res1)) {
6617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6618 }
6619 arg1 = reinterpret_cast< wxRect * >(argp1);
6620 ecode2 = SWIG_AsVal_int(obj1, &val2);
6621 if (!SWIG_IsOK(ecode2)) {
6622 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6623 }
6624 arg2 = static_cast< int >(val2);
6625 {
6626 (arg1)->SetHeight(arg2);
6627 if (PyErr_Occurred()) SWIG_fail;
6628 }
6629 resultobj = SWIG_Py_Void();
6630 return resultobj;
6631 fail:
6632 return NULL;
6633 }
6634
6635
6636 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6637 PyObject *resultobj = 0;
6638 wxRect *arg1 = (wxRect *) 0 ;
6639 wxPoint result;
6640 void *argp1 = 0 ;
6641 int res1 = 0 ;
6642 PyObject *swig_obj[1] ;
6643
6644 if (!args) SWIG_fail;
6645 swig_obj[0] = args;
6646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6647 if (!SWIG_IsOK(res1)) {
6648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6649 }
6650 arg1 = reinterpret_cast< wxRect * >(argp1);
6651 {
6652 result = ((wxRect const *)arg1)->GetPosition();
6653 if (PyErr_Occurred()) SWIG_fail;
6654 }
6655 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6656 return resultobj;
6657 fail:
6658 return NULL;
6659 }
6660
6661
6662 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6663 PyObject *resultobj = 0;
6664 wxRect *arg1 = (wxRect *) 0 ;
6665 wxPoint *arg2 = 0 ;
6666 void *argp1 = 0 ;
6667 int res1 = 0 ;
6668 wxPoint temp2 ;
6669 PyObject * obj0 = 0 ;
6670 PyObject * obj1 = 0 ;
6671 char * kwnames[] = {
6672 (char *) "self",(char *) "p", NULL
6673 };
6674
6675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6677 if (!SWIG_IsOK(res1)) {
6678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6679 }
6680 arg1 = reinterpret_cast< wxRect * >(argp1);
6681 {
6682 arg2 = &temp2;
6683 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6684 }
6685 {
6686 (arg1)->SetPosition((wxPoint const &)*arg2);
6687 if (PyErr_Occurred()) SWIG_fail;
6688 }
6689 resultobj = SWIG_Py_Void();
6690 return resultobj;
6691 fail:
6692 return NULL;
6693 }
6694
6695
6696 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6697 PyObject *resultobj = 0;
6698 wxRect *arg1 = (wxRect *) 0 ;
6699 wxSize result;
6700 void *argp1 = 0 ;
6701 int res1 = 0 ;
6702 PyObject *swig_obj[1] ;
6703
6704 if (!args) SWIG_fail;
6705 swig_obj[0] = args;
6706 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6707 if (!SWIG_IsOK(res1)) {
6708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6709 }
6710 arg1 = reinterpret_cast< wxRect * >(argp1);
6711 {
6712 result = ((wxRect const *)arg1)->GetSize();
6713 if (PyErr_Occurred()) SWIG_fail;
6714 }
6715 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6716 return resultobj;
6717 fail:
6718 return NULL;
6719 }
6720
6721
6722 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6723 PyObject *resultobj = 0;
6724 wxRect *arg1 = (wxRect *) 0 ;
6725 wxSize *arg2 = 0 ;
6726 void *argp1 = 0 ;
6727 int res1 = 0 ;
6728 wxSize temp2 ;
6729 PyObject * obj0 = 0 ;
6730 PyObject * obj1 = 0 ;
6731 char * kwnames[] = {
6732 (char *) "self",(char *) "s", NULL
6733 };
6734
6735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6737 if (!SWIG_IsOK(res1)) {
6738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6739 }
6740 arg1 = reinterpret_cast< wxRect * >(argp1);
6741 {
6742 arg2 = &temp2;
6743 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6744 }
6745 {
6746 (arg1)->SetSize((wxSize const &)*arg2);
6747 if (PyErr_Occurred()) SWIG_fail;
6748 }
6749 resultobj = SWIG_Py_Void();
6750 return resultobj;
6751 fail:
6752 return NULL;
6753 }
6754
6755
6756 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6757 PyObject *resultobj = 0;
6758 wxRect *arg1 = (wxRect *) 0 ;
6759 bool result;
6760 void *argp1 = 0 ;
6761 int res1 = 0 ;
6762 PyObject *swig_obj[1] ;
6763
6764 if (!args) SWIG_fail;
6765 swig_obj[0] = args;
6766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6767 if (!SWIG_IsOK(res1)) {
6768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6769 }
6770 arg1 = reinterpret_cast< wxRect * >(argp1);
6771 {
6772 result = (bool)((wxRect const *)arg1)->IsEmpty();
6773 if (PyErr_Occurred()) SWIG_fail;
6774 }
6775 {
6776 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6777 }
6778 return resultobj;
6779 fail:
6780 return NULL;
6781 }
6782
6783
6784 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6785 PyObject *resultobj = 0;
6786 wxRect *arg1 = (wxRect *) 0 ;
6787 wxPoint result;
6788 void *argp1 = 0 ;
6789 int res1 = 0 ;
6790 PyObject *swig_obj[1] ;
6791
6792 if (!args) SWIG_fail;
6793 swig_obj[0] = args;
6794 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6795 if (!SWIG_IsOK(res1)) {
6796 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6797 }
6798 arg1 = reinterpret_cast< wxRect * >(argp1);
6799 {
6800 result = ((wxRect const *)arg1)->GetTopLeft();
6801 if (PyErr_Occurred()) SWIG_fail;
6802 }
6803 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6804 return resultobj;
6805 fail:
6806 return NULL;
6807 }
6808
6809
6810 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6811 PyObject *resultobj = 0;
6812 wxRect *arg1 = (wxRect *) 0 ;
6813 wxPoint *arg2 = 0 ;
6814 void *argp1 = 0 ;
6815 int res1 = 0 ;
6816 wxPoint temp2 ;
6817 PyObject * obj0 = 0 ;
6818 PyObject * obj1 = 0 ;
6819 char * kwnames[] = {
6820 (char *) "self",(char *) "p", NULL
6821 };
6822
6823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6825 if (!SWIG_IsOK(res1)) {
6826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6827 }
6828 arg1 = reinterpret_cast< wxRect * >(argp1);
6829 {
6830 arg2 = &temp2;
6831 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6832 }
6833 {
6834 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6835 if (PyErr_Occurred()) SWIG_fail;
6836 }
6837 resultobj = SWIG_Py_Void();
6838 return resultobj;
6839 fail:
6840 return NULL;
6841 }
6842
6843
6844 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6845 PyObject *resultobj = 0;
6846 wxRect *arg1 = (wxRect *) 0 ;
6847 wxPoint result;
6848 void *argp1 = 0 ;
6849 int res1 = 0 ;
6850 PyObject *swig_obj[1] ;
6851
6852 if (!args) SWIG_fail;
6853 swig_obj[0] = args;
6854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6855 if (!SWIG_IsOK(res1)) {
6856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6857 }
6858 arg1 = reinterpret_cast< wxRect * >(argp1);
6859 {
6860 result = ((wxRect const *)arg1)->GetBottomRight();
6861 if (PyErr_Occurred()) SWIG_fail;
6862 }
6863 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6864 return resultobj;
6865 fail:
6866 return NULL;
6867 }
6868
6869
6870 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6871 PyObject *resultobj = 0;
6872 wxRect *arg1 = (wxRect *) 0 ;
6873 wxPoint *arg2 = 0 ;
6874 void *argp1 = 0 ;
6875 int res1 = 0 ;
6876 wxPoint temp2 ;
6877 PyObject * obj0 = 0 ;
6878 PyObject * obj1 = 0 ;
6879 char * kwnames[] = {
6880 (char *) "self",(char *) "p", NULL
6881 };
6882
6883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6885 if (!SWIG_IsOK(res1)) {
6886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6887 }
6888 arg1 = reinterpret_cast< wxRect * >(argp1);
6889 {
6890 arg2 = &temp2;
6891 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6892 }
6893 {
6894 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6895 if (PyErr_Occurred()) SWIG_fail;
6896 }
6897 resultobj = SWIG_Py_Void();
6898 return resultobj;
6899 fail:
6900 return NULL;
6901 }
6902
6903
6904 SWIGINTERN PyObject *_wrap_Rect_GetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6905 PyObject *resultobj = 0;
6906 wxRect *arg1 = (wxRect *) 0 ;
6907 wxPoint result;
6908 void *argp1 = 0 ;
6909 int res1 = 0 ;
6910 PyObject *swig_obj[1] ;
6911
6912 if (!args) SWIG_fail;
6913 swig_obj[0] = args;
6914 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6915 if (!SWIG_IsOK(res1)) {
6916 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6917 }
6918 arg1 = reinterpret_cast< wxRect * >(argp1);
6919 {
6920 result = ((wxRect const *)arg1)->GetTopRight();
6921 if (PyErr_Occurred()) SWIG_fail;
6922 }
6923 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6924 return resultobj;
6925 fail:
6926 return NULL;
6927 }
6928
6929
6930 SWIGINTERN PyObject *_wrap_Rect_SetTopRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6931 PyObject *resultobj = 0;
6932 wxRect *arg1 = (wxRect *) 0 ;
6933 wxPoint *arg2 = 0 ;
6934 void *argp1 = 0 ;
6935 int res1 = 0 ;
6936 wxPoint temp2 ;
6937 PyObject * obj0 = 0 ;
6938 PyObject * obj1 = 0 ;
6939 char * kwnames[] = {
6940 (char *) "self",(char *) "p", NULL
6941 };
6942
6943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopRight",kwnames,&obj0,&obj1)) SWIG_fail;
6944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6945 if (!SWIG_IsOK(res1)) {
6946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopRight" "', expected argument " "1"" of type '" "wxRect *""'");
6947 }
6948 arg1 = reinterpret_cast< wxRect * >(argp1);
6949 {
6950 arg2 = &temp2;
6951 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6952 }
6953 {
6954 (arg1)->SetTopRight((wxPoint const &)*arg2);
6955 if (PyErr_Occurred()) SWIG_fail;
6956 }
6957 resultobj = SWIG_Py_Void();
6958 return resultobj;
6959 fail:
6960 return NULL;
6961 }
6962
6963
6964 SWIGINTERN PyObject *_wrap_Rect_GetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6965 PyObject *resultobj = 0;
6966 wxRect *arg1 = (wxRect *) 0 ;
6967 wxPoint result;
6968 void *argp1 = 0 ;
6969 int res1 = 0 ;
6970 PyObject *swig_obj[1] ;
6971
6972 if (!args) SWIG_fail;
6973 swig_obj[0] = args;
6974 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6975 if (!SWIG_IsOK(res1)) {
6976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6977 }
6978 arg1 = reinterpret_cast< wxRect * >(argp1);
6979 {
6980 result = ((wxRect const *)arg1)->GetBottomLeft();
6981 if (PyErr_Occurred()) SWIG_fail;
6982 }
6983 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6984 return resultobj;
6985 fail:
6986 return NULL;
6987 }
6988
6989
6990 SWIGINTERN PyObject *_wrap_Rect_SetBottomLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6991 PyObject *resultobj = 0;
6992 wxRect *arg1 = (wxRect *) 0 ;
6993 wxPoint *arg2 = 0 ;
6994 void *argp1 = 0 ;
6995 int res1 = 0 ;
6996 wxPoint temp2 ;
6997 PyObject * obj0 = 0 ;
6998 PyObject * obj1 = 0 ;
6999 char * kwnames[] = {
7000 (char *) "self",(char *) "p", NULL
7001 };
7002
7003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7005 if (!SWIG_IsOK(res1)) {
7006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7007 }
7008 arg1 = reinterpret_cast< wxRect * >(argp1);
7009 {
7010 arg2 = &temp2;
7011 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7012 }
7013 {
7014 (arg1)->SetBottomLeft((wxPoint const &)*arg2);
7015 if (PyErr_Occurred()) SWIG_fail;
7016 }
7017 resultobj = SWIG_Py_Void();
7018 return resultobj;
7019 fail:
7020 return NULL;
7021 }
7022
7023
7024 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7025 PyObject *resultobj = 0;
7026 wxRect *arg1 = (wxRect *) 0 ;
7027 int result;
7028 void *argp1 = 0 ;
7029 int res1 = 0 ;
7030 PyObject *swig_obj[1] ;
7031
7032 if (!args) SWIG_fail;
7033 swig_obj[0] = args;
7034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7035 if (!SWIG_IsOK(res1)) {
7036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
7037 }
7038 arg1 = reinterpret_cast< wxRect * >(argp1);
7039 {
7040 result = (int)((wxRect const *)arg1)->GetLeft();
7041 if (PyErr_Occurred()) SWIG_fail;
7042 }
7043 resultobj = SWIG_From_int(static_cast< int >(result));
7044 return resultobj;
7045 fail:
7046 return NULL;
7047 }
7048
7049
7050 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7051 PyObject *resultobj = 0;
7052 wxRect *arg1 = (wxRect *) 0 ;
7053 int result;
7054 void *argp1 = 0 ;
7055 int res1 = 0 ;
7056 PyObject *swig_obj[1] ;
7057
7058 if (!args) SWIG_fail;
7059 swig_obj[0] = args;
7060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7061 if (!SWIG_IsOK(res1)) {
7062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
7063 }
7064 arg1 = reinterpret_cast< wxRect * >(argp1);
7065 {
7066 result = (int)((wxRect const *)arg1)->GetTop();
7067 if (PyErr_Occurred()) SWIG_fail;
7068 }
7069 resultobj = SWIG_From_int(static_cast< int >(result));
7070 return resultobj;
7071 fail:
7072 return NULL;
7073 }
7074
7075
7076 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7077 PyObject *resultobj = 0;
7078 wxRect *arg1 = (wxRect *) 0 ;
7079 int result;
7080 void *argp1 = 0 ;
7081 int res1 = 0 ;
7082 PyObject *swig_obj[1] ;
7083
7084 if (!args) SWIG_fail;
7085 swig_obj[0] = args;
7086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7087 if (!SWIG_IsOK(res1)) {
7088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
7089 }
7090 arg1 = reinterpret_cast< wxRect * >(argp1);
7091 {
7092 result = (int)((wxRect const *)arg1)->GetBottom();
7093 if (PyErr_Occurred()) SWIG_fail;
7094 }
7095 resultobj = SWIG_From_int(static_cast< int >(result));
7096 return resultobj;
7097 fail:
7098 return NULL;
7099 }
7100
7101
7102 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7103 PyObject *resultobj = 0;
7104 wxRect *arg1 = (wxRect *) 0 ;
7105 int result;
7106 void *argp1 = 0 ;
7107 int res1 = 0 ;
7108 PyObject *swig_obj[1] ;
7109
7110 if (!args) SWIG_fail;
7111 swig_obj[0] = args;
7112 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7113 if (!SWIG_IsOK(res1)) {
7114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
7115 }
7116 arg1 = reinterpret_cast< wxRect * >(argp1);
7117 {
7118 result = (int)((wxRect const *)arg1)->GetRight();
7119 if (PyErr_Occurred()) SWIG_fail;
7120 }
7121 resultobj = SWIG_From_int(static_cast< int >(result));
7122 return resultobj;
7123 fail:
7124 return NULL;
7125 }
7126
7127
7128 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7129 PyObject *resultobj = 0;
7130 wxRect *arg1 = (wxRect *) 0 ;
7131 int arg2 ;
7132 void *argp1 = 0 ;
7133 int res1 = 0 ;
7134 int val2 ;
7135 int ecode2 = 0 ;
7136 PyObject * obj0 = 0 ;
7137 PyObject * obj1 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "left", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
7143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7144 if (!SWIG_IsOK(res1)) {
7145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
7146 }
7147 arg1 = reinterpret_cast< wxRect * >(argp1);
7148 ecode2 = SWIG_AsVal_int(obj1, &val2);
7149 if (!SWIG_IsOK(ecode2)) {
7150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
7151 }
7152 arg2 = static_cast< int >(val2);
7153 {
7154 (arg1)->SetLeft(arg2);
7155 if (PyErr_Occurred()) SWIG_fail;
7156 }
7157 resultobj = SWIG_Py_Void();
7158 return resultobj;
7159 fail:
7160 return NULL;
7161 }
7162
7163
7164 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7165 PyObject *resultobj = 0;
7166 wxRect *arg1 = (wxRect *) 0 ;
7167 int arg2 ;
7168 void *argp1 = 0 ;
7169 int res1 = 0 ;
7170 int val2 ;
7171 int ecode2 = 0 ;
7172 PyObject * obj0 = 0 ;
7173 PyObject * obj1 = 0 ;
7174 char * kwnames[] = {
7175 (char *) "self",(char *) "right", NULL
7176 };
7177
7178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
7179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7180 if (!SWIG_IsOK(res1)) {
7181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
7182 }
7183 arg1 = reinterpret_cast< wxRect * >(argp1);
7184 ecode2 = SWIG_AsVal_int(obj1, &val2);
7185 if (!SWIG_IsOK(ecode2)) {
7186 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
7187 }
7188 arg2 = static_cast< int >(val2);
7189 {
7190 (arg1)->SetRight(arg2);
7191 if (PyErr_Occurred()) SWIG_fail;
7192 }
7193 resultobj = SWIG_Py_Void();
7194 return resultobj;
7195 fail:
7196 return NULL;
7197 }
7198
7199
7200 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7201 PyObject *resultobj = 0;
7202 wxRect *arg1 = (wxRect *) 0 ;
7203 int arg2 ;
7204 void *argp1 = 0 ;
7205 int res1 = 0 ;
7206 int val2 ;
7207 int ecode2 = 0 ;
7208 PyObject * obj0 = 0 ;
7209 PyObject * obj1 = 0 ;
7210 char * kwnames[] = {
7211 (char *) "self",(char *) "top", NULL
7212 };
7213
7214 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7215 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7216 if (!SWIG_IsOK(res1)) {
7217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7218 }
7219 arg1 = reinterpret_cast< wxRect * >(argp1);
7220 ecode2 = SWIG_AsVal_int(obj1, &val2);
7221 if (!SWIG_IsOK(ecode2)) {
7222 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7223 }
7224 arg2 = static_cast< int >(val2);
7225 {
7226 (arg1)->SetTop(arg2);
7227 if (PyErr_Occurred()) SWIG_fail;
7228 }
7229 resultobj = SWIG_Py_Void();
7230 return resultobj;
7231 fail:
7232 return NULL;
7233 }
7234
7235
7236 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7237 PyObject *resultobj = 0;
7238 wxRect *arg1 = (wxRect *) 0 ;
7239 int arg2 ;
7240 void *argp1 = 0 ;
7241 int res1 = 0 ;
7242 int val2 ;
7243 int ecode2 = 0 ;
7244 PyObject * obj0 = 0 ;
7245 PyObject * obj1 = 0 ;
7246 char * kwnames[] = {
7247 (char *) "self",(char *) "bottom", NULL
7248 };
7249
7250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7252 if (!SWIG_IsOK(res1)) {
7253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7254 }
7255 arg1 = reinterpret_cast< wxRect * >(argp1);
7256 ecode2 = SWIG_AsVal_int(obj1, &val2);
7257 if (!SWIG_IsOK(ecode2)) {
7258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7259 }
7260 arg2 = static_cast< int >(val2);
7261 {
7262 (arg1)->SetBottom(arg2);
7263 if (PyErr_Occurred()) SWIG_fail;
7264 }
7265 resultobj = SWIG_Py_Void();
7266 return resultobj;
7267 fail:
7268 return NULL;
7269 }
7270
7271
7272 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7273 PyObject *resultobj = 0;
7274 wxRect *arg1 = (wxRect *) 0 ;
7275 int arg2 ;
7276 int arg3 ;
7277 wxRect result;
7278 void *argp1 = 0 ;
7279 int res1 = 0 ;
7280 int val2 ;
7281 int ecode2 = 0 ;
7282 int val3 ;
7283 int ecode3 = 0 ;
7284 PyObject * obj0 = 0 ;
7285 PyObject * obj1 = 0 ;
7286 PyObject * obj2 = 0 ;
7287 char * kwnames[] = {
7288 (char *) "self",(char *) "dx",(char *) "dy", NULL
7289 };
7290
7291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7293 if (!SWIG_IsOK(res1)) {
7294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7295 }
7296 arg1 = reinterpret_cast< wxRect * >(argp1);
7297 ecode2 = SWIG_AsVal_int(obj1, &val2);
7298 if (!SWIG_IsOK(ecode2)) {
7299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7300 }
7301 arg2 = static_cast< int >(val2);
7302 ecode3 = SWIG_AsVal_int(obj2, &val3);
7303 if (!SWIG_IsOK(ecode3)) {
7304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7305 }
7306 arg3 = static_cast< int >(val3);
7307 {
7308 result = (arg1)->Inflate(arg2,arg3);
7309 if (PyErr_Occurred()) SWIG_fail;
7310 }
7311 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7312 return resultobj;
7313 fail:
7314 return NULL;
7315 }
7316
7317
7318 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7319 PyObject *resultobj = 0;
7320 wxRect *arg1 = (wxRect *) 0 ;
7321 int arg2 ;
7322 int arg3 ;
7323 wxRect *result = 0 ;
7324 void *argp1 = 0 ;
7325 int res1 = 0 ;
7326 int val2 ;
7327 int ecode2 = 0 ;
7328 int val3 ;
7329 int ecode3 = 0 ;
7330 PyObject * obj0 = 0 ;
7331 PyObject * obj1 = 0 ;
7332 PyObject * obj2 = 0 ;
7333 char * kwnames[] = {
7334 (char *) "self",(char *) "dx",(char *) "dy", NULL
7335 };
7336
7337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7339 if (!SWIG_IsOK(res1)) {
7340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Deflate" "', expected argument " "1"" of type '" "wxRect *""'");
7341 }
7342 arg1 = reinterpret_cast< wxRect * >(argp1);
7343 ecode2 = SWIG_AsVal_int(obj1, &val2);
7344 if (!SWIG_IsOK(ecode2)) {
7345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Deflate" "', expected argument " "2"" of type '" "int""'");
7346 }
7347 arg2 = static_cast< int >(val2);
7348 ecode3 = SWIG_AsVal_int(obj2, &val3);
7349 if (!SWIG_IsOK(ecode3)) {
7350 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7351 }
7352 arg3 = static_cast< int >(val3);
7353 {
7354 {
7355 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7356 result = (wxRect *) &_result_ref;
7357 }
7358 if (PyErr_Occurred()) SWIG_fail;
7359 }
7360 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7361 return resultobj;
7362 fail:
7363 return NULL;
7364 }
7365
7366
7367 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7368 PyObject *resultobj = 0;
7369 wxRect *arg1 = (wxRect *) 0 ;
7370 int arg2 ;
7371 int arg3 ;
7372 void *argp1 = 0 ;
7373 int res1 = 0 ;
7374 int val2 ;
7375 int ecode2 = 0 ;
7376 int val3 ;
7377 int ecode3 = 0 ;
7378 PyObject * obj0 = 0 ;
7379 PyObject * obj1 = 0 ;
7380 PyObject * obj2 = 0 ;
7381 char * kwnames[] = {
7382 (char *) "self",(char *) "dx",(char *) "dy", NULL
7383 };
7384
7385 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7386 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7387 if (!SWIG_IsOK(res1)) {
7388 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7389 }
7390 arg1 = reinterpret_cast< wxRect * >(argp1);
7391 ecode2 = SWIG_AsVal_int(obj1, &val2);
7392 if (!SWIG_IsOK(ecode2)) {
7393 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7394 }
7395 arg2 = static_cast< int >(val2);
7396 ecode3 = SWIG_AsVal_int(obj2, &val3);
7397 if (!SWIG_IsOK(ecode3)) {
7398 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7399 }
7400 arg3 = static_cast< int >(val3);
7401 {
7402 (arg1)->Offset(arg2,arg3);
7403 if (PyErr_Occurred()) SWIG_fail;
7404 }
7405 resultobj = SWIG_Py_Void();
7406 return resultobj;
7407 fail:
7408 return NULL;
7409 }
7410
7411
7412 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7413 PyObject *resultobj = 0;
7414 wxRect *arg1 = (wxRect *) 0 ;
7415 wxPoint *arg2 = 0 ;
7416 void *argp1 = 0 ;
7417 int res1 = 0 ;
7418 wxPoint temp2 ;
7419 PyObject * obj0 = 0 ;
7420 PyObject * obj1 = 0 ;
7421 char * kwnames[] = {
7422 (char *) "self",(char *) "pt", NULL
7423 };
7424
7425 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7426 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7427 if (!SWIG_IsOK(res1)) {
7428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7429 }
7430 arg1 = reinterpret_cast< wxRect * >(argp1);
7431 {
7432 arg2 = &temp2;
7433 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7434 }
7435 {
7436 (arg1)->Offset((wxPoint const &)*arg2);
7437 if (PyErr_Occurred()) SWIG_fail;
7438 }
7439 resultobj = SWIG_Py_Void();
7440 return resultobj;
7441 fail:
7442 return NULL;
7443 }
7444
7445
7446 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7447 PyObject *resultobj = 0;
7448 wxRect *arg1 = (wxRect *) 0 ;
7449 wxRect *arg2 = 0 ;
7450 wxRect result;
7451 void *argp1 = 0 ;
7452 int res1 = 0 ;
7453 wxRect temp2 ;
7454 PyObject * obj0 = 0 ;
7455 PyObject * obj1 = 0 ;
7456 char * kwnames[] = {
7457 (char *) "self",(char *) "rect", NULL
7458 };
7459
7460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7462 if (!SWIG_IsOK(res1)) {
7463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7464 }
7465 arg1 = reinterpret_cast< wxRect * >(argp1);
7466 {
7467 arg2 = &temp2;
7468 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7469 }
7470 {
7471 result = (arg1)->Intersect((wxRect const &)*arg2);
7472 if (PyErr_Occurred()) SWIG_fail;
7473 }
7474 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7475 return resultobj;
7476 fail:
7477 return NULL;
7478 }
7479
7480
7481 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7482 PyObject *resultobj = 0;
7483 wxRect *arg1 = (wxRect *) 0 ;
7484 wxRect *arg2 = 0 ;
7485 wxRect result;
7486 void *argp1 = 0 ;
7487 int res1 = 0 ;
7488 wxRect temp2 ;
7489 PyObject * obj0 = 0 ;
7490 PyObject * obj1 = 0 ;
7491 char * kwnames[] = {
7492 (char *) "self",(char *) "rect", NULL
7493 };
7494
7495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7497 if (!SWIG_IsOK(res1)) {
7498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7499 }
7500 arg1 = reinterpret_cast< wxRect * >(argp1);
7501 {
7502 arg2 = &temp2;
7503 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7504 }
7505 {
7506 result = (arg1)->Union((wxRect const &)*arg2);
7507 if (PyErr_Occurred()) SWIG_fail;
7508 }
7509 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7510 return resultobj;
7511 fail:
7512 return NULL;
7513 }
7514
7515
7516 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7517 PyObject *resultobj = 0;
7518 wxRect *arg1 = (wxRect *) 0 ;
7519 wxRect *arg2 = 0 ;
7520 wxRect result;
7521 void *argp1 = 0 ;
7522 int res1 = 0 ;
7523 wxRect temp2 ;
7524 PyObject * obj0 = 0 ;
7525 PyObject * obj1 = 0 ;
7526 char * kwnames[] = {
7527 (char *) "self",(char *) "rect", NULL
7528 };
7529
7530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7532 if (!SWIG_IsOK(res1)) {
7533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7534 }
7535 arg1 = reinterpret_cast< wxRect * >(argp1);
7536 {
7537 arg2 = &temp2;
7538 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7539 }
7540 {
7541 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7542 if (PyErr_Occurred()) SWIG_fail;
7543 }
7544 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7545 return resultobj;
7546 fail:
7547 return NULL;
7548 }
7549
7550
7551 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7552 PyObject *resultobj = 0;
7553 wxRect *arg1 = (wxRect *) 0 ;
7554 wxRect *arg2 = 0 ;
7555 wxRect *result = 0 ;
7556 void *argp1 = 0 ;
7557 int res1 = 0 ;
7558 wxRect temp2 ;
7559 PyObject * obj0 = 0 ;
7560 PyObject * obj1 = 0 ;
7561 char * kwnames[] = {
7562 (char *) "self",(char *) "rect", NULL
7563 };
7564
7565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7567 if (!SWIG_IsOK(res1)) {
7568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7569 }
7570 arg1 = reinterpret_cast< wxRect * >(argp1);
7571 {
7572 arg2 = &temp2;
7573 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7574 }
7575 {
7576 {
7577 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7578 result = (wxRect *) &_result_ref;
7579 }
7580 if (PyErr_Occurred()) SWIG_fail;
7581 }
7582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7583 return resultobj;
7584 fail:
7585 return NULL;
7586 }
7587
7588
7589 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7590 PyObject *resultobj = 0;
7591 wxRect *arg1 = (wxRect *) 0 ;
7592 PyObject *arg2 = (PyObject *) 0 ;
7593 bool result;
7594 void *argp1 = 0 ;
7595 int res1 = 0 ;
7596 PyObject * obj0 = 0 ;
7597 PyObject * obj1 = 0 ;
7598 char * kwnames[] = {
7599 (char *) "self",(char *) "other", NULL
7600 };
7601
7602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7604 if (!SWIG_IsOK(res1)) {
7605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7606 }
7607 arg1 = reinterpret_cast< wxRect * >(argp1);
7608 arg2 = obj1;
7609 {
7610 result = (bool)wxRect___eq__(arg1,arg2);
7611 if (PyErr_Occurred()) SWIG_fail;
7612 }
7613 {
7614 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7615 }
7616 return resultobj;
7617 fail:
7618 return NULL;
7619 }
7620
7621
7622 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7623 PyObject *resultobj = 0;
7624 wxRect *arg1 = (wxRect *) 0 ;
7625 PyObject *arg2 = (PyObject *) 0 ;
7626 bool result;
7627 void *argp1 = 0 ;
7628 int res1 = 0 ;
7629 PyObject * obj0 = 0 ;
7630 PyObject * obj1 = 0 ;
7631 char * kwnames[] = {
7632 (char *) "self",(char *) "other", NULL
7633 };
7634
7635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7637 if (!SWIG_IsOK(res1)) {
7638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7639 }
7640 arg1 = reinterpret_cast< wxRect * >(argp1);
7641 arg2 = obj1;
7642 {
7643 result = (bool)wxRect___ne__(arg1,arg2);
7644 if (PyErr_Occurred()) SWIG_fail;
7645 }
7646 {
7647 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7648 }
7649 return resultobj;
7650 fail:
7651 return NULL;
7652 }
7653
7654
7655 SWIGINTERN PyObject *_wrap_Rect_ContainsXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7656 PyObject *resultobj = 0;
7657 wxRect *arg1 = (wxRect *) 0 ;
7658 int arg2 ;
7659 int arg3 ;
7660 bool result;
7661 void *argp1 = 0 ;
7662 int res1 = 0 ;
7663 int val2 ;
7664 int ecode2 = 0 ;
7665 int val3 ;
7666 int ecode3 = 0 ;
7667 PyObject * obj0 = 0 ;
7668 PyObject * obj1 = 0 ;
7669 PyObject * obj2 = 0 ;
7670 char * kwnames[] = {
7671 (char *) "self",(char *) "x",(char *) "y", NULL
7672 };
7673
7674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_ContainsXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7676 if (!SWIG_IsOK(res1)) {
7677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7678 }
7679 arg1 = reinterpret_cast< wxRect * >(argp1);
7680 ecode2 = SWIG_AsVal_int(obj1, &val2);
7681 if (!SWIG_IsOK(ecode2)) {
7682 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_ContainsXY" "', expected argument " "2"" of type '" "int""'");
7683 }
7684 arg2 = static_cast< int >(val2);
7685 ecode3 = SWIG_AsVal_int(obj2, &val3);
7686 if (!SWIG_IsOK(ecode3)) {
7687 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_ContainsXY" "', expected argument " "3"" of type '" "int""'");
7688 }
7689 arg3 = static_cast< int >(val3);
7690 {
7691 result = (bool)((wxRect const *)arg1)->Contains(arg2,arg3);
7692 if (PyErr_Occurred()) SWIG_fail;
7693 }
7694 {
7695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7696 }
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 SWIGINTERN PyObject *_wrap_Rect_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7704 PyObject *resultobj = 0;
7705 wxRect *arg1 = (wxRect *) 0 ;
7706 wxPoint *arg2 = 0 ;
7707 bool result;
7708 void *argp1 = 0 ;
7709 int res1 = 0 ;
7710 wxPoint temp2 ;
7711 PyObject * obj0 = 0 ;
7712 PyObject * obj1 = 0 ;
7713 char * kwnames[] = {
7714 (char *) "self",(char *) "pt", NULL
7715 };
7716
7717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
7718 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7719 if (!SWIG_IsOK(res1)) {
7720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Contains" "', expected argument " "1"" of type '" "wxRect const *""'");
7721 }
7722 arg1 = reinterpret_cast< wxRect * >(argp1);
7723 {
7724 arg2 = &temp2;
7725 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7726 }
7727 {
7728 result = (bool)((wxRect const *)arg1)->Contains((wxPoint const &)*arg2);
7729 if (PyErr_Occurred()) SWIG_fail;
7730 }
7731 {
7732 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7733 }
7734 return resultobj;
7735 fail:
7736 return NULL;
7737 }
7738
7739
7740 SWIGINTERN PyObject *_wrap_Rect_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7741 PyObject *resultobj = 0;
7742 wxRect *arg1 = (wxRect *) 0 ;
7743 wxRect *arg2 = 0 ;
7744 bool result;
7745 void *argp1 = 0 ;
7746 int res1 = 0 ;
7747 wxRect temp2 ;
7748 PyObject * obj0 = 0 ;
7749 PyObject * obj1 = 0 ;
7750 char * kwnames[] = {
7751 (char *) "self",(char *) "rect", NULL
7752 };
7753
7754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
7755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7756 if (!SWIG_IsOK(res1)) {
7757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_ContainsRect" "', expected argument " "1"" of type '" "wxRect const *""'");
7758 }
7759 arg1 = reinterpret_cast< wxRect * >(argp1);
7760 {
7761 arg2 = &temp2;
7762 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7763 }
7764 {
7765 result = (bool)((wxRect const *)arg1)->Contains((wxRect const &)*arg2);
7766 if (PyErr_Occurred()) SWIG_fail;
7767 }
7768 {
7769 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7770 }
7771 return resultobj;
7772 fail:
7773 return NULL;
7774 }
7775
7776
7777 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7778 PyObject *resultobj = 0;
7779 wxRect *arg1 = (wxRect *) 0 ;
7780 wxRect *arg2 = 0 ;
7781 bool result;
7782 void *argp1 = 0 ;
7783 int res1 = 0 ;
7784 wxRect temp2 ;
7785 PyObject * obj0 = 0 ;
7786 PyObject * obj1 = 0 ;
7787 char * kwnames[] = {
7788 (char *) "self",(char *) "rect", NULL
7789 };
7790
7791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7793 if (!SWIG_IsOK(res1)) {
7794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7795 }
7796 arg1 = reinterpret_cast< wxRect * >(argp1);
7797 {
7798 arg2 = &temp2;
7799 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7800 }
7801 {
7802 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7803 if (PyErr_Occurred()) SWIG_fail;
7804 }
7805 {
7806 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7807 }
7808 return resultobj;
7809 fail:
7810 return NULL;
7811 }
7812
7813
7814 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7815 PyObject *resultobj = 0;
7816 wxRect *arg1 = (wxRect *) 0 ;
7817 wxRect *arg2 = 0 ;
7818 int arg3 = (int) wxBOTH ;
7819 wxRect result;
7820 void *argp1 = 0 ;
7821 int res1 = 0 ;
7822 wxRect temp2 ;
7823 int val3 ;
7824 int ecode3 = 0 ;
7825 PyObject * obj0 = 0 ;
7826 PyObject * obj1 = 0 ;
7827 PyObject * obj2 = 0 ;
7828 char * kwnames[] = {
7829 (char *) "self",(char *) "r",(char *) "dir", NULL
7830 };
7831
7832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7834 if (!SWIG_IsOK(res1)) {
7835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7836 }
7837 arg1 = reinterpret_cast< wxRect * >(argp1);
7838 {
7839 arg2 = &temp2;
7840 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7841 }
7842 if (obj2) {
7843 ecode3 = SWIG_AsVal_int(obj2, &val3);
7844 if (!SWIG_IsOK(ecode3)) {
7845 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7846 }
7847 arg3 = static_cast< int >(val3);
7848 }
7849 {
7850 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7851 if (PyErr_Occurred()) SWIG_fail;
7852 }
7853 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7854 return resultobj;
7855 fail:
7856 return NULL;
7857 }
7858
7859
7860 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7861 PyObject *resultobj = 0;
7862 wxRect *arg1 = (wxRect *) 0 ;
7863 int arg2 ;
7864 void *argp1 = 0 ;
7865 int res1 = 0 ;
7866 int val2 ;
7867 int ecode2 = 0 ;
7868 PyObject *swig_obj[2] ;
7869
7870 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7872 if (!SWIG_IsOK(res1)) {
7873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7874 }
7875 arg1 = reinterpret_cast< wxRect * >(argp1);
7876 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7877 if (!SWIG_IsOK(ecode2)) {
7878 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7879 }
7880 arg2 = static_cast< int >(val2);
7881 if (arg1) (arg1)->x = arg2;
7882
7883 resultobj = SWIG_Py_Void();
7884 return resultobj;
7885 fail:
7886 return NULL;
7887 }
7888
7889
7890 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7891 PyObject *resultobj = 0;
7892 wxRect *arg1 = (wxRect *) 0 ;
7893 int result;
7894 void *argp1 = 0 ;
7895 int res1 = 0 ;
7896 PyObject *swig_obj[1] ;
7897
7898 if (!args) SWIG_fail;
7899 swig_obj[0] = args;
7900 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7901 if (!SWIG_IsOK(res1)) {
7902 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7903 }
7904 arg1 = reinterpret_cast< wxRect * >(argp1);
7905 result = (int) ((arg1)->x);
7906 resultobj = SWIG_From_int(static_cast< int >(result));
7907 return resultobj;
7908 fail:
7909 return NULL;
7910 }
7911
7912
7913 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7914 PyObject *resultobj = 0;
7915 wxRect *arg1 = (wxRect *) 0 ;
7916 int arg2 ;
7917 void *argp1 = 0 ;
7918 int res1 = 0 ;
7919 int val2 ;
7920 int ecode2 = 0 ;
7921 PyObject *swig_obj[2] ;
7922
7923 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7924 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7925 if (!SWIG_IsOK(res1)) {
7926 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7927 }
7928 arg1 = reinterpret_cast< wxRect * >(argp1);
7929 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7930 if (!SWIG_IsOK(ecode2)) {
7931 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7932 }
7933 arg2 = static_cast< int >(val2);
7934 if (arg1) (arg1)->y = arg2;
7935
7936 resultobj = SWIG_Py_Void();
7937 return resultobj;
7938 fail:
7939 return NULL;
7940 }
7941
7942
7943 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7944 PyObject *resultobj = 0;
7945 wxRect *arg1 = (wxRect *) 0 ;
7946 int result;
7947 void *argp1 = 0 ;
7948 int res1 = 0 ;
7949 PyObject *swig_obj[1] ;
7950
7951 if (!args) SWIG_fail;
7952 swig_obj[0] = args;
7953 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7954 if (!SWIG_IsOK(res1)) {
7955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7956 }
7957 arg1 = reinterpret_cast< wxRect * >(argp1);
7958 result = (int) ((arg1)->y);
7959 resultobj = SWIG_From_int(static_cast< int >(result));
7960 return resultobj;
7961 fail:
7962 return NULL;
7963 }
7964
7965
7966 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7967 PyObject *resultobj = 0;
7968 wxRect *arg1 = (wxRect *) 0 ;
7969 int arg2 ;
7970 void *argp1 = 0 ;
7971 int res1 = 0 ;
7972 int val2 ;
7973 int ecode2 = 0 ;
7974 PyObject *swig_obj[2] ;
7975
7976 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7978 if (!SWIG_IsOK(res1)) {
7979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7980 }
7981 arg1 = reinterpret_cast< wxRect * >(argp1);
7982 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7983 if (!SWIG_IsOK(ecode2)) {
7984 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7985 }
7986 arg2 = static_cast< int >(val2);
7987 if (arg1) (arg1)->width = arg2;
7988
7989 resultobj = SWIG_Py_Void();
7990 return resultobj;
7991 fail:
7992 return NULL;
7993 }
7994
7995
7996 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7997 PyObject *resultobj = 0;
7998 wxRect *arg1 = (wxRect *) 0 ;
7999 int result;
8000 void *argp1 = 0 ;
8001 int res1 = 0 ;
8002 PyObject *swig_obj[1] ;
8003
8004 if (!args) SWIG_fail;
8005 swig_obj[0] = args;
8006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8007 if (!SWIG_IsOK(res1)) {
8008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
8009 }
8010 arg1 = reinterpret_cast< wxRect * >(argp1);
8011 result = (int) ((arg1)->width);
8012 resultobj = SWIG_From_int(static_cast< int >(result));
8013 return resultobj;
8014 fail:
8015 return NULL;
8016 }
8017
8018
8019 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8020 PyObject *resultobj = 0;
8021 wxRect *arg1 = (wxRect *) 0 ;
8022 int arg2 ;
8023 void *argp1 = 0 ;
8024 int res1 = 0 ;
8025 int val2 ;
8026 int ecode2 = 0 ;
8027 PyObject *swig_obj[2] ;
8028
8029 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
8030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8031 if (!SWIG_IsOK(res1)) {
8032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
8033 }
8034 arg1 = reinterpret_cast< wxRect * >(argp1);
8035 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
8036 if (!SWIG_IsOK(ecode2)) {
8037 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
8038 }
8039 arg2 = static_cast< int >(val2);
8040 if (arg1) (arg1)->height = arg2;
8041
8042 resultobj = SWIG_Py_Void();
8043 return resultobj;
8044 fail:
8045 return NULL;
8046 }
8047
8048
8049 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8050 PyObject *resultobj = 0;
8051 wxRect *arg1 = (wxRect *) 0 ;
8052 int result;
8053 void *argp1 = 0 ;
8054 int res1 = 0 ;
8055 PyObject *swig_obj[1] ;
8056
8057 if (!args) SWIG_fail;
8058 swig_obj[0] = args;
8059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8060 if (!SWIG_IsOK(res1)) {
8061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
8062 }
8063 arg1 = reinterpret_cast< wxRect * >(argp1);
8064 result = (int) ((arg1)->height);
8065 resultobj = SWIG_From_int(static_cast< int >(result));
8066 return resultobj;
8067 fail:
8068 return NULL;
8069 }
8070
8071
8072 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8073 PyObject *resultobj = 0;
8074 wxRect *arg1 = (wxRect *) 0 ;
8075 int arg2 = (int) 0 ;
8076 int arg3 = (int) 0 ;
8077 int arg4 = (int) 0 ;
8078 int arg5 = (int) 0 ;
8079 void *argp1 = 0 ;
8080 int res1 = 0 ;
8081 int val2 ;
8082 int ecode2 = 0 ;
8083 int val3 ;
8084 int ecode3 = 0 ;
8085 int val4 ;
8086 int ecode4 = 0 ;
8087 int val5 ;
8088 int ecode5 = 0 ;
8089 PyObject * obj0 = 0 ;
8090 PyObject * obj1 = 0 ;
8091 PyObject * obj2 = 0 ;
8092 PyObject * obj3 = 0 ;
8093 PyObject * obj4 = 0 ;
8094 char * kwnames[] = {
8095 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
8096 };
8097
8098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
8099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8100 if (!SWIG_IsOK(res1)) {
8101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
8102 }
8103 arg1 = reinterpret_cast< wxRect * >(argp1);
8104 if (obj1) {
8105 ecode2 = SWIG_AsVal_int(obj1, &val2);
8106 if (!SWIG_IsOK(ecode2)) {
8107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
8108 }
8109 arg2 = static_cast< int >(val2);
8110 }
8111 if (obj2) {
8112 ecode3 = SWIG_AsVal_int(obj2, &val3);
8113 if (!SWIG_IsOK(ecode3)) {
8114 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
8115 }
8116 arg3 = static_cast< int >(val3);
8117 }
8118 if (obj3) {
8119 ecode4 = SWIG_AsVal_int(obj3, &val4);
8120 if (!SWIG_IsOK(ecode4)) {
8121 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
8122 }
8123 arg4 = static_cast< int >(val4);
8124 }
8125 if (obj4) {
8126 ecode5 = SWIG_AsVal_int(obj4, &val5);
8127 if (!SWIG_IsOK(ecode5)) {
8128 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
8129 }
8130 arg5 = static_cast< int >(val5);
8131 }
8132 {
8133 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
8134 if (PyErr_Occurred()) SWIG_fail;
8135 }
8136 resultobj = SWIG_Py_Void();
8137 return resultobj;
8138 fail:
8139 return NULL;
8140 }
8141
8142
8143 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8144 PyObject *resultobj = 0;
8145 wxRect *arg1 = (wxRect *) 0 ;
8146 PyObject *result = 0 ;
8147 void *argp1 = 0 ;
8148 int res1 = 0 ;
8149 PyObject *swig_obj[1] ;
8150
8151 if (!args) SWIG_fail;
8152 swig_obj[0] = args;
8153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8154 if (!SWIG_IsOK(res1)) {
8155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
8156 }
8157 arg1 = reinterpret_cast< wxRect * >(argp1);
8158 {
8159 result = (PyObject *)wxRect_Get(arg1);
8160 if (PyErr_Occurred()) SWIG_fail;
8161 }
8162 resultobj = result;
8163 return resultobj;
8164 fail:
8165 return NULL;
8166 }
8167
8168
8169 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8170 PyObject *obj;
8171 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8172 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
8173 return SWIG_Py_Void();
8174 }
8175
8176 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8177 return SWIG_Python_InitShadowInstance(args);
8178 }
8179
8180 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8181 PyObject *resultobj = 0;
8182 wxRect *arg1 = (wxRect *) 0 ;
8183 wxRect *arg2 = (wxRect *) 0 ;
8184 PyObject *result = 0 ;
8185 void *argp1 = 0 ;
8186 int res1 = 0 ;
8187 void *argp2 = 0 ;
8188 int res2 = 0 ;
8189 PyObject * obj0 = 0 ;
8190 PyObject * obj1 = 0 ;
8191 char * kwnames[] = {
8192 (char *) "r1",(char *) "r2", NULL
8193 };
8194
8195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
8196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
8197 if (!SWIG_IsOK(res1)) {
8198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
8199 }
8200 arg1 = reinterpret_cast< wxRect * >(argp1);
8201 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
8202 if (!SWIG_IsOK(res2)) {
8203 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
8204 }
8205 arg2 = reinterpret_cast< wxRect * >(argp2);
8206 {
8207 if (!wxPyCheckForApp()) SWIG_fail;
8208 PyThreadState* __tstate = wxPyBeginAllowThreads();
8209 result = (PyObject *)wxIntersectRect(arg1,arg2);
8210 wxPyEndAllowThreads(__tstate);
8211 if (PyErr_Occurred()) SWIG_fail;
8212 }
8213 resultobj = result;
8214 return resultobj;
8215 fail:
8216 return NULL;
8217 }
8218
8219
8220 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8221 PyObject *resultobj = 0;
8222 double arg1 = (double) 0.0 ;
8223 double arg2 = (double) 0.0 ;
8224 wxPoint2D *result = 0 ;
8225 double val1 ;
8226 int ecode1 = 0 ;
8227 double val2 ;
8228 int ecode2 = 0 ;
8229 PyObject * obj0 = 0 ;
8230 PyObject * obj1 = 0 ;
8231 char * kwnames[] = {
8232 (char *) "x",(char *) "y", NULL
8233 };
8234
8235 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8236 if (obj0) {
8237 ecode1 = SWIG_AsVal_double(obj0, &val1);
8238 if (!SWIG_IsOK(ecode1)) {
8239 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8240 }
8241 arg1 = static_cast< double >(val1);
8242 }
8243 if (obj1) {
8244 ecode2 = SWIG_AsVal_double(obj1, &val2);
8245 if (!SWIG_IsOK(ecode2)) {
8246 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8247 }
8248 arg2 = static_cast< double >(val2);
8249 }
8250 {
8251 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8252 if (PyErr_Occurred()) SWIG_fail;
8253 }
8254 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8255 return resultobj;
8256 fail:
8257 return NULL;
8258 }
8259
8260
8261 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8262 PyObject *resultobj = 0;
8263 wxPoint2D *arg1 = 0 ;
8264 wxPoint2D *result = 0 ;
8265 wxPoint2D temp1 ;
8266 PyObject * obj0 = 0 ;
8267 char * kwnames[] = {
8268 (char *) "pt", NULL
8269 };
8270
8271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8272 {
8273 arg1 = &temp1;
8274 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8275 }
8276 {
8277 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8278 if (PyErr_Occurred()) SWIG_fail;
8279 }
8280 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8281 return resultobj;
8282 fail:
8283 return NULL;
8284 }
8285
8286
8287 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8288 PyObject *resultobj = 0;
8289 wxPoint *arg1 = 0 ;
8290 wxPoint2D *result = 0 ;
8291 wxPoint temp1 ;
8292 PyObject * obj0 = 0 ;
8293 char * kwnames[] = {
8294 (char *) "pt", NULL
8295 };
8296
8297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8298 {
8299 arg1 = &temp1;
8300 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8301 }
8302 {
8303 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8304 if (PyErr_Occurred()) SWIG_fail;
8305 }
8306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8307 return resultobj;
8308 fail:
8309 return NULL;
8310 }
8311
8312
8313 SWIGINTERN PyObject *_wrap_delete_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8314 PyObject *resultobj = 0;
8315 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8316 void *argp1 = 0 ;
8317 int res1 = 0 ;
8318 PyObject *swig_obj[1] ;
8319
8320 if (!args) SWIG_fail;
8321 swig_obj[0] = args;
8322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8323 if (!SWIG_IsOK(res1)) {
8324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point2D" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8325 }
8326 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8327 {
8328 delete arg1;
8329
8330 if (PyErr_Occurred()) SWIG_fail;
8331 }
8332 resultobj = SWIG_Py_Void();
8333 return resultobj;
8334 fail:
8335 return NULL;
8336 }
8337
8338
8339 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8340 PyObject *resultobj = 0;
8341 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8342 int *arg2 = (int *) 0 ;
8343 int *arg3 = (int *) 0 ;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 int temp2 ;
8347 int res2 = SWIG_TMPOBJ ;
8348 int temp3 ;
8349 int res3 = SWIG_TMPOBJ ;
8350 PyObject *swig_obj[1] ;
8351
8352 arg2 = &temp2;
8353 arg3 = &temp3;
8354 if (!args) SWIG_fail;
8355 swig_obj[0] = args;
8356 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8357 if (!SWIG_IsOK(res1)) {
8358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8359 }
8360 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8361 {
8362 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8363 if (PyErr_Occurred()) SWIG_fail;
8364 }
8365 resultobj = SWIG_Py_Void();
8366 if (SWIG_IsTmpObj(res2)) {
8367 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8368 } else {
8369 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8370 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8371 }
8372 if (SWIG_IsTmpObj(res3)) {
8373 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8374 } else {
8375 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8376 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8377 }
8378 return resultobj;
8379 fail:
8380 return NULL;
8381 }
8382
8383
8384 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8385 PyObject *resultobj = 0;
8386 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8387 int *arg2 = (int *) 0 ;
8388 int *arg3 = (int *) 0 ;
8389 void *argp1 = 0 ;
8390 int res1 = 0 ;
8391 int temp2 ;
8392 int res2 = SWIG_TMPOBJ ;
8393 int temp3 ;
8394 int res3 = SWIG_TMPOBJ ;
8395 PyObject *swig_obj[1] ;
8396
8397 arg2 = &temp2;
8398 arg3 = &temp3;
8399 if (!args) SWIG_fail;
8400 swig_obj[0] = args;
8401 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8402 if (!SWIG_IsOK(res1)) {
8403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8404 }
8405 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8406 {
8407 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8408 if (PyErr_Occurred()) SWIG_fail;
8409 }
8410 resultobj = SWIG_Py_Void();
8411 if (SWIG_IsTmpObj(res2)) {
8412 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8413 } else {
8414 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8416 }
8417 if (SWIG_IsTmpObj(res3)) {
8418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8419 } else {
8420 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8422 }
8423 return resultobj;
8424 fail:
8425 return NULL;
8426 }
8427
8428
8429 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8430 PyObject *resultobj = 0;
8431 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8432 double result;
8433 void *argp1 = 0 ;
8434 int res1 = 0 ;
8435 PyObject *swig_obj[1] ;
8436
8437 if (!args) SWIG_fail;
8438 swig_obj[0] = args;
8439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8440 if (!SWIG_IsOK(res1)) {
8441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8442 }
8443 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8444 {
8445 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8446 if (PyErr_Occurred()) SWIG_fail;
8447 }
8448 resultobj = SWIG_From_double(static_cast< double >(result));
8449 return resultobj;
8450 fail:
8451 return NULL;
8452 }
8453
8454
8455 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8456 PyObject *resultobj = 0;
8457 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8458 double result;
8459 void *argp1 = 0 ;
8460 int res1 = 0 ;
8461 PyObject *swig_obj[1] ;
8462
8463 if (!args) SWIG_fail;
8464 swig_obj[0] = args;
8465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8466 if (!SWIG_IsOK(res1)) {
8467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8468 }
8469 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8470 {
8471 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8472 if (PyErr_Occurred()) SWIG_fail;
8473 }
8474 resultobj = SWIG_From_double(static_cast< double >(result));
8475 return resultobj;
8476 fail:
8477 return NULL;
8478 }
8479
8480
8481 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8482 PyObject *resultobj = 0;
8483 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8484 double arg2 ;
8485 void *argp1 = 0 ;
8486 int res1 = 0 ;
8487 double val2 ;
8488 int ecode2 = 0 ;
8489 PyObject * obj0 = 0 ;
8490 PyObject * obj1 = 0 ;
8491 char * kwnames[] = {
8492 (char *) "self",(char *) "length", NULL
8493 };
8494
8495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8496 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8497 if (!SWIG_IsOK(res1)) {
8498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8499 }
8500 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8501 ecode2 = SWIG_AsVal_double(obj1, &val2);
8502 if (!SWIG_IsOK(ecode2)) {
8503 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8504 }
8505 arg2 = static_cast< double >(val2);
8506 {
8507 (arg1)->SetVectorLength(arg2);
8508 if (PyErr_Occurred()) SWIG_fail;
8509 }
8510 resultobj = SWIG_Py_Void();
8511 return resultobj;
8512 fail:
8513 return NULL;
8514 }
8515
8516
8517 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8518 PyObject *resultobj = 0;
8519 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8520 double arg2 ;
8521 void *argp1 = 0 ;
8522 int res1 = 0 ;
8523 double val2 ;
8524 int ecode2 = 0 ;
8525 PyObject * obj0 = 0 ;
8526 PyObject * obj1 = 0 ;
8527 char * kwnames[] = {
8528 (char *) "self",(char *) "degrees", NULL
8529 };
8530
8531 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8532 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8533 if (!SWIG_IsOK(res1)) {
8534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8535 }
8536 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8537 ecode2 = SWIG_AsVal_double(obj1, &val2);
8538 if (!SWIG_IsOK(ecode2)) {
8539 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8540 }
8541 arg2 = static_cast< double >(val2);
8542 {
8543 (arg1)->SetVectorAngle(arg2);
8544 if (PyErr_Occurred()) SWIG_fail;
8545 }
8546 resultobj = SWIG_Py_Void();
8547 return resultobj;
8548 fail:
8549 return NULL;
8550 }
8551
8552
8553 SWIGINTERN PyObject *_wrap_Point2D_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8554 PyObject *resultobj = 0;
8555 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8556 wxPoint2D *arg2 = 0 ;
8557 double result;
8558 void *argp1 = 0 ;
8559 int res1 = 0 ;
8560 wxPoint2D temp2 ;
8561 PyObject * obj0 = 0 ;
8562 PyObject * obj1 = 0 ;
8563 char * kwnames[] = {
8564 (char *) "self",(char *) "pt", NULL
8565 };
8566
8567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8569 if (!SWIG_IsOK(res1)) {
8570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8571 }
8572 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8573 {
8574 arg2 = &temp2;
8575 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8576 }
8577 {
8578 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8579 if (PyErr_Occurred()) SWIG_fail;
8580 }
8581 resultobj = SWIG_From_double(static_cast< double >(result));
8582 return resultobj;
8583 fail:
8584 return NULL;
8585 }
8586
8587
8588 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8589 PyObject *resultobj = 0;
8590 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8591 wxPoint2D *arg2 = 0 ;
8592 double result;
8593 void *argp1 = 0 ;
8594 int res1 = 0 ;
8595 wxPoint2D temp2 ;
8596 PyObject * obj0 = 0 ;
8597 PyObject * obj1 = 0 ;
8598 char * kwnames[] = {
8599 (char *) "self",(char *) "pt", NULL
8600 };
8601
8602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8604 if (!SWIG_IsOK(res1)) {
8605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8606 }
8607 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8608 {
8609 arg2 = &temp2;
8610 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8611 }
8612 {
8613 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8614 if (PyErr_Occurred()) SWIG_fail;
8615 }
8616 resultobj = SWIG_From_double(static_cast< double >(result));
8617 return resultobj;
8618 fail:
8619 return NULL;
8620 }
8621
8622
8623 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8624 PyObject *resultobj = 0;
8625 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8626 wxPoint2D *arg2 = 0 ;
8627 double result;
8628 void *argp1 = 0 ;
8629 int res1 = 0 ;
8630 wxPoint2D temp2 ;
8631 PyObject * obj0 = 0 ;
8632 PyObject * obj1 = 0 ;
8633 char * kwnames[] = {
8634 (char *) "self",(char *) "vec", NULL
8635 };
8636
8637 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8638 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8639 if (!SWIG_IsOK(res1)) {
8640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8641 }
8642 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8643 {
8644 arg2 = &temp2;
8645 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8646 }
8647 {
8648 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8649 if (PyErr_Occurred()) SWIG_fail;
8650 }
8651 resultobj = SWIG_From_double(static_cast< double >(result));
8652 return resultobj;
8653 fail:
8654 return NULL;
8655 }
8656
8657
8658 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8659 PyObject *resultobj = 0;
8660 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8661 wxPoint2D *arg2 = 0 ;
8662 double result;
8663 void *argp1 = 0 ;
8664 int res1 = 0 ;
8665 wxPoint2D temp2 ;
8666 PyObject * obj0 = 0 ;
8667 PyObject * obj1 = 0 ;
8668 char * kwnames[] = {
8669 (char *) "self",(char *) "vec", NULL
8670 };
8671
8672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8674 if (!SWIG_IsOK(res1)) {
8675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8676 }
8677 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8678 {
8679 arg2 = &temp2;
8680 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8681 }
8682 {
8683 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8684 if (PyErr_Occurred()) SWIG_fail;
8685 }
8686 resultobj = SWIG_From_double(static_cast< double >(result));
8687 return resultobj;
8688 fail:
8689 return NULL;
8690 }
8691
8692
8693 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8694 PyObject *resultobj = 0;
8695 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8696 wxPoint2D result;
8697 void *argp1 = 0 ;
8698 int res1 = 0 ;
8699 PyObject *swig_obj[1] ;
8700
8701 if (!args) SWIG_fail;
8702 swig_obj[0] = args;
8703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8704 if (!SWIG_IsOK(res1)) {
8705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8706 }
8707 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8708 {
8709 result = (arg1)->operator -();
8710 if (PyErr_Occurred()) SWIG_fail;
8711 }
8712 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8713 return resultobj;
8714 fail:
8715 return NULL;
8716 }
8717
8718
8719 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8720 PyObject *resultobj = 0;
8721 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8722 wxPoint2D *arg2 = 0 ;
8723 wxPoint2D *result = 0 ;
8724 void *argp1 = 0 ;
8725 int res1 = 0 ;
8726 wxPoint2D temp2 ;
8727 PyObject * obj0 = 0 ;
8728 PyObject * obj1 = 0 ;
8729 char * kwnames[] = {
8730 (char *) "self",(char *) "pt", NULL
8731 };
8732
8733 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8734 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8735 if (!SWIG_IsOK(res1)) {
8736 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8737 }
8738 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8739 {
8740 arg2 = &temp2;
8741 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8742 }
8743 {
8744 {
8745 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8746 result = (wxPoint2D *) &_result_ref;
8747 }
8748 if (PyErr_Occurred()) SWIG_fail;
8749 }
8750 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8751 return resultobj;
8752 fail:
8753 return NULL;
8754 }
8755
8756
8757 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8758 PyObject *resultobj = 0;
8759 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8760 wxPoint2D *arg2 = 0 ;
8761 wxPoint2D *result = 0 ;
8762 void *argp1 = 0 ;
8763 int res1 = 0 ;
8764 wxPoint2D temp2 ;
8765 PyObject * obj0 = 0 ;
8766 PyObject * obj1 = 0 ;
8767 char * kwnames[] = {
8768 (char *) "self",(char *) "pt", NULL
8769 };
8770
8771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8773 if (!SWIG_IsOK(res1)) {
8774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8775 }
8776 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8777 {
8778 arg2 = &temp2;
8779 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8780 }
8781 {
8782 {
8783 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8784 result = (wxPoint2D *) &_result_ref;
8785 }
8786 if (PyErr_Occurred()) SWIG_fail;
8787 }
8788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8789 return resultobj;
8790 fail:
8791 return NULL;
8792 }
8793
8794
8795 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8796 PyObject *resultobj = 0;
8797 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8798 wxPoint2D *arg2 = 0 ;
8799 wxPoint2D *result = 0 ;
8800 void *argp1 = 0 ;
8801 int res1 = 0 ;
8802 wxPoint2D temp2 ;
8803 PyObject * obj0 = 0 ;
8804 PyObject * obj1 = 0 ;
8805 char * kwnames[] = {
8806 (char *) "self",(char *) "pt", NULL
8807 };
8808
8809 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8810 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8811 if (!SWIG_IsOK(res1)) {
8812 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8813 }
8814 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8815 {
8816 arg2 = &temp2;
8817 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8818 }
8819 {
8820 {
8821 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8822 result = (wxPoint2D *) &_result_ref;
8823 }
8824 if (PyErr_Occurred()) SWIG_fail;
8825 }
8826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8827 return resultobj;
8828 fail:
8829 return NULL;
8830 }
8831
8832
8833 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8834 PyObject *resultobj = 0;
8835 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8836 wxPoint2D *arg2 = 0 ;
8837 wxPoint2D *result = 0 ;
8838 void *argp1 = 0 ;
8839 int res1 = 0 ;
8840 wxPoint2D temp2 ;
8841 PyObject * obj0 = 0 ;
8842 PyObject * obj1 = 0 ;
8843 char * kwnames[] = {
8844 (char *) "self",(char *) "pt", NULL
8845 };
8846
8847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8849 if (!SWIG_IsOK(res1)) {
8850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8851 }
8852 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8853 {
8854 arg2 = &temp2;
8855 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8856 }
8857 {
8858 {
8859 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8860 result = (wxPoint2D *) &_result_ref;
8861 }
8862 if (PyErr_Occurred()) SWIG_fail;
8863 }
8864 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8865 return resultobj;
8866 fail:
8867 return NULL;
8868 }
8869
8870
8871 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8872 PyObject *resultobj = 0;
8873 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8874 PyObject *arg2 = (PyObject *) 0 ;
8875 bool result;
8876 void *argp1 = 0 ;
8877 int res1 = 0 ;
8878 PyObject * obj0 = 0 ;
8879 PyObject * obj1 = 0 ;
8880 char * kwnames[] = {
8881 (char *) "self",(char *) "other", NULL
8882 };
8883
8884 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8885 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8886 if (!SWIG_IsOK(res1)) {
8887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8888 }
8889 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8890 arg2 = obj1;
8891 {
8892 result = (bool)wxPoint2D___eq__(arg1,arg2);
8893 if (PyErr_Occurred()) SWIG_fail;
8894 }
8895 {
8896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8897 }
8898 return resultobj;
8899 fail:
8900 return NULL;
8901 }
8902
8903
8904 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8905 PyObject *resultobj = 0;
8906 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8907 PyObject *arg2 = (PyObject *) 0 ;
8908 bool result;
8909 void *argp1 = 0 ;
8910 int res1 = 0 ;
8911 PyObject * obj0 = 0 ;
8912 PyObject * obj1 = 0 ;
8913 char * kwnames[] = {
8914 (char *) "self",(char *) "other", NULL
8915 };
8916
8917 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8918 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8919 if (!SWIG_IsOK(res1)) {
8920 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8921 }
8922 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8923 arg2 = obj1;
8924 {
8925 result = (bool)wxPoint2D___ne__(arg1,arg2);
8926 if (PyErr_Occurred()) SWIG_fail;
8927 }
8928 {
8929 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8930 }
8931 return resultobj;
8932 fail:
8933 return NULL;
8934 }
8935
8936
8937 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8938 PyObject *resultobj = 0;
8939 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8940 double arg2 ;
8941 void *argp1 = 0 ;
8942 int res1 = 0 ;
8943 double val2 ;
8944 int ecode2 = 0 ;
8945 PyObject *swig_obj[2] ;
8946
8947 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8948 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8949 if (!SWIG_IsOK(res1)) {
8950 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8951 }
8952 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8953 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8954 if (!SWIG_IsOK(ecode2)) {
8955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8956 }
8957 arg2 = static_cast< double >(val2);
8958 if (arg1) (arg1)->m_x = arg2;
8959
8960 resultobj = SWIG_Py_Void();
8961 return resultobj;
8962 fail:
8963 return NULL;
8964 }
8965
8966
8967 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8968 PyObject *resultobj = 0;
8969 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8970 double result;
8971 void *argp1 = 0 ;
8972 int res1 = 0 ;
8973 PyObject *swig_obj[1] ;
8974
8975 if (!args) SWIG_fail;
8976 swig_obj[0] = args;
8977 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8978 if (!SWIG_IsOK(res1)) {
8979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8980 }
8981 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8982 result = (double) ((arg1)->m_x);
8983 resultobj = SWIG_From_double(static_cast< double >(result));
8984 return resultobj;
8985 fail:
8986 return NULL;
8987 }
8988
8989
8990 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8991 PyObject *resultobj = 0;
8992 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8993 double arg2 ;
8994 void *argp1 = 0 ;
8995 int res1 = 0 ;
8996 double val2 ;
8997 int ecode2 = 0 ;
8998 PyObject *swig_obj[2] ;
8999
9000 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
9001 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9002 if (!SWIG_IsOK(res1)) {
9003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9004 }
9005 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9006 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
9007 if (!SWIG_IsOK(ecode2)) {
9008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
9009 }
9010 arg2 = static_cast< double >(val2);
9011 if (arg1) (arg1)->m_y = arg2;
9012
9013 resultobj = SWIG_Py_Void();
9014 return resultobj;
9015 fail:
9016 return NULL;
9017 }
9018
9019
9020 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9021 PyObject *resultobj = 0;
9022 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9023 double result;
9024 void *argp1 = 0 ;
9025 int res1 = 0 ;
9026 PyObject *swig_obj[1] ;
9027
9028 if (!args) SWIG_fail;
9029 swig_obj[0] = args;
9030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9031 if (!SWIG_IsOK(res1)) {
9032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9033 }
9034 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9035 result = (double) ((arg1)->m_y);
9036 resultobj = SWIG_From_double(static_cast< double >(result));
9037 return resultobj;
9038 fail:
9039 return NULL;
9040 }
9041
9042
9043 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9044 PyObject *resultobj = 0;
9045 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9046 double arg2 = (double) 0 ;
9047 double arg3 = (double) 0 ;
9048 void *argp1 = 0 ;
9049 int res1 = 0 ;
9050 double val2 ;
9051 int ecode2 = 0 ;
9052 double val3 ;
9053 int ecode3 = 0 ;
9054 PyObject * obj0 = 0 ;
9055 PyObject * obj1 = 0 ;
9056 PyObject * obj2 = 0 ;
9057 char * kwnames[] = {
9058 (char *) "self",(char *) "x",(char *) "y", NULL
9059 };
9060
9061 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9062 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9063 if (!SWIG_IsOK(res1)) {
9064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9065 }
9066 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9067 if (obj1) {
9068 ecode2 = SWIG_AsVal_double(obj1, &val2);
9069 if (!SWIG_IsOK(ecode2)) {
9070 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
9071 }
9072 arg2 = static_cast< double >(val2);
9073 }
9074 if (obj2) {
9075 ecode3 = SWIG_AsVal_double(obj2, &val3);
9076 if (!SWIG_IsOK(ecode3)) {
9077 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
9078 }
9079 arg3 = static_cast< double >(val3);
9080 }
9081 {
9082 wxPoint2D_Set(arg1,arg2,arg3);
9083 if (PyErr_Occurred()) SWIG_fail;
9084 }
9085 resultobj = SWIG_Py_Void();
9086 return resultobj;
9087 fail:
9088 return NULL;
9089 }
9090
9091
9092 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9093 PyObject *resultobj = 0;
9094 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
9095 PyObject *result = 0 ;
9096 void *argp1 = 0 ;
9097 int res1 = 0 ;
9098 PyObject *swig_obj[1] ;
9099
9100 if (!args) SWIG_fail;
9101 swig_obj[0] = args;
9102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
9103 if (!SWIG_IsOK(res1)) {
9104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
9105 }
9106 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
9107 {
9108 result = (PyObject *)wxPoint2D_Get(arg1);
9109 if (PyErr_Occurred()) SWIG_fail;
9110 }
9111 resultobj = result;
9112 return resultobj;
9113 fail:
9114 return NULL;
9115 }
9116
9117
9118 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9119 PyObject *obj;
9120 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9121 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
9122 return SWIG_Py_Void();
9123 }
9124
9125 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9126 return SWIG_Python_InitShadowInstance(args);
9127 }
9128
9129 SWIGINTERN PyObject *_wrap_new_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9130 PyObject *resultobj = 0;
9131 wxDouble arg1 = (wxDouble) 0.0 ;
9132 wxDouble arg2 = (wxDouble) 0.0 ;
9133 wxDouble arg3 = (wxDouble) 0.0 ;
9134 wxDouble arg4 = (wxDouble) 0.0 ;
9135 wxRect2D *result = 0 ;
9136 void *argp1 ;
9137 int res1 = 0 ;
9138 void *argp2 ;
9139 int res2 = 0 ;
9140 void *argp3 ;
9141 int res3 = 0 ;
9142 void *argp4 ;
9143 int res4 = 0 ;
9144 PyObject * obj0 = 0 ;
9145 PyObject * obj1 = 0 ;
9146 PyObject * obj2 = 0 ;
9147 PyObject * obj3 = 0 ;
9148 char * kwnames[] = {
9149 (char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
9150 };
9151
9152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect2D",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
9153 if (obj0) {
9154 {
9155 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxDouble, 0 | 0);
9156 if (!SWIG_IsOK(res1)) {
9157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9158 }
9159 if (!argp1) {
9160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "1"" of type '" "wxDouble""'");
9161 } else {
9162 wxDouble * temp = reinterpret_cast< wxDouble * >(argp1);
9163 arg1 = *temp;
9164 if (SWIG_IsNewObj(res1)) delete temp;
9165 }
9166 }
9167 }
9168 if (obj1) {
9169 {
9170 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9171 if (!SWIG_IsOK(res2)) {
9172 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9173 }
9174 if (!argp2) {
9175 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "2"" of type '" "wxDouble""'");
9176 } else {
9177 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9178 arg2 = *temp;
9179 if (SWIG_IsNewObj(res2)) delete temp;
9180 }
9181 }
9182 }
9183 if (obj2) {
9184 {
9185 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
9186 if (!SWIG_IsOK(res3)) {
9187 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9188 }
9189 if (!argp3) {
9190 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "3"" of type '" "wxDouble""'");
9191 } else {
9192 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
9193 arg3 = *temp;
9194 if (SWIG_IsNewObj(res3)) delete temp;
9195 }
9196 }
9197 }
9198 if (obj3) {
9199 {
9200 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
9201 if (!SWIG_IsOK(res4)) {
9202 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9203 }
9204 if (!argp4) {
9205 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Rect2D" "', expected argument " "4"" of type '" "wxDouble""'");
9206 } else {
9207 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
9208 arg4 = *temp;
9209 if (SWIG_IsNewObj(res4)) delete temp;
9210 }
9211 }
9212 }
9213 {
9214 result = (wxRect2D *)new wxRect2D(arg1,arg2,arg3,arg4);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect2D, SWIG_POINTER_NEW | 0 );
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 SWIGINTERN PyObject *_wrap_delete_Rect2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9225 PyObject *resultobj = 0;
9226 wxRect2D *arg1 = (wxRect2D *) 0 ;
9227 void *argp1 = 0 ;
9228 int res1 = 0 ;
9229 PyObject *swig_obj[1] ;
9230
9231 if (!args) SWIG_fail;
9232 swig_obj[0] = args;
9233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, SWIG_POINTER_DISOWN | 0 );
9234 if (!SWIG_IsOK(res1)) {
9235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect2D" "', expected argument " "1"" of type '" "wxRect2D *""'");
9236 }
9237 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9238 {
9239 delete arg1;
9240
9241 if (PyErr_Occurred()) SWIG_fail;
9242 }
9243 resultobj = SWIG_Py_Void();
9244 return resultobj;
9245 fail:
9246 return NULL;
9247 }
9248
9249
9250 SWIGINTERN PyObject *_wrap_Rect2D_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9251 PyObject *resultobj = 0;
9252 wxRect2D *arg1 = (wxRect2D *) 0 ;
9253 wxPoint2D result;
9254 void *argp1 = 0 ;
9255 int res1 = 0 ;
9256 PyObject *swig_obj[1] ;
9257
9258 if (!args) SWIG_fail;
9259 swig_obj[0] = args;
9260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9261 if (!SWIG_IsOK(res1)) {
9262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetPosition" "', expected argument " "1"" of type '" "wxRect2D *""'");
9263 }
9264 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9265 {
9266 result = (arg1)->GetPosition();
9267 if (PyErr_Occurred()) SWIG_fail;
9268 }
9269 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9270 return resultobj;
9271 fail:
9272 return NULL;
9273 }
9274
9275
9276 SWIGINTERN PyObject *_wrap_Rect2D_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9277 PyObject *resultobj = 0;
9278 wxRect2D *arg1 = (wxRect2D *) 0 ;
9279 wxSize result;
9280 void *argp1 = 0 ;
9281 int res1 = 0 ;
9282 PyObject *swig_obj[1] ;
9283
9284 if (!args) SWIG_fail;
9285 swig_obj[0] = args;
9286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9287 if (!SWIG_IsOK(res1)) {
9288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetSize" "', expected argument " "1"" of type '" "wxRect2D *""'");
9289 }
9290 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9291 {
9292 result = (arg1)->GetSize();
9293 if (PyErr_Occurred()) SWIG_fail;
9294 }
9295 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
9296 return resultobj;
9297 fail:
9298 return NULL;
9299 }
9300
9301
9302 SWIGINTERN PyObject *_wrap_Rect2D_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9303 PyObject *resultobj = 0;
9304 wxRect2D *arg1 = (wxRect2D *) 0 ;
9305 wxDouble result;
9306 void *argp1 = 0 ;
9307 int res1 = 0 ;
9308 PyObject *swig_obj[1] ;
9309
9310 if (!args) SWIG_fail;
9311 swig_obj[0] = args;
9312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9313 if (!SWIG_IsOK(res1)) {
9314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeft" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9315 }
9316 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9317 {
9318 result = ((wxRect2D const *)arg1)->GetLeft();
9319 if (PyErr_Occurred()) SWIG_fail;
9320 }
9321 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9322 return resultobj;
9323 fail:
9324 return NULL;
9325 }
9326
9327
9328 SWIGINTERN PyObject *_wrap_Rect2D_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9329 PyObject *resultobj = 0;
9330 wxRect2D *arg1 = (wxRect2D *) 0 ;
9331 wxDouble arg2 ;
9332 void *argp1 = 0 ;
9333 int res1 = 0 ;
9334 void *argp2 ;
9335 int res2 = 0 ;
9336 PyObject * obj0 = 0 ;
9337 PyObject * obj1 = 0 ;
9338 char * kwnames[] = {
9339 (char *) "self",(char *) "n", NULL
9340 };
9341
9342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
9343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9344 if (!SWIG_IsOK(res1)) {
9345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeft" "', expected argument " "1"" of type '" "wxRect2D *""'");
9346 }
9347 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9348 {
9349 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9350 if (!SWIG_IsOK(res2)) {
9351 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9352 }
9353 if (!argp2) {
9354 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetLeft" "', expected argument " "2"" of type '" "wxDouble""'");
9355 } else {
9356 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9357 arg2 = *temp;
9358 if (SWIG_IsNewObj(res2)) delete temp;
9359 }
9360 }
9361 {
9362 (arg1)->SetLeft(arg2);
9363 if (PyErr_Occurred()) SWIG_fail;
9364 }
9365 resultobj = SWIG_Py_Void();
9366 return resultobj;
9367 fail:
9368 return NULL;
9369 }
9370
9371
9372 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9373 PyObject *resultobj = 0;
9374 wxRect2D *arg1 = (wxRect2D *) 0 ;
9375 wxDouble arg2 ;
9376 void *argp1 = 0 ;
9377 int res1 = 0 ;
9378 void *argp2 ;
9379 int res2 = 0 ;
9380 PyObject * obj0 = 0 ;
9381 PyObject * obj1 = 0 ;
9382 char * kwnames[] = {
9383 (char *) "self",(char *) "n", NULL
9384 };
9385
9386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTo",kwnames,&obj0,&obj1)) SWIG_fail;
9387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9388 if (!SWIG_IsOK(res1)) {
9389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9390 }
9391 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9392 {
9393 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9394 if (!SWIG_IsOK(res2)) {
9395 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9396 }
9397 if (!argp2) {
9398 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveLeftTo" "', expected argument " "2"" of type '" "wxDouble""'");
9399 } else {
9400 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9401 arg2 = *temp;
9402 if (SWIG_IsNewObj(res2)) delete temp;
9403 }
9404 }
9405 {
9406 (arg1)->MoveLeftTo(arg2);
9407 if (PyErr_Occurred()) SWIG_fail;
9408 }
9409 resultobj = SWIG_Py_Void();
9410 return resultobj;
9411 fail:
9412 return NULL;
9413 }
9414
9415
9416 SWIGINTERN PyObject *_wrap_Rect2D_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9417 PyObject *resultobj = 0;
9418 wxRect2D *arg1 = (wxRect2D *) 0 ;
9419 wxDouble result;
9420 void *argp1 = 0 ;
9421 int res1 = 0 ;
9422 PyObject *swig_obj[1] ;
9423
9424 if (!args) SWIG_fail;
9425 swig_obj[0] = args;
9426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9427 if (!SWIG_IsOK(res1)) {
9428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9429 }
9430 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9431 {
9432 result = ((wxRect2D const *)arg1)->GetTop();
9433 if (PyErr_Occurred()) SWIG_fail;
9434 }
9435 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9436 return resultobj;
9437 fail:
9438 return NULL;
9439 }
9440
9441
9442 SWIGINTERN PyObject *_wrap_Rect2D_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9443 PyObject *resultobj = 0;
9444 wxRect2D *arg1 = (wxRect2D *) 0 ;
9445 wxDouble arg2 ;
9446 void *argp1 = 0 ;
9447 int res1 = 0 ;
9448 void *argp2 ;
9449 int res2 = 0 ;
9450 PyObject * obj0 = 0 ;
9451 PyObject * obj1 = 0 ;
9452 char * kwnames[] = {
9453 (char *) "self",(char *) "n", NULL
9454 };
9455
9456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
9457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9458 if (!SWIG_IsOK(res1)) {
9459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9460 }
9461 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9462 {
9463 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9464 if (!SWIG_IsOK(res2)) {
9465 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9466 }
9467 if (!argp2) {
9468 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetTop" "', expected argument " "2"" of type '" "wxDouble""'");
9469 } else {
9470 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9471 arg2 = *temp;
9472 if (SWIG_IsNewObj(res2)) delete temp;
9473 }
9474 }
9475 {
9476 (arg1)->SetTop(arg2);
9477 if (PyErr_Occurred()) SWIG_fail;
9478 }
9479 resultobj = SWIG_Py_Void();
9480 return resultobj;
9481 fail:
9482 return NULL;
9483 }
9484
9485
9486 SWIGINTERN PyObject *_wrap_Rect2D_MoveTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9487 PyObject *resultobj = 0;
9488 wxRect2D *arg1 = (wxRect2D *) 0 ;
9489 wxDouble arg2 ;
9490 void *argp1 = 0 ;
9491 int res1 = 0 ;
9492 void *argp2 ;
9493 int res2 = 0 ;
9494 PyObject * obj0 = 0 ;
9495 PyObject * obj1 = 0 ;
9496 char * kwnames[] = {
9497 (char *) "self",(char *) "n", NULL
9498 };
9499
9500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9502 if (!SWIG_IsOK(res1)) {
9503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9504 }
9505 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9506 {
9507 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9508 if (!SWIG_IsOK(res2)) {
9509 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9510 }
9511 if (!argp2) {
9512 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveTopTo" "', expected argument " "2"" of type '" "wxDouble""'");
9513 } else {
9514 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9515 arg2 = *temp;
9516 if (SWIG_IsNewObj(res2)) delete temp;
9517 }
9518 }
9519 {
9520 (arg1)->MoveTopTo(arg2);
9521 if (PyErr_Occurred()) SWIG_fail;
9522 }
9523 resultobj = SWIG_Py_Void();
9524 return resultobj;
9525 fail:
9526 return NULL;
9527 }
9528
9529
9530 SWIGINTERN PyObject *_wrap_Rect2D_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9531 PyObject *resultobj = 0;
9532 wxRect2D *arg1 = (wxRect2D *) 0 ;
9533 wxDouble result;
9534 void *argp1 = 0 ;
9535 int res1 = 0 ;
9536 PyObject *swig_obj[1] ;
9537
9538 if (!args) SWIG_fail;
9539 swig_obj[0] = args;
9540 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9541 if (!SWIG_IsOK(res1)) {
9542 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9543 }
9544 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9545 {
9546 result = ((wxRect2D const *)arg1)->GetBottom();
9547 if (PyErr_Occurred()) SWIG_fail;
9548 }
9549 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9550 return resultobj;
9551 fail:
9552 return NULL;
9553 }
9554
9555
9556 SWIGINTERN PyObject *_wrap_Rect2D_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9557 PyObject *resultobj = 0;
9558 wxRect2D *arg1 = (wxRect2D *) 0 ;
9559 wxDouble arg2 ;
9560 void *argp1 = 0 ;
9561 int res1 = 0 ;
9562 void *argp2 ;
9563 int res2 = 0 ;
9564 PyObject * obj0 = 0 ;
9565 PyObject * obj1 = 0 ;
9566 char * kwnames[] = {
9567 (char *) "self",(char *) "n", NULL
9568 };
9569
9570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9572 if (!SWIG_IsOK(res1)) {
9573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9574 }
9575 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9576 {
9577 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9578 if (!SWIG_IsOK(res2)) {
9579 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9580 }
9581 if (!argp2) {
9582 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetBottom" "', expected argument " "2"" of type '" "wxDouble""'");
9583 } else {
9584 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9585 arg2 = *temp;
9586 if (SWIG_IsNewObj(res2)) delete temp;
9587 }
9588 }
9589 {
9590 (arg1)->SetBottom(arg2);
9591 if (PyErr_Occurred()) SWIG_fail;
9592 }
9593 resultobj = SWIG_Py_Void();
9594 return resultobj;
9595 fail:
9596 return NULL;
9597 }
9598
9599
9600 SWIGINTERN PyObject *_wrap_Rect2D_MoveBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9601 PyObject *resultobj = 0;
9602 wxRect2D *arg1 = (wxRect2D *) 0 ;
9603 wxDouble arg2 ;
9604 void *argp1 = 0 ;
9605 int res1 = 0 ;
9606 void *argp2 ;
9607 int res2 = 0 ;
9608 PyObject * obj0 = 0 ;
9609 PyObject * obj1 = 0 ;
9610 char * kwnames[] = {
9611 (char *) "self",(char *) "n", NULL
9612 };
9613
9614 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9615 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9616 if (!SWIG_IsOK(res1)) {
9617 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9618 }
9619 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9620 {
9621 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9622 if (!SWIG_IsOK(res2)) {
9623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9624 }
9625 if (!argp2) {
9626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveBottomTo" "', expected argument " "2"" of type '" "wxDouble""'");
9627 } else {
9628 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9629 arg2 = *temp;
9630 if (SWIG_IsNewObj(res2)) delete temp;
9631 }
9632 }
9633 {
9634 (arg1)->MoveBottomTo(arg2);
9635 if (PyErr_Occurred()) SWIG_fail;
9636 }
9637 resultobj = SWIG_Py_Void();
9638 return resultobj;
9639 fail:
9640 return NULL;
9641 }
9642
9643
9644 SWIGINTERN PyObject *_wrap_Rect2D_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9645 PyObject *resultobj = 0;
9646 wxRect2D *arg1 = (wxRect2D *) 0 ;
9647 wxDouble result;
9648 void *argp1 = 0 ;
9649 int res1 = 0 ;
9650 PyObject *swig_obj[1] ;
9651
9652 if (!args) SWIG_fail;
9653 swig_obj[0] = args;
9654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9655 if (!SWIG_IsOK(res1)) {
9656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRight" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9657 }
9658 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9659 {
9660 result = ((wxRect2D const *)arg1)->GetRight();
9661 if (PyErr_Occurred()) SWIG_fail;
9662 }
9663 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
9664 return resultobj;
9665 fail:
9666 return NULL;
9667 }
9668
9669
9670 SWIGINTERN PyObject *_wrap_Rect2D_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9671 PyObject *resultobj = 0;
9672 wxRect2D *arg1 = (wxRect2D *) 0 ;
9673 wxDouble arg2 ;
9674 void *argp1 = 0 ;
9675 int res1 = 0 ;
9676 void *argp2 ;
9677 int res2 = 0 ;
9678 PyObject * obj0 = 0 ;
9679 PyObject * obj1 = 0 ;
9680 char * kwnames[] = {
9681 (char *) "self",(char *) "n", NULL
9682 };
9683
9684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
9685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9686 if (!SWIG_IsOK(res1)) {
9687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRight" "', expected argument " "1"" of type '" "wxRect2D *""'");
9688 }
9689 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9690 {
9691 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9692 if (!SWIG_IsOK(res2)) {
9693 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9694 }
9695 if (!argp2) {
9696 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_SetRight" "', expected argument " "2"" of type '" "wxDouble""'");
9697 } else {
9698 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9699 arg2 = *temp;
9700 if (SWIG_IsNewObj(res2)) delete temp;
9701 }
9702 }
9703 {
9704 (arg1)->SetRight(arg2);
9705 if (PyErr_Occurred()) SWIG_fail;
9706 }
9707 resultobj = SWIG_Py_Void();
9708 return resultobj;
9709 fail:
9710 return NULL;
9711 }
9712
9713
9714 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9715 PyObject *resultobj = 0;
9716 wxRect2D *arg1 = (wxRect2D *) 0 ;
9717 wxDouble arg2 ;
9718 void *argp1 = 0 ;
9719 int res1 = 0 ;
9720 void *argp2 ;
9721 int res2 = 0 ;
9722 PyObject * obj0 = 0 ;
9723 PyObject * obj1 = 0 ;
9724 char * kwnames[] = {
9725 (char *) "self",(char *) "n", NULL
9726 };
9727
9728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTo",kwnames,&obj0,&obj1)) SWIG_fail;
9729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9730 if (!SWIG_IsOK(res1)) {
9731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9732 }
9733 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9734 {
9735 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
9736 if (!SWIG_IsOK(res2)) {
9737 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9738 }
9739 if (!argp2) {
9740 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_MoveRightTo" "', expected argument " "2"" of type '" "wxDouble""'");
9741 } else {
9742 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
9743 arg2 = *temp;
9744 if (SWIG_IsNewObj(res2)) delete temp;
9745 }
9746 }
9747 {
9748 (arg1)->MoveRightTo(arg2);
9749 if (PyErr_Occurred()) SWIG_fail;
9750 }
9751 resultobj = SWIG_Py_Void();
9752 return resultobj;
9753 fail:
9754 return NULL;
9755 }
9756
9757
9758 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9759 PyObject *resultobj = 0;
9760 wxRect2D *arg1 = (wxRect2D *) 0 ;
9761 wxPoint2D result;
9762 void *argp1 = 0 ;
9763 int res1 = 0 ;
9764 PyObject *swig_obj[1] ;
9765
9766 if (!args) SWIG_fail;
9767 swig_obj[0] = args;
9768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9769 if (!SWIG_IsOK(res1)) {
9770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9771 }
9772 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9773 {
9774 result = ((wxRect2D const *)arg1)->GetLeftTop();
9775 if (PyErr_Occurred()) SWIG_fail;
9776 }
9777 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9778 return resultobj;
9779 fail:
9780 return NULL;
9781 }
9782
9783
9784 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9785 PyObject *resultobj = 0;
9786 wxRect2D *arg1 = (wxRect2D *) 0 ;
9787 wxPoint2D *arg2 = 0 ;
9788 void *argp1 = 0 ;
9789 int res1 = 0 ;
9790 wxPoint2D temp2 ;
9791 PyObject * obj0 = 0 ;
9792 PyObject * obj1 = 0 ;
9793 char * kwnames[] = {
9794 (char *) "self",(char *) "pt", NULL
9795 };
9796
9797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftTop",kwnames,&obj0,&obj1)) SWIG_fail;
9798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9799 if (!SWIG_IsOK(res1)) {
9800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9801 }
9802 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9803 {
9804 arg2 = &temp2;
9805 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9806 }
9807 {
9808 (arg1)->SetLeftTop((wxPoint2D const &)*arg2);
9809 if (PyErr_Occurred()) SWIG_fail;
9810 }
9811 resultobj = SWIG_Py_Void();
9812 return resultobj;
9813 fail:
9814 return NULL;
9815 }
9816
9817
9818 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9819 PyObject *resultobj = 0;
9820 wxRect2D *arg1 = (wxRect2D *) 0 ;
9821 wxPoint2D *arg2 = 0 ;
9822 void *argp1 = 0 ;
9823 int res1 = 0 ;
9824 wxPoint2D temp2 ;
9825 PyObject * obj0 = 0 ;
9826 PyObject * obj1 = 0 ;
9827 char * kwnames[] = {
9828 (char *) "self",(char *) "pt", NULL
9829 };
9830
9831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
9832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9833 if (!SWIG_IsOK(res1)) {
9834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9835 }
9836 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9837 {
9838 arg2 = &temp2;
9839 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9840 }
9841 {
9842 (arg1)->MoveLeftTopTo((wxPoint2D const &)*arg2);
9843 if (PyErr_Occurred()) SWIG_fail;
9844 }
9845 resultobj = SWIG_Py_Void();
9846 return resultobj;
9847 fail:
9848 return NULL;
9849 }
9850
9851
9852 SWIGINTERN PyObject *_wrap_Rect2D_GetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9853 PyObject *resultobj = 0;
9854 wxRect2D *arg1 = (wxRect2D *) 0 ;
9855 wxPoint2D result;
9856 void *argp1 = 0 ;
9857 int res1 = 0 ;
9858 PyObject *swig_obj[1] ;
9859
9860 if (!args) SWIG_fail;
9861 swig_obj[0] = args;
9862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9863 if (!SWIG_IsOK(res1)) {
9864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9865 }
9866 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9867 {
9868 result = ((wxRect2D const *)arg1)->GetLeftBottom();
9869 if (PyErr_Occurred()) SWIG_fail;
9870 }
9871 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9872 return resultobj;
9873 fail:
9874 return NULL;
9875 }
9876
9877
9878 SWIGINTERN PyObject *_wrap_Rect2D_SetLeftBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9879 PyObject *resultobj = 0;
9880 wxRect2D *arg1 = (wxRect2D *) 0 ;
9881 wxPoint2D *arg2 = 0 ;
9882 void *argp1 = 0 ;
9883 int res1 = 0 ;
9884 wxPoint2D temp2 ;
9885 PyObject * obj0 = 0 ;
9886 PyObject * obj1 = 0 ;
9887 char * kwnames[] = {
9888 (char *) "self",(char *) "pt", NULL
9889 };
9890
9891 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetLeftBottom",kwnames,&obj0,&obj1)) SWIG_fail;
9892 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9893 if (!SWIG_IsOK(res1)) {
9894 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetLeftBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
9895 }
9896 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9897 {
9898 arg2 = &temp2;
9899 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9900 }
9901 {
9902 (arg1)->SetLeftBottom((wxPoint2D const &)*arg2);
9903 if (PyErr_Occurred()) SWIG_fail;
9904 }
9905 resultobj = SWIG_Py_Void();
9906 return resultobj;
9907 fail:
9908 return NULL;
9909 }
9910
9911
9912 SWIGINTERN PyObject *_wrap_Rect2D_MoveLeftBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9913 PyObject *resultobj = 0;
9914 wxRect2D *arg1 = (wxRect2D *) 0 ;
9915 wxPoint2D *arg2 = 0 ;
9916 void *argp1 = 0 ;
9917 int res1 = 0 ;
9918 wxPoint2D temp2 ;
9919 PyObject * obj0 = 0 ;
9920 PyObject * obj1 = 0 ;
9921 char * kwnames[] = {
9922 (char *) "self",(char *) "pt", NULL
9923 };
9924
9925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveLeftBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
9926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9927 if (!SWIG_IsOK(res1)) {
9928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveLeftBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
9929 }
9930 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9931 {
9932 arg2 = &temp2;
9933 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9934 }
9935 {
9936 (arg1)->MoveLeftBottomTo((wxPoint2D const &)*arg2);
9937 if (PyErr_Occurred()) SWIG_fail;
9938 }
9939 resultobj = SWIG_Py_Void();
9940 return resultobj;
9941 fail:
9942 return NULL;
9943 }
9944
9945
9946 SWIGINTERN PyObject *_wrap_Rect2D_GetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9947 PyObject *resultobj = 0;
9948 wxRect2D *arg1 = (wxRect2D *) 0 ;
9949 wxPoint2D result;
9950 void *argp1 = 0 ;
9951 int res1 = 0 ;
9952 PyObject *swig_obj[1] ;
9953
9954 if (!args) SWIG_fail;
9955 swig_obj[0] = args;
9956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9957 if (!SWIG_IsOK(res1)) {
9958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightTop" "', expected argument " "1"" of type '" "wxRect2D const *""'");
9959 }
9960 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9961 {
9962 result = ((wxRect2D const *)arg1)->GetRightTop();
9963 if (PyErr_Occurred()) SWIG_fail;
9964 }
9965 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
9966 return resultobj;
9967 fail:
9968 return NULL;
9969 }
9970
9971
9972 SWIGINTERN PyObject *_wrap_Rect2D_SetRightTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9973 PyObject *resultobj = 0;
9974 wxRect2D *arg1 = (wxRect2D *) 0 ;
9975 wxPoint2D *arg2 = 0 ;
9976 void *argp1 = 0 ;
9977 int res1 = 0 ;
9978 wxPoint2D temp2 ;
9979 PyObject * obj0 = 0 ;
9980 PyObject * obj1 = 0 ;
9981 char * kwnames[] = {
9982 (char *) "self",(char *) "pt", NULL
9983 };
9984
9985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightTop",kwnames,&obj0,&obj1)) SWIG_fail;
9986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
9987 if (!SWIG_IsOK(res1)) {
9988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightTop" "', expected argument " "1"" of type '" "wxRect2D *""'");
9989 }
9990 arg1 = reinterpret_cast< wxRect2D * >(argp1);
9991 {
9992 arg2 = &temp2;
9993 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
9994 }
9995 {
9996 (arg1)->SetRightTop((wxPoint2D const &)*arg2);
9997 if (PyErr_Occurred()) SWIG_fail;
9998 }
9999 resultobj = SWIG_Py_Void();
10000 return resultobj;
10001 fail:
10002 return NULL;
10003 }
10004
10005
10006 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightTopTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10007 PyObject *resultobj = 0;
10008 wxRect2D *arg1 = (wxRect2D *) 0 ;
10009 wxPoint2D *arg2 = 0 ;
10010 void *argp1 = 0 ;
10011 int res1 = 0 ;
10012 wxPoint2D temp2 ;
10013 PyObject * obj0 = 0 ;
10014 PyObject * obj1 = 0 ;
10015 char * kwnames[] = {
10016 (char *) "self",(char *) "pt", NULL
10017 };
10018
10019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightTopTo",kwnames,&obj0,&obj1)) SWIG_fail;
10020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10021 if (!SWIG_IsOK(res1)) {
10022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightTopTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10023 }
10024 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10025 {
10026 arg2 = &temp2;
10027 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10028 }
10029 {
10030 (arg1)->MoveRightTopTo((wxPoint2D const &)*arg2);
10031 if (PyErr_Occurred()) SWIG_fail;
10032 }
10033 resultobj = SWIG_Py_Void();
10034 return resultobj;
10035 fail:
10036 return NULL;
10037 }
10038
10039
10040 SWIGINTERN PyObject *_wrap_Rect2D_GetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10041 PyObject *resultobj = 0;
10042 wxRect2D *arg1 = (wxRect2D *) 0 ;
10043 wxPoint2D result;
10044 void *argp1 = 0 ;
10045 int res1 = 0 ;
10046 PyObject *swig_obj[1] ;
10047
10048 if (!args) SWIG_fail;
10049 swig_obj[0] = args;
10050 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10051 if (!SWIG_IsOK(res1)) {
10052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetRightBottom" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10053 }
10054 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10055 {
10056 result = ((wxRect2D const *)arg1)->GetRightBottom();
10057 if (PyErr_Occurred()) SWIG_fail;
10058 }
10059 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10060 return resultobj;
10061 fail:
10062 return NULL;
10063 }
10064
10065
10066 SWIGINTERN PyObject *_wrap_Rect2D_SetRightBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10067 PyObject *resultobj = 0;
10068 wxRect2D *arg1 = (wxRect2D *) 0 ;
10069 wxPoint2D *arg2 = 0 ;
10070 void *argp1 = 0 ;
10071 int res1 = 0 ;
10072 wxPoint2D temp2 ;
10073 PyObject * obj0 = 0 ;
10074 PyObject * obj1 = 0 ;
10075 char * kwnames[] = {
10076 (char *) "self",(char *) "pt", NULL
10077 };
10078
10079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetRightBottom",kwnames,&obj0,&obj1)) SWIG_fail;
10080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10081 if (!SWIG_IsOK(res1)) {
10082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetRightBottom" "', expected argument " "1"" of type '" "wxRect2D *""'");
10083 }
10084 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10085 {
10086 arg2 = &temp2;
10087 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10088 }
10089 {
10090 (arg1)->SetRightBottom((wxPoint2D const &)*arg2);
10091 if (PyErr_Occurred()) SWIG_fail;
10092 }
10093 resultobj = SWIG_Py_Void();
10094 return resultobj;
10095 fail:
10096 return NULL;
10097 }
10098
10099
10100 SWIGINTERN PyObject *_wrap_Rect2D_MoveRightBottomTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10101 PyObject *resultobj = 0;
10102 wxRect2D *arg1 = (wxRect2D *) 0 ;
10103 wxPoint2D *arg2 = 0 ;
10104 void *argp1 = 0 ;
10105 int res1 = 0 ;
10106 wxPoint2D temp2 ;
10107 PyObject * obj0 = 0 ;
10108 PyObject * obj1 = 0 ;
10109 char * kwnames[] = {
10110 (char *) "self",(char *) "pt", NULL
10111 };
10112
10113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveRightBottomTo",kwnames,&obj0,&obj1)) SWIG_fail;
10114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10115 if (!SWIG_IsOK(res1)) {
10116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveRightBottomTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10117 }
10118 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10119 {
10120 arg2 = &temp2;
10121 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10122 }
10123 {
10124 (arg1)->MoveRightBottomTo((wxPoint2D const &)*arg2);
10125 if (PyErr_Occurred()) SWIG_fail;
10126 }
10127 resultobj = SWIG_Py_Void();
10128 return resultobj;
10129 fail:
10130 return NULL;
10131 }
10132
10133
10134 SWIGINTERN PyObject *_wrap_Rect2D_GetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10135 PyObject *resultobj = 0;
10136 wxRect2D *arg1 = (wxRect2D *) 0 ;
10137 wxPoint2D result;
10138 void *argp1 = 0 ;
10139 int res1 = 0 ;
10140 PyObject *swig_obj[1] ;
10141
10142 if (!args) SWIG_fail;
10143 swig_obj[0] = args;
10144 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10145 if (!SWIG_IsOK(res1)) {
10146 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetCentre" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10147 }
10148 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10149 {
10150 result = ((wxRect2D const *)arg1)->GetCentre();
10151 if (PyErr_Occurred()) SWIG_fail;
10152 }
10153 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10154 return resultobj;
10155 fail:
10156 return NULL;
10157 }
10158
10159
10160 SWIGINTERN PyObject *_wrap_Rect2D_SetCentre(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10161 PyObject *resultobj = 0;
10162 wxRect2D *arg1 = (wxRect2D *) 0 ;
10163 wxPoint2D *arg2 = 0 ;
10164 void *argp1 = 0 ;
10165 int res1 = 0 ;
10166 wxPoint2D temp2 ;
10167 PyObject * obj0 = 0 ;
10168 PyObject * obj1 = 0 ;
10169 char * kwnames[] = {
10170 (char *) "self",(char *) "pt", NULL
10171 };
10172
10173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_SetCentre",kwnames,&obj0,&obj1)) SWIG_fail;
10174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10175 if (!SWIG_IsOK(res1)) {
10176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_SetCentre" "', expected argument " "1"" of type '" "wxRect2D *""'");
10177 }
10178 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10179 {
10180 arg2 = &temp2;
10181 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10182 }
10183 {
10184 (arg1)->SetCentre((wxPoint2D const &)*arg2);
10185 if (PyErr_Occurred()) SWIG_fail;
10186 }
10187 resultobj = SWIG_Py_Void();
10188 return resultobj;
10189 fail:
10190 return NULL;
10191 }
10192
10193
10194 SWIGINTERN PyObject *_wrap_Rect2D_MoveCentreTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10195 PyObject *resultobj = 0;
10196 wxRect2D *arg1 = (wxRect2D *) 0 ;
10197 wxPoint2D *arg2 = 0 ;
10198 void *argp1 = 0 ;
10199 int res1 = 0 ;
10200 wxPoint2D temp2 ;
10201 PyObject * obj0 = 0 ;
10202 PyObject * obj1 = 0 ;
10203 char * kwnames[] = {
10204 (char *) "self",(char *) "pt", NULL
10205 };
10206
10207 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_MoveCentreTo",kwnames,&obj0,&obj1)) SWIG_fail;
10208 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10209 if (!SWIG_IsOK(res1)) {
10210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_MoveCentreTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10211 }
10212 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10213 {
10214 arg2 = &temp2;
10215 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10216 }
10217 {
10218 (arg1)->MoveCentreTo((wxPoint2D const &)*arg2);
10219 if (PyErr_Occurred()) SWIG_fail;
10220 }
10221 resultobj = SWIG_Py_Void();
10222 return resultobj;
10223 fail:
10224 return NULL;
10225 }
10226
10227
10228 SWIGINTERN PyObject *_wrap_Rect2D_GetOutcode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10229 PyObject *resultobj = 0;
10230 wxRect2D *arg1 = (wxRect2D *) 0 ;
10231 wxPoint2D *arg2 = 0 ;
10232 wxOutCode result;
10233 void *argp1 = 0 ;
10234 int res1 = 0 ;
10235 wxPoint2D temp2 ;
10236 PyObject * obj0 = 0 ;
10237 PyObject * obj1 = 0 ;
10238 char * kwnames[] = {
10239 (char *) "self",(char *) "pt", NULL
10240 };
10241
10242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_GetOutcode",kwnames,&obj0,&obj1)) SWIG_fail;
10243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10244 if (!SWIG_IsOK(res1)) {
10245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_GetOutcode" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10246 }
10247 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10248 {
10249 arg2 = &temp2;
10250 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10251 }
10252 {
10253 result = (wxOutCode)((wxRect2D const *)arg1)->GetOutcode((wxPoint2D const &)*arg2);
10254 if (PyErr_Occurred()) SWIG_fail;
10255 }
10256 resultobj = SWIG_From_int(static_cast< int >(result));
10257 return resultobj;
10258 fail:
10259 return NULL;
10260 }
10261
10262
10263 SWIGINTERN PyObject *_wrap_Rect2D_Contains(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10264 PyObject *resultobj = 0;
10265 wxRect2D *arg1 = (wxRect2D *) 0 ;
10266 wxPoint2D *arg2 = 0 ;
10267 bool result;
10268 void *argp1 = 0 ;
10269 int res1 = 0 ;
10270 wxPoint2D temp2 ;
10271 PyObject * obj0 = 0 ;
10272 PyObject * obj1 = 0 ;
10273 char * kwnames[] = {
10274 (char *) "self",(char *) "pt", NULL
10275 };
10276
10277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Contains",kwnames,&obj0,&obj1)) SWIG_fail;
10278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10279 if (!SWIG_IsOK(res1)) {
10280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Contains" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10281 }
10282 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10283 {
10284 arg2 = &temp2;
10285 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10286 }
10287 {
10288 result = (bool)((wxRect2D const *)arg1)->Contains((wxPoint2D const &)*arg2);
10289 if (PyErr_Occurred()) SWIG_fail;
10290 }
10291 {
10292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10293 }
10294 return resultobj;
10295 fail:
10296 return NULL;
10297 }
10298
10299
10300 SWIGINTERN PyObject *_wrap_Rect2D_ContainsRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10301 PyObject *resultobj = 0;
10302 wxRect2D *arg1 = (wxRect2D *) 0 ;
10303 wxRect2D *arg2 = 0 ;
10304 bool result;
10305 void *argp1 = 0 ;
10306 int res1 = 0 ;
10307 wxRect2D temp2 ;
10308 PyObject * obj0 = 0 ;
10309 PyObject * obj1 = 0 ;
10310 char * kwnames[] = {
10311 (char *) "self",(char *) "rect", NULL
10312 };
10313
10314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ContainsRect",kwnames,&obj0,&obj1)) SWIG_fail;
10315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10316 if (!SWIG_IsOK(res1)) {
10317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ContainsRect" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10318 }
10319 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10320 {
10321 arg2 = &temp2;
10322 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10323 }
10324 {
10325 result = (bool)((wxRect2D const *)arg1)->Contains((wxRect2D const &)*arg2);
10326 if (PyErr_Occurred()) SWIG_fail;
10327 }
10328 {
10329 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10330 }
10331 return resultobj;
10332 fail:
10333 return NULL;
10334 }
10335
10336
10337 SWIGINTERN PyObject *_wrap_Rect2D_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10338 PyObject *resultobj = 0;
10339 wxRect2D *arg1 = (wxRect2D *) 0 ;
10340 bool result;
10341 void *argp1 = 0 ;
10342 int res1 = 0 ;
10343 PyObject *swig_obj[1] ;
10344
10345 if (!args) SWIG_fail;
10346 swig_obj[0] = args;
10347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10348 if (!SWIG_IsOK(res1)) {
10349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_IsEmpty" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10350 }
10351 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10352 {
10353 result = (bool)((wxRect2D const *)arg1)->IsEmpty();
10354 if (PyErr_Occurred()) SWIG_fail;
10355 }
10356 {
10357 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10358 }
10359 return resultobj;
10360 fail:
10361 return NULL;
10362 }
10363
10364
10365 SWIGINTERN PyObject *_wrap_Rect2D_HaveEqualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10366 PyObject *resultobj = 0;
10367 wxRect2D *arg1 = (wxRect2D *) 0 ;
10368 wxRect2D *arg2 = 0 ;
10369 bool result;
10370 void *argp1 = 0 ;
10371 int res1 = 0 ;
10372 wxRect2D temp2 ;
10373 PyObject * obj0 = 0 ;
10374 PyObject * obj1 = 0 ;
10375 char * kwnames[] = {
10376 (char *) "self",(char *) "rect", NULL
10377 };
10378
10379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_HaveEqualSize",kwnames,&obj0,&obj1)) SWIG_fail;
10380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10381 if (!SWIG_IsOK(res1)) {
10382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_HaveEqualSize" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10383 }
10384 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10385 {
10386 arg2 = &temp2;
10387 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10388 }
10389 {
10390 result = (bool)((wxRect2D const *)arg1)->HaveEqualSize((wxRect2D const &)*arg2);
10391 if (PyErr_Occurred()) SWIG_fail;
10392 }
10393 {
10394 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10395 }
10396 return resultobj;
10397 fail:
10398 return NULL;
10399 }
10400
10401
10402 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10403 PyObject *resultobj = 0;
10404 wxRect2D *arg1 = (wxRect2D *) 0 ;
10405 wxDouble arg2 ;
10406 wxDouble arg3 ;
10407 void *argp1 = 0 ;
10408 int res1 = 0 ;
10409 void *argp2 ;
10410 int res2 = 0 ;
10411 void *argp3 ;
10412 int res3 = 0 ;
10413
10414 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10415 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10416 if (!SWIG_IsOK(res1)) {
10417 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10418 }
10419 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10420 {
10421 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10422 if (!SWIG_IsOK(res2)) {
10423 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10424 }
10425 if (!argp2) {
10426 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10427 } else {
10428 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10429 arg2 = *temp;
10430 if (SWIG_IsNewObj(res2)) delete temp;
10431 }
10432 }
10433 {
10434 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10435 if (!SWIG_IsOK(res3)) {
10436 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10437 }
10438 if (!argp3) {
10439 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10440 } else {
10441 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10442 arg3 = *temp;
10443 if (SWIG_IsNewObj(res3)) delete temp;
10444 }
10445 }
10446 {
10447 (arg1)->Inset(arg2,arg3);
10448 if (PyErr_Occurred()) SWIG_fail;
10449 }
10450 resultobj = SWIG_Py_Void();
10451 return resultobj;
10452 fail:
10453 return NULL;
10454 }
10455
10456
10457 SWIGINTERN PyObject *_wrap_Rect2D_Inset__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10458 PyObject *resultobj = 0;
10459 wxRect2D *arg1 = (wxRect2D *) 0 ;
10460 wxDouble arg2 ;
10461 wxDouble arg3 ;
10462 wxDouble arg4 ;
10463 wxDouble arg5 ;
10464 void *argp1 = 0 ;
10465 int res1 = 0 ;
10466 void *argp2 ;
10467 int res2 = 0 ;
10468 void *argp3 ;
10469 int res3 = 0 ;
10470 void *argp4 ;
10471 int res4 = 0 ;
10472 void *argp5 ;
10473 int res5 = 0 ;
10474
10475 if ((nobjs < 5) || (nobjs > 5)) SWIG_fail;
10476 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10477 if (!SWIG_IsOK(res1)) {
10478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Inset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10479 }
10480 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10481 {
10482 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10483 if (!SWIG_IsOK(res2)) {
10484 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10485 }
10486 if (!argp2) {
10487 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "2"" of type '" "wxDouble""'");
10488 } else {
10489 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10490 arg2 = *temp;
10491 if (SWIG_IsNewObj(res2)) delete temp;
10492 }
10493 }
10494 {
10495 res3 = SWIG_ConvertPtr(swig_obj[2], &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
10496 if (!SWIG_IsOK(res3)) {
10497 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10498 }
10499 if (!argp3) {
10500 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "3"" of type '" "wxDouble""'");
10501 } else {
10502 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
10503 arg3 = *temp;
10504 if (SWIG_IsNewObj(res3)) delete temp;
10505 }
10506 }
10507 {
10508 res4 = SWIG_ConvertPtr(swig_obj[3], &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
10509 if (!SWIG_IsOK(res4)) {
10510 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10511 }
10512 if (!argp4) {
10513 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "4"" of type '" "wxDouble""'");
10514 } else {
10515 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
10516 arg4 = *temp;
10517 if (SWIG_IsNewObj(res4)) delete temp;
10518 }
10519 }
10520 {
10521 res5 = SWIG_ConvertPtr(swig_obj[4], &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
10522 if (!SWIG_IsOK(res5)) {
10523 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10524 }
10525 if (!argp5) {
10526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Inset" "', expected argument " "5"" of type '" "wxDouble""'");
10527 } else {
10528 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
10529 arg5 = *temp;
10530 if (SWIG_IsNewObj(res5)) delete temp;
10531 }
10532 }
10533 {
10534 (arg1)->Inset(arg2,arg3,arg4,arg5);
10535 if (PyErr_Occurred()) SWIG_fail;
10536 }
10537 resultobj = SWIG_Py_Void();
10538 return resultobj;
10539 fail:
10540 return NULL;
10541 }
10542
10543
10544 SWIGINTERN PyObject *_wrap_Rect2D_Inset(PyObject *self, PyObject *args) {
10545 int argc;
10546 PyObject *argv[6];
10547
10548 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Inset",0,5,argv))) SWIG_fail;
10549 --argc;
10550 if (argc == 3) {
10551 return _wrap_Rect2D_Inset__SWIG_0(self, argc, argv);
10552 }
10553 if (argc == 5) {
10554 return _wrap_Rect2D_Inset__SWIG_1(self, argc, argv);
10555 }
10556
10557 fail:
10558 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Inset'");
10559 return NULL;
10560 }
10561
10562
10563 SWIGINTERN PyObject *_wrap_Rect2D_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10564 PyObject *resultobj = 0;
10565 wxRect2D *arg1 = (wxRect2D *) 0 ;
10566 wxPoint2D *arg2 = 0 ;
10567 void *argp1 = 0 ;
10568 int res1 = 0 ;
10569 wxPoint2D temp2 ;
10570 PyObject * obj0 = 0 ;
10571 PyObject * obj1 = 0 ;
10572 char * kwnames[] = {
10573 (char *) "self",(char *) "pt", NULL
10574 };
10575
10576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
10577 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10578 if (!SWIG_IsOK(res1)) {
10579 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Offset" "', expected argument " "1"" of type '" "wxRect2D *""'");
10580 }
10581 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10582 {
10583 arg2 = &temp2;
10584 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
10585 }
10586 {
10587 (arg1)->Offset((wxPoint2D const &)*arg2);
10588 if (PyErr_Occurred()) SWIG_fail;
10589 }
10590 resultobj = SWIG_Py_Void();
10591 return resultobj;
10592 fail:
10593 return NULL;
10594 }
10595
10596
10597 SWIGINTERN PyObject *_wrap_Rect2D_ConstrainTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10598 PyObject *resultobj = 0;
10599 wxRect2D *arg1 = (wxRect2D *) 0 ;
10600 wxRect2D *arg2 = 0 ;
10601 void *argp1 = 0 ;
10602 int res1 = 0 ;
10603 wxRect2D temp2 ;
10604 PyObject * obj0 = 0 ;
10605 PyObject * obj1 = 0 ;
10606 char * kwnames[] = {
10607 (char *) "self",(char *) "rect", NULL
10608 };
10609
10610 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_ConstrainTo",kwnames,&obj0,&obj1)) SWIG_fail;
10611 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10612 if (!SWIG_IsOK(res1)) {
10613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_ConstrainTo" "', expected argument " "1"" of type '" "wxRect2D *""'");
10614 }
10615 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10616 {
10617 arg2 = &temp2;
10618 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10619 }
10620 {
10621 (arg1)->ConstrainTo((wxRect2D const &)*arg2);
10622 if (PyErr_Occurred()) SWIG_fail;
10623 }
10624 resultobj = SWIG_Py_Void();
10625 return resultobj;
10626 fail:
10627 return NULL;
10628 }
10629
10630
10631 SWIGINTERN PyObject *_wrap_Rect2D_Interpolate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10632 PyObject *resultobj = 0;
10633 wxRect2D *arg1 = (wxRect2D *) 0 ;
10634 int arg2 ;
10635 int arg3 ;
10636 wxPoint2D result;
10637 void *argp1 = 0 ;
10638 int res1 = 0 ;
10639 int val2 ;
10640 int ecode2 = 0 ;
10641 int val3 ;
10642 int ecode3 = 0 ;
10643 PyObject * obj0 = 0 ;
10644 PyObject * obj1 = 0 ;
10645 PyObject * obj2 = 0 ;
10646 char * kwnames[] = {
10647 (char *) "self",(char *) "widthfactor",(char *) "heightfactor", NULL
10648 };
10649
10650 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect2D_Interpolate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10651 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10652 if (!SWIG_IsOK(res1)) {
10653 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Interpolate" "', expected argument " "1"" of type '" "wxRect2D *""'");
10654 }
10655 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10656 ecode2 = SWIG_AsVal_int(obj1, &val2);
10657 if (!SWIG_IsOK(ecode2)) {
10658 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Interpolate" "', expected argument " "2"" of type '" "int""'");
10659 }
10660 arg2 = static_cast< int >(val2);
10661 ecode3 = SWIG_AsVal_int(obj2, &val3);
10662 if (!SWIG_IsOK(ecode3)) {
10663 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Interpolate" "', expected argument " "3"" of type '" "int""'");
10664 }
10665 arg3 = static_cast< int >(val3);
10666 {
10667 result = (arg1)->Interpolate(arg2,arg3);
10668 if (PyErr_Occurred()) SWIG_fail;
10669 }
10670 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
10671 return resultobj;
10672 fail:
10673 return NULL;
10674 }
10675
10676
10677 SWIGINTERN PyObject *_wrap_Rect2D_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10678 PyObject *resultobj = 0;
10679 wxRect2D *arg1 = (wxRect2D *) 0 ;
10680 wxRect2D *arg2 = 0 ;
10681 void *argp1 = 0 ;
10682 int res1 = 0 ;
10683 wxRect2D temp2 ;
10684 PyObject * obj0 = 0 ;
10685 PyObject * obj1 = 0 ;
10686 char * kwnames[] = {
10687 (char *) "self",(char *) "otherRect", NULL
10688 };
10689
10690 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
10691 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10692 if (!SWIG_IsOK(res1)) {
10693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersect" "', expected argument " "1"" of type '" "wxRect2D *""'");
10694 }
10695 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10696 {
10697 arg2 = &temp2;
10698 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10699 }
10700 {
10701 (arg1)->Intersect((wxRect2D const &)*arg2);
10702 if (PyErr_Occurred()) SWIG_fail;
10703 }
10704 resultobj = SWIG_Py_Void();
10705 return resultobj;
10706 fail:
10707 return NULL;
10708 }
10709
10710
10711 SWIGINTERN PyObject *_wrap_Rect2D_CreateIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10712 PyObject *resultobj = 0;
10713 wxRect2D *arg1 = (wxRect2D *) 0 ;
10714 wxRect2D *arg2 = 0 ;
10715 wxRect2D result;
10716 void *argp1 = 0 ;
10717 int res1 = 0 ;
10718 wxRect2D temp2 ;
10719 PyObject * obj0 = 0 ;
10720 PyObject * obj1 = 0 ;
10721 char * kwnames[] = {
10722 (char *) "self",(char *) "otherRect", NULL
10723 };
10724
10725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateIntersection",kwnames,&obj0,&obj1)) SWIG_fail;
10726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10727 if (!SWIG_IsOK(res1)) {
10728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateIntersection" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10729 }
10730 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10731 {
10732 arg2 = &temp2;
10733 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10734 }
10735 {
10736 result = ((wxRect2D const *)arg1)->CreateIntersection((wxRect2D const &)*arg2);
10737 if (PyErr_Occurred()) SWIG_fail;
10738 }
10739 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10740 return resultobj;
10741 fail:
10742 return NULL;
10743 }
10744
10745
10746 SWIGINTERN PyObject *_wrap_Rect2D_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10747 PyObject *resultobj = 0;
10748 wxRect2D *arg1 = (wxRect2D *) 0 ;
10749 wxRect2D *arg2 = 0 ;
10750 bool result;
10751 void *argp1 = 0 ;
10752 int res1 = 0 ;
10753 wxRect2D temp2 ;
10754 PyObject * obj0 = 0 ;
10755 PyObject * obj1 = 0 ;
10756 char * kwnames[] = {
10757 (char *) "self",(char *) "rect", NULL
10758 };
10759
10760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
10761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10762 if (!SWIG_IsOK(res1)) {
10763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Intersects" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10764 }
10765 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10766 {
10767 arg2 = &temp2;
10768 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10769 }
10770 {
10771 result = (bool)((wxRect2D const *)arg1)->Intersects((wxRect2D const &)*arg2);
10772 if (PyErr_Occurred()) SWIG_fail;
10773 }
10774 {
10775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10776 }
10777 return resultobj;
10778 fail:
10779 return NULL;
10780 }
10781
10782
10783 SWIGINTERN PyObject *_wrap_Rect2D_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10784 PyObject *resultobj = 0;
10785 wxRect2D *arg1 = (wxRect2D *) 0 ;
10786 wxRect2D *arg2 = 0 ;
10787 void *argp1 = 0 ;
10788 int res1 = 0 ;
10789 wxRect2D temp2 ;
10790 PyObject * obj0 = 0 ;
10791 PyObject * obj1 = 0 ;
10792 char * kwnames[] = {
10793 (char *) "self",(char *) "otherRect", NULL
10794 };
10795
10796 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_Union",kwnames,&obj0,&obj1)) SWIG_fail;
10797 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10798 if (!SWIG_IsOK(res1)) {
10799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Union" "', expected argument " "1"" of type '" "wxRect2D *""'");
10800 }
10801 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10802 {
10803 arg2 = &temp2;
10804 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10805 }
10806 {
10807 (arg1)->Union((wxRect2D const &)*arg2);
10808 if (PyErr_Occurred()) SWIG_fail;
10809 }
10810 resultobj = SWIG_Py_Void();
10811 return resultobj;
10812 fail:
10813 return NULL;
10814 }
10815
10816
10817 SWIGINTERN PyObject *_wrap_Rect2D_CreateUnion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10818 PyObject *resultobj = 0;
10819 wxRect2D *arg1 = (wxRect2D *) 0 ;
10820 wxRect2D *arg2 = 0 ;
10821 wxRect2D result;
10822 void *argp1 = 0 ;
10823 int res1 = 0 ;
10824 wxRect2D temp2 ;
10825 PyObject * obj0 = 0 ;
10826 PyObject * obj1 = 0 ;
10827 char * kwnames[] = {
10828 (char *) "self",(char *) "otherRect", NULL
10829 };
10830
10831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D_CreateUnion",kwnames,&obj0,&obj1)) SWIG_fail;
10832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10833 if (!SWIG_IsOK(res1)) {
10834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_CreateUnion" "', expected argument " "1"" of type '" "wxRect2D const *""'");
10835 }
10836 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10837 {
10838 arg2 = &temp2;
10839 if ( ! wxRect2D_helper(obj1, &arg2)) SWIG_fail;
10840 }
10841 {
10842 result = ((wxRect2D const *)arg1)->CreateUnion((wxRect2D const &)*arg2);
10843 if (PyErr_Occurred()) SWIG_fail;
10844 }
10845 resultobj = SWIG_NewPointerObj((new wxRect2D(static_cast< const wxRect2D& >(result))), SWIGTYPE_p_wxRect2D, SWIG_POINTER_OWN | 0 );
10846 return resultobj;
10847 fail:
10848 return NULL;
10849 }
10850
10851
10852 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10853 PyObject *resultobj = 0;
10854 wxRect2D *arg1 = (wxRect2D *) 0 ;
10855 wxDouble arg2 ;
10856 void *argp1 = 0 ;
10857 int res1 = 0 ;
10858 void *argp2 ;
10859 int res2 = 0 ;
10860
10861 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
10862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10863 if (!SWIG_IsOK(res1)) {
10864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10865 }
10866 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10867 {
10868 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
10869 if (!SWIG_IsOK(res2)) {
10870 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10871 }
10872 if (!argp2) {
10873 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "wxDouble""'");
10874 } else {
10875 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
10876 arg2 = *temp;
10877 if (SWIG_IsNewObj(res2)) delete temp;
10878 }
10879 }
10880 {
10881 (arg1)->Scale(arg2);
10882 if (PyErr_Occurred()) SWIG_fail;
10883 }
10884 resultobj = SWIG_Py_Void();
10885 return resultobj;
10886 fail:
10887 return NULL;
10888 }
10889
10890
10891 SWIGINTERN PyObject *_wrap_Rect2D_Scale__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
10892 PyObject *resultobj = 0;
10893 wxRect2D *arg1 = (wxRect2D *) 0 ;
10894 int arg2 ;
10895 int arg3 ;
10896 void *argp1 = 0 ;
10897 int res1 = 0 ;
10898 int val2 ;
10899 int ecode2 = 0 ;
10900 int val3 ;
10901 int ecode3 = 0 ;
10902
10903 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
10904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10905 if (!SWIG_IsOK(res1)) {
10906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Scale" "', expected argument " "1"" of type '" "wxRect2D *""'");
10907 }
10908 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10909 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
10910 if (!SWIG_IsOK(ecode2)) {
10911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect2D_Scale" "', expected argument " "2"" of type '" "int""'");
10912 }
10913 arg2 = static_cast< int >(val2);
10914 ecode3 = SWIG_AsVal_int(swig_obj[2], &val3);
10915 if (!SWIG_IsOK(ecode3)) {
10916 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect2D_Scale" "', expected argument " "3"" of type '" "int""'");
10917 }
10918 arg3 = static_cast< int >(val3);
10919 {
10920 (arg1)->Scale(arg2,arg3);
10921 if (PyErr_Occurred()) SWIG_fail;
10922 }
10923 resultobj = SWIG_Py_Void();
10924 return resultobj;
10925 fail:
10926 return NULL;
10927 }
10928
10929
10930 SWIGINTERN PyObject *_wrap_Rect2D_Scale(PyObject *self, PyObject *args) {
10931 int argc;
10932 PyObject *argv[4];
10933
10934 if (!(argc = SWIG_Python_UnpackTuple(args,"Rect2D_Scale",0,3,argv))) SWIG_fail;
10935 --argc;
10936 if (argc == 2) {
10937 return _wrap_Rect2D_Scale__SWIG_0(self, argc, argv);
10938 }
10939 if (argc == 3) {
10940 return _wrap_Rect2D_Scale__SWIG_1(self, argc, argv);
10941 }
10942
10943 fail:
10944 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Rect2D_Scale'");
10945 return NULL;
10946 }
10947
10948
10949 SWIGINTERN PyObject *_wrap_Rect2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10950 PyObject *resultobj = 0;
10951 wxRect2D *arg1 = (wxRect2D *) 0 ;
10952 PyObject *arg2 = (PyObject *) 0 ;
10953 bool result;
10954 void *argp1 = 0 ;
10955 int res1 = 0 ;
10956 PyObject * obj0 = 0 ;
10957 PyObject * obj1 = 0 ;
10958 char * kwnames[] = {
10959 (char *) "self",(char *) "other", NULL
10960 };
10961
10962 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
10963 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10964 if (!SWIG_IsOK(res1)) {
10965 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___eq__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10966 }
10967 arg1 = reinterpret_cast< wxRect2D * >(argp1);
10968 arg2 = obj1;
10969 {
10970 result = (bool)wxRect2D___eq__(arg1,arg2);
10971 if (PyErr_Occurred()) SWIG_fail;
10972 }
10973 {
10974 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10975 }
10976 return resultobj;
10977 fail:
10978 return NULL;
10979 }
10980
10981
10982 SWIGINTERN PyObject *_wrap_Rect2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10983 PyObject *resultobj = 0;
10984 wxRect2D *arg1 = (wxRect2D *) 0 ;
10985 PyObject *arg2 = (PyObject *) 0 ;
10986 bool result;
10987 void *argp1 = 0 ;
10988 int res1 = 0 ;
10989 PyObject * obj0 = 0 ;
10990 PyObject * obj1 = 0 ;
10991 char * kwnames[] = {
10992 (char *) "self",(char *) "other", NULL
10993 };
10994
10995 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
10996 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
10997 if (!SWIG_IsOK(res1)) {
10998 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D___ne__" "', expected argument " "1"" of type '" "wxRect2D *""'");
10999 }
11000 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11001 arg2 = obj1;
11002 {
11003 result = (bool)wxRect2D___ne__(arg1,arg2);
11004 if (PyErr_Occurred()) SWIG_fail;
11005 }
11006 {
11007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11008 }
11009 return resultobj;
11010 fail:
11011 return NULL;
11012 }
11013
11014
11015 SWIGINTERN PyObject *_wrap_Rect2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11016 PyObject *resultobj = 0;
11017 wxRect2D *arg1 = (wxRect2D *) 0 ;
11018 wxDouble arg2 ;
11019 void *argp1 = 0 ;
11020 int res1 = 0 ;
11021 void *argp2 ;
11022 int res2 = 0 ;
11023 PyObject *swig_obj[2] ;
11024
11025 if (!SWIG_Python_UnpackTuple(args,"Rect2D_x_set",2,2,swig_obj)) SWIG_fail;
11026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11027 if (!SWIG_IsOK(res1)) {
11028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11029 }
11030 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11031 {
11032 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11033 if (!SWIG_IsOK(res2)) {
11034 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11035 }
11036 if (!argp2) {
11037 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_x_set" "', expected argument " "2"" of type '" "wxDouble""'");
11038 } else {
11039 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11040 arg2 = *temp;
11041 if (SWIG_IsNewObj(res2)) delete temp;
11042 }
11043 }
11044 if (arg1) (arg1)->m_x = arg2;
11045
11046 resultobj = SWIG_Py_Void();
11047 return resultobj;
11048 fail:
11049 return NULL;
11050 }
11051
11052
11053 SWIGINTERN PyObject *_wrap_Rect2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11054 PyObject *resultobj = 0;
11055 wxRect2D *arg1 = (wxRect2D *) 0 ;
11056 wxDouble result;
11057 void *argp1 = 0 ;
11058 int res1 = 0 ;
11059 PyObject *swig_obj[1] ;
11060
11061 if (!args) SWIG_fail;
11062 swig_obj[0] = args;
11063 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11064 if (!SWIG_IsOK(res1)) {
11065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_x_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11066 }
11067 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11068 result = ((arg1)->m_x);
11069 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11070 return resultobj;
11071 fail:
11072 return NULL;
11073 }
11074
11075
11076 SWIGINTERN PyObject *_wrap_Rect2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11077 PyObject *resultobj = 0;
11078 wxRect2D *arg1 = (wxRect2D *) 0 ;
11079 wxDouble arg2 ;
11080 void *argp1 = 0 ;
11081 int res1 = 0 ;
11082 void *argp2 ;
11083 int res2 = 0 ;
11084 PyObject *swig_obj[2] ;
11085
11086 if (!SWIG_Python_UnpackTuple(args,"Rect2D_y_set",2,2,swig_obj)) SWIG_fail;
11087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11088 if (!SWIG_IsOK(res1)) {
11089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11090 }
11091 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11092 {
11093 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11094 if (!SWIG_IsOK(res2)) {
11095 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11096 }
11097 if (!argp2) {
11098 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_y_set" "', expected argument " "2"" of type '" "wxDouble""'");
11099 } else {
11100 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11101 arg2 = *temp;
11102 if (SWIG_IsNewObj(res2)) delete temp;
11103 }
11104 }
11105 if (arg1) (arg1)->m_y = arg2;
11106
11107 resultobj = SWIG_Py_Void();
11108 return resultobj;
11109 fail:
11110 return NULL;
11111 }
11112
11113
11114 SWIGINTERN PyObject *_wrap_Rect2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11115 PyObject *resultobj = 0;
11116 wxRect2D *arg1 = (wxRect2D *) 0 ;
11117 wxDouble result;
11118 void *argp1 = 0 ;
11119 int res1 = 0 ;
11120 PyObject *swig_obj[1] ;
11121
11122 if (!args) SWIG_fail;
11123 swig_obj[0] = args;
11124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11125 if (!SWIG_IsOK(res1)) {
11126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_y_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11127 }
11128 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11129 result = ((arg1)->m_y);
11130 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11131 return resultobj;
11132 fail:
11133 return NULL;
11134 }
11135
11136
11137 SWIGINTERN PyObject *_wrap_Rect2D_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11138 PyObject *resultobj = 0;
11139 wxRect2D *arg1 = (wxRect2D *) 0 ;
11140 wxDouble arg2 ;
11141 void *argp1 = 0 ;
11142 int res1 = 0 ;
11143 void *argp2 ;
11144 int res2 = 0 ;
11145 PyObject *swig_obj[2] ;
11146
11147 if (!SWIG_Python_UnpackTuple(args,"Rect2D_width_set",2,2,swig_obj)) SWIG_fail;
11148 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11149 if (!SWIG_IsOK(res1)) {
11150 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11151 }
11152 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11153 {
11154 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11155 if (!SWIG_IsOK(res2)) {
11156 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11157 }
11158 if (!argp2) {
11159 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_width_set" "', expected argument " "2"" of type '" "wxDouble""'");
11160 } else {
11161 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11162 arg2 = *temp;
11163 if (SWIG_IsNewObj(res2)) delete temp;
11164 }
11165 }
11166 if (arg1) (arg1)->m_width = arg2;
11167
11168 resultobj = SWIG_Py_Void();
11169 return resultobj;
11170 fail:
11171 return NULL;
11172 }
11173
11174
11175 SWIGINTERN PyObject *_wrap_Rect2D_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11176 PyObject *resultobj = 0;
11177 wxRect2D *arg1 = (wxRect2D *) 0 ;
11178 wxDouble result;
11179 void *argp1 = 0 ;
11180 int res1 = 0 ;
11181 PyObject *swig_obj[1] ;
11182
11183 if (!args) SWIG_fail;
11184 swig_obj[0] = args;
11185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11186 if (!SWIG_IsOK(res1)) {
11187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_width_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11188 }
11189 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11190 result = ((arg1)->m_width);
11191 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11192 return resultobj;
11193 fail:
11194 return NULL;
11195 }
11196
11197
11198 SWIGINTERN PyObject *_wrap_Rect2D_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11199 PyObject *resultobj = 0;
11200 wxRect2D *arg1 = (wxRect2D *) 0 ;
11201 wxDouble arg2 ;
11202 void *argp1 = 0 ;
11203 int res1 = 0 ;
11204 void *argp2 ;
11205 int res2 = 0 ;
11206 PyObject *swig_obj[2] ;
11207
11208 if (!SWIG_Python_UnpackTuple(args,"Rect2D_height_set",2,2,swig_obj)) SWIG_fail;
11209 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11210 if (!SWIG_IsOK(res1)) {
11211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11212 }
11213 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11214 {
11215 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11216 if (!SWIG_IsOK(res2)) {
11217 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11218 }
11219 if (!argp2) {
11220 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_height_set" "', expected argument " "2"" of type '" "wxDouble""'");
11221 } else {
11222 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11223 arg2 = *temp;
11224 if (SWIG_IsNewObj(res2)) delete temp;
11225 }
11226 }
11227 if (arg1) (arg1)->m_height = arg2;
11228
11229 resultobj = SWIG_Py_Void();
11230 return resultobj;
11231 fail:
11232 return NULL;
11233 }
11234
11235
11236 SWIGINTERN PyObject *_wrap_Rect2D_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11237 PyObject *resultobj = 0;
11238 wxRect2D *arg1 = (wxRect2D *) 0 ;
11239 wxDouble result;
11240 void *argp1 = 0 ;
11241 int res1 = 0 ;
11242 PyObject *swig_obj[1] ;
11243
11244 if (!args) SWIG_fail;
11245 swig_obj[0] = args;
11246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11247 if (!SWIG_IsOK(res1)) {
11248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_height_get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11249 }
11250 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11251 result = ((arg1)->m_height);
11252 resultobj = SWIG_NewPointerObj((new wxDouble(static_cast< const wxDouble& >(result))), SWIGTYPE_p_wxDouble, SWIG_POINTER_OWN | 0 );
11253 return resultobj;
11254 fail:
11255 return NULL;
11256 }
11257
11258
11259 SWIGINTERN PyObject *_wrap_Rect2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11260 PyObject *resultobj = 0;
11261 wxRect2D *arg1 = (wxRect2D *) 0 ;
11262 wxDouble arg2 = (wxDouble) 0 ;
11263 wxDouble arg3 = (wxDouble) 0 ;
11264 wxDouble arg4 = (wxDouble) 0 ;
11265 wxDouble arg5 = (wxDouble) 0 ;
11266 void *argp1 = 0 ;
11267 int res1 = 0 ;
11268 void *argp2 ;
11269 int res2 = 0 ;
11270 void *argp3 ;
11271 int res3 = 0 ;
11272 void *argp4 ;
11273 int res4 = 0 ;
11274 void *argp5 ;
11275 int res5 = 0 ;
11276 PyObject * obj0 = 0 ;
11277 PyObject * obj1 = 0 ;
11278 PyObject * obj2 = 0 ;
11279 PyObject * obj3 = 0 ;
11280 PyObject * obj4 = 0 ;
11281 char * kwnames[] = {
11282 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
11283 };
11284
11285 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect2D_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
11286 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11287 if (!SWIG_IsOK(res1)) {
11288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Set" "', expected argument " "1"" of type '" "wxRect2D *""'");
11289 }
11290 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11291 if (obj1) {
11292 {
11293 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDouble, 0 | 0);
11294 if (!SWIG_IsOK(res2)) {
11295 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11296 }
11297 if (!argp2) {
11298 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "2"" of type '" "wxDouble""'");
11299 } else {
11300 wxDouble * temp = reinterpret_cast< wxDouble * >(argp2);
11301 arg2 = *temp;
11302 if (SWIG_IsNewObj(res2)) delete temp;
11303 }
11304 }
11305 }
11306 if (obj2) {
11307 {
11308 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxDouble, 0 | 0);
11309 if (!SWIG_IsOK(res3)) {
11310 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11311 }
11312 if (!argp3) {
11313 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "3"" of type '" "wxDouble""'");
11314 } else {
11315 wxDouble * temp = reinterpret_cast< wxDouble * >(argp3);
11316 arg3 = *temp;
11317 if (SWIG_IsNewObj(res3)) delete temp;
11318 }
11319 }
11320 }
11321 if (obj3) {
11322 {
11323 res4 = SWIG_ConvertPtr(obj3, &argp4, SWIGTYPE_p_wxDouble, 0 | 0);
11324 if (!SWIG_IsOK(res4)) {
11325 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11326 }
11327 if (!argp4) {
11328 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "4"" of type '" "wxDouble""'");
11329 } else {
11330 wxDouble * temp = reinterpret_cast< wxDouble * >(argp4);
11331 arg4 = *temp;
11332 if (SWIG_IsNewObj(res4)) delete temp;
11333 }
11334 }
11335 }
11336 if (obj4) {
11337 {
11338 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDouble, 0 | 0);
11339 if (!SWIG_IsOK(res5)) {
11340 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11341 }
11342 if (!argp5) {
11343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Rect2D_Set" "', expected argument " "5"" of type '" "wxDouble""'");
11344 } else {
11345 wxDouble * temp = reinterpret_cast< wxDouble * >(argp5);
11346 arg5 = *temp;
11347 if (SWIG_IsNewObj(res5)) delete temp;
11348 }
11349 }
11350 }
11351 {
11352 wxRect2D_Set(arg1,arg2,arg3,arg4,arg5);
11353 if (PyErr_Occurred()) SWIG_fail;
11354 }
11355 resultobj = SWIG_Py_Void();
11356 return resultobj;
11357 fail:
11358 return NULL;
11359 }
11360
11361
11362 SWIGINTERN PyObject *_wrap_Rect2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11363 PyObject *resultobj = 0;
11364 wxRect2D *arg1 = (wxRect2D *) 0 ;
11365 PyObject *result = 0 ;
11366 void *argp1 = 0 ;
11367 int res1 = 0 ;
11368 PyObject *swig_obj[1] ;
11369
11370 if (!args) SWIG_fail;
11371 swig_obj[0] = args;
11372 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect2D, 0 | 0 );
11373 if (!SWIG_IsOK(res1)) {
11374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect2D_Get" "', expected argument " "1"" of type '" "wxRect2D *""'");
11375 }
11376 arg1 = reinterpret_cast< wxRect2D * >(argp1);
11377 {
11378 result = (PyObject *)wxRect2D_Get(arg1);
11379 if (PyErr_Occurred()) SWIG_fail;
11380 }
11381 resultobj = result;
11382 return resultobj;
11383 fail:
11384 return NULL;
11385 }
11386
11387
11388 SWIGINTERN PyObject *Rect2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11389 PyObject *obj;
11390 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11391 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect2D, SWIG_NewClientData(obj));
11392 return SWIG_Py_Void();
11393 }
11394
11395 SWIGINTERN PyObject *Rect2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11396 return SWIG_Python_InitShadowInstance(args);
11397 }
11398
11399 SWIGINTERN int DefaultPosition_set(PyObject *) {
11400 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
11401 return 1;
11402 }
11403
11404
11405 SWIGINTERN PyObject *DefaultPosition_get(void) {
11406 PyObject *pyobj = 0;
11407
11408 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
11409 return pyobj;
11410 }
11411
11412
11413 SWIGINTERN int DefaultSize_set(PyObject *) {
11414 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
11415 return 1;
11416 }
11417
11418
11419 SWIGINTERN PyObject *DefaultSize_get(void) {
11420 PyObject *pyobj = 0;
11421
11422 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
11423 return pyobj;
11424 }
11425
11426
11427 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11428 PyObject *resultobj = 0;
11429 PyObject *arg1 = (PyObject *) 0 ;
11430 wxPyInputStream *result = 0 ;
11431 PyObject * obj0 = 0 ;
11432 char * kwnames[] = {
11433 (char *) "p", NULL
11434 };
11435
11436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
11437 arg1 = obj0;
11438 {
11439 PyThreadState* __tstate = wxPyBeginAllowThreads();
11440 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
11441 wxPyEndAllowThreads(__tstate);
11442 if (PyErr_Occurred()) SWIG_fail;
11443 }
11444 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
11445 return resultobj;
11446 fail:
11447 return NULL;
11448 }
11449
11450
11451 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11452 PyObject *resultobj = 0;
11453 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11454 void *argp1 = 0 ;
11455 int res1 = 0 ;
11456 PyObject *swig_obj[1] ;
11457
11458 if (!args) SWIG_fail;
11459 swig_obj[0] = args;
11460 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
11461 if (!SWIG_IsOK(res1)) {
11462 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11463 }
11464 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11465 {
11466 PyThreadState* __tstate = wxPyBeginAllowThreads();
11467 delete arg1;
11468
11469 wxPyEndAllowThreads(__tstate);
11470 if (PyErr_Occurred()) SWIG_fail;
11471 }
11472 resultobj = SWIG_Py_Void();
11473 return resultobj;
11474 fail:
11475 return NULL;
11476 }
11477
11478
11479 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11480 PyObject *resultobj = 0;
11481 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11482 void *argp1 = 0 ;
11483 int res1 = 0 ;
11484 PyObject *swig_obj[1] ;
11485
11486 if (!args) SWIG_fail;
11487 swig_obj[0] = args;
11488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11489 if (!SWIG_IsOK(res1)) {
11490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11491 }
11492 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11493 {
11494 PyThreadState* __tstate = wxPyBeginAllowThreads();
11495 (arg1)->close();
11496 wxPyEndAllowThreads(__tstate);
11497 if (PyErr_Occurred()) SWIG_fail;
11498 }
11499 resultobj = SWIG_Py_Void();
11500 return resultobj;
11501 fail:
11502 return NULL;
11503 }
11504
11505
11506 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11507 PyObject *resultobj = 0;
11508 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11509 void *argp1 = 0 ;
11510 int res1 = 0 ;
11511 PyObject *swig_obj[1] ;
11512
11513 if (!args) SWIG_fail;
11514 swig_obj[0] = args;
11515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11516 if (!SWIG_IsOK(res1)) {
11517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11518 }
11519 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11520 {
11521 PyThreadState* __tstate = wxPyBeginAllowThreads();
11522 (arg1)->flush();
11523 wxPyEndAllowThreads(__tstate);
11524 if (PyErr_Occurred()) SWIG_fail;
11525 }
11526 resultobj = SWIG_Py_Void();
11527 return resultobj;
11528 fail:
11529 return NULL;
11530 }
11531
11532
11533 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11534 PyObject *resultobj = 0;
11535 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11536 bool result;
11537 void *argp1 = 0 ;
11538 int res1 = 0 ;
11539 PyObject *swig_obj[1] ;
11540
11541 if (!args) SWIG_fail;
11542 swig_obj[0] = args;
11543 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11544 if (!SWIG_IsOK(res1)) {
11545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11546 }
11547 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11548 {
11549 PyThreadState* __tstate = wxPyBeginAllowThreads();
11550 result = (bool)(arg1)->eof();
11551 wxPyEndAllowThreads(__tstate);
11552 if (PyErr_Occurred()) SWIG_fail;
11553 }
11554 {
11555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11556 }
11557 return resultobj;
11558 fail:
11559 return NULL;
11560 }
11561
11562
11563 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11564 PyObject *resultobj = 0;
11565 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11566 int arg2 = (int) -1 ;
11567 PyObject *result = 0 ;
11568 void *argp1 = 0 ;
11569 int res1 = 0 ;
11570 int val2 ;
11571 int ecode2 = 0 ;
11572 PyObject * obj0 = 0 ;
11573 PyObject * obj1 = 0 ;
11574 char * kwnames[] = {
11575 (char *) "self",(char *) "size", NULL
11576 };
11577
11578 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
11579 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11580 if (!SWIG_IsOK(res1)) {
11581 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11582 }
11583 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11584 if (obj1) {
11585 ecode2 = SWIG_AsVal_int(obj1, &val2);
11586 if (!SWIG_IsOK(ecode2)) {
11587 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
11588 }
11589 arg2 = static_cast< int >(val2);
11590 }
11591 {
11592 PyThreadState* __tstate = wxPyBeginAllowThreads();
11593 result = (PyObject *)(arg1)->read(arg2);
11594 wxPyEndAllowThreads(__tstate);
11595 if (PyErr_Occurred()) SWIG_fail;
11596 }
11597 resultobj = result;
11598 return resultobj;
11599 fail:
11600 return NULL;
11601 }
11602
11603
11604 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11605 PyObject *resultobj = 0;
11606 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11607 int arg2 = (int) -1 ;
11608 PyObject *result = 0 ;
11609 void *argp1 = 0 ;
11610 int res1 = 0 ;
11611 int val2 ;
11612 int ecode2 = 0 ;
11613 PyObject * obj0 = 0 ;
11614 PyObject * obj1 = 0 ;
11615 char * kwnames[] = {
11616 (char *) "self",(char *) "size", NULL
11617 };
11618
11619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
11620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11621 if (!SWIG_IsOK(res1)) {
11622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11623 }
11624 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11625 if (obj1) {
11626 ecode2 = SWIG_AsVal_int(obj1, &val2);
11627 if (!SWIG_IsOK(ecode2)) {
11628 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
11629 }
11630 arg2 = static_cast< int >(val2);
11631 }
11632 {
11633 PyThreadState* __tstate = wxPyBeginAllowThreads();
11634 result = (PyObject *)(arg1)->readline(arg2);
11635 wxPyEndAllowThreads(__tstate);
11636 if (PyErr_Occurred()) SWIG_fail;
11637 }
11638 resultobj = result;
11639 return resultobj;
11640 fail:
11641 return NULL;
11642 }
11643
11644
11645 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11646 PyObject *resultobj = 0;
11647 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11648 int arg2 = (int) -1 ;
11649 PyObject *result = 0 ;
11650 void *argp1 = 0 ;
11651 int res1 = 0 ;
11652 int val2 ;
11653 int ecode2 = 0 ;
11654 PyObject * obj0 = 0 ;
11655 PyObject * obj1 = 0 ;
11656 char * kwnames[] = {
11657 (char *) "self",(char *) "sizehint", NULL
11658 };
11659
11660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
11661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11662 if (!SWIG_IsOK(res1)) {
11663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11664 }
11665 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11666 if (obj1) {
11667 ecode2 = SWIG_AsVal_int(obj1, &val2);
11668 if (!SWIG_IsOK(ecode2)) {
11669 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
11670 }
11671 arg2 = static_cast< int >(val2);
11672 }
11673 {
11674 PyThreadState* __tstate = wxPyBeginAllowThreads();
11675 result = (PyObject *)(arg1)->readlines(arg2);
11676 wxPyEndAllowThreads(__tstate);
11677 if (PyErr_Occurred()) SWIG_fail;
11678 }
11679 resultobj = result;
11680 return resultobj;
11681 fail:
11682 return NULL;
11683 }
11684
11685
11686 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11687 PyObject *resultobj = 0;
11688 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11689 int arg2 ;
11690 int arg3 = (int) 0 ;
11691 void *argp1 = 0 ;
11692 int res1 = 0 ;
11693 int val2 ;
11694 int ecode2 = 0 ;
11695 int val3 ;
11696 int ecode3 = 0 ;
11697 PyObject * obj0 = 0 ;
11698 PyObject * obj1 = 0 ;
11699 PyObject * obj2 = 0 ;
11700 char * kwnames[] = {
11701 (char *) "self",(char *) "offset",(char *) "whence", NULL
11702 };
11703
11704 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11705 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11706 if (!SWIG_IsOK(res1)) {
11707 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11708 }
11709 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11710 ecode2 = SWIG_AsVal_int(obj1, &val2);
11711 if (!SWIG_IsOK(ecode2)) {
11712 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
11713 }
11714 arg2 = static_cast< int >(val2);
11715 if (obj2) {
11716 ecode3 = SWIG_AsVal_int(obj2, &val3);
11717 if (!SWIG_IsOK(ecode3)) {
11718 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
11719 }
11720 arg3 = static_cast< int >(val3);
11721 }
11722 {
11723 PyThreadState* __tstate = wxPyBeginAllowThreads();
11724 (arg1)->seek(arg2,arg3);
11725 wxPyEndAllowThreads(__tstate);
11726 if (PyErr_Occurred()) SWIG_fail;
11727 }
11728 resultobj = SWIG_Py_Void();
11729 return resultobj;
11730 fail:
11731 return NULL;
11732 }
11733
11734
11735 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11736 PyObject *resultobj = 0;
11737 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11738 int result;
11739 void *argp1 = 0 ;
11740 int res1 = 0 ;
11741 PyObject *swig_obj[1] ;
11742
11743 if (!args) SWIG_fail;
11744 swig_obj[0] = args;
11745 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11746 if (!SWIG_IsOK(res1)) {
11747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11748 }
11749 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11750 {
11751 PyThreadState* __tstate = wxPyBeginAllowThreads();
11752 result = (int)(arg1)->tell();
11753 wxPyEndAllowThreads(__tstate);
11754 if (PyErr_Occurred()) SWIG_fail;
11755 }
11756 resultobj = SWIG_From_int(static_cast< int >(result));
11757 return resultobj;
11758 fail:
11759 return NULL;
11760 }
11761
11762
11763 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11764 PyObject *resultobj = 0;
11765 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11766 char result;
11767 void *argp1 = 0 ;
11768 int res1 = 0 ;
11769 PyObject *swig_obj[1] ;
11770
11771 if (!args) SWIG_fail;
11772 swig_obj[0] = args;
11773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11774 if (!SWIG_IsOK(res1)) {
11775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11776 }
11777 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11778 {
11779 PyThreadState* __tstate = wxPyBeginAllowThreads();
11780 result = (char)(arg1)->Peek();
11781 wxPyEndAllowThreads(__tstate);
11782 if (PyErr_Occurred()) SWIG_fail;
11783 }
11784 resultobj = SWIG_From_char(static_cast< char >(result));
11785 return resultobj;
11786 fail:
11787 return NULL;
11788 }
11789
11790
11791 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11792 PyObject *resultobj = 0;
11793 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11794 char result;
11795 void *argp1 = 0 ;
11796 int res1 = 0 ;
11797 PyObject *swig_obj[1] ;
11798
11799 if (!args) SWIG_fail;
11800 swig_obj[0] = args;
11801 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11802 if (!SWIG_IsOK(res1)) {
11803 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11804 }
11805 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11806 {
11807 PyThreadState* __tstate = wxPyBeginAllowThreads();
11808 result = (char)(arg1)->GetC();
11809 wxPyEndAllowThreads(__tstate);
11810 if (PyErr_Occurred()) SWIG_fail;
11811 }
11812 resultobj = SWIG_From_char(static_cast< char >(result));
11813 return resultobj;
11814 fail:
11815 return NULL;
11816 }
11817
11818
11819 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11820 PyObject *resultobj = 0;
11821 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11822 size_t result;
11823 void *argp1 = 0 ;
11824 int res1 = 0 ;
11825 PyObject *swig_obj[1] ;
11826
11827 if (!args) SWIG_fail;
11828 swig_obj[0] = args;
11829 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11830 if (!SWIG_IsOK(res1)) {
11831 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11832 }
11833 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11834 {
11835 PyThreadState* __tstate = wxPyBeginAllowThreads();
11836 result = (size_t)(arg1)->LastRead();
11837 wxPyEndAllowThreads(__tstate);
11838 if (PyErr_Occurred()) SWIG_fail;
11839 }
11840 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
11841 return resultobj;
11842 fail:
11843 return NULL;
11844 }
11845
11846
11847 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11848 PyObject *resultobj = 0;
11849 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11850 bool result;
11851 void *argp1 = 0 ;
11852 int res1 = 0 ;
11853 PyObject *swig_obj[1] ;
11854
11855 if (!args) SWIG_fail;
11856 swig_obj[0] = args;
11857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11858 if (!SWIG_IsOK(res1)) {
11859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11860 }
11861 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11862 {
11863 PyThreadState* __tstate = wxPyBeginAllowThreads();
11864 result = (bool)(arg1)->CanRead();
11865 wxPyEndAllowThreads(__tstate);
11866 if (PyErr_Occurred()) SWIG_fail;
11867 }
11868 {
11869 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11870 }
11871 return resultobj;
11872 fail:
11873 return NULL;
11874 }
11875
11876
11877 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11878 PyObject *resultobj = 0;
11879 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11880 bool result;
11881 void *argp1 = 0 ;
11882 int res1 = 0 ;
11883 PyObject *swig_obj[1] ;
11884
11885 if (!args) SWIG_fail;
11886 swig_obj[0] = args;
11887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11888 if (!SWIG_IsOK(res1)) {
11889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11890 }
11891 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11892 {
11893 PyThreadState* __tstate = wxPyBeginAllowThreads();
11894 result = (bool)(arg1)->Eof();
11895 wxPyEndAllowThreads(__tstate);
11896 if (PyErr_Occurred()) SWIG_fail;
11897 }
11898 {
11899 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11900 }
11901 return resultobj;
11902 fail:
11903 return NULL;
11904 }
11905
11906
11907 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11908 PyObject *resultobj = 0;
11909 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11910 char arg2 ;
11911 bool result;
11912 void *argp1 = 0 ;
11913 int res1 = 0 ;
11914 char val2 ;
11915 int ecode2 = 0 ;
11916 PyObject * obj0 = 0 ;
11917 PyObject * obj1 = 0 ;
11918 char * kwnames[] = {
11919 (char *) "self",(char *) "c", NULL
11920 };
11921
11922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
11923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11924 if (!SWIG_IsOK(res1)) {
11925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11926 }
11927 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11928 ecode2 = SWIG_AsVal_char(obj1, &val2);
11929 if (!SWIG_IsOK(ecode2)) {
11930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
11931 }
11932 arg2 = static_cast< char >(val2);
11933 {
11934 PyThreadState* __tstate = wxPyBeginAllowThreads();
11935 result = (bool)(arg1)->Ungetch(arg2);
11936 wxPyEndAllowThreads(__tstate);
11937 if (PyErr_Occurred()) SWIG_fail;
11938 }
11939 {
11940 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11941 }
11942 return resultobj;
11943 fail:
11944 return NULL;
11945 }
11946
11947
11948 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11949 PyObject *resultobj = 0;
11950 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
11951 long arg2 ;
11952 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
11953 long result;
11954 void *argp1 = 0 ;
11955 int res1 = 0 ;
11956 long val2 ;
11957 int ecode2 = 0 ;
11958 int val3 ;
11959 int ecode3 = 0 ;
11960 PyObject * obj0 = 0 ;
11961 PyObject * obj1 = 0 ;
11962 PyObject * obj2 = 0 ;
11963 char * kwnames[] = {
11964 (char *) "self",(char *) "pos",(char *) "mode", NULL
11965 };
11966
11967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
11969 if (!SWIG_IsOK(res1)) {
11970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
11971 }
11972 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
11973 ecode2 = SWIG_AsVal_long(obj1, &val2);
11974 if (!SWIG_IsOK(ecode2)) {
11975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
11976 }
11977 arg2 = static_cast< long >(val2);
11978 if (obj2) {
11979 ecode3 = SWIG_AsVal_int(obj2, &val3);
11980 if (!SWIG_IsOK(ecode3)) {
11981 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
11982 }
11983 arg3 = static_cast< wxSeekMode >(val3);
11984 }
11985 {
11986 PyThreadState* __tstate = wxPyBeginAllowThreads();
11987 result = (long)(arg1)->SeekI(arg2,arg3);
11988 wxPyEndAllowThreads(__tstate);
11989 if (PyErr_Occurred()) SWIG_fail;
11990 }
11991 resultobj = SWIG_From_long(static_cast< long >(result));
11992 return resultobj;
11993 fail:
11994 return NULL;
11995 }
11996
11997
11998 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11999 PyObject *resultobj = 0;
12000 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
12001 long result;
12002 void *argp1 = 0 ;
12003 int res1 = 0 ;
12004 PyObject *swig_obj[1] ;
12005
12006 if (!args) SWIG_fail;
12007 swig_obj[0] = args;
12008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
12009 if (!SWIG_IsOK(res1)) {
12010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
12011 }
12012 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
12013 {
12014 PyThreadState* __tstate = wxPyBeginAllowThreads();
12015 result = (long)(arg1)->TellI();
12016 wxPyEndAllowThreads(__tstate);
12017 if (PyErr_Occurred()) SWIG_fail;
12018 }
12019 resultobj = SWIG_From_long(static_cast< long >(result));
12020 return resultobj;
12021 fail:
12022 return NULL;
12023 }
12024
12025
12026 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12027 PyObject *obj;
12028 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12029 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
12030 return SWIG_Py_Void();
12031 }
12032
12033 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12034 return SWIG_Python_InitShadowInstance(args);
12035 }
12036
12037 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12038 PyObject *resultobj = 0;
12039 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12040 PyObject *arg2 = (PyObject *) 0 ;
12041 void *argp1 = 0 ;
12042 int res1 = 0 ;
12043 PyObject * obj0 = 0 ;
12044 PyObject * obj1 = 0 ;
12045 char * kwnames[] = {
12046 (char *) "self",(char *) "obj", NULL
12047 };
12048
12049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
12050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12051 if (!SWIG_IsOK(res1)) {
12052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
12053 }
12054 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12055 arg2 = obj1;
12056 {
12057 PyThreadState* __tstate = wxPyBeginAllowThreads();
12058 wxOutputStream_write(arg1,arg2);
12059 wxPyEndAllowThreads(__tstate);
12060 if (PyErr_Occurred()) SWIG_fail;
12061 }
12062 resultobj = SWIG_Py_Void();
12063 return resultobj;
12064 fail:
12065 return NULL;
12066 }
12067
12068
12069 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12070 PyObject *resultobj = 0;
12071 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
12072 size_t result;
12073 void *argp1 = 0 ;
12074 int res1 = 0 ;
12075 PyObject *swig_obj[1] ;
12076
12077 if (!args) SWIG_fail;
12078 swig_obj[0] = args;
12079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
12080 if (!SWIG_IsOK(res1)) {
12081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
12082 }
12083 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
12084 {
12085 PyThreadState* __tstate = wxPyBeginAllowThreads();
12086 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
12087 wxPyEndAllowThreads(__tstate);
12088 if (PyErr_Occurred()) SWIG_fail;
12089 }
12090 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
12091 return resultobj;
12092 fail:
12093 return NULL;
12094 }
12095
12096
12097 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12098 PyObject *obj;
12099 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12100 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
12101 return SWIG_Py_Void();
12102 }
12103
12104 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12105 PyObject *resultobj = 0;
12106 wxInputStream *arg1 = (wxInputStream *) 0 ;
12107 wxString *arg2 = 0 ;
12108 wxString *arg3 = 0 ;
12109 wxString *arg4 = 0 ;
12110 wxDateTime arg5 ;
12111 wxFSFile *result = 0 ;
12112 wxPyInputStream *temp1 ;
12113 bool temp2 = false ;
12114 bool temp3 = false ;
12115 bool temp4 = false ;
12116 void *argp5 ;
12117 int res5 = 0 ;
12118 PyObject * obj0 = 0 ;
12119 PyObject * obj1 = 0 ;
12120 PyObject * obj2 = 0 ;
12121 PyObject * obj3 = 0 ;
12122 PyObject * obj4 = 0 ;
12123 char * kwnames[] = {
12124 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
12125 };
12126
12127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
12128 {
12129 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
12130 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
12131 } else {
12132 PyErr_Clear(); // clear the failure of the wxPyConvert above
12133 arg1 = wxPyCBInputStream_create(obj0, true);
12134 if (arg1 == NULL) {
12135 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
12136 SWIG_fail;
12137 }
12138 }
12139 }
12140 {
12141 arg2 = wxString_in_helper(obj1);
12142 if (arg2 == NULL) SWIG_fail;
12143 temp2 = true;
12144 }
12145 {
12146 arg3 = wxString_in_helper(obj2);
12147 if (arg3 == NULL) SWIG_fail;
12148 temp3 = true;
12149 }
12150 {
12151 arg4 = wxString_in_helper(obj3);
12152 if (arg4 == NULL) SWIG_fail;
12153 temp4 = true;
12154 }
12155 {
12156 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
12157 if (!SWIG_IsOK(res5)) {
12158 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12159 }
12160 if (!argp5) {
12161 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
12162 } else {
12163 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
12164 arg5 = *temp;
12165 if (SWIG_IsNewObj(res5)) delete temp;
12166 }
12167 }
12168 {
12169 PyThreadState* __tstate = wxPyBeginAllowThreads();
12170 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
12171 wxPyEndAllowThreads(__tstate);
12172 if (PyErr_Occurred()) SWIG_fail;
12173 }
12174 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
12175 {
12176 if (temp2)
12177 delete arg2;
12178 }
12179 {
12180 if (temp3)
12181 delete arg3;
12182 }
12183 {
12184 if (temp4)
12185 delete arg4;
12186 }
12187 return resultobj;
12188 fail:
12189 {
12190 if (temp2)
12191 delete arg2;
12192 }
12193 {
12194 if (temp3)
12195 delete arg3;
12196 }
12197 {
12198 if (temp4)
12199 delete arg4;
12200 }
12201 return NULL;
12202 }
12203
12204
12205 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12206 PyObject *resultobj = 0;
12207 wxFSFile *arg1 = (wxFSFile *) 0 ;
12208 void *argp1 = 0 ;
12209 int res1 = 0 ;
12210 PyObject *swig_obj[1] ;
12211
12212 if (!args) SWIG_fail;
12213 swig_obj[0] = args;
12214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
12215 if (!SWIG_IsOK(res1)) {
12216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
12217 }
12218 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12219 {
12220 PyThreadState* __tstate = wxPyBeginAllowThreads();
12221 delete arg1;
12222
12223 wxPyEndAllowThreads(__tstate);
12224 if (PyErr_Occurred()) SWIG_fail;
12225 }
12226 resultobj = SWIG_Py_Void();
12227 return resultobj;
12228 fail:
12229 return NULL;
12230 }
12231
12232
12233 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12234 PyObject *resultobj = 0;
12235 wxFSFile *arg1 = (wxFSFile *) 0 ;
12236 wxInputStream *result = 0 ;
12237 void *argp1 = 0 ;
12238 int res1 = 0 ;
12239 PyObject *swig_obj[1] ;
12240
12241 if (!args) SWIG_fail;
12242 swig_obj[0] = args;
12243 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12244 if (!SWIG_IsOK(res1)) {
12245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12246 }
12247 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12248 {
12249 PyThreadState* __tstate = wxPyBeginAllowThreads();
12250 result = (wxInputStream *)(arg1)->GetStream();
12251 wxPyEndAllowThreads(__tstate);
12252 if (PyErr_Occurred()) SWIG_fail;
12253 }
12254 {
12255 wxPyInputStream * _ptr = NULL;
12256
12257 if (result) {
12258 _ptr = new wxPyInputStream(result);
12259 }
12260 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
12261 }
12262 return resultobj;
12263 fail:
12264 return NULL;
12265 }
12266
12267
12268 SWIGINTERN PyObject *_wrap_FSFile_DetachStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12269 PyObject *resultobj = 0;
12270 wxFSFile *arg1 = (wxFSFile *) 0 ;
12271 void *argp1 = 0 ;
12272 int res1 = 0 ;
12273 PyObject *swig_obj[1] ;
12274
12275 if (!args) SWIG_fail;
12276 swig_obj[0] = args;
12277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12278 if (!SWIG_IsOK(res1)) {
12279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_DetachStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
12280 }
12281 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12282 {
12283 PyThreadState* __tstate = wxPyBeginAllowThreads();
12284 (arg1)->DetachStream();
12285 wxPyEndAllowThreads(__tstate);
12286 if (PyErr_Occurred()) SWIG_fail;
12287 }
12288 resultobj = SWIG_Py_Void();
12289 return resultobj;
12290 fail:
12291 return NULL;
12292 }
12293
12294
12295 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12296 PyObject *resultobj = 0;
12297 wxFSFile *arg1 = (wxFSFile *) 0 ;
12298 wxString *result = 0 ;
12299 void *argp1 = 0 ;
12300 int res1 = 0 ;
12301 PyObject *swig_obj[1] ;
12302
12303 if (!args) SWIG_fail;
12304 swig_obj[0] = args;
12305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12306 if (!SWIG_IsOK(res1)) {
12307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
12308 }
12309 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12310 {
12311 PyThreadState* __tstate = wxPyBeginAllowThreads();
12312 {
12313 wxString const &_result_ref = (arg1)->GetMimeType();
12314 result = (wxString *) &_result_ref;
12315 }
12316 wxPyEndAllowThreads(__tstate);
12317 if (PyErr_Occurred()) SWIG_fail;
12318 }
12319 {
12320 #if wxUSE_UNICODE
12321 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12322 #else
12323 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12324 #endif
12325 }
12326 return resultobj;
12327 fail:
12328 return NULL;
12329 }
12330
12331
12332 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12333 PyObject *resultobj = 0;
12334 wxFSFile *arg1 = (wxFSFile *) 0 ;
12335 wxString *result = 0 ;
12336 void *argp1 = 0 ;
12337 int res1 = 0 ;
12338 PyObject *swig_obj[1] ;
12339
12340 if (!args) SWIG_fail;
12341 swig_obj[0] = args;
12342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12343 if (!SWIG_IsOK(res1)) {
12344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
12345 }
12346 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12347 {
12348 PyThreadState* __tstate = wxPyBeginAllowThreads();
12349 {
12350 wxString const &_result_ref = (arg1)->GetLocation();
12351 result = (wxString *) &_result_ref;
12352 }
12353 wxPyEndAllowThreads(__tstate);
12354 if (PyErr_Occurred()) SWIG_fail;
12355 }
12356 {
12357 #if wxUSE_UNICODE
12358 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12359 #else
12360 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12361 #endif
12362 }
12363 return resultobj;
12364 fail:
12365 return NULL;
12366 }
12367
12368
12369 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12370 PyObject *resultobj = 0;
12371 wxFSFile *arg1 = (wxFSFile *) 0 ;
12372 wxString *result = 0 ;
12373 void *argp1 = 0 ;
12374 int res1 = 0 ;
12375 PyObject *swig_obj[1] ;
12376
12377 if (!args) SWIG_fail;
12378 swig_obj[0] = args;
12379 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12380 if (!SWIG_IsOK(res1)) {
12381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
12382 }
12383 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12384 {
12385 PyThreadState* __tstate = wxPyBeginAllowThreads();
12386 {
12387 wxString const &_result_ref = (arg1)->GetAnchor();
12388 result = (wxString *) &_result_ref;
12389 }
12390 wxPyEndAllowThreads(__tstate);
12391 if (PyErr_Occurred()) SWIG_fail;
12392 }
12393 {
12394 #if wxUSE_UNICODE
12395 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
12396 #else
12397 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
12398 #endif
12399 }
12400 return resultobj;
12401 fail:
12402 return NULL;
12403 }
12404
12405
12406 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12407 PyObject *resultobj = 0;
12408 wxFSFile *arg1 = (wxFSFile *) 0 ;
12409 wxDateTime result;
12410 void *argp1 = 0 ;
12411 int res1 = 0 ;
12412 PyObject *swig_obj[1] ;
12413
12414 if (!args) SWIG_fail;
12415 swig_obj[0] = args;
12416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
12417 if (!SWIG_IsOK(res1)) {
12418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
12419 }
12420 arg1 = reinterpret_cast< wxFSFile * >(argp1);
12421 {
12422 PyThreadState* __tstate = wxPyBeginAllowThreads();
12423 result = (arg1)->GetModificationTime();
12424 wxPyEndAllowThreads(__tstate);
12425 if (PyErr_Occurred()) SWIG_fail;
12426 }
12427 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
12428 return resultobj;
12429 fail:
12430 return NULL;
12431 }
12432
12433
12434 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12435 PyObject *obj;
12436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12437 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
12438 return SWIG_Py_Void();
12439 }
12440
12441 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12442 return SWIG_Python_InitShadowInstance(args);
12443 }
12444
12445 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12446 PyObject *resultobj = 0;
12447 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
12448 void *argp1 = 0 ;
12449 int res1 = 0 ;
12450 PyObject *swig_obj[1] ;
12451
12452 if (!args) SWIG_fail;
12453 swig_obj[0] = args;
12454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
12455 if (!SWIG_IsOK(res1)) {
12456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
12457 }
12458 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
12459 {
12460 PyThreadState* __tstate = wxPyBeginAllowThreads();
12461 delete arg1;
12462
12463 wxPyEndAllowThreads(__tstate);
12464 if (PyErr_Occurred()) SWIG_fail;
12465 }
12466 resultobj = SWIG_Py_Void();
12467 return resultobj;
12468 fail:
12469 return NULL;
12470 }
12471
12472
12473 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12474 PyObject *obj;
12475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12476 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
12477 return SWIG_Py_Void();
12478 }
12479
12480 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12481 PyObject *resultobj = 0;
12482 wxPyFileSystemHandler *result = 0 ;
12483
12484 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
12485 {
12486 PyThreadState* __tstate = wxPyBeginAllowThreads();
12487 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
12488 wxPyEndAllowThreads(__tstate);
12489 if (PyErr_Occurred()) SWIG_fail;
12490 }
12491 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
12492 return resultobj;
12493 fail:
12494 return NULL;
12495 }
12496
12497
12498 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12499 PyObject *resultobj = 0;
12500 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12501 PyObject *arg2 = (PyObject *) 0 ;
12502 PyObject *arg3 = (PyObject *) 0 ;
12503 void *argp1 = 0 ;
12504 int res1 = 0 ;
12505 PyObject * obj0 = 0 ;
12506 PyObject * obj1 = 0 ;
12507 PyObject * obj2 = 0 ;
12508 char * kwnames[] = {
12509 (char *) "self",(char *) "self",(char *) "_class", NULL
12510 };
12511
12512 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12513 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12514 if (!SWIG_IsOK(res1)) {
12515 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12516 }
12517 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12518 arg2 = obj1;
12519 arg3 = obj2;
12520 {
12521 PyThreadState* __tstate = wxPyBeginAllowThreads();
12522 (arg1)->_setCallbackInfo(arg2,arg3);
12523 wxPyEndAllowThreads(__tstate);
12524 if (PyErr_Occurred()) SWIG_fail;
12525 }
12526 resultobj = SWIG_Py_Void();
12527 return resultobj;
12528 fail:
12529 return NULL;
12530 }
12531
12532
12533 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12534 PyObject *resultobj = 0;
12535 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12536 wxString *arg2 = 0 ;
12537 bool result;
12538 void *argp1 = 0 ;
12539 int res1 = 0 ;
12540 bool temp2 = false ;
12541 PyObject * obj0 = 0 ;
12542 PyObject * obj1 = 0 ;
12543 char * kwnames[] = {
12544 (char *) "self",(char *) "location", NULL
12545 };
12546
12547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
12548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12549 if (!SWIG_IsOK(res1)) {
12550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12551 }
12552 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12553 {
12554 arg2 = wxString_in_helper(obj1);
12555 if (arg2 == NULL) SWIG_fail;
12556 temp2 = true;
12557 }
12558 {
12559 PyThreadState* __tstate = wxPyBeginAllowThreads();
12560 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
12561 wxPyEndAllowThreads(__tstate);
12562 if (PyErr_Occurred()) SWIG_fail;
12563 }
12564 {
12565 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12566 }
12567 {
12568 if (temp2)
12569 delete arg2;
12570 }
12571 return resultobj;
12572 fail:
12573 {
12574 if (temp2)
12575 delete arg2;
12576 }
12577 return NULL;
12578 }
12579
12580
12581 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12582 PyObject *resultobj = 0;
12583 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12584 wxFileSystem *arg2 = 0 ;
12585 wxString *arg3 = 0 ;
12586 wxFSFile *result = 0 ;
12587 void *argp1 = 0 ;
12588 int res1 = 0 ;
12589 void *argp2 = 0 ;
12590 int res2 = 0 ;
12591 bool temp3 = false ;
12592 PyObject * obj0 = 0 ;
12593 PyObject * obj1 = 0 ;
12594 PyObject * obj2 = 0 ;
12595 char * kwnames[] = {
12596 (char *) "self",(char *) "fs",(char *) "location", NULL
12597 };
12598
12599 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12600 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12601 if (!SWIG_IsOK(res1)) {
12602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12603 }
12604 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12605 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
12606 if (!SWIG_IsOK(res2)) {
12607 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12608 }
12609 if (!argp2) {
12610 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
12611 }
12612 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
12613 {
12614 arg3 = wxString_in_helper(obj2);
12615 if (arg3 == NULL) SWIG_fail;
12616 temp3 = true;
12617 }
12618 {
12619 PyThreadState* __tstate = wxPyBeginAllowThreads();
12620 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
12621 wxPyEndAllowThreads(__tstate);
12622 if (PyErr_Occurred()) SWIG_fail;
12623 }
12624 {
12625 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
12626 }
12627 {
12628 if (temp3)
12629 delete arg3;
12630 }
12631 return resultobj;
12632 fail:
12633 {
12634 if (temp3)
12635 delete arg3;
12636 }
12637 return NULL;
12638 }
12639
12640
12641 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12642 PyObject *resultobj = 0;
12643 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12644 wxString *arg2 = 0 ;
12645 int arg3 = (int) 0 ;
12646 wxString result;
12647 void *argp1 = 0 ;
12648 int res1 = 0 ;
12649 bool temp2 = false ;
12650 int val3 ;
12651 int ecode3 = 0 ;
12652 PyObject * obj0 = 0 ;
12653 PyObject * obj1 = 0 ;
12654 PyObject * obj2 = 0 ;
12655 char * kwnames[] = {
12656 (char *) "self",(char *) "spec",(char *) "flags", NULL
12657 };
12658
12659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12661 if (!SWIG_IsOK(res1)) {
12662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12663 }
12664 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12665 {
12666 arg2 = wxString_in_helper(obj1);
12667 if (arg2 == NULL) SWIG_fail;
12668 temp2 = true;
12669 }
12670 if (obj2) {
12671 ecode3 = SWIG_AsVal_int(obj2, &val3);
12672 if (!SWIG_IsOK(ecode3)) {
12673 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
12674 }
12675 arg3 = static_cast< int >(val3);
12676 }
12677 {
12678 PyThreadState* __tstate = wxPyBeginAllowThreads();
12679 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
12680 wxPyEndAllowThreads(__tstate);
12681 if (PyErr_Occurred()) SWIG_fail;
12682 }
12683 {
12684 #if wxUSE_UNICODE
12685 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12686 #else
12687 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12688 #endif
12689 }
12690 {
12691 if (temp2)
12692 delete arg2;
12693 }
12694 return resultobj;
12695 fail:
12696 {
12697 if (temp2)
12698 delete arg2;
12699 }
12700 return NULL;
12701 }
12702
12703
12704 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12705 PyObject *resultobj = 0;
12706 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12707 wxString result;
12708 void *argp1 = 0 ;
12709 int res1 = 0 ;
12710 PyObject *swig_obj[1] ;
12711
12712 if (!args) SWIG_fail;
12713 swig_obj[0] = args;
12714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12715 if (!SWIG_IsOK(res1)) {
12716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12717 }
12718 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12719 {
12720 PyThreadState* __tstate = wxPyBeginAllowThreads();
12721 result = (arg1)->FindNext();
12722 wxPyEndAllowThreads(__tstate);
12723 if (PyErr_Occurred()) SWIG_fail;
12724 }
12725 {
12726 #if wxUSE_UNICODE
12727 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12728 #else
12729 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12730 #endif
12731 }
12732 return resultobj;
12733 fail:
12734 return NULL;
12735 }
12736
12737
12738 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12739 PyObject *resultobj = 0;
12740 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12741 wxString *arg2 = 0 ;
12742 wxString result;
12743 void *argp1 = 0 ;
12744 int res1 = 0 ;
12745 bool temp2 = false ;
12746 PyObject * obj0 = 0 ;
12747 PyObject * obj1 = 0 ;
12748 char * kwnames[] = {
12749 (char *) "self",(char *) "location", NULL
12750 };
12751
12752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
12753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12754 if (!SWIG_IsOK(res1)) {
12755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12756 }
12757 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12758 {
12759 arg2 = wxString_in_helper(obj1);
12760 if (arg2 == NULL) SWIG_fail;
12761 temp2 = true;
12762 }
12763 {
12764 PyThreadState* __tstate = wxPyBeginAllowThreads();
12765 result = (arg1)->GetProtocol((wxString const &)*arg2);
12766 wxPyEndAllowThreads(__tstate);
12767 if (PyErr_Occurred()) SWIG_fail;
12768 }
12769 {
12770 #if wxUSE_UNICODE
12771 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12772 #else
12773 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12774 #endif
12775 }
12776 {
12777 if (temp2)
12778 delete arg2;
12779 }
12780 return resultobj;
12781 fail:
12782 {
12783 if (temp2)
12784 delete arg2;
12785 }
12786 return NULL;
12787 }
12788
12789
12790 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12791 PyObject *resultobj = 0;
12792 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12793 wxString *arg2 = 0 ;
12794 wxString result;
12795 void *argp1 = 0 ;
12796 int res1 = 0 ;
12797 bool temp2 = false ;
12798 PyObject * obj0 = 0 ;
12799 PyObject * obj1 = 0 ;
12800 char * kwnames[] = {
12801 (char *) "self",(char *) "location", NULL
12802 };
12803
12804 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12805 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12806 if (!SWIG_IsOK(res1)) {
12807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12808 }
12809 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12810 {
12811 arg2 = wxString_in_helper(obj1);
12812 if (arg2 == NULL) SWIG_fail;
12813 temp2 = true;
12814 }
12815 {
12816 PyThreadState* __tstate = wxPyBeginAllowThreads();
12817 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
12818 wxPyEndAllowThreads(__tstate);
12819 if (PyErr_Occurred()) SWIG_fail;
12820 }
12821 {
12822 #if wxUSE_UNICODE
12823 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12824 #else
12825 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12826 #endif
12827 }
12828 {
12829 if (temp2)
12830 delete arg2;
12831 }
12832 return resultobj;
12833 fail:
12834 {
12835 if (temp2)
12836 delete arg2;
12837 }
12838 return NULL;
12839 }
12840
12841
12842 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12843 PyObject *resultobj = 0;
12844 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12845 wxString *arg2 = 0 ;
12846 wxString result;
12847 void *argp1 = 0 ;
12848 int res1 = 0 ;
12849 bool temp2 = false ;
12850 PyObject * obj0 = 0 ;
12851 PyObject * obj1 = 0 ;
12852 char * kwnames[] = {
12853 (char *) "self",(char *) "location", NULL
12854 };
12855
12856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
12857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12858 if (!SWIG_IsOK(res1)) {
12859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12860 }
12861 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12862 {
12863 arg2 = wxString_in_helper(obj1);
12864 if (arg2 == NULL) SWIG_fail;
12865 temp2 = true;
12866 }
12867 {
12868 PyThreadState* __tstate = wxPyBeginAllowThreads();
12869 result = (arg1)->GetAnchor((wxString const &)*arg2);
12870 wxPyEndAllowThreads(__tstate);
12871 if (PyErr_Occurred()) SWIG_fail;
12872 }
12873 {
12874 #if wxUSE_UNICODE
12875 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12876 #else
12877 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12878 #endif
12879 }
12880 {
12881 if (temp2)
12882 delete arg2;
12883 }
12884 return resultobj;
12885 fail:
12886 {
12887 if (temp2)
12888 delete arg2;
12889 }
12890 return NULL;
12891 }
12892
12893
12894 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12895 PyObject *resultobj = 0;
12896 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12897 wxString *arg2 = 0 ;
12898 wxString result;
12899 void *argp1 = 0 ;
12900 int res1 = 0 ;
12901 bool temp2 = false ;
12902 PyObject * obj0 = 0 ;
12903 PyObject * obj1 = 0 ;
12904 char * kwnames[] = {
12905 (char *) "self",(char *) "location", NULL
12906 };
12907
12908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
12909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12910 if (!SWIG_IsOK(res1)) {
12911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12912 }
12913 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12914 {
12915 arg2 = wxString_in_helper(obj1);
12916 if (arg2 == NULL) SWIG_fail;
12917 temp2 = true;
12918 }
12919 {
12920 PyThreadState* __tstate = wxPyBeginAllowThreads();
12921 result = (arg1)->GetRightLocation((wxString const &)*arg2);
12922 wxPyEndAllowThreads(__tstate);
12923 if (PyErr_Occurred()) SWIG_fail;
12924 }
12925 {
12926 #if wxUSE_UNICODE
12927 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12928 #else
12929 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12930 #endif
12931 }
12932 {
12933 if (temp2)
12934 delete arg2;
12935 }
12936 return resultobj;
12937 fail:
12938 {
12939 if (temp2)
12940 delete arg2;
12941 }
12942 return NULL;
12943 }
12944
12945
12946 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12947 PyObject *resultobj = 0;
12948 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
12949 wxString *arg2 = 0 ;
12950 wxString result;
12951 void *argp1 = 0 ;
12952 int res1 = 0 ;
12953 bool temp2 = false ;
12954 PyObject * obj0 = 0 ;
12955 PyObject * obj1 = 0 ;
12956 char * kwnames[] = {
12957 (char *) "self",(char *) "location", NULL
12958 };
12959
12960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
12961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
12962 if (!SWIG_IsOK(res1)) {
12963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
12964 }
12965 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
12966 {
12967 arg2 = wxString_in_helper(obj1);
12968 if (arg2 == NULL) SWIG_fail;
12969 temp2 = true;
12970 }
12971 {
12972 PyThreadState* __tstate = wxPyBeginAllowThreads();
12973 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
12974 wxPyEndAllowThreads(__tstate);
12975 if (PyErr_Occurred()) SWIG_fail;
12976 }
12977 {
12978 #if wxUSE_UNICODE
12979 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
12980 #else
12981 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
12982 #endif
12983 }
12984 {
12985 if (temp2)
12986 delete arg2;
12987 }
12988 return resultobj;
12989 fail:
12990 {
12991 if (temp2)
12992 delete arg2;
12993 }
12994 return NULL;
12995 }
12996
12997
12998 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12999 PyObject *obj;
13000 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13001 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
13002 return SWIG_Py_Void();
13003 }
13004
13005 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13006 return SWIG_Python_InitShadowInstance(args);
13007 }
13008
13009 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13010 PyObject *resultobj = 0;
13011 wxFileSystem *result = 0 ;
13012
13013 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
13014 {
13015 PyThreadState* __tstate = wxPyBeginAllowThreads();
13016 result = (wxFileSystem *)new wxFileSystem();
13017 wxPyEndAllowThreads(__tstate);
13018 if (PyErr_Occurred()) SWIG_fail;
13019 }
13020 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystem, SWIG_POINTER_NEW | 0 );
13021 return resultobj;
13022 fail:
13023 return NULL;
13024 }
13025
13026
13027 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13028 PyObject *resultobj = 0;
13029 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13030 void *argp1 = 0 ;
13031 int res1 = 0 ;
13032 PyObject *swig_obj[1] ;
13033
13034 if (!args) SWIG_fail;
13035 swig_obj[0] = args;
13036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
13037 if (!SWIG_IsOK(res1)) {
13038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13039 }
13040 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13041 {
13042 PyThreadState* __tstate = wxPyBeginAllowThreads();
13043 delete arg1;
13044
13045 wxPyEndAllowThreads(__tstate);
13046 if (PyErr_Occurred()) SWIG_fail;
13047 }
13048 resultobj = SWIG_Py_Void();
13049 return resultobj;
13050 fail:
13051 return NULL;
13052 }
13053
13054
13055 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13056 PyObject *resultobj = 0;
13057 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13058 wxString *arg2 = 0 ;
13059 bool arg3 = (bool) false ;
13060 void *argp1 = 0 ;
13061 int res1 = 0 ;
13062 bool temp2 = false ;
13063 bool val3 ;
13064 int ecode3 = 0 ;
13065 PyObject * obj0 = 0 ;
13066 PyObject * obj1 = 0 ;
13067 PyObject * obj2 = 0 ;
13068 char * kwnames[] = {
13069 (char *) "self",(char *) "location",(char *) "is_dir", NULL
13070 };
13071
13072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13074 if (!SWIG_IsOK(res1)) {
13075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13076 }
13077 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13078 {
13079 arg2 = wxString_in_helper(obj1);
13080 if (arg2 == NULL) SWIG_fail;
13081 temp2 = true;
13082 }
13083 if (obj2) {
13084 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13085 if (!SWIG_IsOK(ecode3)) {
13086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
13087 }
13088 arg3 = static_cast< bool >(val3);
13089 }
13090 {
13091 PyThreadState* __tstate = wxPyBeginAllowThreads();
13092 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
13093 wxPyEndAllowThreads(__tstate);
13094 if (PyErr_Occurred()) SWIG_fail;
13095 }
13096 resultobj = SWIG_Py_Void();
13097 {
13098 if (temp2)
13099 delete arg2;
13100 }
13101 return resultobj;
13102 fail:
13103 {
13104 if (temp2)
13105 delete arg2;
13106 }
13107 return NULL;
13108 }
13109
13110
13111 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13112 PyObject *resultobj = 0;
13113 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13114 wxString result;
13115 void *argp1 = 0 ;
13116 int res1 = 0 ;
13117 PyObject *swig_obj[1] ;
13118
13119 if (!args) SWIG_fail;
13120 swig_obj[0] = args;
13121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13122 if (!SWIG_IsOK(res1)) {
13123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13124 }
13125 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13126 {
13127 PyThreadState* __tstate = wxPyBeginAllowThreads();
13128 result = (arg1)->GetPath();
13129 wxPyEndAllowThreads(__tstate);
13130 if (PyErr_Occurred()) SWIG_fail;
13131 }
13132 {
13133 #if wxUSE_UNICODE
13134 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13135 #else
13136 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13137 #endif
13138 }
13139 return resultobj;
13140 fail:
13141 return NULL;
13142 }
13143
13144
13145 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13146 PyObject *resultobj = 0;
13147 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13148 wxString *arg2 = 0 ;
13149 wxFSFile *result = 0 ;
13150 void *argp1 = 0 ;
13151 int res1 = 0 ;
13152 bool temp2 = false ;
13153 PyObject * obj0 = 0 ;
13154 PyObject * obj1 = 0 ;
13155 char * kwnames[] = {
13156 (char *) "self",(char *) "location", NULL
13157 };
13158
13159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
13160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13161 if (!SWIG_IsOK(res1)) {
13162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13163 }
13164 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13165 {
13166 arg2 = wxString_in_helper(obj1);
13167 if (arg2 == NULL) SWIG_fail;
13168 temp2 = true;
13169 }
13170 {
13171 PyThreadState* __tstate = wxPyBeginAllowThreads();
13172 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
13173 wxPyEndAllowThreads(__tstate);
13174 if (PyErr_Occurred()) SWIG_fail;
13175 }
13176 {
13177 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13178 }
13179 {
13180 if (temp2)
13181 delete arg2;
13182 }
13183 return resultobj;
13184 fail:
13185 {
13186 if (temp2)
13187 delete arg2;
13188 }
13189 return NULL;
13190 }
13191
13192
13193 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13194 PyObject *resultobj = 0;
13195 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13196 wxString *arg2 = 0 ;
13197 int arg3 = (int) 0 ;
13198 wxString result;
13199 void *argp1 = 0 ;
13200 int res1 = 0 ;
13201 bool temp2 = false ;
13202 int val3 ;
13203 int ecode3 = 0 ;
13204 PyObject * obj0 = 0 ;
13205 PyObject * obj1 = 0 ;
13206 PyObject * obj2 = 0 ;
13207 char * kwnames[] = {
13208 (char *) "self",(char *) "spec",(char *) "flags", NULL
13209 };
13210
13211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13212 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13213 if (!SWIG_IsOK(res1)) {
13214 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13215 }
13216 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13217 {
13218 arg2 = wxString_in_helper(obj1);
13219 if (arg2 == NULL) SWIG_fail;
13220 temp2 = true;
13221 }
13222 if (obj2) {
13223 ecode3 = SWIG_AsVal_int(obj2, &val3);
13224 if (!SWIG_IsOK(ecode3)) {
13225 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
13226 }
13227 arg3 = static_cast< int >(val3);
13228 }
13229 {
13230 PyThreadState* __tstate = wxPyBeginAllowThreads();
13231 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 {
13236 #if wxUSE_UNICODE
13237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13238 #else
13239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13240 #endif
13241 }
13242 {
13243 if (temp2)
13244 delete arg2;
13245 }
13246 return resultobj;
13247 fail:
13248 {
13249 if (temp2)
13250 delete arg2;
13251 }
13252 return NULL;
13253 }
13254
13255
13256 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13257 PyObject *resultobj = 0;
13258 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
13259 wxString result;
13260 void *argp1 = 0 ;
13261 int res1 = 0 ;
13262 PyObject *swig_obj[1] ;
13263
13264 if (!args) SWIG_fail;
13265 swig_obj[0] = args;
13266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
13267 if (!SWIG_IsOK(res1)) {
13268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
13269 }
13270 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
13271 {
13272 PyThreadState* __tstate = wxPyBeginAllowThreads();
13273 result = (arg1)->FindNext();
13274 wxPyEndAllowThreads(__tstate);
13275 if (PyErr_Occurred()) SWIG_fail;
13276 }
13277 {
13278 #if wxUSE_UNICODE
13279 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13280 #else
13281 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13282 #endif
13283 }
13284 return resultobj;
13285 fail:
13286 return NULL;
13287 }
13288
13289
13290 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13291 PyObject *resultobj = 0;
13292 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13293 int res1 = 0 ;
13294 PyObject * obj0 = 0 ;
13295 char * kwnames[] = {
13296 (char *) "handler", NULL
13297 };
13298
13299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
13300 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
13301 if (!SWIG_IsOK(res1)) {
13302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13303 }
13304 {
13305 PyThreadState* __tstate = wxPyBeginAllowThreads();
13306 wxFileSystem::AddHandler(arg1);
13307 wxPyEndAllowThreads(__tstate);
13308 if (PyErr_Occurred()) SWIG_fail;
13309 }
13310 resultobj = SWIG_Py_Void();
13311 return resultobj;
13312 fail:
13313 return NULL;
13314 }
13315
13316
13317 SWIGINTERN PyObject *_wrap_FileSystem_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13318 PyObject *resultobj = 0;
13319 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
13320 wxFileSystemHandler *result = 0 ;
13321 void *argp1 = 0 ;
13322 int res1 = 0 ;
13323 PyObject * obj0 = 0 ;
13324 char * kwnames[] = {
13325 (char *) "handler", NULL
13326 };
13327
13328 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_RemoveHandler",kwnames,&obj0)) SWIG_fail;
13329 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystemHandler, 0 | 0 );
13330 if (!SWIG_IsOK(res1)) {
13331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_RemoveHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
13332 }
13333 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
13334 {
13335 PyThreadState* __tstate = wxPyBeginAllowThreads();
13336 result = (wxFileSystemHandler *)wxFileSystem::RemoveHandler(arg1);
13337 wxPyEndAllowThreads(__tstate);
13338 if (PyErr_Occurred()) SWIG_fail;
13339 }
13340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_OWN | 0 );
13341 return resultobj;
13342 fail:
13343 return NULL;
13344 }
13345
13346
13347 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13348 PyObject *resultobj = 0;
13349
13350 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
13351 {
13352 PyThreadState* __tstate = wxPyBeginAllowThreads();
13353 wxFileSystem::CleanUpHandlers();
13354 wxPyEndAllowThreads(__tstate);
13355 if (PyErr_Occurred()) SWIG_fail;
13356 }
13357 resultobj = SWIG_Py_Void();
13358 return resultobj;
13359 fail:
13360 return NULL;
13361 }
13362
13363
13364 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13365 PyObject *resultobj = 0;
13366 wxString *arg1 = 0 ;
13367 wxString result;
13368 bool temp1 = false ;
13369 PyObject * obj0 = 0 ;
13370 char * kwnames[] = {
13371 (char *) "filename", NULL
13372 };
13373
13374 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
13375 {
13376 arg1 = wxString_in_helper(obj0);
13377 if (arg1 == NULL) SWIG_fail;
13378 temp1 = true;
13379 }
13380 {
13381 PyThreadState* __tstate = wxPyBeginAllowThreads();
13382 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
13383 wxPyEndAllowThreads(__tstate);
13384 if (PyErr_Occurred()) SWIG_fail;
13385 }
13386 {
13387 #if wxUSE_UNICODE
13388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13389 #else
13390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13391 #endif
13392 }
13393 {
13394 if (temp1)
13395 delete arg1;
13396 }
13397 return resultobj;
13398 fail:
13399 {
13400 if (temp1)
13401 delete arg1;
13402 }
13403 return NULL;
13404 }
13405
13406
13407 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13408 PyObject *resultobj = 0;
13409 wxString *arg1 = 0 ;
13410 wxString result;
13411 bool temp1 = false ;
13412 PyObject * obj0 = 0 ;
13413 char * kwnames[] = {
13414 (char *) "url", NULL
13415 };
13416
13417 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
13418 {
13419 arg1 = wxString_in_helper(obj0);
13420 if (arg1 == NULL) SWIG_fail;
13421 temp1 = true;
13422 }
13423 {
13424 PyThreadState* __tstate = wxPyBeginAllowThreads();
13425 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
13426 wxPyEndAllowThreads(__tstate);
13427 if (PyErr_Occurred()) SWIG_fail;
13428 }
13429 {
13430 #if wxUSE_UNICODE
13431 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13432 #else
13433 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13434 #endif
13435 }
13436 {
13437 if (temp1)
13438 delete arg1;
13439 }
13440 return resultobj;
13441 fail:
13442 {
13443 if (temp1)
13444 delete arg1;
13445 }
13446 return NULL;
13447 }
13448
13449
13450 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13451 PyObject *obj;
13452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13453 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
13454 return SWIG_Py_Void();
13455 }
13456
13457 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13458 return SWIG_Python_InitShadowInstance(args);
13459 }
13460
13461 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13462 PyObject *resultobj = 0;
13463 wxInternetFSHandler *result = 0 ;
13464
13465 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
13466 {
13467 PyThreadState* __tstate = wxPyBeginAllowThreads();
13468 result = (wxInternetFSHandler *)new wxInternetFSHandler();
13469 wxPyEndAllowThreads(__tstate);
13470 if (PyErr_Occurred()) SWIG_fail;
13471 }
13472 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
13473 return resultobj;
13474 fail:
13475 return NULL;
13476 }
13477
13478
13479 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13480 PyObject *resultobj = 0;
13481 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13482 wxString *arg2 = 0 ;
13483 bool result;
13484 void *argp1 = 0 ;
13485 int res1 = 0 ;
13486 bool temp2 = false ;
13487 PyObject * obj0 = 0 ;
13488 PyObject * obj1 = 0 ;
13489 char * kwnames[] = {
13490 (char *) "self",(char *) "location", NULL
13491 };
13492
13493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13495 if (!SWIG_IsOK(res1)) {
13496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13497 }
13498 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13499 {
13500 arg2 = wxString_in_helper(obj1);
13501 if (arg2 == NULL) SWIG_fail;
13502 temp2 = true;
13503 }
13504 {
13505 PyThreadState* __tstate = wxPyBeginAllowThreads();
13506 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13507 wxPyEndAllowThreads(__tstate);
13508 if (PyErr_Occurred()) SWIG_fail;
13509 }
13510 {
13511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13512 }
13513 {
13514 if (temp2)
13515 delete arg2;
13516 }
13517 return resultobj;
13518 fail:
13519 {
13520 if (temp2)
13521 delete arg2;
13522 }
13523 return NULL;
13524 }
13525
13526
13527 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13528 PyObject *resultobj = 0;
13529 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
13530 wxFileSystem *arg2 = 0 ;
13531 wxString *arg3 = 0 ;
13532 wxFSFile *result = 0 ;
13533 void *argp1 = 0 ;
13534 int res1 = 0 ;
13535 void *argp2 = 0 ;
13536 int res2 = 0 ;
13537 bool temp3 = false ;
13538 PyObject * obj0 = 0 ;
13539 PyObject * obj1 = 0 ;
13540 PyObject * obj2 = 0 ;
13541 char * kwnames[] = {
13542 (char *) "self",(char *) "fs",(char *) "location", NULL
13543 };
13544
13545 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13546 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
13547 if (!SWIG_IsOK(res1)) {
13548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
13549 }
13550 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
13551 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13552 if (!SWIG_IsOK(res2)) {
13553 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13554 }
13555 if (!argp2) {
13556 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13557 }
13558 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13559 {
13560 arg3 = wxString_in_helper(obj2);
13561 if (arg3 == NULL) SWIG_fail;
13562 temp3 = true;
13563 }
13564 {
13565 PyThreadState* __tstate = wxPyBeginAllowThreads();
13566 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13567 wxPyEndAllowThreads(__tstate);
13568 if (PyErr_Occurred()) SWIG_fail;
13569 }
13570 {
13571 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13572 }
13573 {
13574 if (temp3)
13575 delete arg3;
13576 }
13577 return resultobj;
13578 fail:
13579 {
13580 if (temp3)
13581 delete arg3;
13582 }
13583 return NULL;
13584 }
13585
13586
13587 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13588 PyObject *obj;
13589 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13590 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
13591 return SWIG_Py_Void();
13592 }
13593
13594 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13595 return SWIG_Python_InitShadowInstance(args);
13596 }
13597
13598 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13599 PyObject *resultobj = 0;
13600 wxZipFSHandler *result = 0 ;
13601
13602 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
13603 {
13604 PyThreadState* __tstate = wxPyBeginAllowThreads();
13605 result = (wxZipFSHandler *)new wxZipFSHandler();
13606 wxPyEndAllowThreads(__tstate);
13607 if (PyErr_Occurred()) SWIG_fail;
13608 }
13609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
13610 return resultobj;
13611 fail:
13612 return NULL;
13613 }
13614
13615
13616 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13617 PyObject *resultobj = 0;
13618 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13619 wxString *arg2 = 0 ;
13620 bool result;
13621 void *argp1 = 0 ;
13622 int res1 = 0 ;
13623 bool temp2 = false ;
13624 PyObject * obj0 = 0 ;
13625 PyObject * obj1 = 0 ;
13626 char * kwnames[] = {
13627 (char *) "self",(char *) "location", NULL
13628 };
13629
13630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
13631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13632 if (!SWIG_IsOK(res1)) {
13633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13634 }
13635 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13636 {
13637 arg2 = wxString_in_helper(obj1);
13638 if (arg2 == NULL) SWIG_fail;
13639 temp2 = true;
13640 }
13641 {
13642 PyThreadState* __tstate = wxPyBeginAllowThreads();
13643 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
13644 wxPyEndAllowThreads(__tstate);
13645 if (PyErr_Occurred()) SWIG_fail;
13646 }
13647 {
13648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
13649 }
13650 {
13651 if (temp2)
13652 delete arg2;
13653 }
13654 return resultobj;
13655 fail:
13656 {
13657 if (temp2)
13658 delete arg2;
13659 }
13660 return NULL;
13661 }
13662
13663
13664 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13665 PyObject *resultobj = 0;
13666 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13667 wxFileSystem *arg2 = 0 ;
13668 wxString *arg3 = 0 ;
13669 wxFSFile *result = 0 ;
13670 void *argp1 = 0 ;
13671 int res1 = 0 ;
13672 void *argp2 = 0 ;
13673 int res2 = 0 ;
13674 bool temp3 = false ;
13675 PyObject * obj0 = 0 ;
13676 PyObject * obj1 = 0 ;
13677 PyObject * obj2 = 0 ;
13678 char * kwnames[] = {
13679 (char *) "self",(char *) "fs",(char *) "location", NULL
13680 };
13681
13682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13684 if (!SWIG_IsOK(res1)) {
13685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13686 }
13687 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13688 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
13689 if (!SWIG_IsOK(res2)) {
13690 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13691 }
13692 if (!argp2) {
13693 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
13694 }
13695 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
13696 {
13697 arg3 = wxString_in_helper(obj2);
13698 if (arg3 == NULL) SWIG_fail;
13699 temp3 = true;
13700 }
13701 {
13702 PyThreadState* __tstate = wxPyBeginAllowThreads();
13703 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
13704 wxPyEndAllowThreads(__tstate);
13705 if (PyErr_Occurred()) SWIG_fail;
13706 }
13707 {
13708 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
13709 }
13710 {
13711 if (temp3)
13712 delete arg3;
13713 }
13714 return resultobj;
13715 fail:
13716 {
13717 if (temp3)
13718 delete arg3;
13719 }
13720 return NULL;
13721 }
13722
13723
13724 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13725 PyObject *resultobj = 0;
13726 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13727 wxString *arg2 = 0 ;
13728 int arg3 = (int) 0 ;
13729 wxString result;
13730 void *argp1 = 0 ;
13731 int res1 = 0 ;
13732 bool temp2 = false ;
13733 int val3 ;
13734 int ecode3 = 0 ;
13735 PyObject * obj0 = 0 ;
13736 PyObject * obj1 = 0 ;
13737 PyObject * obj2 = 0 ;
13738 char * kwnames[] = {
13739 (char *) "self",(char *) "spec",(char *) "flags", NULL
13740 };
13741
13742 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13743 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13744 if (!SWIG_IsOK(res1)) {
13745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13746 }
13747 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13748 {
13749 arg2 = wxString_in_helper(obj1);
13750 if (arg2 == NULL) SWIG_fail;
13751 temp2 = true;
13752 }
13753 if (obj2) {
13754 ecode3 = SWIG_AsVal_int(obj2, &val3);
13755 if (!SWIG_IsOK(ecode3)) {
13756 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
13757 }
13758 arg3 = static_cast< int >(val3);
13759 }
13760 {
13761 PyThreadState* __tstate = wxPyBeginAllowThreads();
13762 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
13763 wxPyEndAllowThreads(__tstate);
13764 if (PyErr_Occurred()) SWIG_fail;
13765 }
13766 {
13767 #if wxUSE_UNICODE
13768 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13769 #else
13770 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13771 #endif
13772 }
13773 {
13774 if (temp2)
13775 delete arg2;
13776 }
13777 return resultobj;
13778 fail:
13779 {
13780 if (temp2)
13781 delete arg2;
13782 }
13783 return NULL;
13784 }
13785
13786
13787 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13788 PyObject *resultobj = 0;
13789 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
13790 wxString result;
13791 void *argp1 = 0 ;
13792 int res1 = 0 ;
13793 PyObject *swig_obj[1] ;
13794
13795 if (!args) SWIG_fail;
13796 swig_obj[0] = args;
13797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
13798 if (!SWIG_IsOK(res1)) {
13799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
13800 }
13801 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
13802 {
13803 PyThreadState* __tstate = wxPyBeginAllowThreads();
13804 result = (arg1)->FindNext();
13805 wxPyEndAllowThreads(__tstate);
13806 if (PyErr_Occurred()) SWIG_fail;
13807 }
13808 {
13809 #if wxUSE_UNICODE
13810 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
13811 #else
13812 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
13813 #endif
13814 }
13815 return resultobj;
13816 fail:
13817 return NULL;
13818 }
13819
13820
13821 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13822 PyObject *obj;
13823 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
13824 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
13825 return SWIG_Py_Void();
13826 }
13827
13828 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13829 return SWIG_Python_InitShadowInstance(args);
13830 }
13831
13832 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13833 PyObject *resultobj = 0;
13834 wxString *arg1 = 0 ;
13835 wxImage *arg2 = 0 ;
13836 long arg3 ;
13837 bool temp1 = false ;
13838 void *argp2 = 0 ;
13839 int res2 = 0 ;
13840 long val3 ;
13841 int ecode3 = 0 ;
13842 PyObject * obj0 = 0 ;
13843 PyObject * obj1 = 0 ;
13844 PyObject * obj2 = 0 ;
13845 char * kwnames[] = {
13846 (char *) "filename",(char *) "image",(char *) "type", NULL
13847 };
13848
13849 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13850 {
13851 arg1 = wxString_in_helper(obj0);
13852 if (arg1 == NULL) SWIG_fail;
13853 temp1 = true;
13854 }
13855 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
13856 if (!SWIG_IsOK(res2)) {
13857 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13858 }
13859 if (!argp2) {
13860 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
13861 }
13862 arg2 = reinterpret_cast< wxImage * >(argp2);
13863 ecode3 = SWIG_AsVal_long(obj2, &val3);
13864 if (!SWIG_IsOK(ecode3)) {
13865 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
13866 }
13867 arg3 = static_cast< long >(val3);
13868 {
13869 PyThreadState* __tstate = wxPyBeginAllowThreads();
13870 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
13871 wxPyEndAllowThreads(__tstate);
13872 if (PyErr_Occurred()) SWIG_fail;
13873 }
13874 resultobj = SWIG_Py_Void();
13875 {
13876 if (temp1)
13877 delete arg1;
13878 }
13879 return resultobj;
13880 fail:
13881 {
13882 if (temp1)
13883 delete arg1;
13884 }
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13890 PyObject *resultobj = 0;
13891 wxString *arg1 = 0 ;
13892 wxBitmap *arg2 = 0 ;
13893 long arg3 ;
13894 bool temp1 = false ;
13895 void *argp2 = 0 ;
13896 int res2 = 0 ;
13897 long val3 ;
13898 int ecode3 = 0 ;
13899 PyObject * obj0 = 0 ;
13900 PyObject * obj1 = 0 ;
13901 PyObject * obj2 = 0 ;
13902 char * kwnames[] = {
13903 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
13904 };
13905
13906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13907 {
13908 arg1 = wxString_in_helper(obj0);
13909 if (arg1 == NULL) SWIG_fail;
13910 temp1 = true;
13911 }
13912 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
13913 if (!SWIG_IsOK(res2)) {
13914 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13915 }
13916 if (!argp2) {
13917 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
13918 }
13919 arg2 = reinterpret_cast< wxBitmap * >(argp2);
13920 ecode3 = SWIG_AsVal_long(obj2, &val3);
13921 if (!SWIG_IsOK(ecode3)) {
13922 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
13923 }
13924 arg3 = static_cast< long >(val3);
13925 {
13926 PyThreadState* __tstate = wxPyBeginAllowThreads();
13927 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
13928 wxPyEndAllowThreads(__tstate);
13929 if (PyErr_Occurred()) SWIG_fail;
13930 }
13931 resultobj = SWIG_Py_Void();
13932 {
13933 if (temp1)
13934 delete arg1;
13935 }
13936 return resultobj;
13937 fail:
13938 {
13939 if (temp1)
13940 delete arg1;
13941 }
13942 return NULL;
13943 }
13944
13945
13946 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13947 PyObject *resultobj = 0;
13948 wxString *arg1 = 0 ;
13949 PyObject *arg2 = (PyObject *) 0 ;
13950 bool temp1 = false ;
13951 PyObject * obj0 = 0 ;
13952 PyObject * obj1 = 0 ;
13953 char * kwnames[] = {
13954 (char *) "filename",(char *) "data", NULL
13955 };
13956
13957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
13958 {
13959 arg1 = wxString_in_helper(obj0);
13960 if (arg1 == NULL) SWIG_fail;
13961 temp1 = true;
13962 }
13963 arg2 = obj1;
13964 {
13965 PyThreadState* __tstate = wxPyBeginAllowThreads();
13966 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
13967 wxPyEndAllowThreads(__tstate);
13968 if (PyErr_Occurred()) SWIG_fail;
13969 }
13970 resultobj = SWIG_Py_Void();
13971 {
13972 if (temp1)
13973 delete arg1;
13974 }
13975 return resultobj;
13976 fail:
13977 {
13978 if (temp1)
13979 delete arg1;
13980 }
13981 return NULL;
13982 }
13983
13984
13985 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13986 PyObject *resultobj = 0;
13987 wxMemoryFSHandler *result = 0 ;
13988
13989 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
13990 {
13991 PyThreadState* __tstate = wxPyBeginAllowThreads();
13992 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
13993 wxPyEndAllowThreads(__tstate);
13994 if (PyErr_Occurred()) SWIG_fail;
13995 }
13996 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
13997 return resultobj;
13998 fail:
13999 return NULL;
14000 }
14001
14002
14003 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14004 PyObject *resultobj = 0;
14005 wxString *arg1 = 0 ;
14006 bool temp1 = false ;
14007 PyObject * obj0 = 0 ;
14008 char * kwnames[] = {
14009 (char *) "filename", NULL
14010 };
14011
14012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
14013 {
14014 arg1 = wxString_in_helper(obj0);
14015 if (arg1 == NULL) SWIG_fail;
14016 temp1 = true;
14017 }
14018 {
14019 PyThreadState* __tstate = wxPyBeginAllowThreads();
14020 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
14021 wxPyEndAllowThreads(__tstate);
14022 if (PyErr_Occurred()) SWIG_fail;
14023 }
14024 resultobj = SWIG_Py_Void();
14025 {
14026 if (temp1)
14027 delete arg1;
14028 }
14029 return resultobj;
14030 fail:
14031 {
14032 if (temp1)
14033 delete arg1;
14034 }
14035 return NULL;
14036 }
14037
14038
14039 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14040 PyObject *resultobj = 0;
14041 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14042 wxString *arg2 = 0 ;
14043 bool result;
14044 void *argp1 = 0 ;
14045 int res1 = 0 ;
14046 bool temp2 = false ;
14047 PyObject * obj0 = 0 ;
14048 PyObject * obj1 = 0 ;
14049 char * kwnames[] = {
14050 (char *) "self",(char *) "location", NULL
14051 };
14052
14053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
14054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14055 if (!SWIG_IsOK(res1)) {
14056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14057 }
14058 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14059 {
14060 arg2 = wxString_in_helper(obj1);
14061 if (arg2 == NULL) SWIG_fail;
14062 temp2 = true;
14063 }
14064 {
14065 PyThreadState* __tstate = wxPyBeginAllowThreads();
14066 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
14067 wxPyEndAllowThreads(__tstate);
14068 if (PyErr_Occurred()) SWIG_fail;
14069 }
14070 {
14071 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14072 }
14073 {
14074 if (temp2)
14075 delete arg2;
14076 }
14077 return resultobj;
14078 fail:
14079 {
14080 if (temp2)
14081 delete arg2;
14082 }
14083 return NULL;
14084 }
14085
14086
14087 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14088 PyObject *resultobj = 0;
14089 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14090 wxFileSystem *arg2 = 0 ;
14091 wxString *arg3 = 0 ;
14092 wxFSFile *result = 0 ;
14093 void *argp1 = 0 ;
14094 int res1 = 0 ;
14095 void *argp2 = 0 ;
14096 int res2 = 0 ;
14097 bool temp3 = false ;
14098 PyObject * obj0 = 0 ;
14099 PyObject * obj1 = 0 ;
14100 PyObject * obj2 = 0 ;
14101 char * kwnames[] = {
14102 (char *) "self",(char *) "fs",(char *) "location", NULL
14103 };
14104
14105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14107 if (!SWIG_IsOK(res1)) {
14108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14109 }
14110 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14111 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
14112 if (!SWIG_IsOK(res2)) {
14113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14114 }
14115 if (!argp2) {
14116 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
14117 }
14118 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
14119 {
14120 arg3 = wxString_in_helper(obj2);
14121 if (arg3 == NULL) SWIG_fail;
14122 temp3 = true;
14123 }
14124 {
14125 PyThreadState* __tstate = wxPyBeginAllowThreads();
14126 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
14127 wxPyEndAllowThreads(__tstate);
14128 if (PyErr_Occurred()) SWIG_fail;
14129 }
14130 {
14131 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
14132 }
14133 {
14134 if (temp3)
14135 delete arg3;
14136 }
14137 return resultobj;
14138 fail:
14139 {
14140 if (temp3)
14141 delete arg3;
14142 }
14143 return NULL;
14144 }
14145
14146
14147 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14148 PyObject *resultobj = 0;
14149 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14150 wxString *arg2 = 0 ;
14151 int arg3 = (int) 0 ;
14152 wxString result;
14153 void *argp1 = 0 ;
14154 int res1 = 0 ;
14155 bool temp2 = false ;
14156 int val3 ;
14157 int ecode3 = 0 ;
14158 PyObject * obj0 = 0 ;
14159 PyObject * obj1 = 0 ;
14160 PyObject * obj2 = 0 ;
14161 char * kwnames[] = {
14162 (char *) "self",(char *) "spec",(char *) "flags", NULL
14163 };
14164
14165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14167 if (!SWIG_IsOK(res1)) {
14168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14169 }
14170 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14171 {
14172 arg2 = wxString_in_helper(obj1);
14173 if (arg2 == NULL) SWIG_fail;
14174 temp2 = true;
14175 }
14176 if (obj2) {
14177 ecode3 = SWIG_AsVal_int(obj2, &val3);
14178 if (!SWIG_IsOK(ecode3)) {
14179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
14180 }
14181 arg3 = static_cast< int >(val3);
14182 }
14183 {
14184 PyThreadState* __tstate = wxPyBeginAllowThreads();
14185 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
14186 wxPyEndAllowThreads(__tstate);
14187 if (PyErr_Occurred()) SWIG_fail;
14188 }
14189 {
14190 #if wxUSE_UNICODE
14191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14192 #else
14193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14194 #endif
14195 }
14196 {
14197 if (temp2)
14198 delete arg2;
14199 }
14200 return resultobj;
14201 fail:
14202 {
14203 if (temp2)
14204 delete arg2;
14205 }
14206 return NULL;
14207 }
14208
14209
14210 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14211 PyObject *resultobj = 0;
14212 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
14213 wxString result;
14214 void *argp1 = 0 ;
14215 int res1 = 0 ;
14216 PyObject *swig_obj[1] ;
14217
14218 if (!args) SWIG_fail;
14219 swig_obj[0] = args;
14220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
14221 if (!SWIG_IsOK(res1)) {
14222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
14223 }
14224 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
14225 {
14226 PyThreadState* __tstate = wxPyBeginAllowThreads();
14227 result = (arg1)->FindNext();
14228 wxPyEndAllowThreads(__tstate);
14229 if (PyErr_Occurred()) SWIG_fail;
14230 }
14231 {
14232 #if wxUSE_UNICODE
14233 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14234 #else
14235 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14236 #endif
14237 }
14238 return resultobj;
14239 fail:
14240 return NULL;
14241 }
14242
14243
14244 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14245 PyObject *obj;
14246 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14247 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
14248 return SWIG_Py_Void();
14249 }
14250
14251 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14252 return SWIG_Python_InitShadowInstance(args);
14253 }
14254
14255 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14256 PyObject *resultobj = 0;
14257 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14258 wxString result;
14259 void *argp1 = 0 ;
14260 int res1 = 0 ;
14261 PyObject *swig_obj[1] ;
14262
14263 if (!args) SWIG_fail;
14264 swig_obj[0] = args;
14265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14266 if (!SWIG_IsOK(res1)) {
14267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14268 }
14269 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14270 {
14271 PyThreadState* __tstate = wxPyBeginAllowThreads();
14272 result = (arg1)->GetName();
14273 wxPyEndAllowThreads(__tstate);
14274 if (PyErr_Occurred()) SWIG_fail;
14275 }
14276 {
14277 #if wxUSE_UNICODE
14278 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14279 #else
14280 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14281 #endif
14282 }
14283 return resultobj;
14284 fail:
14285 return NULL;
14286 }
14287
14288
14289 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14290 PyObject *resultobj = 0;
14291 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14292 wxString result;
14293 void *argp1 = 0 ;
14294 int res1 = 0 ;
14295 PyObject *swig_obj[1] ;
14296
14297 if (!args) SWIG_fail;
14298 swig_obj[0] = args;
14299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14300 if (!SWIG_IsOK(res1)) {
14301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14302 }
14303 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14304 {
14305 PyThreadState* __tstate = wxPyBeginAllowThreads();
14306 result = (arg1)->GetExtension();
14307 wxPyEndAllowThreads(__tstate);
14308 if (PyErr_Occurred()) SWIG_fail;
14309 }
14310 {
14311 #if wxUSE_UNICODE
14312 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14313 #else
14314 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14315 #endif
14316 }
14317 return resultobj;
14318 fail:
14319 return NULL;
14320 }
14321
14322
14323 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14324 PyObject *resultobj = 0;
14325 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14326 long result;
14327 void *argp1 = 0 ;
14328 int res1 = 0 ;
14329 PyObject *swig_obj[1] ;
14330
14331 if (!args) SWIG_fail;
14332 swig_obj[0] = args;
14333 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14334 if (!SWIG_IsOK(res1)) {
14335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14336 }
14337 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14338 {
14339 PyThreadState* __tstate = wxPyBeginAllowThreads();
14340 result = (long)(arg1)->GetType();
14341 wxPyEndAllowThreads(__tstate);
14342 if (PyErr_Occurred()) SWIG_fail;
14343 }
14344 resultobj = SWIG_From_long(static_cast< long >(result));
14345 return resultobj;
14346 fail:
14347 return NULL;
14348 }
14349
14350
14351 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14352 PyObject *resultobj = 0;
14353 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14354 wxString result;
14355 void *argp1 = 0 ;
14356 int res1 = 0 ;
14357 PyObject *swig_obj[1] ;
14358
14359 if (!args) SWIG_fail;
14360 swig_obj[0] = args;
14361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14362 if (!SWIG_IsOK(res1)) {
14363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14364 }
14365 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14366 {
14367 PyThreadState* __tstate = wxPyBeginAllowThreads();
14368 result = (arg1)->GetMimeType();
14369 wxPyEndAllowThreads(__tstate);
14370 if (PyErr_Occurred()) SWIG_fail;
14371 }
14372 {
14373 #if wxUSE_UNICODE
14374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
14375 #else
14376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
14377 #endif
14378 }
14379 return resultobj;
14380 fail:
14381 return NULL;
14382 }
14383
14384
14385 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14386 PyObject *resultobj = 0;
14387 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14388 wxString *arg2 = 0 ;
14389 bool result;
14390 void *argp1 = 0 ;
14391 int res1 = 0 ;
14392 bool temp2 = false ;
14393 PyObject * obj0 = 0 ;
14394 PyObject * obj1 = 0 ;
14395 char * kwnames[] = {
14396 (char *) "self",(char *) "name", NULL
14397 };
14398
14399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
14400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14401 if (!SWIG_IsOK(res1)) {
14402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14403 }
14404 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14405 {
14406 arg2 = wxString_in_helper(obj1);
14407 if (arg2 == NULL) SWIG_fail;
14408 temp2 = true;
14409 }
14410 {
14411 PyThreadState* __tstate = wxPyBeginAllowThreads();
14412 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
14413 wxPyEndAllowThreads(__tstate);
14414 if (PyErr_Occurred()) SWIG_fail;
14415 }
14416 {
14417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14418 }
14419 {
14420 if (temp2)
14421 delete arg2;
14422 }
14423 return resultobj;
14424 fail:
14425 {
14426 if (temp2)
14427 delete arg2;
14428 }
14429 return NULL;
14430 }
14431
14432
14433 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14434 PyObject *resultobj = 0;
14435 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14436 wxInputStream *arg2 = 0 ;
14437 bool result;
14438 void *argp1 = 0 ;
14439 int res1 = 0 ;
14440 wxPyInputStream *temp2 ;
14441 bool created2 ;
14442 PyObject * obj0 = 0 ;
14443 PyObject * obj1 = 0 ;
14444 char * kwnames[] = {
14445 (char *) "self",(char *) "stream", NULL
14446 };
14447
14448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
14449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14450 if (!SWIG_IsOK(res1)) {
14451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14452 }
14453 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14454 {
14455 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14456 arg2 = temp2->m_wxis;
14457 created2 = false;
14458 } else {
14459 PyErr_Clear(); // clear the failure of the wxPyConvert above
14460 arg2 = wxPyCBInputStream_create(obj1, false);
14461 if (arg2 == NULL) {
14462 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14463 SWIG_fail;
14464 }
14465 created2 = true;
14466 }
14467 }
14468 {
14469 PyThreadState* __tstate = wxPyBeginAllowThreads();
14470 result = (bool)(arg1)->CanRead(*arg2);
14471 wxPyEndAllowThreads(__tstate);
14472 if (PyErr_Occurred()) SWIG_fail;
14473 }
14474 {
14475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14476 }
14477 {
14478 if (created2) delete arg2;
14479 }
14480 return resultobj;
14481 fail:
14482 {
14483 if (created2) delete arg2;
14484 }
14485 return NULL;
14486 }
14487
14488
14489 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14490 PyObject *resultobj = 0;
14491 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14492 wxString *arg2 = 0 ;
14493 void *argp1 = 0 ;
14494 int res1 = 0 ;
14495 bool temp2 = false ;
14496 PyObject * obj0 = 0 ;
14497 PyObject * obj1 = 0 ;
14498 char * kwnames[] = {
14499 (char *) "self",(char *) "name", NULL
14500 };
14501
14502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
14503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14504 if (!SWIG_IsOK(res1)) {
14505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14506 }
14507 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14508 {
14509 arg2 = wxString_in_helper(obj1);
14510 if (arg2 == NULL) SWIG_fail;
14511 temp2 = true;
14512 }
14513 {
14514 PyThreadState* __tstate = wxPyBeginAllowThreads();
14515 (arg1)->SetName((wxString const &)*arg2);
14516 wxPyEndAllowThreads(__tstate);
14517 if (PyErr_Occurred()) SWIG_fail;
14518 }
14519 resultobj = SWIG_Py_Void();
14520 {
14521 if (temp2)
14522 delete arg2;
14523 }
14524 return resultobj;
14525 fail:
14526 {
14527 if (temp2)
14528 delete arg2;
14529 }
14530 return NULL;
14531 }
14532
14533
14534 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14535 PyObject *resultobj = 0;
14536 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14537 wxString *arg2 = 0 ;
14538 void *argp1 = 0 ;
14539 int res1 = 0 ;
14540 bool temp2 = false ;
14541 PyObject * obj0 = 0 ;
14542 PyObject * obj1 = 0 ;
14543 char * kwnames[] = {
14544 (char *) "self",(char *) "extension", NULL
14545 };
14546
14547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
14548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14549 if (!SWIG_IsOK(res1)) {
14550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14551 }
14552 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14553 {
14554 arg2 = wxString_in_helper(obj1);
14555 if (arg2 == NULL) SWIG_fail;
14556 temp2 = true;
14557 }
14558 {
14559 PyThreadState* __tstate = wxPyBeginAllowThreads();
14560 (arg1)->SetExtension((wxString const &)*arg2);
14561 wxPyEndAllowThreads(__tstate);
14562 if (PyErr_Occurred()) SWIG_fail;
14563 }
14564 resultobj = SWIG_Py_Void();
14565 {
14566 if (temp2)
14567 delete arg2;
14568 }
14569 return resultobj;
14570 fail:
14571 {
14572 if (temp2)
14573 delete arg2;
14574 }
14575 return NULL;
14576 }
14577
14578
14579 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14580 PyObject *resultobj = 0;
14581 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14582 long arg2 ;
14583 void *argp1 = 0 ;
14584 int res1 = 0 ;
14585 long val2 ;
14586 int ecode2 = 0 ;
14587 PyObject * obj0 = 0 ;
14588 PyObject * obj1 = 0 ;
14589 char * kwnames[] = {
14590 (char *) "self",(char *) "type", NULL
14591 };
14592
14593 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
14594 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14595 if (!SWIG_IsOK(res1)) {
14596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14597 }
14598 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14599 ecode2 = SWIG_AsVal_long(obj1, &val2);
14600 if (!SWIG_IsOK(ecode2)) {
14601 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
14602 }
14603 arg2 = static_cast< long >(val2);
14604 {
14605 PyThreadState* __tstate = wxPyBeginAllowThreads();
14606 (arg1)->SetType(arg2);
14607 wxPyEndAllowThreads(__tstate);
14608 if (PyErr_Occurred()) SWIG_fail;
14609 }
14610 resultobj = SWIG_Py_Void();
14611 return resultobj;
14612 fail:
14613 return NULL;
14614 }
14615
14616
14617 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14618 PyObject *resultobj = 0;
14619 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
14620 wxString *arg2 = 0 ;
14621 void *argp1 = 0 ;
14622 int res1 = 0 ;
14623 bool temp2 = false ;
14624 PyObject * obj0 = 0 ;
14625 PyObject * obj1 = 0 ;
14626 char * kwnames[] = {
14627 (char *) "self",(char *) "mimetype", NULL
14628 };
14629
14630 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
14631 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
14632 if (!SWIG_IsOK(res1)) {
14633 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
14634 }
14635 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
14636 {
14637 arg2 = wxString_in_helper(obj1);
14638 if (arg2 == NULL) SWIG_fail;
14639 temp2 = true;
14640 }
14641 {
14642 PyThreadState* __tstate = wxPyBeginAllowThreads();
14643 (arg1)->SetMimeType((wxString const &)*arg2);
14644 wxPyEndAllowThreads(__tstate);
14645 if (PyErr_Occurred()) SWIG_fail;
14646 }
14647 resultobj = SWIG_Py_Void();
14648 {
14649 if (temp2)
14650 delete arg2;
14651 }
14652 return resultobj;
14653 fail:
14654 {
14655 if (temp2)
14656 delete arg2;
14657 }
14658 return NULL;
14659 }
14660
14661
14662 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14663 PyObject *obj;
14664 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14665 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
14666 return SWIG_Py_Void();
14667 }
14668
14669 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14670 PyObject *resultobj = 0;
14671 wxPyImageHandler *result = 0 ;
14672
14673 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
14674 {
14675 PyThreadState* __tstate = wxPyBeginAllowThreads();
14676 result = (wxPyImageHandler *)new wxPyImageHandler();
14677 wxPyEndAllowThreads(__tstate);
14678 if (PyErr_Occurred()) SWIG_fail;
14679 }
14680 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
14681 return resultobj;
14682 fail:
14683 return NULL;
14684 }
14685
14686
14687 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14688 PyObject *resultobj = 0;
14689 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
14690 PyObject *arg2 = (PyObject *) 0 ;
14691 void *argp1 = 0 ;
14692 int res1 = 0 ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 char * kwnames[] = {
14696 (char *) "self",(char *) "self", NULL
14697 };
14698
14699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
14700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
14701 if (!SWIG_IsOK(res1)) {
14702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
14703 }
14704 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
14705 arg2 = obj1;
14706 {
14707 PyThreadState* __tstate = wxPyBeginAllowThreads();
14708 (arg1)->_SetSelf(arg2);
14709 wxPyEndAllowThreads(__tstate);
14710 if (PyErr_Occurred()) SWIG_fail;
14711 }
14712 resultobj = SWIG_Py_Void();
14713 return resultobj;
14714 fail:
14715 return NULL;
14716 }
14717
14718
14719 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14720 PyObject *obj;
14721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
14722 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
14723 return SWIG_Py_Void();
14724 }
14725
14726 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14727 return SWIG_Python_InitShadowInstance(args);
14728 }
14729
14730 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14731 PyObject *resultobj = 0;
14732 wxImageHistogram *result = 0 ;
14733
14734 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
14735 {
14736 PyThreadState* __tstate = wxPyBeginAllowThreads();
14737 result = (wxImageHistogram *)new wxImageHistogram();
14738 wxPyEndAllowThreads(__tstate);
14739 if (PyErr_Occurred()) SWIG_fail;
14740 }
14741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
14742 return resultobj;
14743 fail:
14744 return NULL;
14745 }
14746
14747
14748 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14749 PyObject *resultobj = 0;
14750 byte arg1 ;
14751 byte arg2 ;
14752 byte arg3 ;
14753 unsigned long result;
14754 unsigned char val1 ;
14755 int ecode1 = 0 ;
14756 unsigned char val2 ;
14757 int ecode2 = 0 ;
14758 unsigned char val3 ;
14759 int ecode3 = 0 ;
14760 PyObject * obj0 = 0 ;
14761 PyObject * obj1 = 0 ;
14762 PyObject * obj2 = 0 ;
14763 char * kwnames[] = {
14764 (char *) "r",(char *) "g",(char *) "b", NULL
14765 };
14766
14767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14768 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
14769 if (!SWIG_IsOK(ecode1)) {
14770 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
14771 }
14772 arg1 = static_cast< byte >(val1);
14773 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14774 if (!SWIG_IsOK(ecode2)) {
14775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
14776 }
14777 arg2 = static_cast< byte >(val2);
14778 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14779 if (!SWIG_IsOK(ecode3)) {
14780 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
14781 }
14782 arg3 = static_cast< byte >(val3);
14783 {
14784 PyThreadState* __tstate = wxPyBeginAllowThreads();
14785 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
14786 wxPyEndAllowThreads(__tstate);
14787 if (PyErr_Occurred()) SWIG_fail;
14788 }
14789 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14790 return resultobj;
14791 fail:
14792 return NULL;
14793 }
14794
14795
14796 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14797 PyObject *resultobj = 0;
14798 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14799 byte *arg2 = (byte *) 0 ;
14800 byte *arg3 = (byte *) 0 ;
14801 byte *arg4 = (byte *) 0 ;
14802 byte arg5 = (byte) 1 ;
14803 byte arg6 = (byte) 0 ;
14804 byte arg7 = (byte) 0 ;
14805 bool result;
14806 void *argp1 = 0 ;
14807 int res1 = 0 ;
14808 byte temp2 ;
14809 int res2 = SWIG_TMPOBJ ;
14810 byte temp3 ;
14811 int res3 = SWIG_TMPOBJ ;
14812 byte temp4 ;
14813 int res4 = SWIG_TMPOBJ ;
14814 unsigned char val5 ;
14815 int ecode5 = 0 ;
14816 unsigned char val6 ;
14817 int ecode6 = 0 ;
14818 unsigned char val7 ;
14819 int ecode7 = 0 ;
14820 PyObject * obj0 = 0 ;
14821 PyObject * obj1 = 0 ;
14822 PyObject * obj2 = 0 ;
14823 PyObject * obj3 = 0 ;
14824 char * kwnames[] = {
14825 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14826 };
14827
14828 arg2 = &temp2;
14829 arg3 = &temp3;
14830 arg4 = &temp4;
14831 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14833 if (!SWIG_IsOK(res1)) {
14834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
14835 }
14836 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14837 if (obj1) {
14838 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14839 if (!SWIG_IsOK(ecode5)) {
14840 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14841 }
14842 arg5 = static_cast< byte >(val5);
14843 }
14844 if (obj2) {
14845 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14846 if (!SWIG_IsOK(ecode6)) {
14847 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14848 }
14849 arg6 = static_cast< byte >(val6);
14850 }
14851 if (obj3) {
14852 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14853 if (!SWIG_IsOK(ecode7)) {
14854 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14855 }
14856 arg7 = static_cast< byte >(val7);
14857 }
14858 {
14859 PyThreadState* __tstate = wxPyBeginAllowThreads();
14860 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14861 wxPyEndAllowThreads(__tstate);
14862 if (PyErr_Occurred()) SWIG_fail;
14863 }
14864 {
14865 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14866 }
14867 if (SWIG_IsTmpObj(res2)) {
14868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14869 } else {
14870 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14872 }
14873 if (SWIG_IsTmpObj(res3)) {
14874 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14875 } else {
14876 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14877 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14878 }
14879 if (SWIG_IsTmpObj(res4)) {
14880 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14881 } else {
14882 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14883 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14884 }
14885 return resultobj;
14886 fail:
14887 return NULL;
14888 }
14889
14890
14891 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14892 PyObject *resultobj = 0;
14893 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14894 unsigned long arg2 ;
14895 unsigned long result;
14896 void *argp1 = 0 ;
14897 int res1 = 0 ;
14898 unsigned long val2 ;
14899 int ecode2 = 0 ;
14900 PyObject * obj0 = 0 ;
14901 PyObject * obj1 = 0 ;
14902 char * kwnames[] = {
14903 (char *) "self",(char *) "key", NULL
14904 };
14905
14906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
14907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14908 if (!SWIG_IsOK(res1)) {
14909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14910 }
14911 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14912 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
14913 if (!SWIG_IsOK(ecode2)) {
14914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
14915 }
14916 arg2 = static_cast< unsigned long >(val2);
14917 {
14918 PyThreadState* __tstate = wxPyBeginAllowThreads();
14919 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
14920 wxPyEndAllowThreads(__tstate);
14921 if (PyErr_Occurred()) SWIG_fail;
14922 }
14923 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14924 return resultobj;
14925 fail:
14926 return NULL;
14927 }
14928
14929
14930 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14931 PyObject *resultobj = 0;
14932 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14933 byte arg2 ;
14934 byte arg3 ;
14935 byte arg4 ;
14936 unsigned long result;
14937 void *argp1 = 0 ;
14938 int res1 = 0 ;
14939 unsigned char val2 ;
14940 int ecode2 = 0 ;
14941 unsigned char val3 ;
14942 int ecode3 = 0 ;
14943 unsigned char val4 ;
14944 int ecode4 = 0 ;
14945 PyObject * obj0 = 0 ;
14946 PyObject * obj1 = 0 ;
14947 PyObject * obj2 = 0 ;
14948 PyObject * obj3 = 0 ;
14949 char * kwnames[] = {
14950 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14951 };
14952
14953 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14954 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
14955 if (!SWIG_IsOK(res1)) {
14956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
14957 }
14958 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
14959 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14960 if (!SWIG_IsOK(ecode2)) {
14961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
14962 }
14963 arg2 = static_cast< byte >(val2);
14964 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14965 if (!SWIG_IsOK(ecode3)) {
14966 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
14967 }
14968 arg3 = static_cast< byte >(val3);
14969 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14970 if (!SWIG_IsOK(ecode4)) {
14971 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
14972 }
14973 arg4 = static_cast< byte >(val4);
14974 {
14975 PyThreadState* __tstate = wxPyBeginAllowThreads();
14976 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
14977 wxPyEndAllowThreads(__tstate);
14978 if (PyErr_Occurred()) SWIG_fail;
14979 }
14980 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
14981 return resultobj;
14982 fail:
14983 return NULL;
14984 }
14985
14986
14987 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14988 PyObject *resultobj = 0;
14989 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
14990 wxColour *arg2 = 0 ;
14991 unsigned long result;
14992 void *argp1 = 0 ;
14993 int res1 = 0 ;
14994 wxColour temp2 ;
14995 PyObject * obj0 = 0 ;
14996 PyObject * obj1 = 0 ;
14997 char * kwnames[] = {
14998 (char *) "self",(char *) "colour", NULL
14999 };
15000
15001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
15002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
15003 if (!SWIG_IsOK(res1)) {
15004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
15005 }
15006 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
15007 {
15008 arg2 = &temp2;
15009 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
15010 }
15011 {
15012 PyThreadState* __tstate = wxPyBeginAllowThreads();
15013 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
15014 wxPyEndAllowThreads(__tstate);
15015 if (PyErr_Occurred()) SWIG_fail;
15016 }
15017 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
15018 return resultobj;
15019 fail:
15020 return NULL;
15021 }
15022
15023
15024 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15025 PyObject *obj;
15026 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15027 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
15028 return SWIG_Py_Void();
15029 }
15030
15031 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15032 return SWIG_Python_InitShadowInstance(args);
15033 }
15034
15035 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15036 PyObject *resultobj = 0;
15037 byte arg1 = (byte) 0 ;
15038 byte arg2 = (byte) 0 ;
15039 byte arg3 = (byte) 0 ;
15040 wxImage_RGBValue *result = 0 ;
15041 unsigned char val1 ;
15042 int ecode1 = 0 ;
15043 unsigned char val2 ;
15044 int ecode2 = 0 ;
15045 unsigned char val3 ;
15046 int ecode3 = 0 ;
15047 PyObject * obj0 = 0 ;
15048 PyObject * obj1 = 0 ;
15049 PyObject * obj2 = 0 ;
15050 char * kwnames[] = {
15051 (char *) "r",(char *) "g",(char *) "b", NULL
15052 };
15053
15054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15055 if (obj0) {
15056 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
15057 if (!SWIG_IsOK(ecode1)) {
15058 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
15059 }
15060 arg1 = static_cast< byte >(val1);
15061 }
15062 if (obj1) {
15063 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15064 if (!SWIG_IsOK(ecode2)) {
15065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
15066 }
15067 arg2 = static_cast< byte >(val2);
15068 }
15069 if (obj2) {
15070 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15071 if (!SWIG_IsOK(ecode3)) {
15072 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
15073 }
15074 arg3 = static_cast< byte >(val3);
15075 }
15076 {
15077 PyThreadState* __tstate = wxPyBeginAllowThreads();
15078 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
15079 wxPyEndAllowThreads(__tstate);
15080 if (PyErr_Occurred()) SWIG_fail;
15081 }
15082 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
15083 return resultobj;
15084 fail:
15085 return NULL;
15086 }
15087
15088
15089 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15090 PyObject *resultobj = 0;
15091 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15092 byte arg2 ;
15093 void *argp1 = 0 ;
15094 int res1 = 0 ;
15095 unsigned char val2 ;
15096 int ecode2 = 0 ;
15097 PyObject *swig_obj[2] ;
15098
15099 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
15100 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15101 if (!SWIG_IsOK(res1)) {
15102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15103 }
15104 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15105 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15106 if (!SWIG_IsOK(ecode2)) {
15107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
15108 }
15109 arg2 = static_cast< byte >(val2);
15110 if (arg1) (arg1)->red = arg2;
15111
15112 resultobj = SWIG_Py_Void();
15113 return resultobj;
15114 fail:
15115 return NULL;
15116 }
15117
15118
15119 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15120 PyObject *resultobj = 0;
15121 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15122 byte result;
15123 void *argp1 = 0 ;
15124 int res1 = 0 ;
15125 PyObject *swig_obj[1] ;
15126
15127 if (!args) SWIG_fail;
15128 swig_obj[0] = args;
15129 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15130 if (!SWIG_IsOK(res1)) {
15131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15132 }
15133 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15134 result = (byte) ((arg1)->red);
15135 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15143 PyObject *resultobj = 0;
15144 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15145 byte arg2 ;
15146 void *argp1 = 0 ;
15147 int res1 = 0 ;
15148 unsigned char val2 ;
15149 int ecode2 = 0 ;
15150 PyObject *swig_obj[2] ;
15151
15152 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
15153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15154 if (!SWIG_IsOK(res1)) {
15155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15156 }
15157 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15158 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15159 if (!SWIG_IsOK(ecode2)) {
15160 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
15161 }
15162 arg2 = static_cast< byte >(val2);
15163 if (arg1) (arg1)->green = arg2;
15164
15165 resultobj = SWIG_Py_Void();
15166 return resultobj;
15167 fail:
15168 return NULL;
15169 }
15170
15171
15172 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15173 PyObject *resultobj = 0;
15174 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15175 byte result;
15176 void *argp1 = 0 ;
15177 int res1 = 0 ;
15178 PyObject *swig_obj[1] ;
15179
15180 if (!args) SWIG_fail;
15181 swig_obj[0] = args;
15182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15183 if (!SWIG_IsOK(res1)) {
15184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15185 }
15186 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15187 result = (byte) ((arg1)->green);
15188 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15189 return resultobj;
15190 fail:
15191 return NULL;
15192 }
15193
15194
15195 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15196 PyObject *resultobj = 0;
15197 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15198 byte arg2 ;
15199 void *argp1 = 0 ;
15200 int res1 = 0 ;
15201 unsigned char val2 ;
15202 int ecode2 = 0 ;
15203 PyObject *swig_obj[2] ;
15204
15205 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
15206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15207 if (!SWIG_IsOK(res1)) {
15208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15209 }
15210 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15211 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
15212 if (!SWIG_IsOK(ecode2)) {
15213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
15214 }
15215 arg2 = static_cast< byte >(val2);
15216 if (arg1) (arg1)->blue = arg2;
15217
15218 resultobj = SWIG_Py_Void();
15219 return resultobj;
15220 fail:
15221 return NULL;
15222 }
15223
15224
15225 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15226 PyObject *resultobj = 0;
15227 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
15228 byte result;
15229 void *argp1 = 0 ;
15230 int res1 = 0 ;
15231 PyObject *swig_obj[1] ;
15232
15233 if (!args) SWIG_fail;
15234 swig_obj[0] = args;
15235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
15236 if (!SWIG_IsOK(res1)) {
15237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
15238 }
15239 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
15240 result = (byte) ((arg1)->blue);
15241 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15242 return resultobj;
15243 fail:
15244 return NULL;
15245 }
15246
15247
15248 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15249 PyObject *obj;
15250 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15251 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
15252 return SWIG_Py_Void();
15253 }
15254
15255 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15256 return SWIG_Python_InitShadowInstance(args);
15257 }
15258
15259 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15260 PyObject *resultobj = 0;
15261 double arg1 = (double) 0.0 ;
15262 double arg2 = (double) 0.0 ;
15263 double arg3 = (double) 0.0 ;
15264 wxImage_HSVValue *result = 0 ;
15265 double val1 ;
15266 int ecode1 = 0 ;
15267 double val2 ;
15268 int ecode2 = 0 ;
15269 double val3 ;
15270 int ecode3 = 0 ;
15271 PyObject * obj0 = 0 ;
15272 PyObject * obj1 = 0 ;
15273 PyObject * obj2 = 0 ;
15274 char * kwnames[] = {
15275 (char *) "h",(char *) "s",(char *) "v", NULL
15276 };
15277
15278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15279 if (obj0) {
15280 ecode1 = SWIG_AsVal_double(obj0, &val1);
15281 if (!SWIG_IsOK(ecode1)) {
15282 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
15283 }
15284 arg1 = static_cast< double >(val1);
15285 }
15286 if (obj1) {
15287 ecode2 = SWIG_AsVal_double(obj1, &val2);
15288 if (!SWIG_IsOK(ecode2)) {
15289 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
15290 }
15291 arg2 = static_cast< double >(val2);
15292 }
15293 if (obj2) {
15294 ecode3 = SWIG_AsVal_double(obj2, &val3);
15295 if (!SWIG_IsOK(ecode3)) {
15296 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
15297 }
15298 arg3 = static_cast< double >(val3);
15299 }
15300 {
15301 PyThreadState* __tstate = wxPyBeginAllowThreads();
15302 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
15303 wxPyEndAllowThreads(__tstate);
15304 if (PyErr_Occurred()) SWIG_fail;
15305 }
15306 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
15307 return resultobj;
15308 fail:
15309 return NULL;
15310 }
15311
15312
15313 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15314 PyObject *resultobj = 0;
15315 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15316 double arg2 ;
15317 void *argp1 = 0 ;
15318 int res1 = 0 ;
15319 double val2 ;
15320 int ecode2 = 0 ;
15321 PyObject *swig_obj[2] ;
15322
15323 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
15324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15325 if (!SWIG_IsOK(res1)) {
15326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15327 }
15328 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15329 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15330 if (!SWIG_IsOK(ecode2)) {
15331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
15332 }
15333 arg2 = static_cast< double >(val2);
15334 if (arg1) (arg1)->hue = arg2;
15335
15336 resultobj = SWIG_Py_Void();
15337 return resultobj;
15338 fail:
15339 return NULL;
15340 }
15341
15342
15343 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15344 PyObject *resultobj = 0;
15345 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15346 double result;
15347 void *argp1 = 0 ;
15348 int res1 = 0 ;
15349 PyObject *swig_obj[1] ;
15350
15351 if (!args) SWIG_fail;
15352 swig_obj[0] = args;
15353 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15354 if (!SWIG_IsOK(res1)) {
15355 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15356 }
15357 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15358 result = (double) ((arg1)->hue);
15359 resultobj = SWIG_From_double(static_cast< double >(result));
15360 return resultobj;
15361 fail:
15362 return NULL;
15363 }
15364
15365
15366 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15367 PyObject *resultobj = 0;
15368 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15369 double arg2 ;
15370 void *argp1 = 0 ;
15371 int res1 = 0 ;
15372 double val2 ;
15373 int ecode2 = 0 ;
15374 PyObject *swig_obj[2] ;
15375
15376 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
15377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15378 if (!SWIG_IsOK(res1)) {
15379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15380 }
15381 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15382 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15383 if (!SWIG_IsOK(ecode2)) {
15384 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
15385 }
15386 arg2 = static_cast< double >(val2);
15387 if (arg1) (arg1)->saturation = arg2;
15388
15389 resultobj = SWIG_Py_Void();
15390 return resultobj;
15391 fail:
15392 return NULL;
15393 }
15394
15395
15396 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15397 PyObject *resultobj = 0;
15398 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15399 double result;
15400 void *argp1 = 0 ;
15401 int res1 = 0 ;
15402 PyObject *swig_obj[1] ;
15403
15404 if (!args) SWIG_fail;
15405 swig_obj[0] = args;
15406 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15407 if (!SWIG_IsOK(res1)) {
15408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15409 }
15410 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15411 result = (double) ((arg1)->saturation);
15412 resultobj = SWIG_From_double(static_cast< double >(result));
15413 return resultobj;
15414 fail:
15415 return NULL;
15416 }
15417
15418
15419 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15420 PyObject *resultobj = 0;
15421 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15422 double arg2 ;
15423 void *argp1 = 0 ;
15424 int res1 = 0 ;
15425 double val2 ;
15426 int ecode2 = 0 ;
15427 PyObject *swig_obj[2] ;
15428
15429 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
15430 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15431 if (!SWIG_IsOK(res1)) {
15432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15433 }
15434 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15435 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
15436 if (!SWIG_IsOK(ecode2)) {
15437 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
15438 }
15439 arg2 = static_cast< double >(val2);
15440 if (arg1) (arg1)->value = arg2;
15441
15442 resultobj = SWIG_Py_Void();
15443 return resultobj;
15444 fail:
15445 return NULL;
15446 }
15447
15448
15449 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15450 PyObject *resultobj = 0;
15451 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
15452 double result;
15453 void *argp1 = 0 ;
15454 int res1 = 0 ;
15455 PyObject *swig_obj[1] ;
15456
15457 if (!args) SWIG_fail;
15458 swig_obj[0] = args;
15459 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
15460 if (!SWIG_IsOK(res1)) {
15461 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
15462 }
15463 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
15464 result = (double) ((arg1)->value);
15465 resultobj = SWIG_From_double(static_cast< double >(result));
15466 return resultobj;
15467 fail:
15468 return NULL;
15469 }
15470
15471
15472 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15473 PyObject *obj;
15474 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
15475 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
15476 return SWIG_Py_Void();
15477 }
15478
15479 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15480 return SWIG_Python_InitShadowInstance(args);
15481 }
15482
15483 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15484 PyObject *resultobj = 0;
15485 wxString *arg1 = 0 ;
15486 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15487 int arg3 = (int) -1 ;
15488 wxImage *result = 0 ;
15489 bool temp1 = false ;
15490 long val2 ;
15491 int ecode2 = 0 ;
15492 int val3 ;
15493 int ecode3 = 0 ;
15494 PyObject * obj0 = 0 ;
15495 PyObject * obj1 = 0 ;
15496 PyObject * obj2 = 0 ;
15497 char * kwnames[] = {
15498 (char *) "name",(char *) "type",(char *) "index", NULL
15499 };
15500
15501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15502 {
15503 arg1 = wxString_in_helper(obj0);
15504 if (arg1 == NULL) SWIG_fail;
15505 temp1 = true;
15506 }
15507 if (obj1) {
15508 ecode2 = SWIG_AsVal_long(obj1, &val2);
15509 if (!SWIG_IsOK(ecode2)) {
15510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
15511 }
15512 arg2 = static_cast< long >(val2);
15513 }
15514 if (obj2) {
15515 ecode3 = SWIG_AsVal_int(obj2, &val3);
15516 if (!SWIG_IsOK(ecode3)) {
15517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
15518 }
15519 arg3 = static_cast< int >(val3);
15520 }
15521 {
15522 PyThreadState* __tstate = wxPyBeginAllowThreads();
15523 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
15524 wxPyEndAllowThreads(__tstate);
15525 if (PyErr_Occurred()) SWIG_fail;
15526 }
15527 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
15528 {
15529 if (temp1)
15530 delete arg1;
15531 }
15532 return resultobj;
15533 fail:
15534 {
15535 if (temp1)
15536 delete arg1;
15537 }
15538 return NULL;
15539 }
15540
15541
15542 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15543 PyObject *resultobj = 0;
15544 wxImage *arg1 = (wxImage *) 0 ;
15545 void *argp1 = 0 ;
15546 int res1 = 0 ;
15547 PyObject *swig_obj[1] ;
15548
15549 if (!args) SWIG_fail;
15550 swig_obj[0] = args;
15551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
15552 if (!SWIG_IsOK(res1)) {
15553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
15554 }
15555 arg1 = reinterpret_cast< wxImage * >(argp1);
15556 {
15557 PyThreadState* __tstate = wxPyBeginAllowThreads();
15558 delete arg1;
15559
15560 wxPyEndAllowThreads(__tstate);
15561 if (PyErr_Occurred()) SWIG_fail;
15562 }
15563 resultobj = SWIG_Py_Void();
15564 return resultobj;
15565 fail:
15566 return NULL;
15567 }
15568
15569
15570 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15571 PyObject *resultobj = 0;
15572 wxString *arg1 = 0 ;
15573 wxString *arg2 = 0 ;
15574 int arg3 = (int) -1 ;
15575 wxImage *result = 0 ;
15576 bool temp1 = false ;
15577 bool temp2 = false ;
15578 int val3 ;
15579 int ecode3 = 0 ;
15580 PyObject * obj0 = 0 ;
15581 PyObject * obj1 = 0 ;
15582 PyObject * obj2 = 0 ;
15583 char * kwnames[] = {
15584 (char *) "name",(char *) "mimetype",(char *) "index", NULL
15585 };
15586
15587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15588 {
15589 arg1 = wxString_in_helper(obj0);
15590 if (arg1 == NULL) SWIG_fail;
15591 temp1 = true;
15592 }
15593 {
15594 arg2 = wxString_in_helper(obj1);
15595 if (arg2 == NULL) SWIG_fail;
15596 temp2 = true;
15597 }
15598 if (obj2) {
15599 ecode3 = SWIG_AsVal_int(obj2, &val3);
15600 if (!SWIG_IsOK(ecode3)) {
15601 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
15602 }
15603 arg3 = static_cast< int >(val3);
15604 }
15605 {
15606 PyThreadState* __tstate = wxPyBeginAllowThreads();
15607 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
15608 wxPyEndAllowThreads(__tstate);
15609 if (PyErr_Occurred()) SWIG_fail;
15610 }
15611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15612 {
15613 if (temp1)
15614 delete arg1;
15615 }
15616 {
15617 if (temp2)
15618 delete arg2;
15619 }
15620 return resultobj;
15621 fail:
15622 {
15623 if (temp1)
15624 delete arg1;
15625 }
15626 {
15627 if (temp2)
15628 delete arg2;
15629 }
15630 return NULL;
15631 }
15632
15633
15634 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15635 PyObject *resultobj = 0;
15636 wxInputStream *arg1 = 0 ;
15637 long arg2 = (long) wxBITMAP_TYPE_ANY ;
15638 int arg3 = (int) -1 ;
15639 wxImage *result = 0 ;
15640 wxPyInputStream *temp1 ;
15641 bool created1 ;
15642 long val2 ;
15643 int ecode2 = 0 ;
15644 int val3 ;
15645 int ecode3 = 0 ;
15646 PyObject * obj0 = 0 ;
15647 PyObject * obj1 = 0 ;
15648 PyObject * obj2 = 0 ;
15649 char * kwnames[] = {
15650 (char *) "stream",(char *) "type",(char *) "index", NULL
15651 };
15652
15653 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15654 {
15655 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15656 arg1 = temp1->m_wxis;
15657 created1 = false;
15658 } else {
15659 PyErr_Clear(); // clear the failure of the wxPyConvert above
15660 arg1 = wxPyCBInputStream_create(obj0, false);
15661 if (arg1 == NULL) {
15662 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15663 SWIG_fail;
15664 }
15665 created1 = true;
15666 }
15667 }
15668 if (obj1) {
15669 ecode2 = SWIG_AsVal_long(obj1, &val2);
15670 if (!SWIG_IsOK(ecode2)) {
15671 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
15672 }
15673 arg2 = static_cast< long >(val2);
15674 }
15675 if (obj2) {
15676 ecode3 = SWIG_AsVal_int(obj2, &val3);
15677 if (!SWIG_IsOK(ecode3)) {
15678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
15679 }
15680 arg3 = static_cast< int >(val3);
15681 }
15682 {
15683 PyThreadState* __tstate = wxPyBeginAllowThreads();
15684 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
15685 wxPyEndAllowThreads(__tstate);
15686 if (PyErr_Occurred()) SWIG_fail;
15687 }
15688 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15689 {
15690 if (created1) delete arg1;
15691 }
15692 return resultobj;
15693 fail:
15694 {
15695 if (created1) delete arg1;
15696 }
15697 return NULL;
15698 }
15699
15700
15701 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15702 PyObject *resultobj = 0;
15703 wxInputStream *arg1 = 0 ;
15704 wxString *arg2 = 0 ;
15705 int arg3 = (int) -1 ;
15706 wxImage *result = 0 ;
15707 wxPyInputStream *temp1 ;
15708 bool created1 ;
15709 bool temp2 = false ;
15710 int val3 ;
15711 int ecode3 = 0 ;
15712 PyObject * obj0 = 0 ;
15713 PyObject * obj1 = 0 ;
15714 PyObject * obj2 = 0 ;
15715 char * kwnames[] = {
15716 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
15717 };
15718
15719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15720 {
15721 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
15722 arg1 = temp1->m_wxis;
15723 created1 = false;
15724 } else {
15725 PyErr_Clear(); // clear the failure of the wxPyConvert above
15726 arg1 = wxPyCBInputStream_create(obj0, false);
15727 if (arg1 == NULL) {
15728 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15729 SWIG_fail;
15730 }
15731 created1 = true;
15732 }
15733 }
15734 {
15735 arg2 = wxString_in_helper(obj1);
15736 if (arg2 == NULL) SWIG_fail;
15737 temp2 = true;
15738 }
15739 if (obj2) {
15740 ecode3 = SWIG_AsVal_int(obj2, &val3);
15741 if (!SWIG_IsOK(ecode3)) {
15742 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
15743 }
15744 arg3 = static_cast< int >(val3);
15745 }
15746 {
15747 PyThreadState* __tstate = wxPyBeginAllowThreads();
15748 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
15749 wxPyEndAllowThreads(__tstate);
15750 if (PyErr_Occurred()) SWIG_fail;
15751 }
15752 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15753 {
15754 if (created1) delete arg1;
15755 }
15756 {
15757 if (temp2)
15758 delete arg2;
15759 }
15760 return resultobj;
15761 fail:
15762 {
15763 if (created1) delete arg1;
15764 }
15765 {
15766 if (temp2)
15767 delete arg2;
15768 }
15769 return NULL;
15770 }
15771
15772
15773 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15774 PyObject *resultobj = 0;
15775 int arg1 = (int) 0 ;
15776 int arg2 = (int) 0 ;
15777 bool arg3 = (bool) true ;
15778 wxImage *result = 0 ;
15779 int val1 ;
15780 int ecode1 = 0 ;
15781 int val2 ;
15782 int ecode2 = 0 ;
15783 bool val3 ;
15784 int ecode3 = 0 ;
15785 PyObject * obj0 = 0 ;
15786 PyObject * obj1 = 0 ;
15787 PyObject * obj2 = 0 ;
15788 char * kwnames[] = {
15789 (char *) "width",(char *) "height",(char *) "clear", NULL
15790 };
15791
15792 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15793 if (obj0) {
15794 ecode1 = SWIG_AsVal_int(obj0, &val1);
15795 if (!SWIG_IsOK(ecode1)) {
15796 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
15797 }
15798 arg1 = static_cast< int >(val1);
15799 }
15800 if (obj1) {
15801 ecode2 = SWIG_AsVal_int(obj1, &val2);
15802 if (!SWIG_IsOK(ecode2)) {
15803 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
15804 }
15805 arg2 = static_cast< int >(val2);
15806 }
15807 if (obj2) {
15808 ecode3 = SWIG_AsVal_bool(obj2, &val3);
15809 if (!SWIG_IsOK(ecode3)) {
15810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
15811 }
15812 arg3 = static_cast< bool >(val3);
15813 }
15814 {
15815 PyThreadState* __tstate = wxPyBeginAllowThreads();
15816 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
15817 wxPyEndAllowThreads(__tstate);
15818 if (PyErr_Occurred()) SWIG_fail;
15819 }
15820 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15821 return resultobj;
15822 fail:
15823 return NULL;
15824 }
15825
15826
15827 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15828 PyObject *resultobj = 0;
15829 wxBitmap *arg1 = 0 ;
15830 wxImage *result = 0 ;
15831 void *argp1 = 0 ;
15832 int res1 = 0 ;
15833 PyObject * obj0 = 0 ;
15834 char * kwnames[] = {
15835 (char *) "bitmap", NULL
15836 };
15837
15838 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
15839 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
15840 if (!SWIG_IsOK(res1)) {
15841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15842 }
15843 if (!argp1) {
15844 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
15845 }
15846 arg1 = reinterpret_cast< wxBitmap * >(argp1);
15847 {
15848 if (!wxPyCheckForApp()) SWIG_fail;
15849 PyThreadState* __tstate = wxPyBeginAllowThreads();
15850 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
15851 wxPyEndAllowThreads(__tstate);
15852 if (PyErr_Occurred()) SWIG_fail;
15853 }
15854 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15855 return resultobj;
15856 fail:
15857 return NULL;
15858 }
15859
15860
15861 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15862 PyObject *resultobj = 0;
15863 int arg1 ;
15864 int arg2 ;
15865 buffer arg3 ;
15866 int arg4 ;
15867 wxImage *result = 0 ;
15868 int val1 ;
15869 int ecode1 = 0 ;
15870 int val2 ;
15871 int ecode2 = 0 ;
15872 Py_ssize_t temp3 ;
15873 PyObject * obj0 = 0 ;
15874 PyObject * obj1 = 0 ;
15875 PyObject * obj2 = 0 ;
15876 char * kwnames[] = {
15877 (char *) "width",(char *) "height",(char *) "data", NULL
15878 };
15879
15880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
15881 ecode1 = SWIG_AsVal_int(obj0, &val1);
15882 if (!SWIG_IsOK(ecode1)) {
15883 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
15884 }
15885 arg1 = static_cast< int >(val1);
15886 ecode2 = SWIG_AsVal_int(obj1, &val2);
15887 if (!SWIG_IsOK(ecode2)) {
15888 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
15889 }
15890 arg2 = static_cast< int >(val2);
15891 {
15892 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15893 arg4 = (int)temp3;
15894 }
15895 {
15896 PyThreadState* __tstate = wxPyBeginAllowThreads();
15897 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
15898 wxPyEndAllowThreads(__tstate);
15899 if (PyErr_Occurred()) SWIG_fail;
15900 }
15901 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15902 return resultobj;
15903 fail:
15904 return NULL;
15905 }
15906
15907
15908 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15909 PyObject *resultobj = 0;
15910 int arg1 ;
15911 int arg2 ;
15912 buffer arg3 ;
15913 int arg4 ;
15914 buffer arg5 ;
15915 int arg6 ;
15916 wxImage *result = 0 ;
15917 int val1 ;
15918 int ecode1 = 0 ;
15919 int val2 ;
15920 int ecode2 = 0 ;
15921 Py_ssize_t temp3 ;
15922 Py_ssize_t temp5 ;
15923 PyObject * obj0 = 0 ;
15924 PyObject * obj1 = 0 ;
15925 PyObject * obj2 = 0 ;
15926 PyObject * obj3 = 0 ;
15927 char * kwnames[] = {
15928 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
15929 };
15930
15931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15932 ecode1 = SWIG_AsVal_int(obj0, &val1);
15933 if (!SWIG_IsOK(ecode1)) {
15934 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
15935 }
15936 arg1 = static_cast< int >(val1);
15937 ecode2 = SWIG_AsVal_int(obj1, &val2);
15938 if (!SWIG_IsOK(ecode2)) {
15939 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
15940 }
15941 arg2 = static_cast< int >(val2);
15942 {
15943 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
15944 arg4 = (int)temp3;
15945 }
15946 {
15947 if (obj3 != Py_None) {
15948 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
15949 arg6 = (int)temp5;
15950 }
15951 }
15952 {
15953 PyThreadState* __tstate = wxPyBeginAllowThreads();
15954 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
15955 wxPyEndAllowThreads(__tstate);
15956 if (PyErr_Occurred()) SWIG_fail;
15957 }
15958 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15959 return resultobj;
15960 fail:
15961 return NULL;
15962 }
15963
15964
15965 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15966 PyObject *resultobj = 0;
15967 wxImage *arg1 = (wxImage *) 0 ;
15968 int arg2 ;
15969 int arg3 ;
15970 bool arg4 = (bool) true ;
15971 void *argp1 = 0 ;
15972 int res1 = 0 ;
15973 int val2 ;
15974 int ecode2 = 0 ;
15975 int val3 ;
15976 int ecode3 = 0 ;
15977 bool val4 ;
15978 int ecode4 = 0 ;
15979 PyObject * obj0 = 0 ;
15980 PyObject * obj1 = 0 ;
15981 PyObject * obj2 = 0 ;
15982 PyObject * obj3 = 0 ;
15983 char * kwnames[] = {
15984 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
15985 };
15986
15987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15989 if (!SWIG_IsOK(res1)) {
15990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
15991 }
15992 arg1 = reinterpret_cast< wxImage * >(argp1);
15993 ecode2 = SWIG_AsVal_int(obj1, &val2);
15994 if (!SWIG_IsOK(ecode2)) {
15995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
15996 }
15997 arg2 = static_cast< int >(val2);
15998 ecode3 = SWIG_AsVal_int(obj2, &val3);
15999 if (!SWIG_IsOK(ecode3)) {
16000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
16001 }
16002 arg3 = static_cast< int >(val3);
16003 if (obj3) {
16004 ecode4 = SWIG_AsVal_bool(obj3, &val4);
16005 if (!SWIG_IsOK(ecode4)) {
16006 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
16007 }
16008 arg4 = static_cast< bool >(val4);
16009 }
16010 {
16011 PyThreadState* __tstate = wxPyBeginAllowThreads();
16012 (arg1)->Create(arg2,arg3,arg4);
16013 wxPyEndAllowThreads(__tstate);
16014 if (PyErr_Occurred()) SWIG_fail;
16015 }
16016 resultobj = SWIG_Py_Void();
16017 return resultobj;
16018 fail:
16019 return NULL;
16020 }
16021
16022
16023 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16024 PyObject *resultobj = 0;
16025 wxImage *arg1 = (wxImage *) 0 ;
16026 void *argp1 = 0 ;
16027 int res1 = 0 ;
16028 PyObject *swig_obj[1] ;
16029
16030 if (!args) SWIG_fail;
16031 swig_obj[0] = args;
16032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16033 if (!SWIG_IsOK(res1)) {
16034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
16035 }
16036 arg1 = reinterpret_cast< wxImage * >(argp1);
16037 {
16038 PyThreadState* __tstate = wxPyBeginAllowThreads();
16039 (arg1)->Destroy();
16040 wxPyEndAllowThreads(__tstate);
16041 if (PyErr_Occurred()) SWIG_fail;
16042 }
16043 resultobj = SWIG_Py_Void();
16044 return resultobj;
16045 fail:
16046 return NULL;
16047 }
16048
16049
16050 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16051 PyObject *resultobj = 0;
16052 wxImage *arg1 = (wxImage *) 0 ;
16053 int arg2 ;
16054 int arg3 ;
16055 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16056 SwigValueWrapper<wxImage > result;
16057 void *argp1 = 0 ;
16058 int res1 = 0 ;
16059 int val2 ;
16060 int ecode2 = 0 ;
16061 int val3 ;
16062 int ecode3 = 0 ;
16063 int val4 ;
16064 int ecode4 = 0 ;
16065 PyObject * obj0 = 0 ;
16066 PyObject * obj1 = 0 ;
16067 PyObject * obj2 = 0 ;
16068 PyObject * obj3 = 0 ;
16069 char * kwnames[] = {
16070 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16071 };
16072
16073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Scale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16075 if (!SWIG_IsOK(res1)) {
16076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
16077 }
16078 arg1 = reinterpret_cast< wxImage * >(argp1);
16079 ecode2 = SWIG_AsVal_int(obj1, &val2);
16080 if (!SWIG_IsOK(ecode2)) {
16081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
16082 }
16083 arg2 = static_cast< int >(val2);
16084 ecode3 = SWIG_AsVal_int(obj2, &val3);
16085 if (!SWIG_IsOK(ecode3)) {
16086 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
16087 }
16088 arg3 = static_cast< int >(val3);
16089 if (obj3) {
16090 ecode4 = SWIG_AsVal_int(obj3, &val4);
16091 if (!SWIG_IsOK(ecode4)) {
16092 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Scale" "', expected argument " "4"" of type '" "int""'");
16093 }
16094 arg4 = static_cast< int >(val4);
16095 }
16096 {
16097 PyThreadState* __tstate = wxPyBeginAllowThreads();
16098 result = (arg1)->Scale(arg2,arg3,arg4);
16099 wxPyEndAllowThreads(__tstate);
16100 if (PyErr_Occurred()) SWIG_fail;
16101 }
16102 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16103 return resultobj;
16104 fail:
16105 return NULL;
16106 }
16107
16108
16109 SWIGINTERN PyObject *_wrap_Image_ResampleBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16110 PyObject *resultobj = 0;
16111 wxImage *arg1 = (wxImage *) 0 ;
16112 int arg2 ;
16113 int arg3 ;
16114 SwigValueWrapper<wxImage > result;
16115 void *argp1 = 0 ;
16116 int res1 = 0 ;
16117 int val2 ;
16118 int ecode2 = 0 ;
16119 int val3 ;
16120 int ecode3 = 0 ;
16121 PyObject * obj0 = 0 ;
16122 PyObject * obj1 = 0 ;
16123 PyObject * obj2 = 0 ;
16124 char * kwnames[] = {
16125 (char *) "self",(char *) "width",(char *) "height", NULL
16126 };
16127
16128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBox",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16130 if (!SWIG_IsOK(res1)) {
16131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBox" "', expected argument " "1"" of type '" "wxImage const *""'");
16132 }
16133 arg1 = reinterpret_cast< wxImage * >(argp1);
16134 ecode2 = SWIG_AsVal_int(obj1, &val2);
16135 if (!SWIG_IsOK(ecode2)) {
16136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBox" "', expected argument " "2"" of type '" "int""'");
16137 }
16138 arg2 = static_cast< int >(val2);
16139 ecode3 = SWIG_AsVal_int(obj2, &val3);
16140 if (!SWIG_IsOK(ecode3)) {
16141 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBox" "', expected argument " "3"" of type '" "int""'");
16142 }
16143 arg3 = static_cast< int >(val3);
16144 {
16145 PyThreadState* __tstate = wxPyBeginAllowThreads();
16146 result = ((wxImage const *)arg1)->ResampleBox(arg2,arg3);
16147 wxPyEndAllowThreads(__tstate);
16148 if (PyErr_Occurred()) SWIG_fail;
16149 }
16150 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16151 return resultobj;
16152 fail:
16153 return NULL;
16154 }
16155
16156
16157 SWIGINTERN PyObject *_wrap_Image_ResampleBicubic(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16158 PyObject *resultobj = 0;
16159 wxImage *arg1 = (wxImage *) 0 ;
16160 int arg2 ;
16161 int arg3 ;
16162 SwigValueWrapper<wxImage > result;
16163 void *argp1 = 0 ;
16164 int res1 = 0 ;
16165 int val2 ;
16166 int ecode2 = 0 ;
16167 int val3 ;
16168 int ecode3 = 0 ;
16169 PyObject * obj0 = 0 ;
16170 PyObject * obj1 = 0 ;
16171 PyObject * obj2 = 0 ;
16172 char * kwnames[] = {
16173 (char *) "self",(char *) "width",(char *) "height", NULL
16174 };
16175
16176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ResampleBicubic",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16178 if (!SWIG_IsOK(res1)) {
16179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ResampleBicubic" "', expected argument " "1"" of type '" "wxImage const *""'");
16180 }
16181 arg1 = reinterpret_cast< wxImage * >(argp1);
16182 ecode2 = SWIG_AsVal_int(obj1, &val2);
16183 if (!SWIG_IsOK(ecode2)) {
16184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ResampleBicubic" "', expected argument " "2"" of type '" "int""'");
16185 }
16186 arg2 = static_cast< int >(val2);
16187 ecode3 = SWIG_AsVal_int(obj2, &val3);
16188 if (!SWIG_IsOK(ecode3)) {
16189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ResampleBicubic" "', expected argument " "3"" of type '" "int""'");
16190 }
16191 arg3 = static_cast< int >(val3);
16192 {
16193 PyThreadState* __tstate = wxPyBeginAllowThreads();
16194 result = ((wxImage const *)arg1)->ResampleBicubic(arg2,arg3);
16195 wxPyEndAllowThreads(__tstate);
16196 if (PyErr_Occurred()) SWIG_fail;
16197 }
16198 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16199 return resultobj;
16200 fail:
16201 return NULL;
16202 }
16203
16204
16205 SWIGINTERN PyObject *_wrap_Image_Blur(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16206 PyObject *resultobj = 0;
16207 wxImage *arg1 = (wxImage *) 0 ;
16208 int arg2 ;
16209 SwigValueWrapper<wxImage > result;
16210 void *argp1 = 0 ;
16211 int res1 = 0 ;
16212 int val2 ;
16213 int ecode2 = 0 ;
16214 PyObject * obj0 = 0 ;
16215 PyObject * obj1 = 0 ;
16216 char * kwnames[] = {
16217 (char *) "self",(char *) "radius", NULL
16218 };
16219
16220 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_Blur",kwnames,&obj0,&obj1)) SWIG_fail;
16221 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16222 if (!SWIG_IsOK(res1)) {
16223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Blur" "', expected argument " "1"" of type '" "wxImage *""'");
16224 }
16225 arg1 = reinterpret_cast< wxImage * >(argp1);
16226 ecode2 = SWIG_AsVal_int(obj1, &val2);
16227 if (!SWIG_IsOK(ecode2)) {
16228 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Blur" "', expected argument " "2"" of type '" "int""'");
16229 }
16230 arg2 = static_cast< int >(val2);
16231 {
16232 PyThreadState* __tstate = wxPyBeginAllowThreads();
16233 result = (arg1)->Blur(arg2);
16234 wxPyEndAllowThreads(__tstate);
16235 if (PyErr_Occurred()) SWIG_fail;
16236 }
16237 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16238 return resultobj;
16239 fail:
16240 return NULL;
16241 }
16242
16243
16244 SWIGINTERN PyObject *_wrap_Image_BlurHorizontal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16245 PyObject *resultobj = 0;
16246 wxImage *arg1 = (wxImage *) 0 ;
16247 int arg2 ;
16248 SwigValueWrapper<wxImage > result;
16249 void *argp1 = 0 ;
16250 int res1 = 0 ;
16251 int val2 ;
16252 int ecode2 = 0 ;
16253 PyObject * obj0 = 0 ;
16254 PyObject * obj1 = 0 ;
16255 char * kwnames[] = {
16256 (char *) "self",(char *) "radius", NULL
16257 };
16258
16259 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurHorizontal",kwnames,&obj0,&obj1)) SWIG_fail;
16260 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16261 if (!SWIG_IsOK(res1)) {
16262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurHorizontal" "', expected argument " "1"" of type '" "wxImage *""'");
16263 }
16264 arg1 = reinterpret_cast< wxImage * >(argp1);
16265 ecode2 = SWIG_AsVal_int(obj1, &val2);
16266 if (!SWIG_IsOK(ecode2)) {
16267 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurHorizontal" "', expected argument " "2"" of type '" "int""'");
16268 }
16269 arg2 = static_cast< int >(val2);
16270 {
16271 PyThreadState* __tstate = wxPyBeginAllowThreads();
16272 result = (arg1)->BlurHorizontal(arg2);
16273 wxPyEndAllowThreads(__tstate);
16274 if (PyErr_Occurred()) SWIG_fail;
16275 }
16276 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16277 return resultobj;
16278 fail:
16279 return NULL;
16280 }
16281
16282
16283 SWIGINTERN PyObject *_wrap_Image_BlurVertical(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16284 PyObject *resultobj = 0;
16285 wxImage *arg1 = (wxImage *) 0 ;
16286 int arg2 ;
16287 SwigValueWrapper<wxImage > result;
16288 void *argp1 = 0 ;
16289 int res1 = 0 ;
16290 int val2 ;
16291 int ecode2 = 0 ;
16292 PyObject * obj0 = 0 ;
16293 PyObject * obj1 = 0 ;
16294 char * kwnames[] = {
16295 (char *) "self",(char *) "radius", NULL
16296 };
16297
16298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_BlurVertical",kwnames,&obj0,&obj1)) SWIG_fail;
16299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16300 if (!SWIG_IsOK(res1)) {
16301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_BlurVertical" "', expected argument " "1"" of type '" "wxImage *""'");
16302 }
16303 arg1 = reinterpret_cast< wxImage * >(argp1);
16304 ecode2 = SWIG_AsVal_int(obj1, &val2);
16305 if (!SWIG_IsOK(ecode2)) {
16306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_BlurVertical" "', expected argument " "2"" of type '" "int""'");
16307 }
16308 arg2 = static_cast< int >(val2);
16309 {
16310 PyThreadState* __tstate = wxPyBeginAllowThreads();
16311 result = (arg1)->BlurVertical(arg2);
16312 wxPyEndAllowThreads(__tstate);
16313 if (PyErr_Occurred()) SWIG_fail;
16314 }
16315 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16316 return resultobj;
16317 fail:
16318 return NULL;
16319 }
16320
16321
16322 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16323 PyObject *resultobj = 0;
16324 wxImage *arg1 = (wxImage *) 0 ;
16325 int arg2 ;
16326 int arg3 ;
16327 SwigValueWrapper<wxImage > result;
16328 void *argp1 = 0 ;
16329 int res1 = 0 ;
16330 int val2 ;
16331 int ecode2 = 0 ;
16332 int val3 ;
16333 int ecode3 = 0 ;
16334 PyObject * obj0 = 0 ;
16335 PyObject * obj1 = 0 ;
16336 PyObject * obj2 = 0 ;
16337 char * kwnames[] = {
16338 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
16339 };
16340
16341 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16342 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16343 if (!SWIG_IsOK(res1)) {
16344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
16345 }
16346 arg1 = reinterpret_cast< wxImage * >(argp1);
16347 ecode2 = SWIG_AsVal_int(obj1, &val2);
16348 if (!SWIG_IsOK(ecode2)) {
16349 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
16350 }
16351 arg2 = static_cast< int >(val2);
16352 ecode3 = SWIG_AsVal_int(obj2, &val3);
16353 if (!SWIG_IsOK(ecode3)) {
16354 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
16355 }
16356 arg3 = static_cast< int >(val3);
16357 {
16358 PyThreadState* __tstate = wxPyBeginAllowThreads();
16359 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
16360 wxPyEndAllowThreads(__tstate);
16361 if (PyErr_Occurred()) SWIG_fail;
16362 }
16363 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16364 return resultobj;
16365 fail:
16366 return NULL;
16367 }
16368
16369
16370 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16371 PyObject *resultobj = 0;
16372 wxImage *arg1 = (wxImage *) 0 ;
16373 int arg2 ;
16374 int arg3 ;
16375 int arg4 = (int) wxIMAGE_QUALITY_NORMAL ;
16376 wxImage *result = 0 ;
16377 void *argp1 = 0 ;
16378 int res1 = 0 ;
16379 int val2 ;
16380 int ecode2 = 0 ;
16381 int val3 ;
16382 int ecode3 = 0 ;
16383 int val4 ;
16384 int ecode4 = 0 ;
16385 PyObject * obj0 = 0 ;
16386 PyObject * obj1 = 0 ;
16387 PyObject * obj2 = 0 ;
16388 PyObject * obj3 = 0 ;
16389 char * kwnames[] = {
16390 (char *) "self",(char *) "width",(char *) "height",(char *) "quality", NULL
16391 };
16392
16393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Rescale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16395 if (!SWIG_IsOK(res1)) {
16396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
16397 }
16398 arg1 = reinterpret_cast< wxImage * >(argp1);
16399 ecode2 = SWIG_AsVal_int(obj1, &val2);
16400 if (!SWIG_IsOK(ecode2)) {
16401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
16402 }
16403 arg2 = static_cast< int >(val2);
16404 ecode3 = SWIG_AsVal_int(obj2, &val3);
16405 if (!SWIG_IsOK(ecode3)) {
16406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
16407 }
16408 arg3 = static_cast< int >(val3);
16409 if (obj3) {
16410 ecode4 = SWIG_AsVal_int(obj3, &val4);
16411 if (!SWIG_IsOK(ecode4)) {
16412 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rescale" "', expected argument " "4"" of type '" "int""'");
16413 }
16414 arg4 = static_cast< int >(val4);
16415 }
16416 {
16417 PyThreadState* __tstate = wxPyBeginAllowThreads();
16418 {
16419 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3,arg4);
16420 result = (wxImage *) &_result_ref;
16421 }
16422 wxPyEndAllowThreads(__tstate);
16423 if (PyErr_Occurred()) SWIG_fail;
16424 }
16425 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16426 return resultobj;
16427 fail:
16428 return NULL;
16429 }
16430
16431
16432 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16433 PyObject *resultobj = 0;
16434 wxImage *arg1 = (wxImage *) 0 ;
16435 wxSize *arg2 = 0 ;
16436 wxPoint *arg3 = 0 ;
16437 int arg4 = (int) -1 ;
16438 int arg5 = (int) -1 ;
16439 int arg6 = (int) -1 ;
16440 wxImage *result = 0 ;
16441 void *argp1 = 0 ;
16442 int res1 = 0 ;
16443 wxSize temp2 ;
16444 wxPoint temp3 ;
16445 int val4 ;
16446 int ecode4 = 0 ;
16447 int val5 ;
16448 int ecode5 = 0 ;
16449 int val6 ;
16450 int ecode6 = 0 ;
16451 PyObject * obj0 = 0 ;
16452 PyObject * obj1 = 0 ;
16453 PyObject * obj2 = 0 ;
16454 PyObject * obj3 = 0 ;
16455 PyObject * obj4 = 0 ;
16456 PyObject * obj5 = 0 ;
16457 char * kwnames[] = {
16458 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
16459 };
16460
16461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16463 if (!SWIG_IsOK(res1)) {
16464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
16465 }
16466 arg1 = reinterpret_cast< wxImage * >(argp1);
16467 {
16468 arg2 = &temp2;
16469 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
16470 }
16471 {
16472 arg3 = &temp3;
16473 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
16474 }
16475 if (obj3) {
16476 ecode4 = SWIG_AsVal_int(obj3, &val4);
16477 if (!SWIG_IsOK(ecode4)) {
16478 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
16479 }
16480 arg4 = static_cast< int >(val4);
16481 }
16482 if (obj4) {
16483 ecode5 = SWIG_AsVal_int(obj4, &val5);
16484 if (!SWIG_IsOK(ecode5)) {
16485 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
16486 }
16487 arg5 = static_cast< int >(val5);
16488 }
16489 if (obj5) {
16490 ecode6 = SWIG_AsVal_int(obj5, &val6);
16491 if (!SWIG_IsOK(ecode6)) {
16492 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
16493 }
16494 arg6 = static_cast< int >(val6);
16495 }
16496 {
16497 PyThreadState* __tstate = wxPyBeginAllowThreads();
16498 {
16499 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
16500 result = (wxImage *) &_result_ref;
16501 }
16502 wxPyEndAllowThreads(__tstate);
16503 if (PyErr_Occurred()) SWIG_fail;
16504 }
16505 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
16506 return resultobj;
16507 fail:
16508 return NULL;
16509 }
16510
16511
16512 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16513 PyObject *resultobj = 0;
16514 wxImage *arg1 = (wxImage *) 0 ;
16515 int arg2 ;
16516 int arg3 ;
16517 byte arg4 ;
16518 byte arg5 ;
16519 byte arg6 ;
16520 void *argp1 = 0 ;
16521 int res1 = 0 ;
16522 int val2 ;
16523 int ecode2 = 0 ;
16524 int val3 ;
16525 int ecode3 = 0 ;
16526 unsigned char val4 ;
16527 int ecode4 = 0 ;
16528 unsigned char val5 ;
16529 int ecode5 = 0 ;
16530 unsigned char val6 ;
16531 int ecode6 = 0 ;
16532 PyObject * obj0 = 0 ;
16533 PyObject * obj1 = 0 ;
16534 PyObject * obj2 = 0 ;
16535 PyObject * obj3 = 0 ;
16536 PyObject * obj4 = 0 ;
16537 PyObject * obj5 = 0 ;
16538 char * kwnames[] = {
16539 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
16540 };
16541
16542 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
16543 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16544 if (!SWIG_IsOK(res1)) {
16545 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
16546 }
16547 arg1 = reinterpret_cast< wxImage * >(argp1);
16548 ecode2 = SWIG_AsVal_int(obj1, &val2);
16549 if (!SWIG_IsOK(ecode2)) {
16550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
16551 }
16552 arg2 = static_cast< int >(val2);
16553 ecode3 = SWIG_AsVal_int(obj2, &val3);
16554 if (!SWIG_IsOK(ecode3)) {
16555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
16556 }
16557 arg3 = static_cast< int >(val3);
16558 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16559 if (!SWIG_IsOK(ecode4)) {
16560 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
16561 }
16562 arg4 = static_cast< byte >(val4);
16563 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16564 if (!SWIG_IsOK(ecode5)) {
16565 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
16566 }
16567 arg5 = static_cast< byte >(val5);
16568 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16569 if (!SWIG_IsOK(ecode6)) {
16570 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
16571 }
16572 arg6 = static_cast< byte >(val6);
16573 {
16574 PyThreadState* __tstate = wxPyBeginAllowThreads();
16575 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
16576 wxPyEndAllowThreads(__tstate);
16577 if (PyErr_Occurred()) SWIG_fail;
16578 }
16579 resultobj = SWIG_Py_Void();
16580 return resultobj;
16581 fail:
16582 return NULL;
16583 }
16584
16585
16586 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16587 PyObject *resultobj = 0;
16588 wxImage *arg1 = (wxImage *) 0 ;
16589 wxRect *arg2 = 0 ;
16590 byte arg3 ;
16591 byte arg4 ;
16592 byte arg5 ;
16593 void *argp1 = 0 ;
16594 int res1 = 0 ;
16595 wxRect temp2 ;
16596 unsigned char val3 ;
16597 int ecode3 = 0 ;
16598 unsigned char val4 ;
16599 int ecode4 = 0 ;
16600 unsigned char val5 ;
16601 int ecode5 = 0 ;
16602 PyObject * obj0 = 0 ;
16603 PyObject * obj1 = 0 ;
16604 PyObject * obj2 = 0 ;
16605 PyObject * obj3 = 0 ;
16606 PyObject * obj4 = 0 ;
16607 char * kwnames[] = {
16608 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
16609 };
16610
16611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
16612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16613 if (!SWIG_IsOK(res1)) {
16614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
16615 }
16616 arg1 = reinterpret_cast< wxImage * >(argp1);
16617 {
16618 arg2 = &temp2;
16619 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
16620 }
16621 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16622 if (!SWIG_IsOK(ecode3)) {
16623 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
16624 }
16625 arg3 = static_cast< byte >(val3);
16626 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16627 if (!SWIG_IsOK(ecode4)) {
16628 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
16629 }
16630 arg4 = static_cast< byte >(val4);
16631 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16632 if (!SWIG_IsOK(ecode5)) {
16633 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
16634 }
16635 arg5 = static_cast< byte >(val5);
16636 {
16637 PyThreadState* __tstate = wxPyBeginAllowThreads();
16638 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
16639 wxPyEndAllowThreads(__tstate);
16640 if (PyErr_Occurred()) SWIG_fail;
16641 }
16642 resultobj = SWIG_Py_Void();
16643 return resultobj;
16644 fail:
16645 return NULL;
16646 }
16647
16648
16649 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16650 PyObject *resultobj = 0;
16651 wxImage *arg1 = (wxImage *) 0 ;
16652 int arg2 ;
16653 int arg3 ;
16654 byte result;
16655 void *argp1 = 0 ;
16656 int res1 = 0 ;
16657 int val2 ;
16658 int ecode2 = 0 ;
16659 int val3 ;
16660 int ecode3 = 0 ;
16661 PyObject * obj0 = 0 ;
16662 PyObject * obj1 = 0 ;
16663 PyObject * obj2 = 0 ;
16664 char * kwnames[] = {
16665 (char *) "self",(char *) "x",(char *) "y", NULL
16666 };
16667
16668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16670 if (!SWIG_IsOK(res1)) {
16671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
16672 }
16673 arg1 = reinterpret_cast< wxImage * >(argp1);
16674 ecode2 = SWIG_AsVal_int(obj1, &val2);
16675 if (!SWIG_IsOK(ecode2)) {
16676 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
16677 }
16678 arg2 = static_cast< int >(val2);
16679 ecode3 = SWIG_AsVal_int(obj2, &val3);
16680 if (!SWIG_IsOK(ecode3)) {
16681 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
16682 }
16683 arg3 = static_cast< int >(val3);
16684 {
16685 PyThreadState* __tstate = wxPyBeginAllowThreads();
16686 result = (byte)(arg1)->GetRed(arg2,arg3);
16687 wxPyEndAllowThreads(__tstate);
16688 if (PyErr_Occurred()) SWIG_fail;
16689 }
16690 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16691 return resultobj;
16692 fail:
16693 return NULL;
16694 }
16695
16696
16697 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16698 PyObject *resultobj = 0;
16699 wxImage *arg1 = (wxImage *) 0 ;
16700 int arg2 ;
16701 int arg3 ;
16702 byte result;
16703 void *argp1 = 0 ;
16704 int res1 = 0 ;
16705 int val2 ;
16706 int ecode2 = 0 ;
16707 int val3 ;
16708 int ecode3 = 0 ;
16709 PyObject * obj0 = 0 ;
16710 PyObject * obj1 = 0 ;
16711 PyObject * obj2 = 0 ;
16712 char * kwnames[] = {
16713 (char *) "self",(char *) "x",(char *) "y", NULL
16714 };
16715
16716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16718 if (!SWIG_IsOK(res1)) {
16719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
16720 }
16721 arg1 = reinterpret_cast< wxImage * >(argp1);
16722 ecode2 = SWIG_AsVal_int(obj1, &val2);
16723 if (!SWIG_IsOK(ecode2)) {
16724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
16725 }
16726 arg2 = static_cast< int >(val2);
16727 ecode3 = SWIG_AsVal_int(obj2, &val3);
16728 if (!SWIG_IsOK(ecode3)) {
16729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
16730 }
16731 arg3 = static_cast< int >(val3);
16732 {
16733 PyThreadState* __tstate = wxPyBeginAllowThreads();
16734 result = (byte)(arg1)->GetGreen(arg2,arg3);
16735 wxPyEndAllowThreads(__tstate);
16736 if (PyErr_Occurred()) SWIG_fail;
16737 }
16738 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16739 return resultobj;
16740 fail:
16741 return NULL;
16742 }
16743
16744
16745 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16746 PyObject *resultobj = 0;
16747 wxImage *arg1 = (wxImage *) 0 ;
16748 int arg2 ;
16749 int arg3 ;
16750 byte result;
16751 void *argp1 = 0 ;
16752 int res1 = 0 ;
16753 int val2 ;
16754 int ecode2 = 0 ;
16755 int val3 ;
16756 int ecode3 = 0 ;
16757 PyObject * obj0 = 0 ;
16758 PyObject * obj1 = 0 ;
16759 PyObject * obj2 = 0 ;
16760 char * kwnames[] = {
16761 (char *) "self",(char *) "x",(char *) "y", NULL
16762 };
16763
16764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16766 if (!SWIG_IsOK(res1)) {
16767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
16768 }
16769 arg1 = reinterpret_cast< wxImage * >(argp1);
16770 ecode2 = SWIG_AsVal_int(obj1, &val2);
16771 if (!SWIG_IsOK(ecode2)) {
16772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
16773 }
16774 arg2 = static_cast< int >(val2);
16775 ecode3 = SWIG_AsVal_int(obj2, &val3);
16776 if (!SWIG_IsOK(ecode3)) {
16777 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
16778 }
16779 arg3 = static_cast< int >(val3);
16780 {
16781 PyThreadState* __tstate = wxPyBeginAllowThreads();
16782 result = (byte)(arg1)->GetBlue(arg2,arg3);
16783 wxPyEndAllowThreads(__tstate);
16784 if (PyErr_Occurred()) SWIG_fail;
16785 }
16786 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16787 return resultobj;
16788 fail:
16789 return NULL;
16790 }
16791
16792
16793 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16794 PyObject *resultobj = 0;
16795 wxImage *arg1 = (wxImage *) 0 ;
16796 int arg2 ;
16797 int arg3 ;
16798 byte arg4 ;
16799 void *argp1 = 0 ;
16800 int res1 = 0 ;
16801 int val2 ;
16802 int ecode2 = 0 ;
16803 int val3 ;
16804 int ecode3 = 0 ;
16805 unsigned char val4 ;
16806 int ecode4 = 0 ;
16807 PyObject * obj0 = 0 ;
16808 PyObject * obj1 = 0 ;
16809 PyObject * obj2 = 0 ;
16810 PyObject * obj3 = 0 ;
16811 char * kwnames[] = {
16812 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
16813 };
16814
16815 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16816 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16817 if (!SWIG_IsOK(res1)) {
16818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16819 }
16820 arg1 = reinterpret_cast< wxImage * >(argp1);
16821 ecode2 = SWIG_AsVal_int(obj1, &val2);
16822 if (!SWIG_IsOK(ecode2)) {
16823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
16824 }
16825 arg2 = static_cast< int >(val2);
16826 ecode3 = SWIG_AsVal_int(obj2, &val3);
16827 if (!SWIG_IsOK(ecode3)) {
16828 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
16829 }
16830 arg3 = static_cast< int >(val3);
16831 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16832 if (!SWIG_IsOK(ecode4)) {
16833 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
16834 }
16835 arg4 = static_cast< byte >(val4);
16836 {
16837 PyThreadState* __tstate = wxPyBeginAllowThreads();
16838 (arg1)->SetAlpha(arg2,arg3,arg4);
16839 wxPyEndAllowThreads(__tstate);
16840 if (PyErr_Occurred()) SWIG_fail;
16841 }
16842 resultobj = SWIG_Py_Void();
16843 return resultobj;
16844 fail:
16845 return NULL;
16846 }
16847
16848
16849 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16850 PyObject *resultobj = 0;
16851 wxImage *arg1 = (wxImage *) 0 ;
16852 int arg2 ;
16853 int arg3 ;
16854 byte result;
16855 void *argp1 = 0 ;
16856 int res1 = 0 ;
16857 int val2 ;
16858 int ecode2 = 0 ;
16859 int val3 ;
16860 int ecode3 = 0 ;
16861 PyObject * obj0 = 0 ;
16862 PyObject * obj1 = 0 ;
16863 PyObject * obj2 = 0 ;
16864 char * kwnames[] = {
16865 (char *) "self",(char *) "x",(char *) "y", NULL
16866 };
16867
16868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16870 if (!SWIG_IsOK(res1)) {
16871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16872 }
16873 arg1 = reinterpret_cast< wxImage * >(argp1);
16874 ecode2 = SWIG_AsVal_int(obj1, &val2);
16875 if (!SWIG_IsOK(ecode2)) {
16876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
16877 }
16878 arg2 = static_cast< int >(val2);
16879 ecode3 = SWIG_AsVal_int(obj2, &val3);
16880 if (!SWIG_IsOK(ecode3)) {
16881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
16882 }
16883 arg3 = static_cast< int >(val3);
16884 {
16885 PyThreadState* __tstate = wxPyBeginAllowThreads();
16886 result = (byte)(arg1)->GetAlpha(arg2,arg3);
16887 wxPyEndAllowThreads(__tstate);
16888 if (PyErr_Occurred()) SWIG_fail;
16889 }
16890 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
16891 return resultobj;
16892 fail:
16893 return NULL;
16894 }
16895
16896
16897 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16898 PyObject *resultobj = 0;
16899 wxImage *arg1 = (wxImage *) 0 ;
16900 bool result;
16901 void *argp1 = 0 ;
16902 int res1 = 0 ;
16903 PyObject *swig_obj[1] ;
16904
16905 if (!args) SWIG_fail;
16906 swig_obj[0] = args;
16907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16908 if (!SWIG_IsOK(res1)) {
16909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16910 }
16911 arg1 = reinterpret_cast< wxImage * >(argp1);
16912 {
16913 PyThreadState* __tstate = wxPyBeginAllowThreads();
16914 result = (bool)(arg1)->HasAlpha();
16915 wxPyEndAllowThreads(__tstate);
16916 if (PyErr_Occurred()) SWIG_fail;
16917 }
16918 {
16919 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16920 }
16921 return resultobj;
16922 fail:
16923 return NULL;
16924 }
16925
16926
16927 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16928 PyObject *resultobj = 0;
16929 wxImage *arg1 = (wxImage *) 0 ;
16930 void *argp1 = 0 ;
16931 int res1 = 0 ;
16932 PyObject *swig_obj[1] ;
16933
16934 if (!args) SWIG_fail;
16935 swig_obj[0] = args;
16936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16937 if (!SWIG_IsOK(res1)) {
16938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
16939 }
16940 arg1 = reinterpret_cast< wxImage * >(argp1);
16941 {
16942 PyThreadState* __tstate = wxPyBeginAllowThreads();
16943 (arg1)->InitAlpha();
16944 wxPyEndAllowThreads(__tstate);
16945 if (PyErr_Occurred()) SWIG_fail;
16946 }
16947 resultobj = SWIG_Py_Void();
16948 return resultobj;
16949 fail:
16950 return NULL;
16951 }
16952
16953
16954 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16955 PyObject *resultobj = 0;
16956 wxImage *arg1 = (wxImage *) 0 ;
16957 int arg2 ;
16958 int arg3 ;
16959 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
16960 bool result;
16961 void *argp1 = 0 ;
16962 int res1 = 0 ;
16963 int val2 ;
16964 int ecode2 = 0 ;
16965 int val3 ;
16966 int ecode3 = 0 ;
16967 unsigned char val4 ;
16968 int ecode4 = 0 ;
16969 PyObject * obj0 = 0 ;
16970 PyObject * obj1 = 0 ;
16971 PyObject * obj2 = 0 ;
16972 PyObject * obj3 = 0 ;
16973 char * kwnames[] = {
16974 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
16975 };
16976
16977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16979 if (!SWIG_IsOK(res1)) {
16980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
16981 }
16982 arg1 = reinterpret_cast< wxImage * >(argp1);
16983 ecode2 = SWIG_AsVal_int(obj1, &val2);
16984 if (!SWIG_IsOK(ecode2)) {
16985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
16986 }
16987 arg2 = static_cast< int >(val2);
16988 ecode3 = SWIG_AsVal_int(obj2, &val3);
16989 if (!SWIG_IsOK(ecode3)) {
16990 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
16991 }
16992 arg3 = static_cast< int >(val3);
16993 if (obj3) {
16994 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16995 if (!SWIG_IsOK(ecode4)) {
16996 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
16997 }
16998 arg4 = static_cast< byte >(val4);
16999 }
17000 {
17001 PyThreadState* __tstate = wxPyBeginAllowThreads();
17002 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
17003 wxPyEndAllowThreads(__tstate);
17004 if (PyErr_Occurred()) SWIG_fail;
17005 }
17006 {
17007 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17008 }
17009 return resultobj;
17010 fail:
17011 return NULL;
17012 }
17013
17014
17015 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17016 PyObject *resultobj = 0;
17017 wxImage *arg1 = (wxImage *) 0 ;
17018 byte *arg2 = (byte *) 0 ;
17019 byte *arg3 = (byte *) 0 ;
17020 byte *arg4 = (byte *) 0 ;
17021 byte arg5 = (byte) 0 ;
17022 byte arg6 = (byte) 0 ;
17023 byte arg7 = (byte) 0 ;
17024 bool result;
17025 void *argp1 = 0 ;
17026 int res1 = 0 ;
17027 byte temp2 ;
17028 int res2 = SWIG_TMPOBJ ;
17029 byte temp3 ;
17030 int res3 = SWIG_TMPOBJ ;
17031 byte temp4 ;
17032 int res4 = SWIG_TMPOBJ ;
17033 unsigned char val5 ;
17034 int ecode5 = 0 ;
17035 unsigned char val6 ;
17036 int ecode6 = 0 ;
17037 unsigned char val7 ;
17038 int ecode7 = 0 ;
17039 PyObject * obj0 = 0 ;
17040 PyObject * obj1 = 0 ;
17041 PyObject * obj2 = 0 ;
17042 PyObject * obj3 = 0 ;
17043 char * kwnames[] = {
17044 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
17045 };
17046
17047 arg2 = &temp2;
17048 arg3 = &temp3;
17049 arg4 = &temp4;
17050 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17051 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17052 if (!SWIG_IsOK(res1)) {
17053 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
17054 }
17055 arg1 = reinterpret_cast< wxImage * >(argp1);
17056 if (obj1) {
17057 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
17058 if (!SWIG_IsOK(ecode5)) {
17059 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
17060 }
17061 arg5 = static_cast< byte >(val5);
17062 }
17063 if (obj2) {
17064 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
17065 if (!SWIG_IsOK(ecode6)) {
17066 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
17067 }
17068 arg6 = static_cast< byte >(val6);
17069 }
17070 if (obj3) {
17071 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
17072 if (!SWIG_IsOK(ecode7)) {
17073 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
17074 }
17075 arg7 = static_cast< byte >(val7);
17076 }
17077 {
17078 PyThreadState* __tstate = wxPyBeginAllowThreads();
17079 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
17080 wxPyEndAllowThreads(__tstate);
17081 if (PyErr_Occurred()) SWIG_fail;
17082 }
17083 {
17084 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17085 }
17086 if (SWIG_IsTmpObj(res2)) {
17087 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
17088 } else {
17089 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17090 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
17091 }
17092 if (SWIG_IsTmpObj(res3)) {
17093 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
17094 } else {
17095 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17096 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
17097 }
17098 if (SWIG_IsTmpObj(res4)) {
17099 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
17100 } else {
17101 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
17102 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
17103 }
17104 return resultobj;
17105 fail:
17106 return NULL;
17107 }
17108
17109
17110 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17111 PyObject *resultobj = 0;
17112 wxImage *arg1 = (wxImage *) 0 ;
17113 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
17114 bool result;
17115 void *argp1 = 0 ;
17116 int res1 = 0 ;
17117 unsigned char val2 ;
17118 int ecode2 = 0 ;
17119 PyObject * obj0 = 0 ;
17120 PyObject * obj1 = 0 ;
17121 char * kwnames[] = {
17122 (char *) "self",(char *) "threshold", NULL
17123 };
17124
17125 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
17126 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17127 if (!SWIG_IsOK(res1)) {
17128 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
17129 }
17130 arg1 = reinterpret_cast< wxImage * >(argp1);
17131 if (obj1) {
17132 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17133 if (!SWIG_IsOK(ecode2)) {
17134 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
17135 }
17136 arg2 = static_cast< byte >(val2);
17137 }
17138 {
17139 PyThreadState* __tstate = wxPyBeginAllowThreads();
17140 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
17141 wxPyEndAllowThreads(__tstate);
17142 if (PyErr_Occurred()) SWIG_fail;
17143 }
17144 {
17145 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17146 }
17147 return resultobj;
17148 fail:
17149 return NULL;
17150 }
17151
17152
17153 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17154 PyObject *resultobj = 0;
17155 wxImage *arg1 = (wxImage *) 0 ;
17156 byte arg2 ;
17157 byte arg3 ;
17158 byte arg4 ;
17159 bool result;
17160 void *argp1 = 0 ;
17161 int res1 = 0 ;
17162 unsigned char val2 ;
17163 int ecode2 = 0 ;
17164 unsigned char val3 ;
17165 int ecode3 = 0 ;
17166 unsigned char val4 ;
17167 int ecode4 = 0 ;
17168 PyObject * obj0 = 0 ;
17169 PyObject * obj1 = 0 ;
17170 PyObject * obj2 = 0 ;
17171 PyObject * obj3 = 0 ;
17172 char * kwnames[] = {
17173 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
17174 };
17175
17176 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17177 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17178 if (!SWIG_IsOK(res1)) {
17179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
17180 }
17181 arg1 = reinterpret_cast< wxImage * >(argp1);
17182 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
17183 if (!SWIG_IsOK(ecode2)) {
17184 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
17185 }
17186 arg2 = static_cast< byte >(val2);
17187 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17188 if (!SWIG_IsOK(ecode3)) {
17189 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
17190 }
17191 arg3 = static_cast< byte >(val3);
17192 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17193 if (!SWIG_IsOK(ecode4)) {
17194 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
17195 }
17196 arg4 = static_cast< byte >(val4);
17197 {
17198 PyThreadState* __tstate = wxPyBeginAllowThreads();
17199 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
17200 wxPyEndAllowThreads(__tstate);
17201 if (PyErr_Occurred()) SWIG_fail;
17202 }
17203 {
17204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17205 }
17206 return resultobj;
17207 fail:
17208 return NULL;
17209 }
17210
17211
17212 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17213 PyObject *resultobj = 0;
17214 wxImage *arg1 = (wxImage *) 0 ;
17215 wxImage *arg2 = 0 ;
17216 byte arg3 ;
17217 byte arg4 ;
17218 byte arg5 ;
17219 bool result;
17220 void *argp1 = 0 ;
17221 int res1 = 0 ;
17222 void *argp2 = 0 ;
17223 int res2 = 0 ;
17224 unsigned char val3 ;
17225 int ecode3 = 0 ;
17226 unsigned char val4 ;
17227 int ecode4 = 0 ;
17228 unsigned char val5 ;
17229 int ecode5 = 0 ;
17230 PyObject * obj0 = 0 ;
17231 PyObject * obj1 = 0 ;
17232 PyObject * obj2 = 0 ;
17233 PyObject * obj3 = 0 ;
17234 PyObject * obj4 = 0 ;
17235 char * kwnames[] = {
17236 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
17237 };
17238
17239 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
17240 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17241 if (!SWIG_IsOK(res1)) {
17242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
17243 }
17244 arg1 = reinterpret_cast< wxImage * >(argp1);
17245 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
17246 if (!SWIG_IsOK(res2)) {
17247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17248 }
17249 if (!argp2) {
17250 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
17251 }
17252 arg2 = reinterpret_cast< wxImage * >(argp2);
17253 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
17254 if (!SWIG_IsOK(ecode3)) {
17255 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
17256 }
17257 arg3 = static_cast< byte >(val3);
17258 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
17259 if (!SWIG_IsOK(ecode4)) {
17260 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
17261 }
17262 arg4 = static_cast< byte >(val4);
17263 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
17264 if (!SWIG_IsOK(ecode5)) {
17265 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
17266 }
17267 arg5 = static_cast< byte >(val5);
17268 {
17269 PyThreadState* __tstate = wxPyBeginAllowThreads();
17270 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
17271 wxPyEndAllowThreads(__tstate);
17272 if (PyErr_Occurred()) SWIG_fail;
17273 }
17274 {
17275 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17276 }
17277 return resultobj;
17278 fail:
17279 return NULL;
17280 }
17281
17282
17283 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17284 PyObject *resultobj = 0;
17285 wxString *arg1 = 0 ;
17286 bool result;
17287 bool temp1 = false ;
17288 PyObject * obj0 = 0 ;
17289 char * kwnames[] = {
17290 (char *) "filename", NULL
17291 };
17292
17293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
17294 {
17295 arg1 = wxString_in_helper(obj0);
17296 if (arg1 == NULL) SWIG_fail;
17297 temp1 = true;
17298 }
17299 {
17300 PyThreadState* __tstate = wxPyBeginAllowThreads();
17301 result = (bool)wxImage::CanRead((wxString const &)*arg1);
17302 wxPyEndAllowThreads(__tstate);
17303 if (PyErr_Occurred()) SWIG_fail;
17304 }
17305 {
17306 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17307 }
17308 {
17309 if (temp1)
17310 delete arg1;
17311 }
17312 return resultobj;
17313 fail:
17314 {
17315 if (temp1)
17316 delete arg1;
17317 }
17318 return NULL;
17319 }
17320
17321
17322 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17323 PyObject *resultobj = 0;
17324 wxString *arg1 = 0 ;
17325 long arg2 = (long) wxBITMAP_TYPE_ANY ;
17326 int result;
17327 bool temp1 = false ;
17328 long val2 ;
17329 int ecode2 = 0 ;
17330 PyObject * obj0 = 0 ;
17331 PyObject * obj1 = 0 ;
17332 char * kwnames[] = {
17333 (char *) "filename",(char *) "type", NULL
17334 };
17335
17336 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
17337 {
17338 arg1 = wxString_in_helper(obj0);
17339 if (arg1 == NULL) SWIG_fail;
17340 temp1 = true;
17341 }
17342 if (obj1) {
17343 ecode2 = SWIG_AsVal_long(obj1, &val2);
17344 if (!SWIG_IsOK(ecode2)) {
17345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
17346 }
17347 arg2 = static_cast< long >(val2);
17348 }
17349 {
17350 PyThreadState* __tstate = wxPyBeginAllowThreads();
17351 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
17352 wxPyEndAllowThreads(__tstate);
17353 if (PyErr_Occurred()) SWIG_fail;
17354 }
17355 resultobj = SWIG_From_int(static_cast< int >(result));
17356 {
17357 if (temp1)
17358 delete arg1;
17359 }
17360 return resultobj;
17361 fail:
17362 {
17363 if (temp1)
17364 delete arg1;
17365 }
17366 return NULL;
17367 }
17368
17369
17370 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17371 PyObject *resultobj = 0;
17372 wxImage *arg1 = (wxImage *) 0 ;
17373 wxString *arg2 = 0 ;
17374 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17375 int arg4 = (int) -1 ;
17376 bool result;
17377 void *argp1 = 0 ;
17378 int res1 = 0 ;
17379 bool temp2 = false ;
17380 long val3 ;
17381 int ecode3 = 0 ;
17382 int val4 ;
17383 int ecode4 = 0 ;
17384 PyObject * obj0 = 0 ;
17385 PyObject * obj1 = 0 ;
17386 PyObject * obj2 = 0 ;
17387 PyObject * obj3 = 0 ;
17388 char * kwnames[] = {
17389 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
17390 };
17391
17392 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17393 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17394 if (!SWIG_IsOK(res1)) {
17395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
17396 }
17397 arg1 = reinterpret_cast< wxImage * >(argp1);
17398 {
17399 arg2 = wxString_in_helper(obj1);
17400 if (arg2 == NULL) SWIG_fail;
17401 temp2 = true;
17402 }
17403 if (obj2) {
17404 ecode3 = SWIG_AsVal_long(obj2, &val3);
17405 if (!SWIG_IsOK(ecode3)) {
17406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
17407 }
17408 arg3 = static_cast< long >(val3);
17409 }
17410 if (obj3) {
17411 ecode4 = SWIG_AsVal_int(obj3, &val4);
17412 if (!SWIG_IsOK(ecode4)) {
17413 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
17414 }
17415 arg4 = static_cast< int >(val4);
17416 }
17417 {
17418 PyThreadState* __tstate = wxPyBeginAllowThreads();
17419 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
17420 wxPyEndAllowThreads(__tstate);
17421 if (PyErr_Occurred()) SWIG_fail;
17422 }
17423 {
17424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17425 }
17426 {
17427 if (temp2)
17428 delete arg2;
17429 }
17430 return resultobj;
17431 fail:
17432 {
17433 if (temp2)
17434 delete arg2;
17435 }
17436 return NULL;
17437 }
17438
17439
17440 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17441 PyObject *resultobj = 0;
17442 wxImage *arg1 = (wxImage *) 0 ;
17443 wxString *arg2 = 0 ;
17444 wxString *arg3 = 0 ;
17445 int arg4 = (int) -1 ;
17446 bool result;
17447 void *argp1 = 0 ;
17448 int res1 = 0 ;
17449 bool temp2 = false ;
17450 bool temp3 = false ;
17451 int val4 ;
17452 int ecode4 = 0 ;
17453 PyObject * obj0 = 0 ;
17454 PyObject * obj1 = 0 ;
17455 PyObject * obj2 = 0 ;
17456 PyObject * obj3 = 0 ;
17457 char * kwnames[] = {
17458 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
17459 };
17460
17461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17463 if (!SWIG_IsOK(res1)) {
17464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17465 }
17466 arg1 = reinterpret_cast< wxImage * >(argp1);
17467 {
17468 arg2 = wxString_in_helper(obj1);
17469 if (arg2 == NULL) SWIG_fail;
17470 temp2 = true;
17471 }
17472 {
17473 arg3 = wxString_in_helper(obj2);
17474 if (arg3 == NULL) SWIG_fail;
17475 temp3 = true;
17476 }
17477 if (obj3) {
17478 ecode4 = SWIG_AsVal_int(obj3, &val4);
17479 if (!SWIG_IsOK(ecode4)) {
17480 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
17481 }
17482 arg4 = static_cast< int >(val4);
17483 }
17484 {
17485 PyThreadState* __tstate = wxPyBeginAllowThreads();
17486 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
17487 wxPyEndAllowThreads(__tstate);
17488 if (PyErr_Occurred()) SWIG_fail;
17489 }
17490 {
17491 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17492 }
17493 {
17494 if (temp2)
17495 delete arg2;
17496 }
17497 {
17498 if (temp3)
17499 delete arg3;
17500 }
17501 return resultobj;
17502 fail:
17503 {
17504 if (temp2)
17505 delete arg2;
17506 }
17507 {
17508 if (temp3)
17509 delete arg3;
17510 }
17511 return NULL;
17512 }
17513
17514
17515 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17516 PyObject *resultobj = 0;
17517 wxImage *arg1 = (wxImage *) 0 ;
17518 wxString *arg2 = 0 ;
17519 int arg3 ;
17520 bool result;
17521 void *argp1 = 0 ;
17522 int res1 = 0 ;
17523 bool temp2 = false ;
17524 int val3 ;
17525 int ecode3 = 0 ;
17526 PyObject * obj0 = 0 ;
17527 PyObject * obj1 = 0 ;
17528 PyObject * obj2 = 0 ;
17529 char * kwnames[] = {
17530 (char *) "self",(char *) "name",(char *) "type", NULL
17531 };
17532
17533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17534 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17535 if (!SWIG_IsOK(res1)) {
17536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
17537 }
17538 arg1 = reinterpret_cast< wxImage * >(argp1);
17539 {
17540 arg2 = wxString_in_helper(obj1);
17541 if (arg2 == NULL) SWIG_fail;
17542 temp2 = true;
17543 }
17544 ecode3 = SWIG_AsVal_int(obj2, &val3);
17545 if (!SWIG_IsOK(ecode3)) {
17546 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
17547 }
17548 arg3 = static_cast< int >(val3);
17549 {
17550 PyThreadState* __tstate = wxPyBeginAllowThreads();
17551 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
17552 wxPyEndAllowThreads(__tstate);
17553 if (PyErr_Occurred()) SWIG_fail;
17554 }
17555 {
17556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17557 }
17558 {
17559 if (temp2)
17560 delete arg2;
17561 }
17562 return resultobj;
17563 fail:
17564 {
17565 if (temp2)
17566 delete arg2;
17567 }
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17573 PyObject *resultobj = 0;
17574 wxImage *arg1 = (wxImage *) 0 ;
17575 wxString *arg2 = 0 ;
17576 wxString *arg3 = 0 ;
17577 bool result;
17578 void *argp1 = 0 ;
17579 int res1 = 0 ;
17580 bool temp2 = false ;
17581 bool temp3 = false ;
17582 PyObject * obj0 = 0 ;
17583 PyObject * obj1 = 0 ;
17584 PyObject * obj2 = 0 ;
17585 char * kwnames[] = {
17586 (char *) "self",(char *) "name",(char *) "mimetype", NULL
17587 };
17588
17589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
17590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17591 if (!SWIG_IsOK(res1)) {
17592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
17593 }
17594 arg1 = reinterpret_cast< wxImage * >(argp1);
17595 {
17596 arg2 = wxString_in_helper(obj1);
17597 if (arg2 == NULL) SWIG_fail;
17598 temp2 = true;
17599 }
17600 {
17601 arg3 = wxString_in_helper(obj2);
17602 if (arg3 == NULL) SWIG_fail;
17603 temp3 = true;
17604 }
17605 {
17606 PyThreadState* __tstate = wxPyBeginAllowThreads();
17607 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
17608 wxPyEndAllowThreads(__tstate);
17609 if (PyErr_Occurred()) SWIG_fail;
17610 }
17611 {
17612 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17613 }
17614 {
17615 if (temp2)
17616 delete arg2;
17617 }
17618 {
17619 if (temp3)
17620 delete arg3;
17621 }
17622 return resultobj;
17623 fail:
17624 {
17625 if (temp2)
17626 delete arg2;
17627 }
17628 {
17629 if (temp3)
17630 delete arg3;
17631 }
17632 return NULL;
17633 }
17634
17635
17636 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17637 PyObject *resultobj = 0;
17638 wxInputStream *arg1 = 0 ;
17639 bool result;
17640 wxPyInputStream *temp1 ;
17641 bool created1 ;
17642 PyObject * obj0 = 0 ;
17643 char * kwnames[] = {
17644 (char *) "stream", NULL
17645 };
17646
17647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
17648 {
17649 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
17650 arg1 = temp1->m_wxis;
17651 created1 = false;
17652 } else {
17653 PyErr_Clear(); // clear the failure of the wxPyConvert above
17654 arg1 = wxPyCBInputStream_create(obj0, false);
17655 if (arg1 == NULL) {
17656 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17657 SWIG_fail;
17658 }
17659 created1 = true;
17660 }
17661 }
17662 {
17663 PyThreadState* __tstate = wxPyBeginAllowThreads();
17664 result = (bool)wxImage::CanRead(*arg1);
17665 wxPyEndAllowThreads(__tstate);
17666 if (PyErr_Occurred()) SWIG_fail;
17667 }
17668 {
17669 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17670 }
17671 {
17672 if (created1) delete arg1;
17673 }
17674 return resultobj;
17675 fail:
17676 {
17677 if (created1) delete arg1;
17678 }
17679 return NULL;
17680 }
17681
17682
17683 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17684 PyObject *resultobj = 0;
17685 wxImage *arg1 = (wxImage *) 0 ;
17686 wxInputStream *arg2 = 0 ;
17687 long arg3 = (long) wxBITMAP_TYPE_ANY ;
17688 int arg4 = (int) -1 ;
17689 bool result;
17690 void *argp1 = 0 ;
17691 int res1 = 0 ;
17692 wxPyInputStream *temp2 ;
17693 bool created2 ;
17694 long val3 ;
17695 int ecode3 = 0 ;
17696 int val4 ;
17697 int ecode4 = 0 ;
17698 PyObject * obj0 = 0 ;
17699 PyObject * obj1 = 0 ;
17700 PyObject * obj2 = 0 ;
17701 PyObject * obj3 = 0 ;
17702 char * kwnames[] = {
17703 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
17704 };
17705
17706 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17707 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17708 if (!SWIG_IsOK(res1)) {
17709 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
17710 }
17711 arg1 = reinterpret_cast< wxImage * >(argp1);
17712 {
17713 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17714 arg2 = temp2->m_wxis;
17715 created2 = false;
17716 } else {
17717 PyErr_Clear(); // clear the failure of the wxPyConvert above
17718 arg2 = wxPyCBInputStream_create(obj1, false);
17719 if (arg2 == NULL) {
17720 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17721 SWIG_fail;
17722 }
17723 created2 = true;
17724 }
17725 }
17726 if (obj2) {
17727 ecode3 = SWIG_AsVal_long(obj2, &val3);
17728 if (!SWIG_IsOK(ecode3)) {
17729 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
17730 }
17731 arg3 = static_cast< long >(val3);
17732 }
17733 if (obj3) {
17734 ecode4 = SWIG_AsVal_int(obj3, &val4);
17735 if (!SWIG_IsOK(ecode4)) {
17736 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
17737 }
17738 arg4 = static_cast< int >(val4);
17739 }
17740 {
17741 PyThreadState* __tstate = wxPyBeginAllowThreads();
17742 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
17743 wxPyEndAllowThreads(__tstate);
17744 if (PyErr_Occurred()) SWIG_fail;
17745 }
17746 {
17747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17748 }
17749 {
17750 if (created2) delete arg2;
17751 }
17752 return resultobj;
17753 fail:
17754 {
17755 if (created2) delete arg2;
17756 }
17757 return NULL;
17758 }
17759
17760
17761 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17762 PyObject *resultobj = 0;
17763 wxImage *arg1 = (wxImage *) 0 ;
17764 wxInputStream *arg2 = 0 ;
17765 wxString *arg3 = 0 ;
17766 int arg4 = (int) -1 ;
17767 bool result;
17768 void *argp1 = 0 ;
17769 int res1 = 0 ;
17770 wxPyInputStream *temp2 ;
17771 bool created2 ;
17772 bool temp3 = false ;
17773 int val4 ;
17774 int ecode4 = 0 ;
17775 PyObject * obj0 = 0 ;
17776 PyObject * obj1 = 0 ;
17777 PyObject * obj2 = 0 ;
17778 PyObject * obj3 = 0 ;
17779 char * kwnames[] = {
17780 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
17781 };
17782
17783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17785 if (!SWIG_IsOK(res1)) {
17786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
17787 }
17788 arg1 = reinterpret_cast< wxImage * >(argp1);
17789 {
17790 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
17791 arg2 = temp2->m_wxis;
17792 created2 = false;
17793 } else {
17794 PyErr_Clear(); // clear the failure of the wxPyConvert above
17795 arg2 = wxPyCBInputStream_create(obj1, false);
17796 if (arg2 == NULL) {
17797 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
17798 SWIG_fail;
17799 }
17800 created2 = true;
17801 }
17802 }
17803 {
17804 arg3 = wxString_in_helper(obj2);
17805 if (arg3 == NULL) SWIG_fail;
17806 temp3 = true;
17807 }
17808 if (obj3) {
17809 ecode4 = SWIG_AsVal_int(obj3, &val4);
17810 if (!SWIG_IsOK(ecode4)) {
17811 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
17812 }
17813 arg4 = static_cast< int >(val4);
17814 }
17815 {
17816 PyThreadState* __tstate = wxPyBeginAllowThreads();
17817 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
17818 wxPyEndAllowThreads(__tstate);
17819 if (PyErr_Occurred()) SWIG_fail;
17820 }
17821 {
17822 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17823 }
17824 {
17825 if (created2) delete arg2;
17826 }
17827 {
17828 if (temp3)
17829 delete arg3;
17830 }
17831 return resultobj;
17832 fail:
17833 {
17834 if (created2) delete arg2;
17835 }
17836 {
17837 if (temp3)
17838 delete arg3;
17839 }
17840 return NULL;
17841 }
17842
17843
17844 SWIGINTERN PyObject *_wrap_Image_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17845 PyObject *resultobj = 0;
17846 wxImage *arg1 = (wxImage *) 0 ;
17847 bool result;
17848 void *argp1 = 0 ;
17849 int res1 = 0 ;
17850 PyObject *swig_obj[1] ;
17851
17852 if (!args) SWIG_fail;
17853 swig_obj[0] = args;
17854 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17855 if (!SWIG_IsOK(res1)) {
17856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsOk" "', expected argument " "1"" of type '" "wxImage *""'");
17857 }
17858 arg1 = reinterpret_cast< wxImage * >(argp1);
17859 {
17860 PyThreadState* __tstate = wxPyBeginAllowThreads();
17861 result = (bool)(arg1)->IsOk();
17862 wxPyEndAllowThreads(__tstate);
17863 if (PyErr_Occurred()) SWIG_fail;
17864 }
17865 {
17866 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17867 }
17868 return resultobj;
17869 fail:
17870 return NULL;
17871 }
17872
17873
17874 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17875 PyObject *resultobj = 0;
17876 wxImage *arg1 = (wxImage *) 0 ;
17877 int result;
17878 void *argp1 = 0 ;
17879 int res1 = 0 ;
17880 PyObject *swig_obj[1] ;
17881
17882 if (!args) SWIG_fail;
17883 swig_obj[0] = args;
17884 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17885 if (!SWIG_IsOK(res1)) {
17886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
17887 }
17888 arg1 = reinterpret_cast< wxImage * >(argp1);
17889 {
17890 PyThreadState* __tstate = wxPyBeginAllowThreads();
17891 result = (int)(arg1)->GetWidth();
17892 wxPyEndAllowThreads(__tstate);
17893 if (PyErr_Occurred()) SWIG_fail;
17894 }
17895 resultobj = SWIG_From_int(static_cast< int >(result));
17896 return resultobj;
17897 fail:
17898 return NULL;
17899 }
17900
17901
17902 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17903 PyObject *resultobj = 0;
17904 wxImage *arg1 = (wxImage *) 0 ;
17905 int result;
17906 void *argp1 = 0 ;
17907 int res1 = 0 ;
17908 PyObject *swig_obj[1] ;
17909
17910 if (!args) SWIG_fail;
17911 swig_obj[0] = args;
17912 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17913 if (!SWIG_IsOK(res1)) {
17914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
17915 }
17916 arg1 = reinterpret_cast< wxImage * >(argp1);
17917 {
17918 PyThreadState* __tstate = wxPyBeginAllowThreads();
17919 result = (int)(arg1)->GetHeight();
17920 wxPyEndAllowThreads(__tstate);
17921 if (PyErr_Occurred()) SWIG_fail;
17922 }
17923 resultobj = SWIG_From_int(static_cast< int >(result));
17924 return resultobj;
17925 fail:
17926 return NULL;
17927 }
17928
17929
17930 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17931 PyObject *resultobj = 0;
17932 wxImage *arg1 = (wxImage *) 0 ;
17933 wxSize result;
17934 void *argp1 = 0 ;
17935 int res1 = 0 ;
17936 PyObject *swig_obj[1] ;
17937
17938 if (!args) SWIG_fail;
17939 swig_obj[0] = args;
17940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17941 if (!SWIG_IsOK(res1)) {
17942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
17943 }
17944 arg1 = reinterpret_cast< wxImage * >(argp1);
17945 {
17946 PyThreadState* __tstate = wxPyBeginAllowThreads();
17947 result = wxImage_GetSize(arg1);
17948 wxPyEndAllowThreads(__tstate);
17949 if (PyErr_Occurred()) SWIG_fail;
17950 }
17951 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
17952 return resultobj;
17953 fail:
17954 return NULL;
17955 }
17956
17957
17958 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17959 PyObject *resultobj = 0;
17960 wxImage *arg1 = (wxImage *) 0 ;
17961 wxRect *arg2 = 0 ;
17962 SwigValueWrapper<wxImage > result;
17963 void *argp1 = 0 ;
17964 int res1 = 0 ;
17965 wxRect temp2 ;
17966 PyObject * obj0 = 0 ;
17967 PyObject * obj1 = 0 ;
17968 char * kwnames[] = {
17969 (char *) "self",(char *) "rect", NULL
17970 };
17971
17972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
17973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
17974 if (!SWIG_IsOK(res1)) {
17975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
17976 }
17977 arg1 = reinterpret_cast< wxImage * >(argp1);
17978 {
17979 arg2 = &temp2;
17980 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
17981 }
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 result = (arg1)->GetSubImage((wxRect const &)*arg2);
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17996 PyObject *resultobj = 0;
17997 wxImage *arg1 = (wxImage *) 0 ;
17998 wxSize *arg2 = 0 ;
17999 wxPoint *arg3 = 0 ;
18000 int arg4 = (int) -1 ;
18001 int arg5 = (int) -1 ;
18002 int arg6 = (int) -1 ;
18003 SwigValueWrapper<wxImage > result;
18004 void *argp1 = 0 ;
18005 int res1 = 0 ;
18006 wxSize temp2 ;
18007 wxPoint temp3 ;
18008 int val4 ;
18009 int ecode4 = 0 ;
18010 int val5 ;
18011 int ecode5 = 0 ;
18012 int val6 ;
18013 int ecode6 = 0 ;
18014 PyObject * obj0 = 0 ;
18015 PyObject * obj1 = 0 ;
18016 PyObject * obj2 = 0 ;
18017 PyObject * obj3 = 0 ;
18018 PyObject * obj4 = 0 ;
18019 PyObject * obj5 = 0 ;
18020 char * kwnames[] = {
18021 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
18022 };
18023
18024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
18025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18026 if (!SWIG_IsOK(res1)) {
18027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
18028 }
18029 arg1 = reinterpret_cast< wxImage * >(argp1);
18030 {
18031 arg2 = &temp2;
18032 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
18033 }
18034 {
18035 arg3 = &temp3;
18036 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18037 }
18038 if (obj3) {
18039 ecode4 = SWIG_AsVal_int(obj3, &val4);
18040 if (!SWIG_IsOK(ecode4)) {
18041 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
18042 }
18043 arg4 = static_cast< int >(val4);
18044 }
18045 if (obj4) {
18046 ecode5 = SWIG_AsVal_int(obj4, &val5);
18047 if (!SWIG_IsOK(ecode5)) {
18048 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
18049 }
18050 arg5 = static_cast< int >(val5);
18051 }
18052 if (obj5) {
18053 ecode6 = SWIG_AsVal_int(obj5, &val6);
18054 if (!SWIG_IsOK(ecode6)) {
18055 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
18056 }
18057 arg6 = static_cast< int >(val6);
18058 }
18059 {
18060 PyThreadState* __tstate = wxPyBeginAllowThreads();
18061 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
18062 wxPyEndAllowThreads(__tstate);
18063 if (PyErr_Occurred()) SWIG_fail;
18064 }
18065 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18066 return resultobj;
18067 fail:
18068 return NULL;
18069 }
18070
18071
18072 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18073 PyObject *resultobj = 0;
18074 wxImage *arg1 = (wxImage *) 0 ;
18075 SwigValueWrapper<wxImage > result;
18076 void *argp1 = 0 ;
18077 int res1 = 0 ;
18078 PyObject *swig_obj[1] ;
18079
18080 if (!args) SWIG_fail;
18081 swig_obj[0] = args;
18082 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18083 if (!SWIG_IsOK(res1)) {
18084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
18085 }
18086 arg1 = reinterpret_cast< wxImage * >(argp1);
18087 {
18088 PyThreadState* __tstate = wxPyBeginAllowThreads();
18089 result = (arg1)->Copy();
18090 wxPyEndAllowThreads(__tstate);
18091 if (PyErr_Occurred()) SWIG_fail;
18092 }
18093 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18094 return resultobj;
18095 fail:
18096 return NULL;
18097 }
18098
18099
18100 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18101 PyObject *resultobj = 0;
18102 wxImage *arg1 = (wxImage *) 0 ;
18103 wxImage *arg2 = 0 ;
18104 int arg3 ;
18105 int arg4 ;
18106 void *argp1 = 0 ;
18107 int res1 = 0 ;
18108 void *argp2 = 0 ;
18109 int res2 = 0 ;
18110 int val3 ;
18111 int ecode3 = 0 ;
18112 int val4 ;
18113 int ecode4 = 0 ;
18114 PyObject * obj0 = 0 ;
18115 PyObject * obj1 = 0 ;
18116 PyObject * obj2 = 0 ;
18117 PyObject * obj3 = 0 ;
18118 char * kwnames[] = {
18119 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
18120 };
18121
18122 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18123 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18124 if (!SWIG_IsOK(res1)) {
18125 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
18126 }
18127 arg1 = reinterpret_cast< wxImage * >(argp1);
18128 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
18129 if (!SWIG_IsOK(res2)) {
18130 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18131 }
18132 if (!argp2) {
18133 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
18134 }
18135 arg2 = reinterpret_cast< wxImage * >(argp2);
18136 ecode3 = SWIG_AsVal_int(obj2, &val3);
18137 if (!SWIG_IsOK(ecode3)) {
18138 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
18139 }
18140 arg3 = static_cast< int >(val3);
18141 ecode4 = SWIG_AsVal_int(obj3, &val4);
18142 if (!SWIG_IsOK(ecode4)) {
18143 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
18144 }
18145 arg4 = static_cast< int >(val4);
18146 {
18147 PyThreadState* __tstate = wxPyBeginAllowThreads();
18148 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
18149 wxPyEndAllowThreads(__tstate);
18150 if (PyErr_Occurred()) SWIG_fail;
18151 }
18152 resultobj = SWIG_Py_Void();
18153 return resultobj;
18154 fail:
18155 return NULL;
18156 }
18157
18158
18159 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18160 PyObject *resultobj = 0;
18161 wxImage *arg1 = (wxImage *) 0 ;
18162 PyObject *result = 0 ;
18163 void *argp1 = 0 ;
18164 int res1 = 0 ;
18165 PyObject *swig_obj[1] ;
18166
18167 if (!args) SWIG_fail;
18168 swig_obj[0] = args;
18169 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18170 if (!SWIG_IsOK(res1)) {
18171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
18172 }
18173 arg1 = reinterpret_cast< wxImage * >(argp1);
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 result = (PyObject *)wxImage_GetData(arg1);
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 resultobj = result;
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18188 PyObject *resultobj = 0;
18189 wxImage *arg1 = (wxImage *) 0 ;
18190 buffer arg2 ;
18191 int arg3 ;
18192 void *argp1 = 0 ;
18193 int res1 = 0 ;
18194 Py_ssize_t temp2 ;
18195 PyObject * obj0 = 0 ;
18196 PyObject * obj1 = 0 ;
18197 char * kwnames[] = {
18198 (char *) "self",(char *) "data", NULL
18199 };
18200
18201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
18202 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18203 if (!SWIG_IsOK(res1)) {
18204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
18205 }
18206 arg1 = reinterpret_cast< wxImage * >(argp1);
18207 {
18208 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18209 arg3 = (int)temp2;
18210 }
18211 {
18212 PyThreadState* __tstate = wxPyBeginAllowThreads();
18213 wxImage_SetData(arg1,arg2,arg3);
18214 wxPyEndAllowThreads(__tstate);
18215 if (PyErr_Occurred()) SWIG_fail;
18216 }
18217 resultobj = SWIG_Py_Void();
18218 return resultobj;
18219 fail:
18220 return NULL;
18221 }
18222
18223
18224 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18225 PyObject *resultobj = 0;
18226 wxImage *arg1 = (wxImage *) 0 ;
18227 PyObject *result = 0 ;
18228 void *argp1 = 0 ;
18229 int res1 = 0 ;
18230 PyObject *swig_obj[1] ;
18231
18232 if (!args) SWIG_fail;
18233 swig_obj[0] = args;
18234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18235 if (!SWIG_IsOK(res1)) {
18236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18237 }
18238 arg1 = reinterpret_cast< wxImage * >(argp1);
18239 {
18240 PyThreadState* __tstate = wxPyBeginAllowThreads();
18241 result = (PyObject *)wxImage_GetDataBuffer(arg1);
18242 wxPyEndAllowThreads(__tstate);
18243 if (PyErr_Occurred()) SWIG_fail;
18244 }
18245 resultobj = result;
18246 return resultobj;
18247 fail:
18248 return NULL;
18249 }
18250
18251
18252 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18253 PyObject *resultobj = 0;
18254 wxImage *arg1 = (wxImage *) 0 ;
18255 buffer arg2 ;
18256 int arg3 ;
18257 void *argp1 = 0 ;
18258 int res1 = 0 ;
18259 Py_ssize_t temp2 ;
18260 PyObject * obj0 = 0 ;
18261 PyObject * obj1 = 0 ;
18262 char * kwnames[] = {
18263 (char *) "self",(char *) "data", NULL
18264 };
18265
18266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18268 if (!SWIG_IsOK(res1)) {
18269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18270 }
18271 arg1 = reinterpret_cast< wxImage * >(argp1);
18272 {
18273 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18274 arg3 = (int)temp2;
18275 }
18276 {
18277 PyThreadState* __tstate = wxPyBeginAllowThreads();
18278 wxImage_SetDataBuffer(arg1,arg2,arg3);
18279 wxPyEndAllowThreads(__tstate);
18280 if (PyErr_Occurred()) SWIG_fail;
18281 }
18282 resultobj = SWIG_Py_Void();
18283 return resultobj;
18284 fail:
18285 return NULL;
18286 }
18287
18288
18289 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18290 PyObject *resultobj = 0;
18291 wxImage *arg1 = (wxImage *) 0 ;
18292 PyObject *result = 0 ;
18293 void *argp1 = 0 ;
18294 int res1 = 0 ;
18295 PyObject *swig_obj[1] ;
18296
18297 if (!args) SWIG_fail;
18298 swig_obj[0] = args;
18299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18300 if (!SWIG_IsOK(res1)) {
18301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18302 }
18303 arg1 = reinterpret_cast< wxImage * >(argp1);
18304 {
18305 PyThreadState* __tstate = wxPyBeginAllowThreads();
18306 result = (PyObject *)wxImage_GetAlphaData(arg1);
18307 wxPyEndAllowThreads(__tstate);
18308 if (PyErr_Occurred()) SWIG_fail;
18309 }
18310 resultobj = result;
18311 return resultobj;
18312 fail:
18313 return NULL;
18314 }
18315
18316
18317 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18318 PyObject *resultobj = 0;
18319 wxImage *arg1 = (wxImage *) 0 ;
18320 buffer arg2 ;
18321 int arg3 ;
18322 void *argp1 = 0 ;
18323 int res1 = 0 ;
18324 Py_ssize_t temp2 ;
18325 PyObject * obj0 = 0 ;
18326 PyObject * obj1 = 0 ;
18327 char * kwnames[] = {
18328 (char *) "self",(char *) "alpha", NULL
18329 };
18330
18331 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
18332 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18333 if (!SWIG_IsOK(res1)) {
18334 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
18335 }
18336 arg1 = reinterpret_cast< wxImage * >(argp1);
18337 {
18338 if (obj1 != Py_None) {
18339 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18340 arg3 = (int)temp2;
18341 }
18342 }
18343 {
18344 PyThreadState* __tstate = wxPyBeginAllowThreads();
18345 wxImage_SetAlphaData(arg1,arg2,arg3);
18346 wxPyEndAllowThreads(__tstate);
18347 if (PyErr_Occurred()) SWIG_fail;
18348 }
18349 resultobj = SWIG_Py_Void();
18350 return resultobj;
18351 fail:
18352 return NULL;
18353 }
18354
18355
18356 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18357 PyObject *resultobj = 0;
18358 wxImage *arg1 = (wxImage *) 0 ;
18359 PyObject *result = 0 ;
18360 void *argp1 = 0 ;
18361 int res1 = 0 ;
18362 PyObject *swig_obj[1] ;
18363
18364 if (!args) SWIG_fail;
18365 swig_obj[0] = args;
18366 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18367 if (!SWIG_IsOK(res1)) {
18368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18369 }
18370 arg1 = reinterpret_cast< wxImage * >(argp1);
18371 {
18372 PyThreadState* __tstate = wxPyBeginAllowThreads();
18373 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
18374 wxPyEndAllowThreads(__tstate);
18375 if (PyErr_Occurred()) SWIG_fail;
18376 }
18377 resultobj = result;
18378 return resultobj;
18379 fail:
18380 return NULL;
18381 }
18382
18383
18384 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18385 PyObject *resultobj = 0;
18386 wxImage *arg1 = (wxImage *) 0 ;
18387 buffer arg2 ;
18388 int arg3 ;
18389 void *argp1 = 0 ;
18390 int res1 = 0 ;
18391 Py_ssize_t temp2 ;
18392 PyObject * obj0 = 0 ;
18393 PyObject * obj1 = 0 ;
18394 char * kwnames[] = {
18395 (char *) "self",(char *) "alpha", NULL
18396 };
18397
18398 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
18399 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18400 if (!SWIG_IsOK(res1)) {
18401 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
18402 }
18403 arg1 = reinterpret_cast< wxImage * >(argp1);
18404 {
18405 if (obj1 != Py_None) {
18406 if (PyObject_AsReadBuffer(obj1, (const void**)(&arg2), &temp2) == -1) SWIG_fail;
18407 arg3 = (int)temp2;
18408 }
18409 }
18410 {
18411 PyThreadState* __tstate = wxPyBeginAllowThreads();
18412 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
18413 wxPyEndAllowThreads(__tstate);
18414 if (PyErr_Occurred()) SWIG_fail;
18415 }
18416 resultobj = SWIG_Py_Void();
18417 return resultobj;
18418 fail:
18419 return NULL;
18420 }
18421
18422
18423 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18424 PyObject *resultobj = 0;
18425 wxImage *arg1 = (wxImage *) 0 ;
18426 byte arg2 ;
18427 byte arg3 ;
18428 byte arg4 ;
18429 void *argp1 = 0 ;
18430 int res1 = 0 ;
18431 unsigned char val2 ;
18432 int ecode2 = 0 ;
18433 unsigned char val3 ;
18434 int ecode3 = 0 ;
18435 unsigned char val4 ;
18436 int ecode4 = 0 ;
18437 PyObject * obj0 = 0 ;
18438 PyObject * obj1 = 0 ;
18439 PyObject * obj2 = 0 ;
18440 PyObject * obj3 = 0 ;
18441 char * kwnames[] = {
18442 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
18443 };
18444
18445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18447 if (!SWIG_IsOK(res1)) {
18448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
18449 }
18450 arg1 = reinterpret_cast< wxImage * >(argp1);
18451 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18452 if (!SWIG_IsOK(ecode2)) {
18453 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
18454 }
18455 arg2 = static_cast< byte >(val2);
18456 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18457 if (!SWIG_IsOK(ecode3)) {
18458 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
18459 }
18460 arg3 = static_cast< byte >(val3);
18461 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18462 if (!SWIG_IsOK(ecode4)) {
18463 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
18464 }
18465 arg4 = static_cast< byte >(val4);
18466 {
18467 PyThreadState* __tstate = wxPyBeginAllowThreads();
18468 (arg1)->SetMaskColour(arg2,arg3,arg4);
18469 wxPyEndAllowThreads(__tstate);
18470 if (PyErr_Occurred()) SWIG_fail;
18471 }
18472 resultobj = SWIG_Py_Void();
18473 return resultobj;
18474 fail:
18475 return NULL;
18476 }
18477
18478
18479 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18480 PyObject *resultobj = 0;
18481 wxImage *arg1 = (wxImage *) 0 ;
18482 byte *arg2 = (byte *) 0 ;
18483 byte *arg3 = (byte *) 0 ;
18484 byte *arg4 = (byte *) 0 ;
18485 void *argp1 = 0 ;
18486 int res1 = 0 ;
18487 byte temp2 ;
18488 int res2 = SWIG_TMPOBJ ;
18489 byte temp3 ;
18490 int res3 = SWIG_TMPOBJ ;
18491 byte temp4 ;
18492 int res4 = SWIG_TMPOBJ ;
18493 PyObject *swig_obj[1] ;
18494
18495 arg2 = &temp2;
18496 arg3 = &temp3;
18497 arg4 = &temp4;
18498 if (!args) SWIG_fail;
18499 swig_obj[0] = args;
18500 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18501 if (!SWIG_IsOK(res1)) {
18502 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
18503 }
18504 arg1 = reinterpret_cast< wxImage * >(argp1);
18505 {
18506 PyThreadState* __tstate = wxPyBeginAllowThreads();
18507 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
18508 wxPyEndAllowThreads(__tstate);
18509 if (PyErr_Occurred()) SWIG_fail;
18510 }
18511 resultobj = SWIG_Py_Void();
18512 if (SWIG_IsTmpObj(res2)) {
18513 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
18514 } else {
18515 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18516 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
18517 }
18518 if (SWIG_IsTmpObj(res3)) {
18519 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
18520 } else {
18521 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18522 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
18523 }
18524 if (SWIG_IsTmpObj(res4)) {
18525 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
18526 } else {
18527 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
18528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
18529 }
18530 return resultobj;
18531 fail:
18532 return NULL;
18533 }
18534
18535
18536 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18537 PyObject *resultobj = 0;
18538 wxImage *arg1 = (wxImage *) 0 ;
18539 byte result;
18540 void *argp1 = 0 ;
18541 int res1 = 0 ;
18542 PyObject *swig_obj[1] ;
18543
18544 if (!args) SWIG_fail;
18545 swig_obj[0] = args;
18546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18547 if (!SWIG_IsOK(res1)) {
18548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
18549 }
18550 arg1 = reinterpret_cast< wxImage * >(argp1);
18551 {
18552 PyThreadState* __tstate = wxPyBeginAllowThreads();
18553 result = (byte)(arg1)->GetMaskRed();
18554 wxPyEndAllowThreads(__tstate);
18555 if (PyErr_Occurred()) SWIG_fail;
18556 }
18557 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18558 return resultobj;
18559 fail:
18560 return NULL;
18561 }
18562
18563
18564 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18565 PyObject *resultobj = 0;
18566 wxImage *arg1 = (wxImage *) 0 ;
18567 byte result;
18568 void *argp1 = 0 ;
18569 int res1 = 0 ;
18570 PyObject *swig_obj[1] ;
18571
18572 if (!args) SWIG_fail;
18573 swig_obj[0] = args;
18574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18575 if (!SWIG_IsOK(res1)) {
18576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
18577 }
18578 arg1 = reinterpret_cast< wxImage * >(argp1);
18579 {
18580 PyThreadState* __tstate = wxPyBeginAllowThreads();
18581 result = (byte)(arg1)->GetMaskGreen();
18582 wxPyEndAllowThreads(__tstate);
18583 if (PyErr_Occurred()) SWIG_fail;
18584 }
18585 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18586 return resultobj;
18587 fail:
18588 return NULL;
18589 }
18590
18591
18592 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18593 PyObject *resultobj = 0;
18594 wxImage *arg1 = (wxImage *) 0 ;
18595 byte result;
18596 void *argp1 = 0 ;
18597 int res1 = 0 ;
18598 PyObject *swig_obj[1] ;
18599
18600 if (!args) SWIG_fail;
18601 swig_obj[0] = args;
18602 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18603 if (!SWIG_IsOK(res1)) {
18604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
18605 }
18606 arg1 = reinterpret_cast< wxImage * >(argp1);
18607 {
18608 PyThreadState* __tstate = wxPyBeginAllowThreads();
18609 result = (byte)(arg1)->GetMaskBlue();
18610 wxPyEndAllowThreads(__tstate);
18611 if (PyErr_Occurred()) SWIG_fail;
18612 }
18613 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
18614 return resultobj;
18615 fail:
18616 return NULL;
18617 }
18618
18619
18620 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18621 PyObject *resultobj = 0;
18622 wxImage *arg1 = (wxImage *) 0 ;
18623 bool arg2 = (bool) true ;
18624 void *argp1 = 0 ;
18625 int res1 = 0 ;
18626 bool val2 ;
18627 int ecode2 = 0 ;
18628 PyObject * obj0 = 0 ;
18629 PyObject * obj1 = 0 ;
18630 char * kwnames[] = {
18631 (char *) "self",(char *) "mask", NULL
18632 };
18633
18634 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
18635 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18636 if (!SWIG_IsOK(res1)) {
18637 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
18638 }
18639 arg1 = reinterpret_cast< wxImage * >(argp1);
18640 if (obj1) {
18641 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18642 if (!SWIG_IsOK(ecode2)) {
18643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
18644 }
18645 arg2 = static_cast< bool >(val2);
18646 }
18647 {
18648 PyThreadState* __tstate = wxPyBeginAllowThreads();
18649 (arg1)->SetMask(arg2);
18650 wxPyEndAllowThreads(__tstate);
18651 if (PyErr_Occurred()) SWIG_fail;
18652 }
18653 resultobj = SWIG_Py_Void();
18654 return resultobj;
18655 fail:
18656 return NULL;
18657 }
18658
18659
18660 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18661 PyObject *resultobj = 0;
18662 wxImage *arg1 = (wxImage *) 0 ;
18663 bool result;
18664 void *argp1 = 0 ;
18665 int res1 = 0 ;
18666 PyObject *swig_obj[1] ;
18667
18668 if (!args) SWIG_fail;
18669 swig_obj[0] = args;
18670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18671 if (!SWIG_IsOK(res1)) {
18672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
18673 }
18674 arg1 = reinterpret_cast< wxImage * >(argp1);
18675 {
18676 PyThreadState* __tstate = wxPyBeginAllowThreads();
18677 result = (bool)(arg1)->HasMask();
18678 wxPyEndAllowThreads(__tstate);
18679 if (PyErr_Occurred()) SWIG_fail;
18680 }
18681 {
18682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18683 }
18684 return resultobj;
18685 fail:
18686 return NULL;
18687 }
18688
18689
18690 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18691 PyObject *resultobj = 0;
18692 wxImage *arg1 = (wxImage *) 0 ;
18693 double arg2 ;
18694 wxPoint *arg3 = 0 ;
18695 bool arg4 = (bool) true ;
18696 wxPoint *arg5 = (wxPoint *) NULL ;
18697 SwigValueWrapper<wxImage > result;
18698 void *argp1 = 0 ;
18699 int res1 = 0 ;
18700 double val2 ;
18701 int ecode2 = 0 ;
18702 wxPoint temp3 ;
18703 bool val4 ;
18704 int ecode4 = 0 ;
18705 void *argp5 = 0 ;
18706 int res5 = 0 ;
18707 PyObject * obj0 = 0 ;
18708 PyObject * obj1 = 0 ;
18709 PyObject * obj2 = 0 ;
18710 PyObject * obj3 = 0 ;
18711 PyObject * obj4 = 0 ;
18712 char * kwnames[] = {
18713 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
18714 };
18715
18716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18718 if (!SWIG_IsOK(res1)) {
18719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
18720 }
18721 arg1 = reinterpret_cast< wxImage * >(argp1);
18722 ecode2 = SWIG_AsVal_double(obj1, &val2);
18723 if (!SWIG_IsOK(ecode2)) {
18724 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
18725 }
18726 arg2 = static_cast< double >(val2);
18727 {
18728 arg3 = &temp3;
18729 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
18730 }
18731 if (obj3) {
18732 ecode4 = SWIG_AsVal_bool(obj3, &val4);
18733 if (!SWIG_IsOK(ecode4)) {
18734 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
18735 }
18736 arg4 = static_cast< bool >(val4);
18737 }
18738 if (obj4) {
18739 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
18740 if (!SWIG_IsOK(res5)) {
18741 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
18742 }
18743 arg5 = reinterpret_cast< wxPoint * >(argp5);
18744 }
18745 {
18746 PyThreadState* __tstate = wxPyBeginAllowThreads();
18747 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
18748 wxPyEndAllowThreads(__tstate);
18749 if (PyErr_Occurred()) SWIG_fail;
18750 }
18751 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18752 return resultobj;
18753 fail:
18754 return NULL;
18755 }
18756
18757
18758 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18759 PyObject *resultobj = 0;
18760 wxImage *arg1 = (wxImage *) 0 ;
18761 bool arg2 = (bool) true ;
18762 SwigValueWrapper<wxImage > result;
18763 void *argp1 = 0 ;
18764 int res1 = 0 ;
18765 bool val2 ;
18766 int ecode2 = 0 ;
18767 PyObject * obj0 = 0 ;
18768 PyObject * obj1 = 0 ;
18769 char * kwnames[] = {
18770 (char *) "self",(char *) "clockwise", NULL
18771 };
18772
18773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
18774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18775 if (!SWIG_IsOK(res1)) {
18776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
18777 }
18778 arg1 = reinterpret_cast< wxImage * >(argp1);
18779 if (obj1) {
18780 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18781 if (!SWIG_IsOK(ecode2)) {
18782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
18783 }
18784 arg2 = static_cast< bool >(val2);
18785 }
18786 {
18787 PyThreadState* __tstate = wxPyBeginAllowThreads();
18788 result = (arg1)->Rotate90(arg2);
18789 wxPyEndAllowThreads(__tstate);
18790 if (PyErr_Occurred()) SWIG_fail;
18791 }
18792 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18793 return resultobj;
18794 fail:
18795 return NULL;
18796 }
18797
18798
18799 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18800 PyObject *resultobj = 0;
18801 wxImage *arg1 = (wxImage *) 0 ;
18802 bool arg2 = (bool) true ;
18803 SwigValueWrapper<wxImage > result;
18804 void *argp1 = 0 ;
18805 int res1 = 0 ;
18806 bool val2 ;
18807 int ecode2 = 0 ;
18808 PyObject * obj0 = 0 ;
18809 PyObject * obj1 = 0 ;
18810 char * kwnames[] = {
18811 (char *) "self",(char *) "horizontally", NULL
18812 };
18813
18814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
18815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18816 if (!SWIG_IsOK(res1)) {
18817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
18818 }
18819 arg1 = reinterpret_cast< wxImage * >(argp1);
18820 if (obj1) {
18821 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18822 if (!SWIG_IsOK(ecode2)) {
18823 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
18824 }
18825 arg2 = static_cast< bool >(val2);
18826 }
18827 {
18828 PyThreadState* __tstate = wxPyBeginAllowThreads();
18829 result = (arg1)->Mirror(arg2);
18830 wxPyEndAllowThreads(__tstate);
18831 if (PyErr_Occurred()) SWIG_fail;
18832 }
18833 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18834 return resultobj;
18835 fail:
18836 return NULL;
18837 }
18838
18839
18840 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18841 PyObject *resultobj = 0;
18842 wxImage *arg1 = (wxImage *) 0 ;
18843 byte arg2 ;
18844 byte arg3 ;
18845 byte arg4 ;
18846 byte arg5 ;
18847 byte arg6 ;
18848 byte arg7 ;
18849 void *argp1 = 0 ;
18850 int res1 = 0 ;
18851 unsigned char val2 ;
18852 int ecode2 = 0 ;
18853 unsigned char val3 ;
18854 int ecode3 = 0 ;
18855 unsigned char val4 ;
18856 int ecode4 = 0 ;
18857 unsigned char val5 ;
18858 int ecode5 = 0 ;
18859 unsigned char val6 ;
18860 int ecode6 = 0 ;
18861 unsigned char val7 ;
18862 int ecode7 = 0 ;
18863 PyObject * obj0 = 0 ;
18864 PyObject * obj1 = 0 ;
18865 PyObject * obj2 = 0 ;
18866 PyObject * obj3 = 0 ;
18867 PyObject * obj4 = 0 ;
18868 PyObject * obj5 = 0 ;
18869 PyObject * obj6 = 0 ;
18870 char * kwnames[] = {
18871 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
18872 };
18873
18874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
18875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18876 if (!SWIG_IsOK(res1)) {
18877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
18878 }
18879 arg1 = reinterpret_cast< wxImage * >(argp1);
18880 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
18881 if (!SWIG_IsOK(ecode2)) {
18882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
18883 }
18884 arg2 = static_cast< byte >(val2);
18885 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
18886 if (!SWIG_IsOK(ecode3)) {
18887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
18888 }
18889 arg3 = static_cast< byte >(val3);
18890 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
18891 if (!SWIG_IsOK(ecode4)) {
18892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
18893 }
18894 arg4 = static_cast< byte >(val4);
18895 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
18896 if (!SWIG_IsOK(ecode5)) {
18897 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
18898 }
18899 arg5 = static_cast< byte >(val5);
18900 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
18901 if (!SWIG_IsOK(ecode6)) {
18902 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
18903 }
18904 arg6 = static_cast< byte >(val6);
18905 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
18906 if (!SWIG_IsOK(ecode7)) {
18907 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
18908 }
18909 arg7 = static_cast< byte >(val7);
18910 {
18911 PyThreadState* __tstate = wxPyBeginAllowThreads();
18912 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
18913 wxPyEndAllowThreads(__tstate);
18914 if (PyErr_Occurred()) SWIG_fail;
18915 }
18916 resultobj = SWIG_Py_Void();
18917 return resultobj;
18918 fail:
18919 return NULL;
18920 }
18921
18922
18923 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18924 PyObject *resultobj = 0;
18925 wxImage *arg1 = (wxImage *) 0 ;
18926 double arg2 = (double) 0.299 ;
18927 double arg3 = (double) 0.587 ;
18928 double arg4 = (double) 0.114 ;
18929 SwigValueWrapper<wxImage > result;
18930 void *argp1 = 0 ;
18931 int res1 = 0 ;
18932 double val2 ;
18933 int ecode2 = 0 ;
18934 double val3 ;
18935 int ecode3 = 0 ;
18936 double val4 ;
18937 int ecode4 = 0 ;
18938 PyObject * obj0 = 0 ;
18939 PyObject * obj1 = 0 ;
18940 PyObject * obj2 = 0 ;
18941 PyObject * obj3 = 0 ;
18942 char * kwnames[] = {
18943 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
18944 };
18945
18946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
18948 if (!SWIG_IsOK(res1)) {
18949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
18950 }
18951 arg1 = reinterpret_cast< wxImage * >(argp1);
18952 if (obj1) {
18953 ecode2 = SWIG_AsVal_double(obj1, &val2);
18954 if (!SWIG_IsOK(ecode2)) {
18955 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
18956 }
18957 arg2 = static_cast< double >(val2);
18958 }
18959 if (obj2) {
18960 ecode3 = SWIG_AsVal_double(obj2, &val3);
18961 if (!SWIG_IsOK(ecode3)) {
18962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
18963 }
18964 arg3 = static_cast< double >(val3);
18965 }
18966 if (obj3) {
18967 ecode4 = SWIG_AsVal_double(obj3, &val4);
18968 if (!SWIG_IsOK(ecode4)) {
18969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
18970 }
18971 arg4 = static_cast< double >(val4);
18972 }
18973 {
18974 PyThreadState* __tstate = wxPyBeginAllowThreads();
18975 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
18976 wxPyEndAllowThreads(__tstate);
18977 if (PyErr_Occurred()) SWIG_fail;
18978 }
18979 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
18980 return resultobj;
18981 fail:
18982 return NULL;
18983 }
18984
18985
18986 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18987 PyObject *resultobj = 0;
18988 wxImage *arg1 = (wxImage *) 0 ;
18989 byte arg2 ;
18990 byte arg3 ;
18991 byte arg4 ;
18992 SwigValueWrapper<wxImage > result;
18993 void *argp1 = 0 ;
18994 int res1 = 0 ;
18995 unsigned char val2 ;
18996 int ecode2 = 0 ;
18997 unsigned char val3 ;
18998 int ecode3 = 0 ;
18999 unsigned char val4 ;
19000 int ecode4 = 0 ;
19001 PyObject * obj0 = 0 ;
19002 PyObject * obj1 = 0 ;
19003 PyObject * obj2 = 0 ;
19004 PyObject * obj3 = 0 ;
19005 char * kwnames[] = {
19006 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
19007 };
19008
19009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19011 if (!SWIG_IsOK(res1)) {
19012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
19013 }
19014 arg1 = reinterpret_cast< wxImage * >(argp1);
19015 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19016 if (!SWIG_IsOK(ecode2)) {
19017 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
19018 }
19019 arg2 = static_cast< byte >(val2);
19020 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19021 if (!SWIG_IsOK(ecode3)) {
19022 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
19023 }
19024 arg3 = static_cast< byte >(val3);
19025 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19026 if (!SWIG_IsOK(ecode4)) {
19027 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
19028 }
19029 arg4 = static_cast< byte >(val4);
19030 {
19031 PyThreadState* __tstate = wxPyBeginAllowThreads();
19032 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
19033 wxPyEndAllowThreads(__tstate);
19034 if (PyErr_Occurred()) SWIG_fail;
19035 }
19036 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
19037 return resultobj;
19038 fail:
19039 return NULL;
19040 }
19041
19042
19043 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19044 PyObject *resultobj = 0;
19045 wxImage *arg1 = (wxImage *) 0 ;
19046 wxString *arg2 = 0 ;
19047 wxString *arg3 = 0 ;
19048 void *argp1 = 0 ;
19049 int res1 = 0 ;
19050 bool temp2 = false ;
19051 bool temp3 = false ;
19052 PyObject * obj0 = 0 ;
19053 PyObject * obj1 = 0 ;
19054 PyObject * obj2 = 0 ;
19055 char * kwnames[] = {
19056 (char *) "self",(char *) "name",(char *) "value", NULL
19057 };
19058
19059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19061 if (!SWIG_IsOK(res1)) {
19062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
19063 }
19064 arg1 = reinterpret_cast< wxImage * >(argp1);
19065 {
19066 arg2 = wxString_in_helper(obj1);
19067 if (arg2 == NULL) SWIG_fail;
19068 temp2 = true;
19069 }
19070 {
19071 arg3 = wxString_in_helper(obj2);
19072 if (arg3 == NULL) SWIG_fail;
19073 temp3 = true;
19074 }
19075 {
19076 PyThreadState* __tstate = wxPyBeginAllowThreads();
19077 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
19078 wxPyEndAllowThreads(__tstate);
19079 if (PyErr_Occurred()) SWIG_fail;
19080 }
19081 resultobj = SWIG_Py_Void();
19082 {
19083 if (temp2)
19084 delete arg2;
19085 }
19086 {
19087 if (temp3)
19088 delete arg3;
19089 }
19090 return resultobj;
19091 fail:
19092 {
19093 if (temp2)
19094 delete arg2;
19095 }
19096 {
19097 if (temp3)
19098 delete arg3;
19099 }
19100 return NULL;
19101 }
19102
19103
19104 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19105 PyObject *resultobj = 0;
19106 wxImage *arg1 = (wxImage *) 0 ;
19107 wxString *arg2 = 0 ;
19108 int arg3 ;
19109 void *argp1 = 0 ;
19110 int res1 = 0 ;
19111 bool temp2 = false ;
19112 int val3 ;
19113 int ecode3 = 0 ;
19114 PyObject * obj0 = 0 ;
19115 PyObject * obj1 = 0 ;
19116 PyObject * obj2 = 0 ;
19117 char * kwnames[] = {
19118 (char *) "self",(char *) "name",(char *) "value", NULL
19119 };
19120
19121 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19122 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19123 if (!SWIG_IsOK(res1)) {
19124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
19125 }
19126 arg1 = reinterpret_cast< wxImage * >(argp1);
19127 {
19128 arg2 = wxString_in_helper(obj1);
19129 if (arg2 == NULL) SWIG_fail;
19130 temp2 = true;
19131 }
19132 ecode3 = SWIG_AsVal_int(obj2, &val3);
19133 if (!SWIG_IsOK(ecode3)) {
19134 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
19135 }
19136 arg3 = static_cast< int >(val3);
19137 {
19138 PyThreadState* __tstate = wxPyBeginAllowThreads();
19139 (arg1)->SetOption((wxString const &)*arg2,arg3);
19140 wxPyEndAllowThreads(__tstate);
19141 if (PyErr_Occurred()) SWIG_fail;
19142 }
19143 resultobj = SWIG_Py_Void();
19144 {
19145 if (temp2)
19146 delete arg2;
19147 }
19148 return resultobj;
19149 fail:
19150 {
19151 if (temp2)
19152 delete arg2;
19153 }
19154 return NULL;
19155 }
19156
19157
19158 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19159 PyObject *resultobj = 0;
19160 wxImage *arg1 = (wxImage *) 0 ;
19161 wxString *arg2 = 0 ;
19162 wxString result;
19163 void *argp1 = 0 ;
19164 int res1 = 0 ;
19165 bool temp2 = false ;
19166 PyObject * obj0 = 0 ;
19167 PyObject * obj1 = 0 ;
19168 char * kwnames[] = {
19169 (char *) "self",(char *) "name", NULL
19170 };
19171
19172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
19173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19174 if (!SWIG_IsOK(res1)) {
19175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19176 }
19177 arg1 = reinterpret_cast< wxImage * >(argp1);
19178 {
19179 arg2 = wxString_in_helper(obj1);
19180 if (arg2 == NULL) SWIG_fail;
19181 temp2 = true;
19182 }
19183 {
19184 PyThreadState* __tstate = wxPyBeginAllowThreads();
19185 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
19186 wxPyEndAllowThreads(__tstate);
19187 if (PyErr_Occurred()) SWIG_fail;
19188 }
19189 {
19190 #if wxUSE_UNICODE
19191 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19192 #else
19193 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19194 #endif
19195 }
19196 {
19197 if (temp2)
19198 delete arg2;
19199 }
19200 return resultobj;
19201 fail:
19202 {
19203 if (temp2)
19204 delete arg2;
19205 }
19206 return NULL;
19207 }
19208
19209
19210 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19211 PyObject *resultobj = 0;
19212 wxImage *arg1 = (wxImage *) 0 ;
19213 wxString *arg2 = 0 ;
19214 int result;
19215 void *argp1 = 0 ;
19216 int res1 = 0 ;
19217 bool temp2 = false ;
19218 PyObject * obj0 = 0 ;
19219 PyObject * obj1 = 0 ;
19220 char * kwnames[] = {
19221 (char *) "self",(char *) "name", NULL
19222 };
19223
19224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
19225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19226 if (!SWIG_IsOK(res1)) {
19227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
19228 }
19229 arg1 = reinterpret_cast< wxImage * >(argp1);
19230 {
19231 arg2 = wxString_in_helper(obj1);
19232 if (arg2 == NULL) SWIG_fail;
19233 temp2 = true;
19234 }
19235 {
19236 PyThreadState* __tstate = wxPyBeginAllowThreads();
19237 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
19238 wxPyEndAllowThreads(__tstate);
19239 if (PyErr_Occurred()) SWIG_fail;
19240 }
19241 resultobj = SWIG_From_int(static_cast< int >(result));
19242 {
19243 if (temp2)
19244 delete arg2;
19245 }
19246 return resultobj;
19247 fail:
19248 {
19249 if (temp2)
19250 delete arg2;
19251 }
19252 return NULL;
19253 }
19254
19255
19256 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19257 PyObject *resultobj = 0;
19258 wxImage *arg1 = (wxImage *) 0 ;
19259 wxString *arg2 = 0 ;
19260 bool result;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 bool temp2 = false ;
19264 PyObject * obj0 = 0 ;
19265 PyObject * obj1 = 0 ;
19266 char * kwnames[] = {
19267 (char *) "self",(char *) "name", NULL
19268 };
19269
19270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
19271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19272 if (!SWIG_IsOK(res1)) {
19273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
19274 }
19275 arg1 = reinterpret_cast< wxImage * >(argp1);
19276 {
19277 arg2 = wxString_in_helper(obj1);
19278 if (arg2 == NULL) SWIG_fail;
19279 temp2 = true;
19280 }
19281 {
19282 PyThreadState* __tstate = wxPyBeginAllowThreads();
19283 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
19284 wxPyEndAllowThreads(__tstate);
19285 if (PyErr_Occurred()) SWIG_fail;
19286 }
19287 {
19288 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19289 }
19290 {
19291 if (temp2)
19292 delete arg2;
19293 }
19294 return resultobj;
19295 fail:
19296 {
19297 if (temp2)
19298 delete arg2;
19299 }
19300 return NULL;
19301 }
19302
19303
19304 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19305 PyObject *resultobj = 0;
19306 wxImage *arg1 = (wxImage *) 0 ;
19307 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
19308 unsigned long result;
19309 void *argp1 = 0 ;
19310 int res1 = 0 ;
19311 unsigned long val2 ;
19312 int ecode2 = 0 ;
19313 PyObject * obj0 = 0 ;
19314 PyObject * obj1 = 0 ;
19315 char * kwnames[] = {
19316 (char *) "self",(char *) "stopafter", NULL
19317 };
19318
19319 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
19320 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19321 if (!SWIG_IsOK(res1)) {
19322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
19323 }
19324 arg1 = reinterpret_cast< wxImage * >(argp1);
19325 if (obj1) {
19326 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
19327 if (!SWIG_IsOK(ecode2)) {
19328 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
19329 }
19330 arg2 = static_cast< unsigned long >(val2);
19331 }
19332 {
19333 PyThreadState* __tstate = wxPyBeginAllowThreads();
19334 result = (unsigned long)(arg1)->CountColours(arg2);
19335 wxPyEndAllowThreads(__tstate);
19336 if (PyErr_Occurred()) SWIG_fail;
19337 }
19338 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19339 return resultobj;
19340 fail:
19341 return NULL;
19342 }
19343
19344
19345 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19346 PyObject *resultobj = 0;
19347 wxImage *arg1 = (wxImage *) 0 ;
19348 wxImageHistogram *arg2 = 0 ;
19349 unsigned long result;
19350 void *argp1 = 0 ;
19351 int res1 = 0 ;
19352 void *argp2 = 0 ;
19353 int res2 = 0 ;
19354 PyObject * obj0 = 0 ;
19355 PyObject * obj1 = 0 ;
19356 char * kwnames[] = {
19357 (char *) "self",(char *) "h", NULL
19358 };
19359
19360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
19361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19362 if (!SWIG_IsOK(res1)) {
19363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
19364 }
19365 arg1 = reinterpret_cast< wxImage * >(argp1);
19366 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
19367 if (!SWIG_IsOK(res2)) {
19368 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19369 }
19370 if (!argp2) {
19371 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
19372 }
19373 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
19374 {
19375 PyThreadState* __tstate = wxPyBeginAllowThreads();
19376 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
19377 wxPyEndAllowThreads(__tstate);
19378 if (PyErr_Occurred()) SWIG_fail;
19379 }
19380 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
19381 return resultobj;
19382 fail:
19383 return NULL;
19384 }
19385
19386
19387 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19388 PyObject *resultobj = 0;
19389 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19390 void *argp1 = 0 ;
19391 int res1 = 0 ;
19392 PyObject * obj0 = 0 ;
19393 char * kwnames[] = {
19394 (char *) "handler", NULL
19395 };
19396
19397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
19398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19399 if (!SWIG_IsOK(res1)) {
19400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19401 }
19402 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19403 {
19404 PyThreadState* __tstate = wxPyBeginAllowThreads();
19405 wxImage::AddHandler(arg1);
19406 wxPyEndAllowThreads(__tstate);
19407 if (PyErr_Occurred()) SWIG_fail;
19408 }
19409 resultobj = SWIG_Py_Void();
19410 return resultobj;
19411 fail:
19412 return NULL;
19413 }
19414
19415
19416 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19417 PyObject *resultobj = 0;
19418 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
19419 void *argp1 = 0 ;
19420 int res1 = 0 ;
19421 PyObject * obj0 = 0 ;
19422 char * kwnames[] = {
19423 (char *) "handler", NULL
19424 };
19425
19426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
19427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
19428 if (!SWIG_IsOK(res1)) {
19429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
19430 }
19431 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
19432 {
19433 PyThreadState* __tstate = wxPyBeginAllowThreads();
19434 wxImage::InsertHandler(arg1);
19435 wxPyEndAllowThreads(__tstate);
19436 if (PyErr_Occurred()) SWIG_fail;
19437 }
19438 resultobj = SWIG_Py_Void();
19439 return resultobj;
19440 fail:
19441 return NULL;
19442 }
19443
19444
19445 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19446 PyObject *resultobj = 0;
19447 wxString *arg1 = 0 ;
19448 bool result;
19449 bool temp1 = false ;
19450 PyObject * obj0 = 0 ;
19451 char * kwnames[] = {
19452 (char *) "name", NULL
19453 };
19454
19455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
19456 {
19457 arg1 = wxString_in_helper(obj0);
19458 if (arg1 == NULL) SWIG_fail;
19459 temp1 = true;
19460 }
19461 {
19462 PyThreadState* __tstate = wxPyBeginAllowThreads();
19463 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
19464 wxPyEndAllowThreads(__tstate);
19465 if (PyErr_Occurred()) SWIG_fail;
19466 }
19467 {
19468 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19469 }
19470 {
19471 if (temp1)
19472 delete arg1;
19473 }
19474 return resultobj;
19475 fail:
19476 {
19477 if (temp1)
19478 delete arg1;
19479 }
19480 return NULL;
19481 }
19482
19483
19484 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19485 PyObject *resultobj = 0;
19486 PyObject *result = 0 ;
19487
19488 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
19489 {
19490 PyThreadState* __tstate = wxPyBeginAllowThreads();
19491 result = (PyObject *)wxImage_GetHandlers();
19492 wxPyEndAllowThreads(__tstate);
19493 if (PyErr_Occurred()) SWIG_fail;
19494 }
19495 resultobj = result;
19496 return resultobj;
19497 fail:
19498 return NULL;
19499 }
19500
19501
19502 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19503 PyObject *resultobj = 0;
19504 wxString result;
19505
19506 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
19507 {
19508 PyThreadState* __tstate = wxPyBeginAllowThreads();
19509 result = wxImage::GetImageExtWildcard();
19510 wxPyEndAllowThreads(__tstate);
19511 if (PyErr_Occurred()) SWIG_fail;
19512 }
19513 {
19514 #if wxUSE_UNICODE
19515 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19516 #else
19517 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19518 #endif
19519 }
19520 return resultobj;
19521 fail:
19522 return NULL;
19523 }
19524
19525
19526 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19527 PyObject *resultobj = 0;
19528 wxImage *arg1 = (wxImage *) 0 ;
19529 int arg2 = (int) -1 ;
19530 wxBitmap result;
19531 void *argp1 = 0 ;
19532 int res1 = 0 ;
19533 int val2 ;
19534 int ecode2 = 0 ;
19535 PyObject * obj0 = 0 ;
19536 PyObject * obj1 = 0 ;
19537 char * kwnames[] = {
19538 (char *) "self",(char *) "depth", NULL
19539 };
19540
19541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
19542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19543 if (!SWIG_IsOK(res1)) {
19544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19545 }
19546 arg1 = reinterpret_cast< wxImage * >(argp1);
19547 if (obj1) {
19548 ecode2 = SWIG_AsVal_int(obj1, &val2);
19549 if (!SWIG_IsOK(ecode2)) {
19550 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
19551 }
19552 arg2 = static_cast< int >(val2);
19553 }
19554 {
19555 if (!wxPyCheckForApp()) SWIG_fail;
19556 PyThreadState* __tstate = wxPyBeginAllowThreads();
19557 result = wxImage_ConvertToBitmap(arg1,arg2);
19558 wxPyEndAllowThreads(__tstate);
19559 if (PyErr_Occurred()) SWIG_fail;
19560 }
19561 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19562 return resultobj;
19563 fail:
19564 return NULL;
19565 }
19566
19567
19568 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19569 PyObject *resultobj = 0;
19570 wxImage *arg1 = (wxImage *) 0 ;
19571 byte arg2 ;
19572 byte arg3 ;
19573 byte arg4 ;
19574 wxBitmap result;
19575 void *argp1 = 0 ;
19576 int res1 = 0 ;
19577 unsigned char val2 ;
19578 int ecode2 = 0 ;
19579 unsigned char val3 ;
19580 int ecode3 = 0 ;
19581 unsigned char val4 ;
19582 int ecode4 = 0 ;
19583 PyObject * obj0 = 0 ;
19584 PyObject * obj1 = 0 ;
19585 PyObject * obj2 = 0 ;
19586 PyObject * obj3 = 0 ;
19587 char * kwnames[] = {
19588 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
19589 };
19590
19591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19593 if (!SWIG_IsOK(res1)) {
19594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
19595 }
19596 arg1 = reinterpret_cast< wxImage * >(argp1);
19597 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
19598 if (!SWIG_IsOK(ecode2)) {
19599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
19600 }
19601 arg2 = static_cast< byte >(val2);
19602 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
19603 if (!SWIG_IsOK(ecode3)) {
19604 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
19605 }
19606 arg3 = static_cast< byte >(val3);
19607 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
19608 if (!SWIG_IsOK(ecode4)) {
19609 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
19610 }
19611 arg4 = static_cast< byte >(val4);
19612 {
19613 if (!wxPyCheckForApp()) SWIG_fail;
19614 PyThreadState* __tstate = wxPyBeginAllowThreads();
19615 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
19616 wxPyEndAllowThreads(__tstate);
19617 if (PyErr_Occurred()) SWIG_fail;
19618 }
19619 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
19620 return resultobj;
19621 fail:
19622 return NULL;
19623 }
19624
19625
19626 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19627 PyObject *resultobj = 0;
19628 wxImage *arg1 = (wxImage *) 0 ;
19629 double arg2 ;
19630 void *argp1 = 0 ;
19631 int res1 = 0 ;
19632 double val2 ;
19633 int ecode2 = 0 ;
19634 PyObject * obj0 = 0 ;
19635 PyObject * obj1 = 0 ;
19636 char * kwnames[] = {
19637 (char *) "self",(char *) "angle", NULL
19638 };
19639
19640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) SWIG_fail;
19641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
19642 if (!SWIG_IsOK(res1)) {
19643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
19644 }
19645 arg1 = reinterpret_cast< wxImage * >(argp1);
19646 ecode2 = SWIG_AsVal_double(obj1, &val2);
19647 if (!SWIG_IsOK(ecode2)) {
19648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
19649 }
19650 arg2 = static_cast< double >(val2);
19651 {
19652 PyThreadState* __tstate = wxPyBeginAllowThreads();
19653 (arg1)->RotateHue(arg2);
19654 wxPyEndAllowThreads(__tstate);
19655 if (PyErr_Occurred()) SWIG_fail;
19656 }
19657 resultobj = SWIG_Py_Void();
19658 return resultobj;
19659 fail:
19660 return NULL;
19661 }
19662
19663
19664 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19665 PyObject *resultobj = 0;
19666 wxImage_RGBValue arg1 ;
19667 wxImage_HSVValue result;
19668 void *argp1 ;
19669 int res1 = 0 ;
19670 PyObject * obj0 = 0 ;
19671 char * kwnames[] = {
19672 (char *) "rgb", NULL
19673 };
19674
19675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
19676 {
19677 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
19678 if (!SWIG_IsOK(res1)) {
19679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19680 }
19681 if (!argp1) {
19682 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
19683 } else {
19684 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
19685 arg1 = *temp;
19686 if (SWIG_IsNewObj(res1)) delete temp;
19687 }
19688 }
19689 {
19690 PyThreadState* __tstate = wxPyBeginAllowThreads();
19691 result = wxImage::RGBtoHSV(arg1);
19692 wxPyEndAllowThreads(__tstate);
19693 if (PyErr_Occurred()) SWIG_fail;
19694 }
19695 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
19696 return resultobj;
19697 fail:
19698 return NULL;
19699 }
19700
19701
19702 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19703 PyObject *resultobj = 0;
19704 wxImage_HSVValue arg1 ;
19705 wxImage_RGBValue result;
19706 void *argp1 ;
19707 int res1 = 0 ;
19708 PyObject * obj0 = 0 ;
19709 char * kwnames[] = {
19710 (char *) "hsv", NULL
19711 };
19712
19713 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
19714 {
19715 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
19716 if (!SWIG_IsOK(res1)) {
19717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19718 }
19719 if (!argp1) {
19720 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
19721 } else {
19722 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
19723 arg1 = *temp;
19724 if (SWIG_IsNewObj(res1)) delete temp;
19725 }
19726 }
19727 {
19728 PyThreadState* __tstate = wxPyBeginAllowThreads();
19729 result = wxImage::HSVtoRGB(arg1);
19730 wxPyEndAllowThreads(__tstate);
19731 if (PyErr_Occurred()) SWIG_fail;
19732 }
19733 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
19734 return resultobj;
19735 fail:
19736 return NULL;
19737 }
19738
19739
19740 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19741 PyObject *obj;
19742 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19743 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
19744 return SWIG_Py_Void();
19745 }
19746
19747 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19748 return SWIG_Python_InitShadowInstance(args);
19749 }
19750
19751 SWIGINTERN PyObject *_wrap__ImageFromBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19752 PyObject *resultobj = 0;
19753 int arg1 ;
19754 int arg2 ;
19755 buffer arg3 ;
19756 int arg4 ;
19757 buffer arg5 = (buffer) NULL ;
19758 int arg6 = (int) 0 ;
19759 wxImage *result = 0 ;
19760 int val1 ;
19761 int ecode1 = 0 ;
19762 int val2 ;
19763 int ecode2 = 0 ;
19764 Py_ssize_t temp3 ;
19765 Py_ssize_t temp5 ;
19766 PyObject * obj0 = 0 ;
19767 PyObject * obj1 = 0 ;
19768 PyObject * obj2 = 0 ;
19769 PyObject * obj3 = 0 ;
19770 char * kwnames[] = {
19771 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
19772 };
19773
19774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:_ImageFromBuffer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19775 ecode1 = SWIG_AsVal_int(obj0, &val1);
19776 if (!SWIG_IsOK(ecode1)) {
19777 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "_ImageFromBuffer" "', expected argument " "1"" of type '" "int""'");
19778 }
19779 arg1 = static_cast< int >(val1);
19780 ecode2 = SWIG_AsVal_int(obj1, &val2);
19781 if (!SWIG_IsOK(ecode2)) {
19782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "_ImageFromBuffer" "', expected argument " "2"" of type '" "int""'");
19783 }
19784 arg2 = static_cast< int >(val2);
19785 {
19786 if (PyObject_AsReadBuffer(obj2, (const void**)(&arg3), &temp3) == -1) SWIG_fail;
19787 arg4 = (int)temp3;
19788 }
19789 if (obj3) {
19790 {
19791 if (obj3 != Py_None) {
19792 if (PyObject_AsReadBuffer(obj3, (const void**)(&arg5), &temp5) == -1) SWIG_fail;
19793 arg6 = (int)temp5;
19794 }
19795 }
19796 }
19797 {
19798 PyThreadState* __tstate = wxPyBeginAllowThreads();
19799 result = (wxImage *)_ImageFromBuffer(arg1,arg2,arg3,arg4,arg5,arg6);
19800 wxPyEndAllowThreads(__tstate);
19801 if (PyErr_Occurred()) SWIG_fail;
19802 }
19803 {
19804 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
19805 }
19806 return resultobj;
19807 fail:
19808 return NULL;
19809 }
19810
19811
19812 SWIGINTERN int NullImage_set(PyObject *) {
19813 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
19814 return 1;
19815 }
19816
19817
19818 SWIGINTERN PyObject *NullImage_get(void) {
19819 PyObject *pyobj = 0;
19820
19821 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
19822 return pyobj;
19823 }
19824
19825
19826 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
19827 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
19828 return 1;
19829 }
19830
19831
19832 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
19833 PyObject *pyobj = 0;
19834
19835 {
19836 #if wxUSE_UNICODE
19837 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19838 #else
19839 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
19840 #endif
19841 }
19842 return pyobj;
19843 }
19844
19845
19846 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
19847 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
19848 return 1;
19849 }
19850
19851
19852 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
19853 PyObject *pyobj = 0;
19854
19855 {
19856 #if wxUSE_UNICODE
19857 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19858 #else
19859 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
19860 #endif
19861 }
19862 return pyobj;
19863 }
19864
19865
19866 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
19867 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
19868 return 1;
19869 }
19870
19871
19872 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
19873 PyObject *pyobj = 0;
19874
19875 {
19876 #if wxUSE_UNICODE
19877 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19878 #else
19879 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
19880 #endif
19881 }
19882 return pyobj;
19883 }
19884
19885
19886 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
19887 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
19888 return 1;
19889 }
19890
19891
19892 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
19893 PyObject *pyobj = 0;
19894
19895 {
19896 #if wxUSE_UNICODE
19897 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19898 #else
19899 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
19900 #endif
19901 }
19902 return pyobj;
19903 }
19904
19905
19906 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
19907 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
19908 return 1;
19909 }
19910
19911
19912 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
19913 PyObject *pyobj = 0;
19914
19915 {
19916 #if wxUSE_UNICODE
19917 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19918 #else
19919 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
19920 #endif
19921 }
19922 return pyobj;
19923 }
19924
19925
19926 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
19927 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
19928 return 1;
19929 }
19930
19931
19932 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
19933 PyObject *pyobj = 0;
19934
19935 {
19936 #if wxUSE_UNICODE
19937 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19938 #else
19939 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
19940 #endif
19941 }
19942 return pyobj;
19943 }
19944
19945
19946 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
19947 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
19948 return 1;
19949 }
19950
19951
19952 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
19953 PyObject *pyobj = 0;
19954
19955 {
19956 #if wxUSE_UNICODE
19957 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19958 #else
19959 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
19960 #endif
19961 }
19962 return pyobj;
19963 }
19964
19965
19966 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
19967 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
19968 return 1;
19969 }
19970
19971
19972 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
19973 PyObject *pyobj = 0;
19974
19975 {
19976 #if wxUSE_UNICODE
19977 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19978 #else
19979 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
19980 #endif
19981 }
19982 return pyobj;
19983 }
19984
19985
19986 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
19987 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
19988 return 1;
19989 }
19990
19991
19992 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
19993 PyObject *pyobj = 0;
19994
19995 {
19996 #if wxUSE_UNICODE
19997 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
19998 #else
19999 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
20000 #endif
20001 }
20002 return pyobj;
20003 }
20004
20005
20006 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
20007 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
20008 return 1;
20009 }
20010
20011
20012 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
20013 PyObject *pyobj = 0;
20014
20015 {
20016 #if wxUSE_UNICODE
20017 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20018 #else
20019 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
20020 #endif
20021 }
20022 return pyobj;
20023 }
20024
20025
20026 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
20027 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
20028 return 1;
20029 }
20030
20031
20032 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
20033 PyObject *pyobj = 0;
20034
20035 {
20036 #if wxUSE_UNICODE
20037 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20038 #else
20039 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
20040 #endif
20041 }
20042 return pyobj;
20043 }
20044
20045
20046 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
20047 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
20048 return 1;
20049 }
20050
20051
20052 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
20053 PyObject *pyobj = 0;
20054
20055 {
20056 #if wxUSE_UNICODE
20057 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20058 #else
20059 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
20060 #endif
20061 }
20062 return pyobj;
20063 }
20064
20065
20066 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
20067 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
20068 return 1;
20069 }
20070
20071
20072 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
20073 PyObject *pyobj = 0;
20074
20075 {
20076 #if wxUSE_UNICODE
20077 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20078 #else
20079 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
20080 #endif
20081 }
20082 return pyobj;
20083 }
20084
20085
20086 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
20087 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
20088 return 1;
20089 }
20090
20091
20092 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
20093 PyObject *pyobj = 0;
20094
20095 {
20096 #if wxUSE_UNICODE
20097 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20098 #else
20099 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
20100 #endif
20101 }
20102 return pyobj;
20103 }
20104
20105
20106 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
20107 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
20108 return 1;
20109 }
20110
20111
20112 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
20113 PyObject *pyobj = 0;
20114
20115 {
20116 #if wxUSE_UNICODE
20117 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20118 #else
20119 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
20120 #endif
20121 }
20122 return pyobj;
20123 }
20124
20125
20126 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20127 PyObject *resultobj = 0;
20128 wxBMPHandler *result = 0 ;
20129
20130 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = (wxBMPHandler *)new wxBMPHandler();
20134 wxPyEndAllowThreads(__tstate);
20135 if (PyErr_Occurred()) SWIG_fail;
20136 }
20137 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
20138 return resultobj;
20139 fail:
20140 return NULL;
20141 }
20142
20143
20144 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20145 PyObject *obj;
20146 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20147 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
20148 return SWIG_Py_Void();
20149 }
20150
20151 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20152 return SWIG_Python_InitShadowInstance(args);
20153 }
20154
20155 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20156 PyObject *resultobj = 0;
20157 wxICOHandler *result = 0 ;
20158
20159 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
20160 {
20161 PyThreadState* __tstate = wxPyBeginAllowThreads();
20162 result = (wxICOHandler *)new wxICOHandler();
20163 wxPyEndAllowThreads(__tstate);
20164 if (PyErr_Occurred()) SWIG_fail;
20165 }
20166 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
20167 return resultobj;
20168 fail:
20169 return NULL;
20170 }
20171
20172
20173 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20174 PyObject *obj;
20175 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20176 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
20177 return SWIG_Py_Void();
20178 }
20179
20180 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20181 return SWIG_Python_InitShadowInstance(args);
20182 }
20183
20184 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20185 PyObject *resultobj = 0;
20186 wxCURHandler *result = 0 ;
20187
20188 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (wxCURHandler *)new wxCURHandler();
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
20196 return resultobj;
20197 fail:
20198 return NULL;
20199 }
20200
20201
20202 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20203 PyObject *obj;
20204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20205 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
20206 return SWIG_Py_Void();
20207 }
20208
20209 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20210 return SWIG_Python_InitShadowInstance(args);
20211 }
20212
20213 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20214 PyObject *resultobj = 0;
20215 wxANIHandler *result = 0 ;
20216
20217 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
20218 {
20219 PyThreadState* __tstate = wxPyBeginAllowThreads();
20220 result = (wxANIHandler *)new wxANIHandler();
20221 wxPyEndAllowThreads(__tstate);
20222 if (PyErr_Occurred()) SWIG_fail;
20223 }
20224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
20225 return resultobj;
20226 fail:
20227 return NULL;
20228 }
20229
20230
20231 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20232 PyObject *obj;
20233 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20234 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
20235 return SWIG_Py_Void();
20236 }
20237
20238 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20239 return SWIG_Python_InitShadowInstance(args);
20240 }
20241
20242 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20243 PyObject *resultobj = 0;
20244 wxPNGHandler *result = 0 ;
20245
20246 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
20247 {
20248 PyThreadState* __tstate = wxPyBeginAllowThreads();
20249 result = (wxPNGHandler *)new wxPNGHandler();
20250 wxPyEndAllowThreads(__tstate);
20251 if (PyErr_Occurred()) SWIG_fail;
20252 }
20253 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
20254 return resultobj;
20255 fail:
20256 return NULL;
20257 }
20258
20259
20260 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20261 PyObject *obj;
20262 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20263 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
20264 return SWIG_Py_Void();
20265 }
20266
20267 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20268 return SWIG_Python_InitShadowInstance(args);
20269 }
20270
20271 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20272 PyObject *resultobj = 0;
20273 wxGIFHandler *result = 0 ;
20274
20275 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
20276 {
20277 PyThreadState* __tstate = wxPyBeginAllowThreads();
20278 result = (wxGIFHandler *)new wxGIFHandler();
20279 wxPyEndAllowThreads(__tstate);
20280 if (PyErr_Occurred()) SWIG_fail;
20281 }
20282 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
20283 return resultobj;
20284 fail:
20285 return NULL;
20286 }
20287
20288
20289 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20290 PyObject *obj;
20291 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20292 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
20293 return SWIG_Py_Void();
20294 }
20295
20296 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20297 return SWIG_Python_InitShadowInstance(args);
20298 }
20299
20300 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20301 PyObject *resultobj = 0;
20302 wxPCXHandler *result = 0 ;
20303
20304 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
20305 {
20306 PyThreadState* __tstate = wxPyBeginAllowThreads();
20307 result = (wxPCXHandler *)new wxPCXHandler();
20308 wxPyEndAllowThreads(__tstate);
20309 if (PyErr_Occurred()) SWIG_fail;
20310 }
20311 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
20312 return resultobj;
20313 fail:
20314 return NULL;
20315 }
20316
20317
20318 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20319 PyObject *obj;
20320 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20321 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
20322 return SWIG_Py_Void();
20323 }
20324
20325 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20326 return SWIG_Python_InitShadowInstance(args);
20327 }
20328
20329 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20330 PyObject *resultobj = 0;
20331 wxJPEGHandler *result = 0 ;
20332
20333 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
20334 {
20335 PyThreadState* __tstate = wxPyBeginAllowThreads();
20336 result = (wxJPEGHandler *)new wxJPEGHandler();
20337 wxPyEndAllowThreads(__tstate);
20338 if (PyErr_Occurred()) SWIG_fail;
20339 }
20340 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
20341 return resultobj;
20342 fail:
20343 return NULL;
20344 }
20345
20346
20347 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20348 PyObject *obj;
20349 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20350 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
20351 return SWIG_Py_Void();
20352 }
20353
20354 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20355 return SWIG_Python_InitShadowInstance(args);
20356 }
20357
20358 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20359 PyObject *resultobj = 0;
20360 wxPNMHandler *result = 0 ;
20361
20362 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
20363 {
20364 PyThreadState* __tstate = wxPyBeginAllowThreads();
20365 result = (wxPNMHandler *)new wxPNMHandler();
20366 wxPyEndAllowThreads(__tstate);
20367 if (PyErr_Occurred()) SWIG_fail;
20368 }
20369 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
20370 return resultobj;
20371 fail:
20372 return NULL;
20373 }
20374
20375
20376 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20377 PyObject *obj;
20378 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20379 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
20380 return SWIG_Py_Void();
20381 }
20382
20383 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20384 return SWIG_Python_InitShadowInstance(args);
20385 }
20386
20387 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20388 PyObject *resultobj = 0;
20389 wxXPMHandler *result = 0 ;
20390
20391 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
20392 {
20393 PyThreadState* __tstate = wxPyBeginAllowThreads();
20394 result = (wxXPMHandler *)new wxXPMHandler();
20395 wxPyEndAllowThreads(__tstate);
20396 if (PyErr_Occurred()) SWIG_fail;
20397 }
20398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
20399 return resultobj;
20400 fail:
20401 return NULL;
20402 }
20403
20404
20405 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20406 PyObject *obj;
20407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20408 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
20409 return SWIG_Py_Void();
20410 }
20411
20412 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20413 return SWIG_Python_InitShadowInstance(args);
20414 }
20415
20416 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20417 PyObject *resultobj = 0;
20418 wxTIFFHandler *result = 0 ;
20419
20420 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
20421 {
20422 PyThreadState* __tstate = wxPyBeginAllowThreads();
20423 result = (wxTIFFHandler *)new wxTIFFHandler();
20424 wxPyEndAllowThreads(__tstate);
20425 if (PyErr_Occurred()) SWIG_fail;
20426 }
20427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
20428 return resultobj;
20429 fail:
20430 return NULL;
20431 }
20432
20433
20434 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20435 PyObject *obj;
20436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20437 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
20438 return SWIG_Py_Void();
20439 }
20440
20441 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20442 return SWIG_Python_InitShadowInstance(args);
20443 }
20444
20445 SWIGINTERN PyObject *_wrap_new_TGAHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20446 PyObject *resultobj = 0;
20447 wxTGAHandler *result = 0 ;
20448
20449 if (!SWIG_Python_UnpackTuple(args,"new_TGAHandler",0,0,0)) SWIG_fail;
20450 {
20451 PyThreadState* __tstate = wxPyBeginAllowThreads();
20452 result = (wxTGAHandler *)new wxTGAHandler();
20453 wxPyEndAllowThreads(__tstate);
20454 if (PyErr_Occurred()) SWIG_fail;
20455 }
20456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTGAHandler, SWIG_POINTER_NEW | 0 );
20457 return resultobj;
20458 fail:
20459 return NULL;
20460 }
20461
20462
20463 SWIGINTERN PyObject *TGAHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20464 PyObject *obj;
20465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20466 SWIG_TypeNewClientData(SWIGTYPE_p_wxTGAHandler, SWIG_NewClientData(obj));
20467 return SWIG_Py_Void();
20468 }
20469
20470 SWIGINTERN PyObject *TGAHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20471 return SWIG_Python_InitShadowInstance(args);
20472 }
20473
20474 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20475 PyObject *resultobj = 0;
20476 wxImage *arg1 = 0 ;
20477 wxImage *arg2 = 0 ;
20478 int arg3 = (int) 236 ;
20479 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
20480 bool result;
20481 void *argp1 = 0 ;
20482 int res1 = 0 ;
20483 void *argp2 = 0 ;
20484 int res2 = 0 ;
20485 int val3 ;
20486 int ecode3 = 0 ;
20487 int val4 ;
20488 int ecode4 = 0 ;
20489 PyObject * obj0 = 0 ;
20490 PyObject * obj1 = 0 ;
20491 PyObject * obj2 = 0 ;
20492 PyObject * obj3 = 0 ;
20493 char * kwnames[] = {
20494 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
20495 };
20496
20497 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20498 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
20499 if (!SWIG_IsOK(res1)) {
20500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20501 }
20502 if (!argp1) {
20503 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
20504 }
20505 arg1 = reinterpret_cast< wxImage * >(argp1);
20506 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
20507 if (!SWIG_IsOK(res2)) {
20508 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20509 }
20510 if (!argp2) {
20511 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
20512 }
20513 arg2 = reinterpret_cast< wxImage * >(argp2);
20514 if (obj2) {
20515 ecode3 = SWIG_AsVal_int(obj2, &val3);
20516 if (!SWIG_IsOK(ecode3)) {
20517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
20518 }
20519 arg3 = static_cast< int >(val3);
20520 }
20521 if (obj3) {
20522 ecode4 = SWIG_AsVal_int(obj3, &val4);
20523 if (!SWIG_IsOK(ecode4)) {
20524 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
20525 }
20526 arg4 = static_cast< int >(val4);
20527 }
20528 {
20529 PyThreadState* __tstate = wxPyBeginAllowThreads();
20530 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
20531 wxPyEndAllowThreads(__tstate);
20532 if (PyErr_Occurred()) SWIG_fail;
20533 }
20534 {
20535 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20536 }
20537 return resultobj;
20538 fail:
20539 return NULL;
20540 }
20541
20542
20543 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20544 PyObject *obj;
20545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
20546 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
20547 return SWIG_Py_Void();
20548 }
20549
20550 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20551 PyObject *resultobj = 0;
20552 wxEvtHandler *result = 0 ;
20553
20554 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
20555 {
20556 PyThreadState* __tstate = wxPyBeginAllowThreads();
20557 result = (wxEvtHandler *)new wxEvtHandler();
20558 wxPyEndAllowThreads(__tstate);
20559 if (PyErr_Occurred()) SWIG_fail;
20560 }
20561 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
20562 return resultobj;
20563 fail:
20564 return NULL;
20565 }
20566
20567
20568 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20569 PyObject *resultobj = 0;
20570 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20571 wxEvtHandler *result = 0 ;
20572 void *argp1 = 0 ;
20573 int res1 = 0 ;
20574 PyObject *swig_obj[1] ;
20575
20576 if (!args) SWIG_fail;
20577 swig_obj[0] = args;
20578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20579 if (!SWIG_IsOK(res1)) {
20580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20581 }
20582 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20583 {
20584 PyThreadState* __tstate = wxPyBeginAllowThreads();
20585 result = (wxEvtHandler *)(arg1)->GetNextHandler();
20586 wxPyEndAllowThreads(__tstate);
20587 if (PyErr_Occurred()) SWIG_fail;
20588 }
20589 {
20590 resultobj = wxPyMake_wxObject(result, 0);
20591 }
20592 return resultobj;
20593 fail:
20594 return NULL;
20595 }
20596
20597
20598 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20599 PyObject *resultobj = 0;
20600 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20601 wxEvtHandler *result = 0 ;
20602 void *argp1 = 0 ;
20603 int res1 = 0 ;
20604 PyObject *swig_obj[1] ;
20605
20606 if (!args) SWIG_fail;
20607 swig_obj[0] = args;
20608 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20609 if (!SWIG_IsOK(res1)) {
20610 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20611 }
20612 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20613 {
20614 PyThreadState* __tstate = wxPyBeginAllowThreads();
20615 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
20616 wxPyEndAllowThreads(__tstate);
20617 if (PyErr_Occurred()) SWIG_fail;
20618 }
20619 {
20620 resultobj = wxPyMake_wxObject(result, 0);
20621 }
20622 return resultobj;
20623 fail:
20624 return NULL;
20625 }
20626
20627
20628 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20629 PyObject *resultobj = 0;
20630 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20631 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20632 void *argp1 = 0 ;
20633 int res1 = 0 ;
20634 void *argp2 = 0 ;
20635 int res2 = 0 ;
20636 PyObject * obj0 = 0 ;
20637 PyObject * obj1 = 0 ;
20638 char * kwnames[] = {
20639 (char *) "self",(char *) "handler", NULL
20640 };
20641
20642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20643 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20644 if (!SWIG_IsOK(res1)) {
20645 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20646 }
20647 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20648 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20649 if (!SWIG_IsOK(res2)) {
20650 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20651 }
20652 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20653 {
20654 PyThreadState* __tstate = wxPyBeginAllowThreads();
20655 (arg1)->SetNextHandler(arg2);
20656 wxPyEndAllowThreads(__tstate);
20657 if (PyErr_Occurred()) SWIG_fail;
20658 }
20659 resultobj = SWIG_Py_Void();
20660 return resultobj;
20661 fail:
20662 return NULL;
20663 }
20664
20665
20666 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20667 PyObject *resultobj = 0;
20668 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20669 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
20670 void *argp1 = 0 ;
20671 int res1 = 0 ;
20672 void *argp2 = 0 ;
20673 int res2 = 0 ;
20674 PyObject * obj0 = 0 ;
20675 PyObject * obj1 = 0 ;
20676 char * kwnames[] = {
20677 (char *) "self",(char *) "handler", NULL
20678 };
20679
20680 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
20681 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20682 if (!SWIG_IsOK(res1)) {
20683 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20684 }
20685 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20686 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20687 if (!SWIG_IsOK(res2)) {
20688 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
20689 }
20690 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
20691 {
20692 PyThreadState* __tstate = wxPyBeginAllowThreads();
20693 (arg1)->SetPreviousHandler(arg2);
20694 wxPyEndAllowThreads(__tstate);
20695 if (PyErr_Occurred()) SWIG_fail;
20696 }
20697 resultobj = SWIG_Py_Void();
20698 return resultobj;
20699 fail:
20700 return NULL;
20701 }
20702
20703
20704 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20705 PyObject *resultobj = 0;
20706 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20707 bool result;
20708 void *argp1 = 0 ;
20709 int res1 = 0 ;
20710 PyObject *swig_obj[1] ;
20711
20712 if (!args) SWIG_fail;
20713 swig_obj[0] = args;
20714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20715 if (!SWIG_IsOK(res1)) {
20716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20717 }
20718 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20719 {
20720 PyThreadState* __tstate = wxPyBeginAllowThreads();
20721 result = (bool)(arg1)->GetEvtHandlerEnabled();
20722 wxPyEndAllowThreads(__tstate);
20723 if (PyErr_Occurred()) SWIG_fail;
20724 }
20725 {
20726 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20727 }
20728 return resultobj;
20729 fail:
20730 return NULL;
20731 }
20732
20733
20734 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20735 PyObject *resultobj = 0;
20736 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20737 bool arg2 ;
20738 void *argp1 = 0 ;
20739 int res1 = 0 ;
20740 bool val2 ;
20741 int ecode2 = 0 ;
20742 PyObject * obj0 = 0 ;
20743 PyObject * obj1 = 0 ;
20744 char * kwnames[] = {
20745 (char *) "self",(char *) "enabled", NULL
20746 };
20747
20748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
20749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20750 if (!SWIG_IsOK(res1)) {
20751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20752 }
20753 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
20755 if (!SWIG_IsOK(ecode2)) {
20756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
20757 }
20758 arg2 = static_cast< bool >(val2);
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 (arg1)->SetEvtHandlerEnabled(arg2);
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 resultobj = SWIG_Py_Void();
20766 return resultobj;
20767 fail:
20768 return NULL;
20769 }
20770
20771
20772 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20773 PyObject *resultobj = 0;
20774 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20775 wxEvent *arg2 = 0 ;
20776 bool result;
20777 void *argp1 = 0 ;
20778 int res1 = 0 ;
20779 void *argp2 = 0 ;
20780 int res2 = 0 ;
20781 PyObject * obj0 = 0 ;
20782 PyObject * obj1 = 0 ;
20783 char * kwnames[] = {
20784 (char *) "self",(char *) "event", NULL
20785 };
20786
20787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20789 if (!SWIG_IsOK(res1)) {
20790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20791 }
20792 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20793 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20794 if (!SWIG_IsOK(res2)) {
20795 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20796 }
20797 if (!argp2) {
20798 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20799 }
20800 arg2 = reinterpret_cast< wxEvent * >(argp2);
20801 {
20802 PyThreadState* __tstate = wxPyBeginAllowThreads();
20803 result = (bool)(arg1)->ProcessEvent(*arg2);
20804 wxPyEndAllowThreads(__tstate);
20805 if (PyErr_Occurred()) SWIG_fail;
20806 }
20807 {
20808 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20809 }
20810 return resultobj;
20811 fail:
20812 return NULL;
20813 }
20814
20815
20816 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20817 PyObject *resultobj = 0;
20818 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20819 wxEvent *arg2 = 0 ;
20820 void *argp1 = 0 ;
20821 int res1 = 0 ;
20822 void *argp2 = 0 ;
20823 int res2 = 0 ;
20824 PyObject * obj0 = 0 ;
20825 PyObject * obj1 = 0 ;
20826 char * kwnames[] = {
20827 (char *) "self",(char *) "event", NULL
20828 };
20829
20830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
20831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20832 if (!SWIG_IsOK(res1)) {
20833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20834 }
20835 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20836 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
20837 if (!SWIG_IsOK(res2)) {
20838 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20839 }
20840 if (!argp2) {
20841 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
20842 }
20843 arg2 = reinterpret_cast< wxEvent * >(argp2);
20844 {
20845 PyThreadState* __tstate = wxPyBeginAllowThreads();
20846 (arg1)->AddPendingEvent(*arg2);
20847 wxPyEndAllowThreads(__tstate);
20848 if (PyErr_Occurred()) SWIG_fail;
20849 }
20850 resultobj = SWIG_Py_Void();
20851 return resultobj;
20852 fail:
20853 return NULL;
20854 }
20855
20856
20857 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20858 PyObject *resultobj = 0;
20859 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20860 void *argp1 = 0 ;
20861 int res1 = 0 ;
20862 PyObject *swig_obj[1] ;
20863
20864 if (!args) SWIG_fail;
20865 swig_obj[0] = args;
20866 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20867 if (!SWIG_IsOK(res1)) {
20868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20869 }
20870 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20871 {
20872 PyThreadState* __tstate = wxPyBeginAllowThreads();
20873 (arg1)->ProcessPendingEvents();
20874 wxPyEndAllowThreads(__tstate);
20875 if (PyErr_Occurred()) SWIG_fail;
20876 }
20877 resultobj = SWIG_Py_Void();
20878 return resultobj;
20879 fail:
20880 return NULL;
20881 }
20882
20883
20884 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20885 PyObject *resultobj = 0;
20886 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20887 int arg2 ;
20888 int arg3 ;
20889 int arg4 ;
20890 PyObject *arg5 = (PyObject *) 0 ;
20891 void *argp1 = 0 ;
20892 int res1 = 0 ;
20893 int val2 ;
20894 int ecode2 = 0 ;
20895 int val3 ;
20896 int ecode3 = 0 ;
20897 int val4 ;
20898 int ecode4 = 0 ;
20899 PyObject * obj0 = 0 ;
20900 PyObject * obj1 = 0 ;
20901 PyObject * obj2 = 0 ;
20902 PyObject * obj3 = 0 ;
20903 PyObject * obj4 = 0 ;
20904 char * kwnames[] = {
20905 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
20906 };
20907
20908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
20909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20910 if (!SWIG_IsOK(res1)) {
20911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20912 }
20913 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20914 ecode2 = SWIG_AsVal_int(obj1, &val2);
20915 if (!SWIG_IsOK(ecode2)) {
20916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
20917 }
20918 arg2 = static_cast< int >(val2);
20919 ecode3 = SWIG_AsVal_int(obj2, &val3);
20920 if (!SWIG_IsOK(ecode3)) {
20921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
20922 }
20923 arg3 = static_cast< int >(val3);
20924 ecode4 = SWIG_AsVal_int(obj3, &val4);
20925 if (!SWIG_IsOK(ecode4)) {
20926 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
20927 }
20928 arg4 = static_cast< int >(val4);
20929 arg5 = obj4;
20930 {
20931 PyThreadState* __tstate = wxPyBeginAllowThreads();
20932 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
20933 wxPyEndAllowThreads(__tstate);
20934 if (PyErr_Occurred()) SWIG_fail;
20935 }
20936 resultobj = SWIG_Py_Void();
20937 return resultobj;
20938 fail:
20939 return NULL;
20940 }
20941
20942
20943 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20944 PyObject *resultobj = 0;
20945 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
20946 int arg2 ;
20947 int arg3 = (int) -1 ;
20948 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
20949 bool result;
20950 void *argp1 = 0 ;
20951 int res1 = 0 ;
20952 int val2 ;
20953 int ecode2 = 0 ;
20954 int val3 ;
20955 int ecode3 = 0 ;
20956 int val4 ;
20957 int ecode4 = 0 ;
20958 PyObject * obj0 = 0 ;
20959 PyObject * obj1 = 0 ;
20960 PyObject * obj2 = 0 ;
20961 PyObject * obj3 = 0 ;
20962 char * kwnames[] = {
20963 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
20964 };
20965
20966 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
20967 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
20968 if (!SWIG_IsOK(res1)) {
20969 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
20970 }
20971 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
20972 ecode2 = SWIG_AsVal_int(obj1, &val2);
20973 if (!SWIG_IsOK(ecode2)) {
20974 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
20975 }
20976 arg2 = static_cast< int >(val2);
20977 if (obj2) {
20978 ecode3 = SWIG_AsVal_int(obj2, &val3);
20979 if (!SWIG_IsOK(ecode3)) {
20980 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
20981 }
20982 arg3 = static_cast< int >(val3);
20983 }
20984 if (obj3) {
20985 ecode4 = SWIG_AsVal_int(obj3, &val4);
20986 if (!SWIG_IsOK(ecode4)) {
20987 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
20988 }
20989 arg4 = static_cast< wxEventType >(val4);
20990 }
20991 {
20992 PyThreadState* __tstate = wxPyBeginAllowThreads();
20993 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
20994 wxPyEndAllowThreads(__tstate);
20995 if (PyErr_Occurred()) SWIG_fail;
20996 }
20997 {
20998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20999 }
21000 return resultobj;
21001 fail:
21002 return NULL;
21003 }
21004
21005
21006 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21007 PyObject *resultobj = 0;
21008 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
21009 PyObject *arg2 = (PyObject *) 0 ;
21010 bool arg3 = (bool) true ;
21011 void *argp1 = 0 ;
21012 int res1 = 0 ;
21013 bool val3 ;
21014 int ecode3 = 0 ;
21015 PyObject * obj0 = 0 ;
21016 PyObject * obj1 = 0 ;
21017 PyObject * obj2 = 0 ;
21018 char * kwnames[] = {
21019 (char *) "self",(char *) "_self",(char *) "incref", NULL
21020 };
21021
21022 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
21023 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
21024 if (!SWIG_IsOK(res1)) {
21025 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
21026 }
21027 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
21028 arg2 = obj1;
21029 if (obj2) {
21030 ecode3 = SWIG_AsVal_bool(obj2, &val3);
21031 if (!SWIG_IsOK(ecode3)) {
21032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
21033 }
21034 arg3 = static_cast< bool >(val3);
21035 }
21036 {
21037 PyThreadState* __tstate = wxPyBeginAllowThreads();
21038 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
21039 wxPyEndAllowThreads(__tstate);
21040 if (PyErr_Occurred()) SWIG_fail;
21041 }
21042 resultobj = SWIG_Py_Void();
21043 return resultobj;
21044 fail:
21045 return NULL;
21046 }
21047
21048
21049 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21050 PyObject *obj;
21051 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21052 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
21053 return SWIG_Py_Void();
21054 }
21055
21056 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21057 return SWIG_Python_InitShadowInstance(args);
21058 }
21059
21060 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21061 PyObject *resultobj = 0;
21062 wxEventType result;
21063
21064 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
21065 {
21066 PyThreadState* __tstate = wxPyBeginAllowThreads();
21067 result = (wxEventType)wxNewEventType();
21068 wxPyEndAllowThreads(__tstate);
21069 if (PyErr_Occurred()) SWIG_fail;
21070 }
21071 resultobj = SWIG_From_int(static_cast< int >(result));
21072 return resultobj;
21073 fail:
21074 return NULL;
21075 }
21076
21077
21078 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21079 PyObject *resultobj = 0;
21080 wxEvent *arg1 = (wxEvent *) 0 ;
21081 void *argp1 = 0 ;
21082 int res1 = 0 ;
21083 PyObject *swig_obj[1] ;
21084
21085 if (!args) SWIG_fail;
21086 swig_obj[0] = args;
21087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
21088 if (!SWIG_IsOK(res1)) {
21089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
21090 }
21091 arg1 = reinterpret_cast< wxEvent * >(argp1);
21092 {
21093 PyThreadState* __tstate = wxPyBeginAllowThreads();
21094 delete arg1;
21095
21096 wxPyEndAllowThreads(__tstate);
21097 if (PyErr_Occurred()) SWIG_fail;
21098 }
21099 resultobj = SWIG_Py_Void();
21100 return resultobj;
21101 fail:
21102 return NULL;
21103 }
21104
21105
21106 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21107 PyObject *resultobj = 0;
21108 wxEvent *arg1 = (wxEvent *) 0 ;
21109 wxEventType arg2 ;
21110 void *argp1 = 0 ;
21111 int res1 = 0 ;
21112 int val2 ;
21113 int ecode2 = 0 ;
21114 PyObject * obj0 = 0 ;
21115 PyObject * obj1 = 0 ;
21116 char * kwnames[] = {
21117 (char *) "self",(char *) "typ", NULL
21118 };
21119
21120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
21121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21122 if (!SWIG_IsOK(res1)) {
21123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
21124 }
21125 arg1 = reinterpret_cast< wxEvent * >(argp1);
21126 ecode2 = SWIG_AsVal_int(obj1, &val2);
21127 if (!SWIG_IsOK(ecode2)) {
21128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
21129 }
21130 arg2 = static_cast< wxEventType >(val2);
21131 {
21132 PyThreadState* __tstate = wxPyBeginAllowThreads();
21133 (arg1)->SetEventType(arg2);
21134 wxPyEndAllowThreads(__tstate);
21135 if (PyErr_Occurred()) SWIG_fail;
21136 }
21137 resultobj = SWIG_Py_Void();
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21145 PyObject *resultobj = 0;
21146 wxEvent *arg1 = (wxEvent *) 0 ;
21147 wxEventType result;
21148 void *argp1 = 0 ;
21149 int res1 = 0 ;
21150 PyObject *swig_obj[1] ;
21151
21152 if (!args) SWIG_fail;
21153 swig_obj[0] = args;
21154 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21155 if (!SWIG_IsOK(res1)) {
21156 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
21157 }
21158 arg1 = reinterpret_cast< wxEvent * >(argp1);
21159 {
21160 PyThreadState* __tstate = wxPyBeginAllowThreads();
21161 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
21162 wxPyEndAllowThreads(__tstate);
21163 if (PyErr_Occurred()) SWIG_fail;
21164 }
21165 resultobj = SWIG_From_int(static_cast< int >(result));
21166 return resultobj;
21167 fail:
21168 return NULL;
21169 }
21170
21171
21172 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21173 PyObject *resultobj = 0;
21174 wxEvent *arg1 = (wxEvent *) 0 ;
21175 wxObject *result = 0 ;
21176 void *argp1 = 0 ;
21177 int res1 = 0 ;
21178 PyObject *swig_obj[1] ;
21179
21180 if (!args) SWIG_fail;
21181 swig_obj[0] = args;
21182 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21183 if (!SWIG_IsOK(res1)) {
21184 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
21185 }
21186 arg1 = reinterpret_cast< wxEvent * >(argp1);
21187 {
21188 PyThreadState* __tstate = wxPyBeginAllowThreads();
21189 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
21190 wxPyEndAllowThreads(__tstate);
21191 if (PyErr_Occurred()) SWIG_fail;
21192 }
21193 {
21194 resultobj = wxPyMake_wxObject(result, (bool)0);
21195 }
21196 return resultobj;
21197 fail:
21198 return NULL;
21199 }
21200
21201
21202 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21203 PyObject *resultobj = 0;
21204 wxEvent *arg1 = (wxEvent *) 0 ;
21205 wxObject *arg2 = (wxObject *) 0 ;
21206 void *argp1 = 0 ;
21207 int res1 = 0 ;
21208 void *argp2 = 0 ;
21209 int res2 = 0 ;
21210 PyObject * obj0 = 0 ;
21211 PyObject * obj1 = 0 ;
21212 char * kwnames[] = {
21213 (char *) "self",(char *) "obj", NULL
21214 };
21215
21216 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
21217 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21218 if (!SWIG_IsOK(res1)) {
21219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
21220 }
21221 arg1 = reinterpret_cast< wxEvent * >(argp1);
21222 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
21223 if (!SWIG_IsOK(res2)) {
21224 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
21225 }
21226 arg2 = reinterpret_cast< wxObject * >(argp2);
21227 {
21228 PyThreadState* __tstate = wxPyBeginAllowThreads();
21229 (arg1)->SetEventObject(arg2);
21230 wxPyEndAllowThreads(__tstate);
21231 if (PyErr_Occurred()) SWIG_fail;
21232 }
21233 resultobj = SWIG_Py_Void();
21234 return resultobj;
21235 fail:
21236 return NULL;
21237 }
21238
21239
21240 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21241 PyObject *resultobj = 0;
21242 wxEvent *arg1 = (wxEvent *) 0 ;
21243 long result;
21244 void *argp1 = 0 ;
21245 int res1 = 0 ;
21246 PyObject *swig_obj[1] ;
21247
21248 if (!args) SWIG_fail;
21249 swig_obj[0] = args;
21250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21251 if (!SWIG_IsOK(res1)) {
21252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
21253 }
21254 arg1 = reinterpret_cast< wxEvent * >(argp1);
21255 {
21256 PyThreadState* __tstate = wxPyBeginAllowThreads();
21257 result = (long)((wxEvent const *)arg1)->GetTimestamp();
21258 wxPyEndAllowThreads(__tstate);
21259 if (PyErr_Occurred()) SWIG_fail;
21260 }
21261 resultobj = SWIG_From_long(static_cast< long >(result));
21262 return resultobj;
21263 fail:
21264 return NULL;
21265 }
21266
21267
21268 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21269 PyObject *resultobj = 0;
21270 wxEvent *arg1 = (wxEvent *) 0 ;
21271 long arg2 = (long) 0 ;
21272 void *argp1 = 0 ;
21273 int res1 = 0 ;
21274 long val2 ;
21275 int ecode2 = 0 ;
21276 PyObject * obj0 = 0 ;
21277 PyObject * obj1 = 0 ;
21278 char * kwnames[] = {
21279 (char *) "self",(char *) "ts", NULL
21280 };
21281
21282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
21283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21284 if (!SWIG_IsOK(res1)) {
21285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
21286 }
21287 arg1 = reinterpret_cast< wxEvent * >(argp1);
21288 if (obj1) {
21289 ecode2 = SWIG_AsVal_long(obj1, &val2);
21290 if (!SWIG_IsOK(ecode2)) {
21291 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
21292 }
21293 arg2 = static_cast< long >(val2);
21294 }
21295 {
21296 PyThreadState* __tstate = wxPyBeginAllowThreads();
21297 (arg1)->SetTimestamp(arg2);
21298 wxPyEndAllowThreads(__tstate);
21299 if (PyErr_Occurred()) SWIG_fail;
21300 }
21301 resultobj = SWIG_Py_Void();
21302 return resultobj;
21303 fail:
21304 return NULL;
21305 }
21306
21307
21308 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21309 PyObject *resultobj = 0;
21310 wxEvent *arg1 = (wxEvent *) 0 ;
21311 int result;
21312 void *argp1 = 0 ;
21313 int res1 = 0 ;
21314 PyObject *swig_obj[1] ;
21315
21316 if (!args) SWIG_fail;
21317 swig_obj[0] = args;
21318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21319 if (!SWIG_IsOK(res1)) {
21320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
21321 }
21322 arg1 = reinterpret_cast< wxEvent * >(argp1);
21323 {
21324 PyThreadState* __tstate = wxPyBeginAllowThreads();
21325 result = (int)((wxEvent const *)arg1)->GetId();
21326 wxPyEndAllowThreads(__tstate);
21327 if (PyErr_Occurred()) SWIG_fail;
21328 }
21329 resultobj = SWIG_From_int(static_cast< int >(result));
21330 return resultobj;
21331 fail:
21332 return NULL;
21333 }
21334
21335
21336 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21337 PyObject *resultobj = 0;
21338 wxEvent *arg1 = (wxEvent *) 0 ;
21339 int arg2 ;
21340 void *argp1 = 0 ;
21341 int res1 = 0 ;
21342 int val2 ;
21343 int ecode2 = 0 ;
21344 PyObject * obj0 = 0 ;
21345 PyObject * obj1 = 0 ;
21346 char * kwnames[] = {
21347 (char *) "self",(char *) "Id", NULL
21348 };
21349
21350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
21351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21352 if (!SWIG_IsOK(res1)) {
21353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
21354 }
21355 arg1 = reinterpret_cast< wxEvent * >(argp1);
21356 ecode2 = SWIG_AsVal_int(obj1, &val2);
21357 if (!SWIG_IsOK(ecode2)) {
21358 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
21359 }
21360 arg2 = static_cast< int >(val2);
21361 {
21362 PyThreadState* __tstate = wxPyBeginAllowThreads();
21363 (arg1)->SetId(arg2);
21364 wxPyEndAllowThreads(__tstate);
21365 if (PyErr_Occurred()) SWIG_fail;
21366 }
21367 resultobj = SWIG_Py_Void();
21368 return resultobj;
21369 fail:
21370 return NULL;
21371 }
21372
21373
21374 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21375 PyObject *resultobj = 0;
21376 wxEvent *arg1 = (wxEvent *) 0 ;
21377 bool result;
21378 void *argp1 = 0 ;
21379 int res1 = 0 ;
21380 PyObject *swig_obj[1] ;
21381
21382 if (!args) SWIG_fail;
21383 swig_obj[0] = args;
21384 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21385 if (!SWIG_IsOK(res1)) {
21386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
21387 }
21388 arg1 = reinterpret_cast< wxEvent * >(argp1);
21389 {
21390 PyThreadState* __tstate = wxPyBeginAllowThreads();
21391 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
21392 wxPyEndAllowThreads(__tstate);
21393 if (PyErr_Occurred()) SWIG_fail;
21394 }
21395 {
21396 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21397 }
21398 return resultobj;
21399 fail:
21400 return NULL;
21401 }
21402
21403
21404 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21405 PyObject *resultobj = 0;
21406 wxEvent *arg1 = (wxEvent *) 0 ;
21407 bool arg2 = (bool) true ;
21408 void *argp1 = 0 ;
21409 int res1 = 0 ;
21410 bool val2 ;
21411 int ecode2 = 0 ;
21412 PyObject * obj0 = 0 ;
21413 PyObject * obj1 = 0 ;
21414 char * kwnames[] = {
21415 (char *) "self",(char *) "skip", NULL
21416 };
21417
21418 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
21419 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21420 if (!SWIG_IsOK(res1)) {
21421 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
21422 }
21423 arg1 = reinterpret_cast< wxEvent * >(argp1);
21424 if (obj1) {
21425 ecode2 = SWIG_AsVal_bool(obj1, &val2);
21426 if (!SWIG_IsOK(ecode2)) {
21427 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
21428 }
21429 arg2 = static_cast< bool >(val2);
21430 }
21431 {
21432 PyThreadState* __tstate = wxPyBeginAllowThreads();
21433 (arg1)->Skip(arg2);
21434 wxPyEndAllowThreads(__tstate);
21435 if (PyErr_Occurred()) SWIG_fail;
21436 }
21437 resultobj = SWIG_Py_Void();
21438 return resultobj;
21439 fail:
21440 return NULL;
21441 }
21442
21443
21444 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21445 PyObject *resultobj = 0;
21446 wxEvent *arg1 = (wxEvent *) 0 ;
21447 bool result;
21448 void *argp1 = 0 ;
21449 int res1 = 0 ;
21450 PyObject *swig_obj[1] ;
21451
21452 if (!args) SWIG_fail;
21453 swig_obj[0] = args;
21454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21455 if (!SWIG_IsOK(res1)) {
21456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
21457 }
21458 arg1 = reinterpret_cast< wxEvent * >(argp1);
21459 {
21460 PyThreadState* __tstate = wxPyBeginAllowThreads();
21461 result = (bool)((wxEvent const *)arg1)->GetSkipped();
21462 wxPyEndAllowThreads(__tstate);
21463 if (PyErr_Occurred()) SWIG_fail;
21464 }
21465 {
21466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21467 }
21468 return resultobj;
21469 fail:
21470 return NULL;
21471 }
21472
21473
21474 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21475 PyObject *resultobj = 0;
21476 wxEvent *arg1 = (wxEvent *) 0 ;
21477 bool result;
21478 void *argp1 = 0 ;
21479 int res1 = 0 ;
21480 PyObject *swig_obj[1] ;
21481
21482 if (!args) SWIG_fail;
21483 swig_obj[0] = args;
21484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21485 if (!SWIG_IsOK(res1)) {
21486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
21487 }
21488 arg1 = reinterpret_cast< wxEvent * >(argp1);
21489 {
21490 PyThreadState* __tstate = wxPyBeginAllowThreads();
21491 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
21492 wxPyEndAllowThreads(__tstate);
21493 if (PyErr_Occurred()) SWIG_fail;
21494 }
21495 {
21496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21497 }
21498 return resultobj;
21499 fail:
21500 return NULL;
21501 }
21502
21503
21504 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21505 PyObject *resultobj = 0;
21506 wxEvent *arg1 = (wxEvent *) 0 ;
21507 int result;
21508 void *argp1 = 0 ;
21509 int res1 = 0 ;
21510 PyObject *swig_obj[1] ;
21511
21512 if (!args) SWIG_fail;
21513 swig_obj[0] = args;
21514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21515 if (!SWIG_IsOK(res1)) {
21516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21517 }
21518 arg1 = reinterpret_cast< wxEvent * >(argp1);
21519 {
21520 PyThreadState* __tstate = wxPyBeginAllowThreads();
21521 result = (int)(arg1)->StopPropagation();
21522 wxPyEndAllowThreads(__tstate);
21523 if (PyErr_Occurred()) SWIG_fail;
21524 }
21525 resultobj = SWIG_From_int(static_cast< int >(result));
21526 return resultobj;
21527 fail:
21528 return NULL;
21529 }
21530
21531
21532 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21533 PyObject *resultobj = 0;
21534 wxEvent *arg1 = (wxEvent *) 0 ;
21535 int arg2 ;
21536 void *argp1 = 0 ;
21537 int res1 = 0 ;
21538 int val2 ;
21539 int ecode2 = 0 ;
21540 PyObject * obj0 = 0 ;
21541 PyObject * obj1 = 0 ;
21542 char * kwnames[] = {
21543 (char *) "self",(char *) "propagationLevel", NULL
21544 };
21545
21546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
21547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21548 if (!SWIG_IsOK(res1)) {
21549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
21550 }
21551 arg1 = reinterpret_cast< wxEvent * >(argp1);
21552 ecode2 = SWIG_AsVal_int(obj1, &val2);
21553 if (!SWIG_IsOK(ecode2)) {
21554 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
21555 }
21556 arg2 = static_cast< int >(val2);
21557 {
21558 PyThreadState* __tstate = wxPyBeginAllowThreads();
21559 (arg1)->ResumePropagation(arg2);
21560 wxPyEndAllowThreads(__tstate);
21561 if (PyErr_Occurred()) SWIG_fail;
21562 }
21563 resultobj = SWIG_Py_Void();
21564 return resultobj;
21565 fail:
21566 return NULL;
21567 }
21568
21569
21570 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21571 PyObject *resultobj = 0;
21572 wxEvent *arg1 = (wxEvent *) 0 ;
21573 wxEvent *result = 0 ;
21574 void *argp1 = 0 ;
21575 int res1 = 0 ;
21576 PyObject *swig_obj[1] ;
21577
21578 if (!args) SWIG_fail;
21579 swig_obj[0] = args;
21580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
21581 if (!SWIG_IsOK(res1)) {
21582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
21583 }
21584 arg1 = reinterpret_cast< wxEvent * >(argp1);
21585 {
21586 PyThreadState* __tstate = wxPyBeginAllowThreads();
21587 result = (wxEvent *)(arg1)->Clone();
21588 wxPyEndAllowThreads(__tstate);
21589 if (PyErr_Occurred()) SWIG_fail;
21590 }
21591 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
21592 return resultobj;
21593 fail:
21594 return NULL;
21595 }
21596
21597
21598 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21599 PyObject *obj;
21600 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21601 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
21602 return SWIG_Py_Void();
21603 }
21604
21605 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21606 PyObject *resultobj = 0;
21607 wxEvent *arg1 = 0 ;
21608 wxPropagationDisabler *result = 0 ;
21609 void *argp1 = 0 ;
21610 int res1 = 0 ;
21611 PyObject * obj0 = 0 ;
21612 char * kwnames[] = {
21613 (char *) "event", NULL
21614 };
21615
21616 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
21617 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21618 if (!SWIG_IsOK(res1)) {
21619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21620 }
21621 if (!argp1) {
21622 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
21623 }
21624 arg1 = reinterpret_cast< wxEvent * >(argp1);
21625 {
21626 PyThreadState* __tstate = wxPyBeginAllowThreads();
21627 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
21628 wxPyEndAllowThreads(__tstate);
21629 if (PyErr_Occurred()) SWIG_fail;
21630 }
21631 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
21632 return resultobj;
21633 fail:
21634 return NULL;
21635 }
21636
21637
21638 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21639 PyObject *resultobj = 0;
21640 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
21641 void *argp1 = 0 ;
21642 int res1 = 0 ;
21643 PyObject *swig_obj[1] ;
21644
21645 if (!args) SWIG_fail;
21646 swig_obj[0] = args;
21647 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
21648 if (!SWIG_IsOK(res1)) {
21649 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
21650 }
21651 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
21652 {
21653 PyThreadState* __tstate = wxPyBeginAllowThreads();
21654 delete arg1;
21655
21656 wxPyEndAllowThreads(__tstate);
21657 if (PyErr_Occurred()) SWIG_fail;
21658 }
21659 resultobj = SWIG_Py_Void();
21660 return resultobj;
21661 fail:
21662 return NULL;
21663 }
21664
21665
21666 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21667 PyObject *obj;
21668 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21669 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
21670 return SWIG_Py_Void();
21671 }
21672
21673 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21674 return SWIG_Python_InitShadowInstance(args);
21675 }
21676
21677 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21678 PyObject *resultobj = 0;
21679 wxEvent *arg1 = 0 ;
21680 wxPropagateOnce *result = 0 ;
21681 void *argp1 = 0 ;
21682 int res1 = 0 ;
21683 PyObject * obj0 = 0 ;
21684 char * kwnames[] = {
21685 (char *) "event", NULL
21686 };
21687
21688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
21689 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
21690 if (!SWIG_IsOK(res1)) {
21691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21692 }
21693 if (!argp1) {
21694 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
21695 }
21696 arg1 = reinterpret_cast< wxEvent * >(argp1);
21697 {
21698 PyThreadState* __tstate = wxPyBeginAllowThreads();
21699 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
21700 wxPyEndAllowThreads(__tstate);
21701 if (PyErr_Occurred()) SWIG_fail;
21702 }
21703 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
21704 return resultobj;
21705 fail:
21706 return NULL;
21707 }
21708
21709
21710 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21711 PyObject *resultobj = 0;
21712 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
21713 void *argp1 = 0 ;
21714 int res1 = 0 ;
21715 PyObject *swig_obj[1] ;
21716
21717 if (!args) SWIG_fail;
21718 swig_obj[0] = args;
21719 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
21720 if (!SWIG_IsOK(res1)) {
21721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
21722 }
21723 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
21724 {
21725 PyThreadState* __tstate = wxPyBeginAllowThreads();
21726 delete arg1;
21727
21728 wxPyEndAllowThreads(__tstate);
21729 if (PyErr_Occurred()) SWIG_fail;
21730 }
21731 resultobj = SWIG_Py_Void();
21732 return resultobj;
21733 fail:
21734 return NULL;
21735 }
21736
21737
21738 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21739 PyObject *obj;
21740 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21741 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
21742 return SWIG_Py_Void();
21743 }
21744
21745 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21746 return SWIG_Python_InitShadowInstance(args);
21747 }
21748
21749 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21750 PyObject *resultobj = 0;
21751 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21752 int arg2 = (int) 0 ;
21753 wxCommandEvent *result = 0 ;
21754 int val1 ;
21755 int ecode1 = 0 ;
21756 int val2 ;
21757 int ecode2 = 0 ;
21758 PyObject * obj0 = 0 ;
21759 PyObject * obj1 = 0 ;
21760 char * kwnames[] = {
21761 (char *) "commandType",(char *) "winid", NULL
21762 };
21763
21764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21765 if (obj0) {
21766 ecode1 = SWIG_AsVal_int(obj0, &val1);
21767 if (!SWIG_IsOK(ecode1)) {
21768 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21769 }
21770 arg1 = static_cast< wxEventType >(val1);
21771 }
21772 if (obj1) {
21773 ecode2 = SWIG_AsVal_int(obj1, &val2);
21774 if (!SWIG_IsOK(ecode2)) {
21775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
21776 }
21777 arg2 = static_cast< int >(val2);
21778 }
21779 {
21780 PyThreadState* __tstate = wxPyBeginAllowThreads();
21781 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
21782 wxPyEndAllowThreads(__tstate);
21783 if (PyErr_Occurred()) SWIG_fail;
21784 }
21785 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
21786 return resultobj;
21787 fail:
21788 return NULL;
21789 }
21790
21791
21792 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21793 PyObject *resultobj = 0;
21794 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21795 int result;
21796 void *argp1 = 0 ;
21797 int res1 = 0 ;
21798 PyObject *swig_obj[1] ;
21799
21800 if (!args) SWIG_fail;
21801 swig_obj[0] = args;
21802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21803 if (!SWIG_IsOK(res1)) {
21804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21805 }
21806 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21807 {
21808 PyThreadState* __tstate = wxPyBeginAllowThreads();
21809 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
21810 wxPyEndAllowThreads(__tstate);
21811 if (PyErr_Occurred()) SWIG_fail;
21812 }
21813 resultobj = SWIG_From_int(static_cast< int >(result));
21814 return resultobj;
21815 fail:
21816 return NULL;
21817 }
21818
21819
21820 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21821 PyObject *resultobj = 0;
21822 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21823 wxString *arg2 = 0 ;
21824 void *argp1 = 0 ;
21825 int res1 = 0 ;
21826 bool temp2 = false ;
21827 PyObject * obj0 = 0 ;
21828 PyObject * obj1 = 0 ;
21829 char * kwnames[] = {
21830 (char *) "self",(char *) "s", NULL
21831 };
21832
21833 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
21834 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21835 if (!SWIG_IsOK(res1)) {
21836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21837 }
21838 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21839 {
21840 arg2 = wxString_in_helper(obj1);
21841 if (arg2 == NULL) SWIG_fail;
21842 temp2 = true;
21843 }
21844 {
21845 PyThreadState* __tstate = wxPyBeginAllowThreads();
21846 (arg1)->SetString((wxString const &)*arg2);
21847 wxPyEndAllowThreads(__tstate);
21848 if (PyErr_Occurred()) SWIG_fail;
21849 }
21850 resultobj = SWIG_Py_Void();
21851 {
21852 if (temp2)
21853 delete arg2;
21854 }
21855 return resultobj;
21856 fail:
21857 {
21858 if (temp2)
21859 delete arg2;
21860 }
21861 return NULL;
21862 }
21863
21864
21865 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21866 PyObject *resultobj = 0;
21867 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21868 wxString result;
21869 void *argp1 = 0 ;
21870 int res1 = 0 ;
21871 PyObject *swig_obj[1] ;
21872
21873 if (!args) SWIG_fail;
21874 swig_obj[0] = args;
21875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21876 if (!SWIG_IsOK(res1)) {
21877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21878 }
21879 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21880 {
21881 PyThreadState* __tstate = wxPyBeginAllowThreads();
21882 result = ((wxCommandEvent const *)arg1)->GetString();
21883 wxPyEndAllowThreads(__tstate);
21884 if (PyErr_Occurred()) SWIG_fail;
21885 }
21886 {
21887 #if wxUSE_UNICODE
21888 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
21889 #else
21890 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
21891 #endif
21892 }
21893 return resultobj;
21894 fail:
21895 return NULL;
21896 }
21897
21898
21899 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21900 PyObject *resultobj = 0;
21901 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21902 bool result;
21903 void *argp1 = 0 ;
21904 int res1 = 0 ;
21905 PyObject *swig_obj[1] ;
21906
21907 if (!args) SWIG_fail;
21908 swig_obj[0] = args;
21909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21910 if (!SWIG_IsOK(res1)) {
21911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21912 }
21913 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21914 {
21915 PyThreadState* __tstate = wxPyBeginAllowThreads();
21916 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
21917 wxPyEndAllowThreads(__tstate);
21918 if (PyErr_Occurred()) SWIG_fail;
21919 }
21920 {
21921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21922 }
21923 return resultobj;
21924 fail:
21925 return NULL;
21926 }
21927
21928
21929 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21930 PyObject *resultobj = 0;
21931 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21932 bool result;
21933 void *argp1 = 0 ;
21934 int res1 = 0 ;
21935 PyObject *swig_obj[1] ;
21936
21937 if (!args) SWIG_fail;
21938 swig_obj[0] = args;
21939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21940 if (!SWIG_IsOK(res1)) {
21941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
21942 }
21943 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21944 {
21945 PyThreadState* __tstate = wxPyBeginAllowThreads();
21946 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
21947 wxPyEndAllowThreads(__tstate);
21948 if (PyErr_Occurred()) SWIG_fail;
21949 }
21950 {
21951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21952 }
21953 return resultobj;
21954 fail:
21955 return NULL;
21956 }
21957
21958
21959 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21960 PyObject *resultobj = 0;
21961 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
21962 long arg2 ;
21963 void *argp1 = 0 ;
21964 int res1 = 0 ;
21965 long val2 ;
21966 int ecode2 = 0 ;
21967 PyObject * obj0 = 0 ;
21968 PyObject * obj1 = 0 ;
21969 char * kwnames[] = {
21970 (char *) "self",(char *) "extraLong", NULL
21971 };
21972
21973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
21974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
21975 if (!SWIG_IsOK(res1)) {
21976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
21977 }
21978 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
21979 ecode2 = SWIG_AsVal_long(obj1, &val2);
21980 if (!SWIG_IsOK(ecode2)) {
21981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
21982 }
21983 arg2 = static_cast< long >(val2);
21984 {
21985 PyThreadState* __tstate = wxPyBeginAllowThreads();
21986 (arg1)->SetExtraLong(arg2);
21987 wxPyEndAllowThreads(__tstate);
21988 if (PyErr_Occurred()) SWIG_fail;
21989 }
21990 resultobj = SWIG_Py_Void();
21991 return resultobj;
21992 fail:
21993 return NULL;
21994 }
21995
21996
21997 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21998 PyObject *resultobj = 0;
21999 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22000 long result;
22001 void *argp1 = 0 ;
22002 int res1 = 0 ;
22003 PyObject *swig_obj[1] ;
22004
22005 if (!args) SWIG_fail;
22006 swig_obj[0] = args;
22007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22008 if (!SWIG_IsOK(res1)) {
22009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22010 }
22011 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22012 {
22013 PyThreadState* __tstate = wxPyBeginAllowThreads();
22014 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
22015 wxPyEndAllowThreads(__tstate);
22016 if (PyErr_Occurred()) SWIG_fail;
22017 }
22018 resultobj = SWIG_From_long(static_cast< long >(result));
22019 return resultobj;
22020 fail:
22021 return NULL;
22022 }
22023
22024
22025 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22026 PyObject *resultobj = 0;
22027 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22028 int arg2 ;
22029 void *argp1 = 0 ;
22030 int res1 = 0 ;
22031 int val2 ;
22032 int ecode2 = 0 ;
22033 PyObject * obj0 = 0 ;
22034 PyObject * obj1 = 0 ;
22035 char * kwnames[] = {
22036 (char *) "self",(char *) "i", NULL
22037 };
22038
22039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
22040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22041 if (!SWIG_IsOK(res1)) {
22042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22043 }
22044 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22045 ecode2 = SWIG_AsVal_int(obj1, &val2);
22046 if (!SWIG_IsOK(ecode2)) {
22047 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
22048 }
22049 arg2 = static_cast< int >(val2);
22050 {
22051 PyThreadState* __tstate = wxPyBeginAllowThreads();
22052 (arg1)->SetInt(arg2);
22053 wxPyEndAllowThreads(__tstate);
22054 if (PyErr_Occurred()) SWIG_fail;
22055 }
22056 resultobj = SWIG_Py_Void();
22057 return resultobj;
22058 fail:
22059 return NULL;
22060 }
22061
22062
22063 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22064 PyObject *resultobj = 0;
22065 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22066 int result;
22067 void *argp1 = 0 ;
22068 int res1 = 0 ;
22069 PyObject *swig_obj[1] ;
22070
22071 if (!args) SWIG_fail;
22072 swig_obj[0] = args;
22073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22074 if (!SWIG_IsOK(res1)) {
22075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22076 }
22077 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22078 {
22079 PyThreadState* __tstate = wxPyBeginAllowThreads();
22080 result = (int)((wxCommandEvent const *)arg1)->GetInt();
22081 wxPyEndAllowThreads(__tstate);
22082 if (PyErr_Occurred()) SWIG_fail;
22083 }
22084 resultobj = SWIG_From_int(static_cast< int >(result));
22085 return resultobj;
22086 fail:
22087 return NULL;
22088 }
22089
22090
22091 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22092 PyObject *resultobj = 0;
22093 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22094 PyObject *result = 0 ;
22095 void *argp1 = 0 ;
22096 int res1 = 0 ;
22097 PyObject *swig_obj[1] ;
22098
22099 if (!args) SWIG_fail;
22100 swig_obj[0] = args;
22101 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22102 if (!SWIG_IsOK(res1)) {
22103 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22104 }
22105 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22106 {
22107 PyThreadState* __tstate = wxPyBeginAllowThreads();
22108 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
22109 wxPyEndAllowThreads(__tstate);
22110 if (PyErr_Occurred()) SWIG_fail;
22111 }
22112 resultobj = result;
22113 return resultobj;
22114 fail:
22115 return NULL;
22116 }
22117
22118
22119 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22120 PyObject *resultobj = 0;
22121 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22122 PyObject *arg2 = (PyObject *) 0 ;
22123 void *argp1 = 0 ;
22124 int res1 = 0 ;
22125 PyObject * obj0 = 0 ;
22126 PyObject * obj1 = 0 ;
22127 char * kwnames[] = {
22128 (char *) "self",(char *) "clientData", NULL
22129 };
22130
22131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
22132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22133 if (!SWIG_IsOK(res1)) {
22134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
22135 }
22136 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22137 arg2 = obj1;
22138 {
22139 PyThreadState* __tstate = wxPyBeginAllowThreads();
22140 wxCommandEvent_SetClientData(arg1,arg2);
22141 wxPyEndAllowThreads(__tstate);
22142 if (PyErr_Occurred()) SWIG_fail;
22143 }
22144 resultobj = SWIG_Py_Void();
22145 return resultobj;
22146 fail:
22147 return NULL;
22148 }
22149
22150
22151 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22152 PyObject *resultobj = 0;
22153 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
22154 wxEvent *result = 0 ;
22155 void *argp1 = 0 ;
22156 int res1 = 0 ;
22157 PyObject *swig_obj[1] ;
22158
22159 if (!args) SWIG_fail;
22160 swig_obj[0] = args;
22161 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
22162 if (!SWIG_IsOK(res1)) {
22163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
22164 }
22165 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
22166 {
22167 PyThreadState* __tstate = wxPyBeginAllowThreads();
22168 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
22169 wxPyEndAllowThreads(__tstate);
22170 if (PyErr_Occurred()) SWIG_fail;
22171 }
22172 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
22173 return resultobj;
22174 fail:
22175 return NULL;
22176 }
22177
22178
22179 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22180 PyObject *obj;
22181 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22182 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
22183 return SWIG_Py_Void();
22184 }
22185
22186 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22187 return SWIG_Python_InitShadowInstance(args);
22188 }
22189
22190 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22191 PyObject *resultobj = 0;
22192 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22193 int arg2 = (int) 0 ;
22194 wxNotifyEvent *result = 0 ;
22195 int val1 ;
22196 int ecode1 = 0 ;
22197 int val2 ;
22198 int ecode2 = 0 ;
22199 PyObject * obj0 = 0 ;
22200 PyObject * obj1 = 0 ;
22201 char * kwnames[] = {
22202 (char *) "commandType",(char *) "winid", NULL
22203 };
22204
22205 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
22206 if (obj0) {
22207 ecode1 = SWIG_AsVal_int(obj0, &val1);
22208 if (!SWIG_IsOK(ecode1)) {
22209 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22210 }
22211 arg1 = static_cast< wxEventType >(val1);
22212 }
22213 if (obj1) {
22214 ecode2 = SWIG_AsVal_int(obj1, &val2);
22215 if (!SWIG_IsOK(ecode2)) {
22216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
22217 }
22218 arg2 = static_cast< int >(val2);
22219 }
22220 {
22221 PyThreadState* __tstate = wxPyBeginAllowThreads();
22222 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
22223 wxPyEndAllowThreads(__tstate);
22224 if (PyErr_Occurred()) SWIG_fail;
22225 }
22226 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
22227 return resultobj;
22228 fail:
22229 return NULL;
22230 }
22231
22232
22233 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22234 PyObject *resultobj = 0;
22235 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22236 void *argp1 = 0 ;
22237 int res1 = 0 ;
22238 PyObject *swig_obj[1] ;
22239
22240 if (!args) SWIG_fail;
22241 swig_obj[0] = args;
22242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22243 if (!SWIG_IsOK(res1)) {
22244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22245 }
22246 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22247 {
22248 PyThreadState* __tstate = wxPyBeginAllowThreads();
22249 (arg1)->Veto();
22250 wxPyEndAllowThreads(__tstate);
22251 if (PyErr_Occurred()) SWIG_fail;
22252 }
22253 resultobj = SWIG_Py_Void();
22254 return resultobj;
22255 fail:
22256 return NULL;
22257 }
22258
22259
22260 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22261 PyObject *resultobj = 0;
22262 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22263 void *argp1 = 0 ;
22264 int res1 = 0 ;
22265 PyObject *swig_obj[1] ;
22266
22267 if (!args) SWIG_fail;
22268 swig_obj[0] = args;
22269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22270 if (!SWIG_IsOK(res1)) {
22271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22272 }
22273 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22274 {
22275 PyThreadState* __tstate = wxPyBeginAllowThreads();
22276 (arg1)->Allow();
22277 wxPyEndAllowThreads(__tstate);
22278 if (PyErr_Occurred()) SWIG_fail;
22279 }
22280 resultobj = SWIG_Py_Void();
22281 return resultobj;
22282 fail:
22283 return NULL;
22284 }
22285
22286
22287 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22288 PyObject *resultobj = 0;
22289 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
22290 bool result;
22291 void *argp1 = 0 ;
22292 int res1 = 0 ;
22293 PyObject *swig_obj[1] ;
22294
22295 if (!args) SWIG_fail;
22296 swig_obj[0] = args;
22297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
22298 if (!SWIG_IsOK(res1)) {
22299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
22300 }
22301 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
22302 {
22303 PyThreadState* __tstate = wxPyBeginAllowThreads();
22304 result = (bool)(arg1)->IsAllowed();
22305 wxPyEndAllowThreads(__tstate);
22306 if (PyErr_Occurred()) SWIG_fail;
22307 }
22308 {
22309 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22310 }
22311 return resultobj;
22312 fail:
22313 return NULL;
22314 }
22315
22316
22317 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22318 PyObject *obj;
22319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22320 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
22321 return SWIG_Py_Void();
22322 }
22323
22324 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22325 return SWIG_Python_InitShadowInstance(args);
22326 }
22327
22328 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22329 PyObject *resultobj = 0;
22330 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22331 int arg2 = (int) 0 ;
22332 int arg3 = (int) 0 ;
22333 int arg4 = (int) 0 ;
22334 wxScrollEvent *result = 0 ;
22335 int val1 ;
22336 int ecode1 = 0 ;
22337 int val2 ;
22338 int ecode2 = 0 ;
22339 int val3 ;
22340 int ecode3 = 0 ;
22341 int val4 ;
22342 int ecode4 = 0 ;
22343 PyObject * obj0 = 0 ;
22344 PyObject * obj1 = 0 ;
22345 PyObject * obj2 = 0 ;
22346 PyObject * obj3 = 0 ;
22347 char * kwnames[] = {
22348 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
22349 };
22350
22351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
22352 if (obj0) {
22353 ecode1 = SWIG_AsVal_int(obj0, &val1);
22354 if (!SWIG_IsOK(ecode1)) {
22355 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22356 }
22357 arg1 = static_cast< wxEventType >(val1);
22358 }
22359 if (obj1) {
22360 ecode2 = SWIG_AsVal_int(obj1, &val2);
22361 if (!SWIG_IsOK(ecode2)) {
22362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
22363 }
22364 arg2 = static_cast< int >(val2);
22365 }
22366 if (obj2) {
22367 ecode3 = SWIG_AsVal_int(obj2, &val3);
22368 if (!SWIG_IsOK(ecode3)) {
22369 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
22370 }
22371 arg3 = static_cast< int >(val3);
22372 }
22373 if (obj3) {
22374 ecode4 = SWIG_AsVal_int(obj3, &val4);
22375 if (!SWIG_IsOK(ecode4)) {
22376 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
22377 }
22378 arg4 = static_cast< int >(val4);
22379 }
22380 {
22381 PyThreadState* __tstate = wxPyBeginAllowThreads();
22382 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
22383 wxPyEndAllowThreads(__tstate);
22384 if (PyErr_Occurred()) SWIG_fail;
22385 }
22386 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
22387 return resultobj;
22388 fail:
22389 return NULL;
22390 }
22391
22392
22393 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22394 PyObject *resultobj = 0;
22395 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22396 int result;
22397 void *argp1 = 0 ;
22398 int res1 = 0 ;
22399 PyObject *swig_obj[1] ;
22400
22401 if (!args) SWIG_fail;
22402 swig_obj[0] = args;
22403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22404 if (!SWIG_IsOK(res1)) {
22405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22406 }
22407 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22408 {
22409 PyThreadState* __tstate = wxPyBeginAllowThreads();
22410 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
22411 wxPyEndAllowThreads(__tstate);
22412 if (PyErr_Occurred()) SWIG_fail;
22413 }
22414 resultobj = SWIG_From_int(static_cast< int >(result));
22415 return resultobj;
22416 fail:
22417 return NULL;
22418 }
22419
22420
22421 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22422 PyObject *resultobj = 0;
22423 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22424 int result;
22425 void *argp1 = 0 ;
22426 int res1 = 0 ;
22427 PyObject *swig_obj[1] ;
22428
22429 if (!args) SWIG_fail;
22430 swig_obj[0] = args;
22431 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22432 if (!SWIG_IsOK(res1)) {
22433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
22434 }
22435 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22436 {
22437 PyThreadState* __tstate = wxPyBeginAllowThreads();
22438 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
22439 wxPyEndAllowThreads(__tstate);
22440 if (PyErr_Occurred()) SWIG_fail;
22441 }
22442 resultobj = SWIG_From_int(static_cast< int >(result));
22443 return resultobj;
22444 fail:
22445 return NULL;
22446 }
22447
22448
22449 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22450 PyObject *resultobj = 0;
22451 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22452 int arg2 ;
22453 void *argp1 = 0 ;
22454 int res1 = 0 ;
22455 int val2 ;
22456 int ecode2 = 0 ;
22457 PyObject * obj0 = 0 ;
22458 PyObject * obj1 = 0 ;
22459 char * kwnames[] = {
22460 (char *) "self",(char *) "orient", NULL
22461 };
22462
22463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22465 if (!SWIG_IsOK(res1)) {
22466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22467 }
22468 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22469 ecode2 = SWIG_AsVal_int(obj1, &val2);
22470 if (!SWIG_IsOK(ecode2)) {
22471 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22472 }
22473 arg2 = static_cast< int >(val2);
22474 {
22475 PyThreadState* __tstate = wxPyBeginAllowThreads();
22476 (arg1)->SetOrientation(arg2);
22477 wxPyEndAllowThreads(__tstate);
22478 if (PyErr_Occurred()) SWIG_fail;
22479 }
22480 resultobj = SWIG_Py_Void();
22481 return resultobj;
22482 fail:
22483 return NULL;
22484 }
22485
22486
22487 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22488 PyObject *resultobj = 0;
22489 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
22490 int arg2 ;
22491 void *argp1 = 0 ;
22492 int res1 = 0 ;
22493 int val2 ;
22494 int ecode2 = 0 ;
22495 PyObject * obj0 = 0 ;
22496 PyObject * obj1 = 0 ;
22497 char * kwnames[] = {
22498 (char *) "self",(char *) "pos", NULL
22499 };
22500
22501 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22502 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
22503 if (!SWIG_IsOK(res1)) {
22504 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
22505 }
22506 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
22507 ecode2 = SWIG_AsVal_int(obj1, &val2);
22508 if (!SWIG_IsOK(ecode2)) {
22509 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22510 }
22511 arg2 = static_cast< int >(val2);
22512 {
22513 PyThreadState* __tstate = wxPyBeginAllowThreads();
22514 (arg1)->SetPosition(arg2);
22515 wxPyEndAllowThreads(__tstate);
22516 if (PyErr_Occurred()) SWIG_fail;
22517 }
22518 resultobj = SWIG_Py_Void();
22519 return resultobj;
22520 fail:
22521 return NULL;
22522 }
22523
22524
22525 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22526 PyObject *obj;
22527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22528 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
22529 return SWIG_Py_Void();
22530 }
22531
22532 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22533 return SWIG_Python_InitShadowInstance(args);
22534 }
22535
22536 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22537 PyObject *resultobj = 0;
22538 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22539 int arg2 = (int) 0 ;
22540 int arg3 = (int) 0 ;
22541 wxScrollWinEvent *result = 0 ;
22542 int val1 ;
22543 int ecode1 = 0 ;
22544 int val2 ;
22545 int ecode2 = 0 ;
22546 int val3 ;
22547 int ecode3 = 0 ;
22548 PyObject * obj0 = 0 ;
22549 PyObject * obj1 = 0 ;
22550 PyObject * obj2 = 0 ;
22551 char * kwnames[] = {
22552 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
22553 };
22554
22555 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
22556 if (obj0) {
22557 ecode1 = SWIG_AsVal_int(obj0, &val1);
22558 if (!SWIG_IsOK(ecode1)) {
22559 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22560 }
22561 arg1 = static_cast< wxEventType >(val1);
22562 }
22563 if (obj1) {
22564 ecode2 = SWIG_AsVal_int(obj1, &val2);
22565 if (!SWIG_IsOK(ecode2)) {
22566 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
22567 }
22568 arg2 = static_cast< int >(val2);
22569 }
22570 if (obj2) {
22571 ecode3 = SWIG_AsVal_int(obj2, &val3);
22572 if (!SWIG_IsOK(ecode3)) {
22573 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
22574 }
22575 arg3 = static_cast< int >(val3);
22576 }
22577 {
22578 PyThreadState* __tstate = wxPyBeginAllowThreads();
22579 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
22580 wxPyEndAllowThreads(__tstate);
22581 if (PyErr_Occurred()) SWIG_fail;
22582 }
22583 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
22584 return resultobj;
22585 fail:
22586 return NULL;
22587 }
22588
22589
22590 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22591 PyObject *resultobj = 0;
22592 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22593 int result;
22594 void *argp1 = 0 ;
22595 int res1 = 0 ;
22596 PyObject *swig_obj[1] ;
22597
22598 if (!args) SWIG_fail;
22599 swig_obj[0] = args;
22600 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22601 if (!SWIG_IsOK(res1)) {
22602 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22603 }
22604 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22605 {
22606 PyThreadState* __tstate = wxPyBeginAllowThreads();
22607 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
22608 wxPyEndAllowThreads(__tstate);
22609 if (PyErr_Occurred()) SWIG_fail;
22610 }
22611 resultobj = SWIG_From_int(static_cast< int >(result));
22612 return resultobj;
22613 fail:
22614 return NULL;
22615 }
22616
22617
22618 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22619 PyObject *resultobj = 0;
22620 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22621 int result;
22622 void *argp1 = 0 ;
22623 int res1 = 0 ;
22624 PyObject *swig_obj[1] ;
22625
22626 if (!args) SWIG_fail;
22627 swig_obj[0] = args;
22628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22629 if (!SWIG_IsOK(res1)) {
22630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
22631 }
22632 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22633 {
22634 PyThreadState* __tstate = wxPyBeginAllowThreads();
22635 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
22636 wxPyEndAllowThreads(__tstate);
22637 if (PyErr_Occurred()) SWIG_fail;
22638 }
22639 resultobj = SWIG_From_int(static_cast< int >(result));
22640 return resultobj;
22641 fail:
22642 return NULL;
22643 }
22644
22645
22646 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22647 PyObject *resultobj = 0;
22648 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22649 int arg2 ;
22650 void *argp1 = 0 ;
22651 int res1 = 0 ;
22652 int val2 ;
22653 int ecode2 = 0 ;
22654 PyObject * obj0 = 0 ;
22655 PyObject * obj1 = 0 ;
22656 char * kwnames[] = {
22657 (char *) "self",(char *) "orient", NULL
22658 };
22659
22660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
22661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22662 if (!SWIG_IsOK(res1)) {
22663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22664 }
22665 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22666 ecode2 = SWIG_AsVal_int(obj1, &val2);
22667 if (!SWIG_IsOK(ecode2)) {
22668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
22669 }
22670 arg2 = static_cast< int >(val2);
22671 {
22672 PyThreadState* __tstate = wxPyBeginAllowThreads();
22673 (arg1)->SetOrientation(arg2);
22674 wxPyEndAllowThreads(__tstate);
22675 if (PyErr_Occurred()) SWIG_fail;
22676 }
22677 resultobj = SWIG_Py_Void();
22678 return resultobj;
22679 fail:
22680 return NULL;
22681 }
22682
22683
22684 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22685 PyObject *resultobj = 0;
22686 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
22687 int arg2 ;
22688 void *argp1 = 0 ;
22689 int res1 = 0 ;
22690 int val2 ;
22691 int ecode2 = 0 ;
22692 PyObject * obj0 = 0 ;
22693 PyObject * obj1 = 0 ;
22694 char * kwnames[] = {
22695 (char *) "self",(char *) "pos", NULL
22696 };
22697
22698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
22699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
22700 if (!SWIG_IsOK(res1)) {
22701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
22702 }
22703 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
22704 ecode2 = SWIG_AsVal_int(obj1, &val2);
22705 if (!SWIG_IsOK(ecode2)) {
22706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
22707 }
22708 arg2 = static_cast< int >(val2);
22709 {
22710 PyThreadState* __tstate = wxPyBeginAllowThreads();
22711 (arg1)->SetPosition(arg2);
22712 wxPyEndAllowThreads(__tstate);
22713 if (PyErr_Occurred()) SWIG_fail;
22714 }
22715 resultobj = SWIG_Py_Void();
22716 return resultobj;
22717 fail:
22718 return NULL;
22719 }
22720
22721
22722 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22723 PyObject *obj;
22724 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
22725 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
22726 return SWIG_Py_Void();
22727 }
22728
22729 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22730 return SWIG_Python_InitShadowInstance(args);
22731 }
22732
22733 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22734 PyObject *resultobj = 0;
22735 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
22736 wxMouseEvent *result = 0 ;
22737 int val1 ;
22738 int ecode1 = 0 ;
22739 PyObject * obj0 = 0 ;
22740 char * kwnames[] = {
22741 (char *) "mouseType", NULL
22742 };
22743
22744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
22745 if (obj0) {
22746 ecode1 = SWIG_AsVal_int(obj0, &val1);
22747 if (!SWIG_IsOK(ecode1)) {
22748 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
22749 }
22750 arg1 = static_cast< wxEventType >(val1);
22751 }
22752 {
22753 PyThreadState* __tstate = wxPyBeginAllowThreads();
22754 result = (wxMouseEvent *)new wxMouseEvent(arg1);
22755 wxPyEndAllowThreads(__tstate);
22756 if (PyErr_Occurred()) SWIG_fail;
22757 }
22758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseEvent, SWIG_POINTER_NEW | 0 );
22759 return resultobj;
22760 fail:
22761 return NULL;
22762 }
22763
22764
22765 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22766 PyObject *resultobj = 0;
22767 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22768 bool result;
22769 void *argp1 = 0 ;
22770 int res1 = 0 ;
22771 PyObject *swig_obj[1] ;
22772
22773 if (!args) SWIG_fail;
22774 swig_obj[0] = args;
22775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22776 if (!SWIG_IsOK(res1)) {
22777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22778 }
22779 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22780 {
22781 PyThreadState* __tstate = wxPyBeginAllowThreads();
22782 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
22783 wxPyEndAllowThreads(__tstate);
22784 if (PyErr_Occurred()) SWIG_fail;
22785 }
22786 {
22787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22788 }
22789 return resultobj;
22790 fail:
22791 return NULL;
22792 }
22793
22794
22795 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22796 PyObject *resultobj = 0;
22797 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22798 int arg2 = (int) wxMOUSE_BTN_ANY ;
22799 bool result;
22800 void *argp1 = 0 ;
22801 int res1 = 0 ;
22802 int val2 ;
22803 int ecode2 = 0 ;
22804 PyObject * obj0 = 0 ;
22805 PyObject * obj1 = 0 ;
22806 char * kwnames[] = {
22807 (char *) "self",(char *) "but", NULL
22808 };
22809
22810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
22811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22812 if (!SWIG_IsOK(res1)) {
22813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22814 }
22815 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22816 if (obj1) {
22817 ecode2 = SWIG_AsVal_int(obj1, &val2);
22818 if (!SWIG_IsOK(ecode2)) {
22819 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
22820 }
22821 arg2 = static_cast< int >(val2);
22822 }
22823 {
22824 PyThreadState* __tstate = wxPyBeginAllowThreads();
22825 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
22826 wxPyEndAllowThreads(__tstate);
22827 if (PyErr_Occurred()) SWIG_fail;
22828 }
22829 {
22830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22831 }
22832 return resultobj;
22833 fail:
22834 return NULL;
22835 }
22836
22837
22838 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22839 PyObject *resultobj = 0;
22840 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22841 int arg2 = (int) wxMOUSE_BTN_ANY ;
22842 bool result;
22843 void *argp1 = 0 ;
22844 int res1 = 0 ;
22845 int val2 ;
22846 int ecode2 = 0 ;
22847 PyObject * obj0 = 0 ;
22848 PyObject * obj1 = 0 ;
22849 char * kwnames[] = {
22850 (char *) "self",(char *) "but", NULL
22851 };
22852
22853 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
22854 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22855 if (!SWIG_IsOK(res1)) {
22856 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22857 }
22858 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22859 if (obj1) {
22860 ecode2 = SWIG_AsVal_int(obj1, &val2);
22861 if (!SWIG_IsOK(ecode2)) {
22862 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
22863 }
22864 arg2 = static_cast< int >(val2);
22865 }
22866 {
22867 PyThreadState* __tstate = wxPyBeginAllowThreads();
22868 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
22869 wxPyEndAllowThreads(__tstate);
22870 if (PyErr_Occurred()) SWIG_fail;
22871 }
22872 {
22873 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22874 }
22875 return resultobj;
22876 fail:
22877 return NULL;
22878 }
22879
22880
22881 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22882 PyObject *resultobj = 0;
22883 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22884 int arg2 = (int) wxMOUSE_BTN_ANY ;
22885 bool result;
22886 void *argp1 = 0 ;
22887 int res1 = 0 ;
22888 int val2 ;
22889 int ecode2 = 0 ;
22890 PyObject * obj0 = 0 ;
22891 PyObject * obj1 = 0 ;
22892 char * kwnames[] = {
22893 (char *) "self",(char *) "but", NULL
22894 };
22895
22896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
22897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22898 if (!SWIG_IsOK(res1)) {
22899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22900 }
22901 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22902 if (obj1) {
22903 ecode2 = SWIG_AsVal_int(obj1, &val2);
22904 if (!SWIG_IsOK(ecode2)) {
22905 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
22906 }
22907 arg2 = static_cast< int >(val2);
22908 }
22909 {
22910 PyThreadState* __tstate = wxPyBeginAllowThreads();
22911 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
22912 wxPyEndAllowThreads(__tstate);
22913 if (PyErr_Occurred()) SWIG_fail;
22914 }
22915 {
22916 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22917 }
22918 return resultobj;
22919 fail:
22920 return NULL;
22921 }
22922
22923
22924 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22925 PyObject *resultobj = 0;
22926 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22927 int arg2 ;
22928 bool result;
22929 void *argp1 = 0 ;
22930 int res1 = 0 ;
22931 int val2 ;
22932 int ecode2 = 0 ;
22933 PyObject * obj0 = 0 ;
22934 PyObject * obj1 = 0 ;
22935 char * kwnames[] = {
22936 (char *) "self",(char *) "button", NULL
22937 };
22938
22939 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
22940 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22941 if (!SWIG_IsOK(res1)) {
22942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22943 }
22944 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22945 ecode2 = SWIG_AsVal_int(obj1, &val2);
22946 if (!SWIG_IsOK(ecode2)) {
22947 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
22948 }
22949 arg2 = static_cast< int >(val2);
22950 {
22951 PyThreadState* __tstate = wxPyBeginAllowThreads();
22952 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
22953 wxPyEndAllowThreads(__tstate);
22954 if (PyErr_Occurred()) SWIG_fail;
22955 }
22956 {
22957 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22958 }
22959 return resultobj;
22960 fail:
22961 return NULL;
22962 }
22963
22964
22965 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22966 PyObject *resultobj = 0;
22967 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
22968 int arg2 ;
22969 bool result;
22970 void *argp1 = 0 ;
22971 int res1 = 0 ;
22972 int val2 ;
22973 int ecode2 = 0 ;
22974 PyObject * obj0 = 0 ;
22975 PyObject * obj1 = 0 ;
22976 char * kwnames[] = {
22977 (char *) "self",(char *) "but", NULL
22978 };
22979
22980 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
22981 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
22982 if (!SWIG_IsOK(res1)) {
22983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
22984 }
22985 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
22986 ecode2 = SWIG_AsVal_int(obj1, &val2);
22987 if (!SWIG_IsOK(ecode2)) {
22988 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
22989 }
22990 arg2 = static_cast< int >(val2);
22991 {
22992 PyThreadState* __tstate = wxPyBeginAllowThreads();
22993 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
22994 wxPyEndAllowThreads(__tstate);
22995 if (PyErr_Occurred()) SWIG_fail;
22996 }
22997 {
22998 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22999 }
23000 return resultobj;
23001 fail:
23002 return NULL;
23003 }
23004
23005
23006 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23007 PyObject *resultobj = 0;
23008 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23009 int result;
23010 void *argp1 = 0 ;
23011 int res1 = 0 ;
23012 PyObject *swig_obj[1] ;
23013
23014 if (!args) SWIG_fail;
23015 swig_obj[0] = args;
23016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23017 if (!SWIG_IsOK(res1)) {
23018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23019 }
23020 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23021 {
23022 PyThreadState* __tstate = wxPyBeginAllowThreads();
23023 result = (int)((wxMouseEvent const *)arg1)->GetButton();
23024 wxPyEndAllowThreads(__tstate);
23025 if (PyErr_Occurred()) SWIG_fail;
23026 }
23027 resultobj = SWIG_From_int(static_cast< int >(result));
23028 return resultobj;
23029 fail:
23030 return NULL;
23031 }
23032
23033
23034 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23035 PyObject *resultobj = 0;
23036 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23037 bool result;
23038 void *argp1 = 0 ;
23039 int res1 = 0 ;
23040 PyObject *swig_obj[1] ;
23041
23042 if (!args) SWIG_fail;
23043 swig_obj[0] = args;
23044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23045 if (!SWIG_IsOK(res1)) {
23046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23047 }
23048 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23049 {
23050 PyThreadState* __tstate = wxPyBeginAllowThreads();
23051 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
23052 wxPyEndAllowThreads(__tstate);
23053 if (PyErr_Occurred()) SWIG_fail;
23054 }
23055 {
23056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23057 }
23058 return resultobj;
23059 fail:
23060 return NULL;
23061 }
23062
23063
23064 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23065 PyObject *resultobj = 0;
23066 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23067 bool result;
23068 void *argp1 = 0 ;
23069 int res1 = 0 ;
23070 PyObject *swig_obj[1] ;
23071
23072 if (!args) SWIG_fail;
23073 swig_obj[0] = args;
23074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23075 if (!SWIG_IsOK(res1)) {
23076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23077 }
23078 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23079 {
23080 PyThreadState* __tstate = wxPyBeginAllowThreads();
23081 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
23082 wxPyEndAllowThreads(__tstate);
23083 if (PyErr_Occurred()) SWIG_fail;
23084 }
23085 {
23086 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23087 }
23088 return resultobj;
23089 fail:
23090 return NULL;
23091 }
23092
23093
23094 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23095 PyObject *resultobj = 0;
23096 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23097 bool result;
23098 void *argp1 = 0 ;
23099 int res1 = 0 ;
23100 PyObject *swig_obj[1] ;
23101
23102 if (!args) SWIG_fail;
23103 swig_obj[0] = args;
23104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23105 if (!SWIG_IsOK(res1)) {
23106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23107 }
23108 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23109 {
23110 PyThreadState* __tstate = wxPyBeginAllowThreads();
23111 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
23112 wxPyEndAllowThreads(__tstate);
23113 if (PyErr_Occurred()) SWIG_fail;
23114 }
23115 {
23116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23117 }
23118 return resultobj;
23119 fail:
23120 return NULL;
23121 }
23122
23123
23124 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23125 PyObject *resultobj = 0;
23126 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23127 bool result;
23128 void *argp1 = 0 ;
23129 int res1 = 0 ;
23130 PyObject *swig_obj[1] ;
23131
23132 if (!args) SWIG_fail;
23133 swig_obj[0] = args;
23134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23135 if (!SWIG_IsOK(res1)) {
23136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23137 }
23138 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23139 {
23140 PyThreadState* __tstate = wxPyBeginAllowThreads();
23141 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
23142 wxPyEndAllowThreads(__tstate);
23143 if (PyErr_Occurred()) SWIG_fail;
23144 }
23145 {
23146 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23147 }
23148 return resultobj;
23149 fail:
23150 return NULL;
23151 }
23152
23153
23154 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23155 PyObject *resultobj = 0;
23156 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23157 bool result;
23158 void *argp1 = 0 ;
23159 int res1 = 0 ;
23160 PyObject *swig_obj[1] ;
23161
23162 if (!args) SWIG_fail;
23163 swig_obj[0] = args;
23164 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23165 if (!SWIG_IsOK(res1)) {
23166 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23167 }
23168 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23169 {
23170 PyThreadState* __tstate = wxPyBeginAllowThreads();
23171 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
23172 wxPyEndAllowThreads(__tstate);
23173 if (PyErr_Occurred()) SWIG_fail;
23174 }
23175 {
23176 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23177 }
23178 return resultobj;
23179 fail:
23180 return NULL;
23181 }
23182
23183
23184 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23185 PyObject *resultobj = 0;
23186 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23187 bool result;
23188 void *argp1 = 0 ;
23189 int res1 = 0 ;
23190 PyObject *swig_obj[1] ;
23191
23192 if (!args) SWIG_fail;
23193 swig_obj[0] = args;
23194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23195 if (!SWIG_IsOK(res1)) {
23196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23197 }
23198 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23199 {
23200 PyThreadState* __tstate = wxPyBeginAllowThreads();
23201 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
23202 wxPyEndAllowThreads(__tstate);
23203 if (PyErr_Occurred()) SWIG_fail;
23204 }
23205 {
23206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23207 }
23208 return resultobj;
23209 fail:
23210 return NULL;
23211 }
23212
23213
23214 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23215 PyObject *resultobj = 0;
23216 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23217 bool result;
23218 void *argp1 = 0 ;
23219 int res1 = 0 ;
23220 PyObject *swig_obj[1] ;
23221
23222 if (!args) SWIG_fail;
23223 swig_obj[0] = args;
23224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23225 if (!SWIG_IsOK(res1)) {
23226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23227 }
23228 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23229 {
23230 PyThreadState* __tstate = wxPyBeginAllowThreads();
23231 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
23232 wxPyEndAllowThreads(__tstate);
23233 if (PyErr_Occurred()) SWIG_fail;
23234 }
23235 {
23236 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23237 }
23238 return resultobj;
23239 fail:
23240 return NULL;
23241 }
23242
23243
23244 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23245 PyObject *resultobj = 0;
23246 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23247 bool result;
23248 void *argp1 = 0 ;
23249 int res1 = 0 ;
23250 PyObject *swig_obj[1] ;
23251
23252 if (!args) SWIG_fail;
23253 swig_obj[0] = args;
23254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23255 if (!SWIG_IsOK(res1)) {
23256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23257 }
23258 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23259 {
23260 PyThreadState* __tstate = wxPyBeginAllowThreads();
23261 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
23262 wxPyEndAllowThreads(__tstate);
23263 if (PyErr_Occurred()) SWIG_fail;
23264 }
23265 {
23266 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23267 }
23268 return resultobj;
23269 fail:
23270 return NULL;
23271 }
23272
23273
23274 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23275 PyObject *resultobj = 0;
23276 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23277 bool result;
23278 void *argp1 = 0 ;
23279 int res1 = 0 ;
23280 PyObject *swig_obj[1] ;
23281
23282 if (!args) SWIG_fail;
23283 swig_obj[0] = args;
23284 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23285 if (!SWIG_IsOK(res1)) {
23286 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23287 }
23288 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23289 {
23290 PyThreadState* __tstate = wxPyBeginAllowThreads();
23291 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
23292 wxPyEndAllowThreads(__tstate);
23293 if (PyErr_Occurred()) SWIG_fail;
23294 }
23295 {
23296 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23297 }
23298 return resultobj;
23299 fail:
23300 return NULL;
23301 }
23302
23303
23304 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23305 PyObject *resultobj = 0;
23306 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23307 bool result;
23308 void *argp1 = 0 ;
23309 int res1 = 0 ;
23310 PyObject *swig_obj[1] ;
23311
23312 if (!args) SWIG_fail;
23313 swig_obj[0] = args;
23314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23315 if (!SWIG_IsOK(res1)) {
23316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23317 }
23318 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23319 {
23320 PyThreadState* __tstate = wxPyBeginAllowThreads();
23321 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
23322 wxPyEndAllowThreads(__tstate);
23323 if (PyErr_Occurred()) SWIG_fail;
23324 }
23325 {
23326 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23327 }
23328 return resultobj;
23329 fail:
23330 return NULL;
23331 }
23332
23333
23334 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23335 PyObject *resultobj = 0;
23336 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23337 bool result;
23338 void *argp1 = 0 ;
23339 int res1 = 0 ;
23340 PyObject *swig_obj[1] ;
23341
23342 if (!args) SWIG_fail;
23343 swig_obj[0] = args;
23344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23345 if (!SWIG_IsOK(res1)) {
23346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23347 }
23348 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23349 {
23350 PyThreadState* __tstate = wxPyBeginAllowThreads();
23351 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
23352 wxPyEndAllowThreads(__tstate);
23353 if (PyErr_Occurred()) SWIG_fail;
23354 }
23355 {
23356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23357 }
23358 return resultobj;
23359 fail:
23360 return NULL;
23361 }
23362
23363
23364 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23365 PyObject *resultobj = 0;
23366 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23367 bool result;
23368 void *argp1 = 0 ;
23369 int res1 = 0 ;
23370 PyObject *swig_obj[1] ;
23371
23372 if (!args) SWIG_fail;
23373 swig_obj[0] = args;
23374 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23375 if (!SWIG_IsOK(res1)) {
23376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23377 }
23378 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23379 {
23380 PyThreadState* __tstate = wxPyBeginAllowThreads();
23381 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
23382 wxPyEndAllowThreads(__tstate);
23383 if (PyErr_Occurred()) SWIG_fail;
23384 }
23385 {
23386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23387 }
23388 return resultobj;
23389 fail:
23390 return NULL;
23391 }
23392
23393
23394 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23395 PyObject *resultobj = 0;
23396 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23397 bool result;
23398 void *argp1 = 0 ;
23399 int res1 = 0 ;
23400 PyObject *swig_obj[1] ;
23401
23402 if (!args) SWIG_fail;
23403 swig_obj[0] = args;
23404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23405 if (!SWIG_IsOK(res1)) {
23406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23407 }
23408 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23409 {
23410 PyThreadState* __tstate = wxPyBeginAllowThreads();
23411 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
23412 wxPyEndAllowThreads(__tstate);
23413 if (PyErr_Occurred()) SWIG_fail;
23414 }
23415 {
23416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23417 }
23418 return resultobj;
23419 fail:
23420 return NULL;
23421 }
23422
23423
23424 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23425 PyObject *resultobj = 0;
23426 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23427 bool result;
23428 void *argp1 = 0 ;
23429 int res1 = 0 ;
23430 PyObject *swig_obj[1] ;
23431
23432 if (!args) SWIG_fail;
23433 swig_obj[0] = args;
23434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23435 if (!SWIG_IsOK(res1)) {
23436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23437 }
23438 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23439 {
23440 PyThreadState* __tstate = wxPyBeginAllowThreads();
23441 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
23442 wxPyEndAllowThreads(__tstate);
23443 if (PyErr_Occurred()) SWIG_fail;
23444 }
23445 {
23446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23447 }
23448 return resultobj;
23449 fail:
23450 return NULL;
23451 }
23452
23453
23454 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23455 PyObject *resultobj = 0;
23456 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23457 bool result;
23458 void *argp1 = 0 ;
23459 int res1 = 0 ;
23460 PyObject *swig_obj[1] ;
23461
23462 if (!args) SWIG_fail;
23463 swig_obj[0] = args;
23464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23465 if (!SWIG_IsOK(res1)) {
23466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23467 }
23468 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23469 {
23470 PyThreadState* __tstate = wxPyBeginAllowThreads();
23471 result = (bool)(arg1)->LeftIsDown();
23472 wxPyEndAllowThreads(__tstate);
23473 if (PyErr_Occurred()) SWIG_fail;
23474 }
23475 {
23476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23477 }
23478 return resultobj;
23479 fail:
23480 return NULL;
23481 }
23482
23483
23484 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23485 PyObject *resultobj = 0;
23486 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23487 bool result;
23488 void *argp1 = 0 ;
23489 int res1 = 0 ;
23490 PyObject *swig_obj[1] ;
23491
23492 if (!args) SWIG_fail;
23493 swig_obj[0] = args;
23494 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23495 if (!SWIG_IsOK(res1)) {
23496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23497 }
23498 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23499 {
23500 PyThreadState* __tstate = wxPyBeginAllowThreads();
23501 result = (bool)(arg1)->MiddleIsDown();
23502 wxPyEndAllowThreads(__tstate);
23503 if (PyErr_Occurred()) SWIG_fail;
23504 }
23505 {
23506 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23507 }
23508 return resultobj;
23509 fail:
23510 return NULL;
23511 }
23512
23513
23514 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23515 PyObject *resultobj = 0;
23516 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23517 bool result;
23518 void *argp1 = 0 ;
23519 int res1 = 0 ;
23520 PyObject *swig_obj[1] ;
23521
23522 if (!args) SWIG_fail;
23523 swig_obj[0] = args;
23524 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23525 if (!SWIG_IsOK(res1)) {
23526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23527 }
23528 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23529 {
23530 PyThreadState* __tstate = wxPyBeginAllowThreads();
23531 result = (bool)(arg1)->RightIsDown();
23532 wxPyEndAllowThreads(__tstate);
23533 if (PyErr_Occurred()) SWIG_fail;
23534 }
23535 {
23536 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23537 }
23538 return resultobj;
23539 fail:
23540 return NULL;
23541 }
23542
23543
23544 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23545 PyObject *resultobj = 0;
23546 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23547 bool result;
23548 void *argp1 = 0 ;
23549 int res1 = 0 ;
23550 PyObject *swig_obj[1] ;
23551
23552 if (!args) SWIG_fail;
23553 swig_obj[0] = args;
23554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23555 if (!SWIG_IsOK(res1)) {
23556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23557 }
23558 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23559 {
23560 PyThreadState* __tstate = wxPyBeginAllowThreads();
23561 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
23562 wxPyEndAllowThreads(__tstate);
23563 if (PyErr_Occurred()) SWIG_fail;
23564 }
23565 {
23566 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23567 }
23568 return resultobj;
23569 fail:
23570 return NULL;
23571 }
23572
23573
23574 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23575 PyObject *resultobj = 0;
23576 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23577 bool result;
23578 void *argp1 = 0 ;
23579 int res1 = 0 ;
23580 PyObject *swig_obj[1] ;
23581
23582 if (!args) SWIG_fail;
23583 swig_obj[0] = args;
23584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23585 if (!SWIG_IsOK(res1)) {
23586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23587 }
23588 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 result = (bool)((wxMouseEvent const *)arg1)->Moving();
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 {
23596 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23597 }
23598 return resultobj;
23599 fail:
23600 return NULL;
23601 }
23602
23603
23604 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23605 PyObject *resultobj = 0;
23606 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23607 bool result;
23608 void *argp1 = 0 ;
23609 int res1 = 0 ;
23610 PyObject *swig_obj[1] ;
23611
23612 if (!args) SWIG_fail;
23613 swig_obj[0] = args;
23614 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23615 if (!SWIG_IsOK(res1)) {
23616 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23617 }
23618 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23619 {
23620 PyThreadState* __tstate = wxPyBeginAllowThreads();
23621 result = (bool)((wxMouseEvent const *)arg1)->Entering();
23622 wxPyEndAllowThreads(__tstate);
23623 if (PyErr_Occurred()) SWIG_fail;
23624 }
23625 {
23626 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23627 }
23628 return resultobj;
23629 fail:
23630 return NULL;
23631 }
23632
23633
23634 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23635 PyObject *resultobj = 0;
23636 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23637 bool result;
23638 void *argp1 = 0 ;
23639 int res1 = 0 ;
23640 PyObject *swig_obj[1] ;
23641
23642 if (!args) SWIG_fail;
23643 swig_obj[0] = args;
23644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23645 if (!SWIG_IsOK(res1)) {
23646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23647 }
23648 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23649 {
23650 PyThreadState* __tstate = wxPyBeginAllowThreads();
23651 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
23652 wxPyEndAllowThreads(__tstate);
23653 if (PyErr_Occurred()) SWIG_fail;
23654 }
23655 {
23656 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23657 }
23658 return resultobj;
23659 fail:
23660 return NULL;
23661 }
23662
23663
23664 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23665 PyObject *resultobj = 0;
23666 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23667 wxPoint result;
23668 void *argp1 = 0 ;
23669 int res1 = 0 ;
23670 PyObject *swig_obj[1] ;
23671
23672 if (!args) SWIG_fail;
23673 swig_obj[0] = args;
23674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23675 if (!SWIG_IsOK(res1)) {
23676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23677 }
23678 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23679 {
23680 PyThreadState* __tstate = wxPyBeginAllowThreads();
23681 result = (arg1)->GetPosition();
23682 wxPyEndAllowThreads(__tstate);
23683 if (PyErr_Occurred()) SWIG_fail;
23684 }
23685 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23686 return resultobj;
23687 fail:
23688 return NULL;
23689 }
23690
23691
23692 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23693 PyObject *resultobj = 0;
23694 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23695 long *arg2 = (long *) 0 ;
23696 long *arg3 = (long *) 0 ;
23697 void *argp1 = 0 ;
23698 int res1 = 0 ;
23699 long temp2 ;
23700 int res2 = SWIG_TMPOBJ ;
23701 long temp3 ;
23702 int res3 = SWIG_TMPOBJ ;
23703 PyObject *swig_obj[1] ;
23704
23705 arg2 = &temp2;
23706 arg3 = &temp3;
23707 if (!args) SWIG_fail;
23708 swig_obj[0] = args;
23709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23710 if (!SWIG_IsOK(res1)) {
23711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23712 }
23713 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23714 {
23715 PyThreadState* __tstate = wxPyBeginAllowThreads();
23716 (arg1)->GetPosition(arg2,arg3);
23717 wxPyEndAllowThreads(__tstate);
23718 if (PyErr_Occurred()) SWIG_fail;
23719 }
23720 resultobj = SWIG_Py_Void();
23721 if (SWIG_IsTmpObj(res2)) {
23722 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
23723 } else {
23724 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23725 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
23726 }
23727 if (SWIG_IsTmpObj(res3)) {
23728 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
23729 } else {
23730 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
23731 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
23732 }
23733 return resultobj;
23734 fail:
23735 return NULL;
23736 }
23737
23738
23739 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23740 PyObject *resultobj = 0;
23741 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23742 wxDC *arg2 = 0 ;
23743 wxPoint result;
23744 void *argp1 = 0 ;
23745 int res1 = 0 ;
23746 void *argp2 = 0 ;
23747 int res2 = 0 ;
23748 PyObject * obj0 = 0 ;
23749 PyObject * obj1 = 0 ;
23750 char * kwnames[] = {
23751 (char *) "self",(char *) "dc", NULL
23752 };
23753
23754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23755 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23756 if (!SWIG_IsOK(res1)) {
23757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23758 }
23759 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23760 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
23761 if (!SWIG_IsOK(res2)) {
23762 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23763 }
23764 if (!argp2) {
23765 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
23766 }
23767 arg2 = reinterpret_cast< wxDC * >(argp2);
23768 {
23769 PyThreadState* __tstate = wxPyBeginAllowThreads();
23770 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
23771 wxPyEndAllowThreads(__tstate);
23772 if (PyErr_Occurred()) SWIG_fail;
23773 }
23774 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23775 return resultobj;
23776 fail:
23777 return NULL;
23778 }
23779
23780
23781 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23782 PyObject *resultobj = 0;
23783 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23784 int result;
23785 void *argp1 = 0 ;
23786 int res1 = 0 ;
23787 PyObject *swig_obj[1] ;
23788
23789 if (!args) SWIG_fail;
23790 swig_obj[0] = args;
23791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23792 if (!SWIG_IsOK(res1)) {
23793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23794 }
23795 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23796 {
23797 PyThreadState* __tstate = wxPyBeginAllowThreads();
23798 result = (int)((wxMouseEvent const *)arg1)->GetX();
23799 wxPyEndAllowThreads(__tstate);
23800 if (PyErr_Occurred()) SWIG_fail;
23801 }
23802 resultobj = SWIG_From_int(static_cast< int >(result));
23803 return resultobj;
23804 fail:
23805 return NULL;
23806 }
23807
23808
23809 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23810 PyObject *resultobj = 0;
23811 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23812 int result;
23813 void *argp1 = 0 ;
23814 int res1 = 0 ;
23815 PyObject *swig_obj[1] ;
23816
23817 if (!args) SWIG_fail;
23818 swig_obj[0] = args;
23819 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23820 if (!SWIG_IsOK(res1)) {
23821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23822 }
23823 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23824 {
23825 PyThreadState* __tstate = wxPyBeginAllowThreads();
23826 result = (int)((wxMouseEvent const *)arg1)->GetY();
23827 wxPyEndAllowThreads(__tstate);
23828 if (PyErr_Occurred()) SWIG_fail;
23829 }
23830 resultobj = SWIG_From_int(static_cast< int >(result));
23831 return resultobj;
23832 fail:
23833 return NULL;
23834 }
23835
23836
23837 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23838 PyObject *resultobj = 0;
23839 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23840 int result;
23841 void *argp1 = 0 ;
23842 int res1 = 0 ;
23843 PyObject *swig_obj[1] ;
23844
23845 if (!args) SWIG_fail;
23846 swig_obj[0] = args;
23847 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23848 if (!SWIG_IsOK(res1)) {
23849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23850 }
23851 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23852 {
23853 PyThreadState* __tstate = wxPyBeginAllowThreads();
23854 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
23855 wxPyEndAllowThreads(__tstate);
23856 if (PyErr_Occurred()) SWIG_fail;
23857 }
23858 resultobj = SWIG_From_int(static_cast< int >(result));
23859 return resultobj;
23860 fail:
23861 return NULL;
23862 }
23863
23864
23865 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23866 PyObject *resultobj = 0;
23867 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23868 int result;
23869 void *argp1 = 0 ;
23870 int res1 = 0 ;
23871 PyObject *swig_obj[1] ;
23872
23873 if (!args) SWIG_fail;
23874 swig_obj[0] = args;
23875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23876 if (!SWIG_IsOK(res1)) {
23877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23878 }
23879 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23880 {
23881 PyThreadState* __tstate = wxPyBeginAllowThreads();
23882 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
23883 wxPyEndAllowThreads(__tstate);
23884 if (PyErr_Occurred()) SWIG_fail;
23885 }
23886 resultobj = SWIG_From_int(static_cast< int >(result));
23887 return resultobj;
23888 fail:
23889 return NULL;
23890 }
23891
23892
23893 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelAxis(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23894 PyObject *resultobj = 0;
23895 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23896 int result;
23897 void *argp1 = 0 ;
23898 int res1 = 0 ;
23899 PyObject *swig_obj[1] ;
23900
23901 if (!args) SWIG_fail;
23902 swig_obj[0] = args;
23903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23904 if (!SWIG_IsOK(res1)) {
23905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelAxis" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23906 }
23907 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23908 {
23909 PyThreadState* __tstate = wxPyBeginAllowThreads();
23910 result = (int)((wxMouseEvent const *)arg1)->GetWheelAxis();
23911 wxPyEndAllowThreads(__tstate);
23912 if (PyErr_Occurred()) SWIG_fail;
23913 }
23914 resultobj = SWIG_From_int(static_cast< int >(result));
23915 return resultobj;
23916 fail:
23917 return NULL;
23918 }
23919
23920
23921 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23922 PyObject *resultobj = 0;
23923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23924 int result;
23925 void *argp1 = 0 ;
23926 int res1 = 0 ;
23927 PyObject *swig_obj[1] ;
23928
23929 if (!args) SWIG_fail;
23930 swig_obj[0] = args;
23931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23932 if (!SWIG_IsOK(res1)) {
23933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23934 }
23935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23936 {
23937 PyThreadState* __tstate = wxPyBeginAllowThreads();
23938 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
23939 wxPyEndAllowThreads(__tstate);
23940 if (PyErr_Occurred()) SWIG_fail;
23941 }
23942 resultobj = SWIG_From_int(static_cast< int >(result));
23943 return resultobj;
23944 fail:
23945 return NULL;
23946 }
23947
23948
23949 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23950 PyObject *resultobj = 0;
23951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23952 bool result;
23953 void *argp1 = 0 ;
23954 int res1 = 0 ;
23955 PyObject *swig_obj[1] ;
23956
23957 if (!args) SWIG_fail;
23958 swig_obj[0] = args;
23959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23960 if (!SWIG_IsOK(res1)) {
23961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
23962 }
23963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23964 {
23965 PyThreadState* __tstate = wxPyBeginAllowThreads();
23966 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
23967 wxPyEndAllowThreads(__tstate);
23968 if (PyErr_Occurred()) SWIG_fail;
23969 }
23970 {
23971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23972 }
23973 return resultobj;
23974 fail:
23975 return NULL;
23976 }
23977
23978
23979 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23980 PyObject *resultobj = 0;
23981 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
23982 int arg2 ;
23983 void *argp1 = 0 ;
23984 int res1 = 0 ;
23985 int val2 ;
23986 int ecode2 = 0 ;
23987 PyObject *swig_obj[2] ;
23988
23989 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
23990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
23991 if (!SWIG_IsOK(res1)) {
23992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
23993 }
23994 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
23995 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
23996 if (!SWIG_IsOK(ecode2)) {
23997 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
23998 }
23999 arg2 = static_cast< int >(val2);
24000 if (arg1) (arg1)->m_x = arg2;
24001
24002 resultobj = SWIG_Py_Void();
24003 return resultobj;
24004 fail:
24005 return NULL;
24006 }
24007
24008
24009 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24010 PyObject *resultobj = 0;
24011 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24012 int result;
24013 void *argp1 = 0 ;
24014 int res1 = 0 ;
24015 PyObject *swig_obj[1] ;
24016
24017 if (!args) SWIG_fail;
24018 swig_obj[0] = args;
24019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24020 if (!SWIG_IsOK(res1)) {
24021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24022 }
24023 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24024 result = (int) ((arg1)->m_x);
24025 resultobj = SWIG_From_int(static_cast< int >(result));
24026 return resultobj;
24027 fail:
24028 return NULL;
24029 }
24030
24031
24032 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24033 PyObject *resultobj = 0;
24034 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24035 int arg2 ;
24036 void *argp1 = 0 ;
24037 int res1 = 0 ;
24038 int val2 ;
24039 int ecode2 = 0 ;
24040 PyObject *swig_obj[2] ;
24041
24042 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
24043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24044 if (!SWIG_IsOK(res1)) {
24045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24046 }
24047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24048 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24049 if (!SWIG_IsOK(ecode2)) {
24050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
24051 }
24052 arg2 = static_cast< int >(val2);
24053 if (arg1) (arg1)->m_y = arg2;
24054
24055 resultobj = SWIG_Py_Void();
24056 return resultobj;
24057 fail:
24058 return NULL;
24059 }
24060
24061
24062 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24063 PyObject *resultobj = 0;
24064 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24065 int result;
24066 void *argp1 = 0 ;
24067 int res1 = 0 ;
24068 PyObject *swig_obj[1] ;
24069
24070 if (!args) SWIG_fail;
24071 swig_obj[0] = args;
24072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24073 if (!SWIG_IsOK(res1)) {
24074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24075 }
24076 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24077 result = (int) ((arg1)->m_y);
24078 resultobj = SWIG_From_int(static_cast< int >(result));
24079 return resultobj;
24080 fail:
24081 return NULL;
24082 }
24083
24084
24085 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24086 PyObject *resultobj = 0;
24087 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24088 bool arg2 ;
24089 void *argp1 = 0 ;
24090 int res1 = 0 ;
24091 bool val2 ;
24092 int ecode2 = 0 ;
24093 PyObject *swig_obj[2] ;
24094
24095 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
24096 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24097 if (!SWIG_IsOK(res1)) {
24098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24099 }
24100 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24101 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24102 if (!SWIG_IsOK(ecode2)) {
24103 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
24104 }
24105 arg2 = static_cast< bool >(val2);
24106 if (arg1) (arg1)->m_leftDown = arg2;
24107
24108 resultobj = SWIG_Py_Void();
24109 return resultobj;
24110 fail:
24111 return NULL;
24112 }
24113
24114
24115 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24116 PyObject *resultobj = 0;
24117 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24118 bool result;
24119 void *argp1 = 0 ;
24120 int res1 = 0 ;
24121 PyObject *swig_obj[1] ;
24122
24123 if (!args) SWIG_fail;
24124 swig_obj[0] = args;
24125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24126 if (!SWIG_IsOK(res1)) {
24127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24128 }
24129 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24130 result = (bool) ((arg1)->m_leftDown);
24131 {
24132 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24133 }
24134 return resultobj;
24135 fail:
24136 return NULL;
24137 }
24138
24139
24140 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24141 PyObject *resultobj = 0;
24142 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24143 bool arg2 ;
24144 void *argp1 = 0 ;
24145 int res1 = 0 ;
24146 bool val2 ;
24147 int ecode2 = 0 ;
24148 PyObject *swig_obj[2] ;
24149
24150 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
24151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24152 if (!SWIG_IsOK(res1)) {
24153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24154 }
24155 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24156 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24157 if (!SWIG_IsOK(ecode2)) {
24158 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
24159 }
24160 arg2 = static_cast< bool >(val2);
24161 if (arg1) (arg1)->m_middleDown = arg2;
24162
24163 resultobj = SWIG_Py_Void();
24164 return resultobj;
24165 fail:
24166 return NULL;
24167 }
24168
24169
24170 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24171 PyObject *resultobj = 0;
24172 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24173 bool result;
24174 void *argp1 = 0 ;
24175 int res1 = 0 ;
24176 PyObject *swig_obj[1] ;
24177
24178 if (!args) SWIG_fail;
24179 swig_obj[0] = args;
24180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24181 if (!SWIG_IsOK(res1)) {
24182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24183 }
24184 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24185 result = (bool) ((arg1)->m_middleDown);
24186 {
24187 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24188 }
24189 return resultobj;
24190 fail:
24191 return NULL;
24192 }
24193
24194
24195 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24196 PyObject *resultobj = 0;
24197 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24198 bool arg2 ;
24199 void *argp1 = 0 ;
24200 int res1 = 0 ;
24201 bool val2 ;
24202 int ecode2 = 0 ;
24203 PyObject *swig_obj[2] ;
24204
24205 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
24206 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24207 if (!SWIG_IsOK(res1)) {
24208 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24209 }
24210 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24211 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24212 if (!SWIG_IsOK(ecode2)) {
24213 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
24214 }
24215 arg2 = static_cast< bool >(val2);
24216 if (arg1) (arg1)->m_rightDown = arg2;
24217
24218 resultobj = SWIG_Py_Void();
24219 return resultobj;
24220 fail:
24221 return NULL;
24222 }
24223
24224
24225 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24226 PyObject *resultobj = 0;
24227 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24228 bool result;
24229 void *argp1 = 0 ;
24230 int res1 = 0 ;
24231 PyObject *swig_obj[1] ;
24232
24233 if (!args) SWIG_fail;
24234 swig_obj[0] = args;
24235 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24236 if (!SWIG_IsOK(res1)) {
24237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24238 }
24239 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24240 result = (bool) ((arg1)->m_rightDown);
24241 {
24242 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24243 }
24244 return resultobj;
24245 fail:
24246 return NULL;
24247 }
24248
24249
24250 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24251 PyObject *resultobj = 0;
24252 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24253 bool arg2 ;
24254 void *argp1 = 0 ;
24255 int res1 = 0 ;
24256 bool val2 ;
24257 int ecode2 = 0 ;
24258 PyObject *swig_obj[2] ;
24259
24260 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
24261 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24262 if (!SWIG_IsOK(res1)) {
24263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24264 }
24265 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24266 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24267 if (!SWIG_IsOK(ecode2)) {
24268 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
24269 }
24270 arg2 = static_cast< bool >(val2);
24271 if (arg1) (arg1)->m_controlDown = arg2;
24272
24273 resultobj = SWIG_Py_Void();
24274 return resultobj;
24275 fail:
24276 return NULL;
24277 }
24278
24279
24280 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24281 PyObject *resultobj = 0;
24282 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24283 bool result;
24284 void *argp1 = 0 ;
24285 int res1 = 0 ;
24286 PyObject *swig_obj[1] ;
24287
24288 if (!args) SWIG_fail;
24289 swig_obj[0] = args;
24290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24291 if (!SWIG_IsOK(res1)) {
24292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24293 }
24294 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24295 result = (bool) ((arg1)->m_controlDown);
24296 {
24297 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24298 }
24299 return resultobj;
24300 fail:
24301 return NULL;
24302 }
24303
24304
24305 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24306 PyObject *resultobj = 0;
24307 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24308 bool arg2 ;
24309 void *argp1 = 0 ;
24310 int res1 = 0 ;
24311 bool val2 ;
24312 int ecode2 = 0 ;
24313 PyObject *swig_obj[2] ;
24314
24315 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
24316 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24317 if (!SWIG_IsOK(res1)) {
24318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24319 }
24320 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24321 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24322 if (!SWIG_IsOK(ecode2)) {
24323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
24324 }
24325 arg2 = static_cast< bool >(val2);
24326 if (arg1) (arg1)->m_shiftDown = arg2;
24327
24328 resultobj = SWIG_Py_Void();
24329 return resultobj;
24330 fail:
24331 return NULL;
24332 }
24333
24334
24335 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24336 PyObject *resultobj = 0;
24337 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24338 bool result;
24339 void *argp1 = 0 ;
24340 int res1 = 0 ;
24341 PyObject *swig_obj[1] ;
24342
24343 if (!args) SWIG_fail;
24344 swig_obj[0] = args;
24345 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24346 if (!SWIG_IsOK(res1)) {
24347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24348 }
24349 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24350 result = (bool) ((arg1)->m_shiftDown);
24351 {
24352 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24353 }
24354 return resultobj;
24355 fail:
24356 return NULL;
24357 }
24358
24359
24360 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24361 PyObject *resultobj = 0;
24362 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24363 bool arg2 ;
24364 void *argp1 = 0 ;
24365 int res1 = 0 ;
24366 bool val2 ;
24367 int ecode2 = 0 ;
24368 PyObject *swig_obj[2] ;
24369
24370 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
24371 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24372 if (!SWIG_IsOK(res1)) {
24373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24374 }
24375 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24376 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24377 if (!SWIG_IsOK(ecode2)) {
24378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
24379 }
24380 arg2 = static_cast< bool >(val2);
24381 if (arg1) (arg1)->m_altDown = arg2;
24382
24383 resultobj = SWIG_Py_Void();
24384 return resultobj;
24385 fail:
24386 return NULL;
24387 }
24388
24389
24390 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24391 PyObject *resultobj = 0;
24392 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24393 bool result;
24394 void *argp1 = 0 ;
24395 int res1 = 0 ;
24396 PyObject *swig_obj[1] ;
24397
24398 if (!args) SWIG_fail;
24399 swig_obj[0] = args;
24400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24401 if (!SWIG_IsOK(res1)) {
24402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24403 }
24404 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24405 result = (bool) ((arg1)->m_altDown);
24406 {
24407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24408 }
24409 return resultobj;
24410 fail:
24411 return NULL;
24412 }
24413
24414
24415 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24416 PyObject *resultobj = 0;
24417 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24418 bool arg2 ;
24419 void *argp1 = 0 ;
24420 int res1 = 0 ;
24421 bool val2 ;
24422 int ecode2 = 0 ;
24423 PyObject *swig_obj[2] ;
24424
24425 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
24426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24427 if (!SWIG_IsOK(res1)) {
24428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24429 }
24430 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24431 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
24432 if (!SWIG_IsOK(ecode2)) {
24433 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
24434 }
24435 arg2 = static_cast< bool >(val2);
24436 if (arg1) (arg1)->m_metaDown = arg2;
24437
24438 resultobj = SWIG_Py_Void();
24439 return resultobj;
24440 fail:
24441 return NULL;
24442 }
24443
24444
24445 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24446 PyObject *resultobj = 0;
24447 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24448 bool result;
24449 void *argp1 = 0 ;
24450 int res1 = 0 ;
24451 PyObject *swig_obj[1] ;
24452
24453 if (!args) SWIG_fail;
24454 swig_obj[0] = args;
24455 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24456 if (!SWIG_IsOK(res1)) {
24457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24458 }
24459 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24460 result = (bool) ((arg1)->m_metaDown);
24461 {
24462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24463 }
24464 return resultobj;
24465 fail:
24466 return NULL;
24467 }
24468
24469
24470 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24471 PyObject *resultobj = 0;
24472 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24473 int arg2 ;
24474 void *argp1 = 0 ;
24475 int res1 = 0 ;
24476 int val2 ;
24477 int ecode2 = 0 ;
24478 PyObject *swig_obj[2] ;
24479
24480 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
24481 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24482 if (!SWIG_IsOK(res1)) {
24483 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24484 }
24485 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24486 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24487 if (!SWIG_IsOK(ecode2)) {
24488 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
24489 }
24490 arg2 = static_cast< int >(val2);
24491 if (arg1) (arg1)->m_wheelRotation = arg2;
24492
24493 resultobj = SWIG_Py_Void();
24494 return resultobj;
24495 fail:
24496 return NULL;
24497 }
24498
24499
24500 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24501 PyObject *resultobj = 0;
24502 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24503 int result;
24504 void *argp1 = 0 ;
24505 int res1 = 0 ;
24506 PyObject *swig_obj[1] ;
24507
24508 if (!args) SWIG_fail;
24509 swig_obj[0] = args;
24510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24511 if (!SWIG_IsOK(res1)) {
24512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24513 }
24514 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24515 result = (int) ((arg1)->m_wheelRotation);
24516 resultobj = SWIG_From_int(static_cast< int >(result));
24517 return resultobj;
24518 fail:
24519 return NULL;
24520 }
24521
24522
24523 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24524 PyObject *resultobj = 0;
24525 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24526 int arg2 ;
24527 void *argp1 = 0 ;
24528 int res1 = 0 ;
24529 int val2 ;
24530 int ecode2 = 0 ;
24531 PyObject *swig_obj[2] ;
24532
24533 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
24534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24537 }
24538 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24539 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24540 if (!SWIG_IsOK(ecode2)) {
24541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
24542 }
24543 arg2 = static_cast< int >(val2);
24544 if (arg1) (arg1)->m_wheelDelta = arg2;
24545
24546 resultobj = SWIG_Py_Void();
24547 return resultobj;
24548 fail:
24549 return NULL;
24550 }
24551
24552
24553 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24554 PyObject *resultobj = 0;
24555 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24556 int result;
24557 void *argp1 = 0 ;
24558 int res1 = 0 ;
24559 PyObject *swig_obj[1] ;
24560
24561 if (!args) SWIG_fail;
24562 swig_obj[0] = args;
24563 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24564 if (!SWIG_IsOK(res1)) {
24565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24566 }
24567 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24568 result = (int) ((arg1)->m_wheelDelta);
24569 resultobj = SWIG_From_int(static_cast< int >(result));
24570 return resultobj;
24571 fail:
24572 return NULL;
24573 }
24574
24575
24576 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24577 PyObject *resultobj = 0;
24578 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24579 int arg2 ;
24580 void *argp1 = 0 ;
24581 int res1 = 0 ;
24582 int val2 ;
24583 int ecode2 = 0 ;
24584 PyObject *swig_obj[2] ;
24585
24586 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
24587 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24588 if (!SWIG_IsOK(res1)) {
24589 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24590 }
24591 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24592 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
24593 if (!SWIG_IsOK(ecode2)) {
24594 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
24595 }
24596 arg2 = static_cast< int >(val2);
24597 if (arg1) (arg1)->m_linesPerAction = arg2;
24598
24599 resultobj = SWIG_Py_Void();
24600 return resultobj;
24601 fail:
24602 return NULL;
24603 }
24604
24605
24606 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24607 PyObject *resultobj = 0;
24608 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
24609 int result;
24610 void *argp1 = 0 ;
24611 int res1 = 0 ;
24612 PyObject *swig_obj[1] ;
24613
24614 if (!args) SWIG_fail;
24615 swig_obj[0] = args;
24616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
24617 if (!SWIG_IsOK(res1)) {
24618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
24619 }
24620 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
24621 result = (int) ((arg1)->m_linesPerAction);
24622 resultobj = SWIG_From_int(static_cast< int >(result));
24623 return resultobj;
24624 fail:
24625 return NULL;
24626 }
24627
24628
24629 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24630 PyObject *obj;
24631 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24632 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
24633 return SWIG_Py_Void();
24634 }
24635
24636 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24637 return SWIG_Python_InitShadowInstance(args);
24638 }
24639
24640 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24641 PyObject *resultobj = 0;
24642 int arg1 = (int) 0 ;
24643 int arg2 = (int) 0 ;
24644 wxSetCursorEvent *result = 0 ;
24645 int val1 ;
24646 int ecode1 = 0 ;
24647 int val2 ;
24648 int ecode2 = 0 ;
24649 PyObject * obj0 = 0 ;
24650 PyObject * obj1 = 0 ;
24651 char * kwnames[] = {
24652 (char *) "x",(char *) "y", NULL
24653 };
24654
24655 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24656 if (obj0) {
24657 ecode1 = SWIG_AsVal_int(obj0, &val1);
24658 if (!SWIG_IsOK(ecode1)) {
24659 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
24660 }
24661 arg1 = static_cast< int >(val1);
24662 }
24663 if (obj1) {
24664 ecode2 = SWIG_AsVal_int(obj1, &val2);
24665 if (!SWIG_IsOK(ecode2)) {
24666 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
24667 }
24668 arg2 = static_cast< int >(val2);
24669 }
24670 {
24671 PyThreadState* __tstate = wxPyBeginAllowThreads();
24672 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
24673 wxPyEndAllowThreads(__tstate);
24674 if (PyErr_Occurred()) SWIG_fail;
24675 }
24676 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
24677 return resultobj;
24678 fail:
24679 return NULL;
24680 }
24681
24682
24683 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24684 PyObject *resultobj = 0;
24685 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24686 int result;
24687 void *argp1 = 0 ;
24688 int res1 = 0 ;
24689 PyObject *swig_obj[1] ;
24690
24691 if (!args) SWIG_fail;
24692 swig_obj[0] = args;
24693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24694 if (!SWIG_IsOK(res1)) {
24695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24696 }
24697 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24698 {
24699 PyThreadState* __tstate = wxPyBeginAllowThreads();
24700 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
24701 wxPyEndAllowThreads(__tstate);
24702 if (PyErr_Occurred()) SWIG_fail;
24703 }
24704 resultobj = SWIG_From_int(static_cast< int >(result));
24705 return resultobj;
24706 fail:
24707 return NULL;
24708 }
24709
24710
24711 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24712 PyObject *resultobj = 0;
24713 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24714 int result;
24715 void *argp1 = 0 ;
24716 int res1 = 0 ;
24717 PyObject *swig_obj[1] ;
24718
24719 if (!args) SWIG_fail;
24720 swig_obj[0] = args;
24721 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24722 if (!SWIG_IsOK(res1)) {
24723 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24724 }
24725 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24726 {
24727 PyThreadState* __tstate = wxPyBeginAllowThreads();
24728 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
24729 wxPyEndAllowThreads(__tstate);
24730 if (PyErr_Occurred()) SWIG_fail;
24731 }
24732 resultobj = SWIG_From_int(static_cast< int >(result));
24733 return resultobj;
24734 fail:
24735 return NULL;
24736 }
24737
24738
24739 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24740 PyObject *resultobj = 0;
24741 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24742 wxCursor *arg2 = 0 ;
24743 void *argp1 = 0 ;
24744 int res1 = 0 ;
24745 void *argp2 = 0 ;
24746 int res2 = 0 ;
24747 PyObject * obj0 = 0 ;
24748 PyObject * obj1 = 0 ;
24749 char * kwnames[] = {
24750 (char *) "self",(char *) "cursor", NULL
24751 };
24752
24753 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
24754 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24755 if (!SWIG_IsOK(res1)) {
24756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
24757 }
24758 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24759 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
24760 if (!SWIG_IsOK(res2)) {
24761 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24762 }
24763 if (!argp2) {
24764 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
24765 }
24766 arg2 = reinterpret_cast< wxCursor * >(argp2);
24767 {
24768 PyThreadState* __tstate = wxPyBeginAllowThreads();
24769 (arg1)->SetCursor((wxCursor const &)*arg2);
24770 wxPyEndAllowThreads(__tstate);
24771 if (PyErr_Occurred()) SWIG_fail;
24772 }
24773 resultobj = SWIG_Py_Void();
24774 return resultobj;
24775 fail:
24776 return NULL;
24777 }
24778
24779
24780 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24781 PyObject *resultobj = 0;
24782 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24783 wxCursor *result = 0 ;
24784 void *argp1 = 0 ;
24785 int res1 = 0 ;
24786 PyObject *swig_obj[1] ;
24787
24788 if (!args) SWIG_fail;
24789 swig_obj[0] = args;
24790 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24791 if (!SWIG_IsOK(res1)) {
24792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24793 }
24794 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24795 {
24796 PyThreadState* __tstate = wxPyBeginAllowThreads();
24797 {
24798 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
24799 result = (wxCursor *) &_result_ref;
24800 }
24801 wxPyEndAllowThreads(__tstate);
24802 if (PyErr_Occurred()) SWIG_fail;
24803 }
24804 {
24805 wxCursor* resultptr = new wxCursor(*result);
24806 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
24807 }
24808 return resultobj;
24809 fail:
24810 return NULL;
24811 }
24812
24813
24814 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24815 PyObject *resultobj = 0;
24816 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
24817 bool result;
24818 void *argp1 = 0 ;
24819 int res1 = 0 ;
24820 PyObject *swig_obj[1] ;
24821
24822 if (!args) SWIG_fail;
24823 swig_obj[0] = args;
24824 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
24825 if (!SWIG_IsOK(res1)) {
24826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
24827 }
24828 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
24829 {
24830 PyThreadState* __tstate = wxPyBeginAllowThreads();
24831 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
24832 wxPyEndAllowThreads(__tstate);
24833 if (PyErr_Occurred()) SWIG_fail;
24834 }
24835 {
24836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24837 }
24838 return resultobj;
24839 fail:
24840 return NULL;
24841 }
24842
24843
24844 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24845 PyObject *obj;
24846 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24847 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
24848 return SWIG_Py_Void();
24849 }
24850
24851 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24852 return SWIG_Python_InitShadowInstance(args);
24853 }
24854
24855 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24856 PyObject *resultobj = 0;
24857 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24858 wxKeyEvent *result = 0 ;
24859 int val1 ;
24860 int ecode1 = 0 ;
24861 PyObject * obj0 = 0 ;
24862 char * kwnames[] = {
24863 (char *) "eventType", NULL
24864 };
24865
24866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
24867 if (obj0) {
24868 ecode1 = SWIG_AsVal_int(obj0, &val1);
24869 if (!SWIG_IsOK(ecode1)) {
24870 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24871 }
24872 arg1 = static_cast< wxEventType >(val1);
24873 }
24874 {
24875 PyThreadState* __tstate = wxPyBeginAllowThreads();
24876 result = (wxKeyEvent *)new wxKeyEvent(arg1);
24877 wxPyEndAllowThreads(__tstate);
24878 if (PyErr_Occurred()) SWIG_fail;
24879 }
24880 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
24881 return resultobj;
24882 fail:
24883 return NULL;
24884 }
24885
24886
24887 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24888 PyObject *resultobj = 0;
24889 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24890 int result;
24891 void *argp1 = 0 ;
24892 int res1 = 0 ;
24893 PyObject *swig_obj[1] ;
24894
24895 if (!args) SWIG_fail;
24896 swig_obj[0] = args;
24897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24898 if (!SWIG_IsOK(res1)) {
24899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24900 }
24901 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24902 {
24903 PyThreadState* __tstate = wxPyBeginAllowThreads();
24904 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
24905 wxPyEndAllowThreads(__tstate);
24906 if (PyErr_Occurred()) SWIG_fail;
24907 }
24908 resultobj = SWIG_From_int(static_cast< int >(result));
24909 return resultobj;
24910 fail:
24911 return NULL;
24912 }
24913
24914
24915 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24916 PyObject *resultobj = 0;
24917 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24918 bool result;
24919 void *argp1 = 0 ;
24920 int res1 = 0 ;
24921 PyObject *swig_obj[1] ;
24922
24923 if (!args) SWIG_fail;
24924 swig_obj[0] = args;
24925 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24926 if (!SWIG_IsOK(res1)) {
24927 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24928 }
24929 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24930 {
24931 PyThreadState* __tstate = wxPyBeginAllowThreads();
24932 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
24933 wxPyEndAllowThreads(__tstate);
24934 if (PyErr_Occurred()) SWIG_fail;
24935 }
24936 {
24937 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24938 }
24939 return resultobj;
24940 fail:
24941 return NULL;
24942 }
24943
24944
24945 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24946 PyObject *resultobj = 0;
24947 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24948 bool result;
24949 void *argp1 = 0 ;
24950 int res1 = 0 ;
24951 PyObject *swig_obj[1] ;
24952
24953 if (!args) SWIG_fail;
24954 swig_obj[0] = args;
24955 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24956 if (!SWIG_IsOK(res1)) {
24957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24958 }
24959 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24960 {
24961 PyThreadState* __tstate = wxPyBeginAllowThreads();
24962 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
24963 wxPyEndAllowThreads(__tstate);
24964 if (PyErr_Occurred()) SWIG_fail;
24965 }
24966 {
24967 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24968 }
24969 return resultobj;
24970 fail:
24971 return NULL;
24972 }
24973
24974
24975 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24976 PyObject *resultobj = 0;
24977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
24978 bool result;
24979 void *argp1 = 0 ;
24980 int res1 = 0 ;
24981 PyObject *swig_obj[1] ;
24982
24983 if (!args) SWIG_fail;
24984 swig_obj[0] = args;
24985 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
24986 if (!SWIG_IsOK(res1)) {
24987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
24988 }
24989 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
24990 {
24991 PyThreadState* __tstate = wxPyBeginAllowThreads();
24992 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
24993 wxPyEndAllowThreads(__tstate);
24994 if (PyErr_Occurred()) SWIG_fail;
24995 }
24996 {
24997 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24998 }
24999 return resultobj;
25000 fail:
25001 return NULL;
25002 }
25003
25004
25005 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25006 PyObject *resultobj = 0;
25007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25008 bool result;
25009 void *argp1 = 0 ;
25010 int res1 = 0 ;
25011 PyObject *swig_obj[1] ;
25012
25013 if (!args) SWIG_fail;
25014 swig_obj[0] = args;
25015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25016 if (!SWIG_IsOK(res1)) {
25017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25018 }
25019 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25020 {
25021 PyThreadState* __tstate = wxPyBeginAllowThreads();
25022 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
25023 wxPyEndAllowThreads(__tstate);
25024 if (PyErr_Occurred()) SWIG_fail;
25025 }
25026 {
25027 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25028 }
25029 return resultobj;
25030 fail:
25031 return NULL;
25032 }
25033
25034
25035 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25036 PyObject *resultobj = 0;
25037 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25038 bool result;
25039 void *argp1 = 0 ;
25040 int res1 = 0 ;
25041 PyObject *swig_obj[1] ;
25042
25043 if (!args) SWIG_fail;
25044 swig_obj[0] = args;
25045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25046 if (!SWIG_IsOK(res1)) {
25047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25048 }
25049 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25050 {
25051 PyThreadState* __tstate = wxPyBeginAllowThreads();
25052 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
25053 wxPyEndAllowThreads(__tstate);
25054 if (PyErr_Occurred()) SWIG_fail;
25055 }
25056 {
25057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25058 }
25059 return resultobj;
25060 fail:
25061 return NULL;
25062 }
25063
25064
25065 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25066 PyObject *resultobj = 0;
25067 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25068 bool result;
25069 void *argp1 = 0 ;
25070 int res1 = 0 ;
25071 PyObject *swig_obj[1] ;
25072
25073 if (!args) SWIG_fail;
25074 swig_obj[0] = args;
25075 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25076 if (!SWIG_IsOK(res1)) {
25077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25078 }
25079 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25080 {
25081 PyThreadState* __tstate = wxPyBeginAllowThreads();
25082 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
25083 wxPyEndAllowThreads(__tstate);
25084 if (PyErr_Occurred()) SWIG_fail;
25085 }
25086 {
25087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25088 }
25089 return resultobj;
25090 fail:
25091 return NULL;
25092 }
25093
25094
25095 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25096 PyObject *resultobj = 0;
25097 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25098 int result;
25099 void *argp1 = 0 ;
25100 int res1 = 0 ;
25101 PyObject *swig_obj[1] ;
25102
25103 if (!args) SWIG_fail;
25104 swig_obj[0] = args;
25105 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25106 if (!SWIG_IsOK(res1)) {
25107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25108 }
25109 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25110 {
25111 PyThreadState* __tstate = wxPyBeginAllowThreads();
25112 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
25113 wxPyEndAllowThreads(__tstate);
25114 if (PyErr_Occurred()) SWIG_fail;
25115 }
25116 resultobj = SWIG_From_int(static_cast< int >(result));
25117 return resultobj;
25118 fail:
25119 return NULL;
25120 }
25121
25122
25123 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25124 PyObject *resultobj = 0;
25125 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25126 int result;
25127 void *argp1 = 0 ;
25128 int res1 = 0 ;
25129 PyObject *swig_obj[1] ;
25130
25131 if (!args) SWIG_fail;
25132 swig_obj[0] = args;
25133 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25134 if (!SWIG_IsOK(res1)) {
25135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25136 }
25137 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25138 {
25139 PyThreadState* __tstate = wxPyBeginAllowThreads();
25140 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
25141 wxPyEndAllowThreads(__tstate);
25142 if (PyErr_Occurred()) SWIG_fail;
25143 }
25144 resultobj = SWIG_From_int(static_cast< int >(result));
25145 return resultobj;
25146 fail:
25147 return NULL;
25148 }
25149
25150
25151 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25152 PyObject *resultobj = 0;
25153 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25154 int arg2 ;
25155 void *argp1 = 0 ;
25156 int res1 = 0 ;
25157 int val2 ;
25158 int ecode2 = 0 ;
25159 PyObject * obj0 = 0 ;
25160 PyObject * obj1 = 0 ;
25161 char * kwnames[] = {
25162 (char *) "self",(char *) "uniChar", NULL
25163 };
25164
25165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
25166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25167 if (!SWIG_IsOK(res1)) {
25168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25169 }
25170 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25171 ecode2 = SWIG_AsVal_int(obj1, &val2);
25172 if (!SWIG_IsOK(ecode2)) {
25173 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
25174 }
25175 arg2 = static_cast< int >(val2);
25176 {
25177 PyThreadState* __tstate = wxPyBeginAllowThreads();
25178 wxKeyEvent_SetUnicodeKey(arg1,arg2);
25179 wxPyEndAllowThreads(__tstate);
25180 if (PyErr_Occurred()) SWIG_fail;
25181 }
25182 resultobj = SWIG_Py_Void();
25183 return resultobj;
25184 fail:
25185 return NULL;
25186 }
25187
25188
25189 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25190 PyObject *resultobj = 0;
25191 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25192 unsigned int result;
25193 void *argp1 = 0 ;
25194 int res1 = 0 ;
25195 PyObject *swig_obj[1] ;
25196
25197 if (!args) SWIG_fail;
25198 swig_obj[0] = args;
25199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25200 if (!SWIG_IsOK(res1)) {
25201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25202 }
25203 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25204 {
25205 PyThreadState* __tstate = wxPyBeginAllowThreads();
25206 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
25207 wxPyEndAllowThreads(__tstate);
25208 if (PyErr_Occurred()) SWIG_fail;
25209 }
25210 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25211 return resultobj;
25212 fail:
25213 return NULL;
25214 }
25215
25216
25217 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25218 PyObject *resultobj = 0;
25219 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25220 unsigned int result;
25221 void *argp1 = 0 ;
25222 int res1 = 0 ;
25223 PyObject *swig_obj[1] ;
25224
25225 if (!args) SWIG_fail;
25226 swig_obj[0] = args;
25227 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25228 if (!SWIG_IsOK(res1)) {
25229 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25230 }
25231 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25232 {
25233 PyThreadState* __tstate = wxPyBeginAllowThreads();
25234 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
25235 wxPyEndAllowThreads(__tstate);
25236 if (PyErr_Occurred()) SWIG_fail;
25237 }
25238 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25239 return resultobj;
25240 fail:
25241 return NULL;
25242 }
25243
25244
25245 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25246 PyObject *resultobj = 0;
25247 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25248 wxPoint result;
25249 void *argp1 = 0 ;
25250 int res1 = 0 ;
25251 PyObject *swig_obj[1] ;
25252
25253 if (!args) SWIG_fail;
25254 swig_obj[0] = args;
25255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25256 if (!SWIG_IsOK(res1)) {
25257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25258 }
25259 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25260 {
25261 PyThreadState* __tstate = wxPyBeginAllowThreads();
25262 result = (arg1)->GetPosition();
25263 wxPyEndAllowThreads(__tstate);
25264 if (PyErr_Occurred()) SWIG_fail;
25265 }
25266 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
25267 return resultobj;
25268 fail:
25269 return NULL;
25270 }
25271
25272
25273 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25274 PyObject *resultobj = 0;
25275 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25276 long *arg2 = (long *) 0 ;
25277 long *arg3 = (long *) 0 ;
25278 void *argp1 = 0 ;
25279 int res1 = 0 ;
25280 long temp2 ;
25281 int res2 = SWIG_TMPOBJ ;
25282 long temp3 ;
25283 int res3 = SWIG_TMPOBJ ;
25284 PyObject *swig_obj[1] ;
25285
25286 arg2 = &temp2;
25287 arg3 = &temp3;
25288 if (!args) SWIG_fail;
25289 swig_obj[0] = args;
25290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25291 if (!SWIG_IsOK(res1)) {
25292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25293 }
25294 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25295 {
25296 PyThreadState* __tstate = wxPyBeginAllowThreads();
25297 (arg1)->GetPosition(arg2,arg3);
25298 wxPyEndAllowThreads(__tstate);
25299 if (PyErr_Occurred()) SWIG_fail;
25300 }
25301 resultobj = SWIG_Py_Void();
25302 if (SWIG_IsTmpObj(res2)) {
25303 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
25304 } else {
25305 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25306 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
25307 }
25308 if (SWIG_IsTmpObj(res3)) {
25309 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
25310 } else {
25311 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
25312 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
25313 }
25314 return resultobj;
25315 fail:
25316 return NULL;
25317 }
25318
25319
25320 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25321 PyObject *resultobj = 0;
25322 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25323 int result;
25324 void *argp1 = 0 ;
25325 int res1 = 0 ;
25326 PyObject *swig_obj[1] ;
25327
25328 if (!args) SWIG_fail;
25329 swig_obj[0] = args;
25330 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25331 if (!SWIG_IsOK(res1)) {
25332 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25333 }
25334 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25335 {
25336 PyThreadState* __tstate = wxPyBeginAllowThreads();
25337 result = (int)((wxKeyEvent const *)arg1)->GetX();
25338 wxPyEndAllowThreads(__tstate);
25339 if (PyErr_Occurred()) SWIG_fail;
25340 }
25341 resultobj = SWIG_From_int(static_cast< int >(result));
25342 return resultobj;
25343 fail:
25344 return NULL;
25345 }
25346
25347
25348 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25349 PyObject *resultobj = 0;
25350 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25351 int result;
25352 void *argp1 = 0 ;
25353 int res1 = 0 ;
25354 PyObject *swig_obj[1] ;
25355
25356 if (!args) SWIG_fail;
25357 swig_obj[0] = args;
25358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25359 if (!SWIG_IsOK(res1)) {
25360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
25361 }
25362 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25363 {
25364 PyThreadState* __tstate = wxPyBeginAllowThreads();
25365 result = (int)((wxKeyEvent const *)arg1)->GetY();
25366 wxPyEndAllowThreads(__tstate);
25367 if (PyErr_Occurred()) SWIG_fail;
25368 }
25369 resultobj = SWIG_From_int(static_cast< int >(result));
25370 return resultobj;
25371 fail:
25372 return NULL;
25373 }
25374
25375
25376 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25377 PyObject *resultobj = 0;
25378 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25379 int arg2 ;
25380 void *argp1 = 0 ;
25381 int res1 = 0 ;
25382 int val2 ;
25383 int ecode2 = 0 ;
25384 PyObject *swig_obj[2] ;
25385
25386 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
25387 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25388 if (!SWIG_IsOK(res1)) {
25389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25390 }
25391 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25392 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25393 if (!SWIG_IsOK(ecode2)) {
25394 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
25395 }
25396 arg2 = static_cast< int >(val2);
25397 if (arg1) (arg1)->m_x = arg2;
25398
25399 resultobj = SWIG_Py_Void();
25400 return resultobj;
25401 fail:
25402 return NULL;
25403 }
25404
25405
25406 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25407 PyObject *resultobj = 0;
25408 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25409 int result;
25410 void *argp1 = 0 ;
25411 int res1 = 0 ;
25412 PyObject *swig_obj[1] ;
25413
25414 if (!args) SWIG_fail;
25415 swig_obj[0] = args;
25416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25417 if (!SWIG_IsOK(res1)) {
25418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25419 }
25420 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25421 result = (int) ((arg1)->m_x);
25422 resultobj = SWIG_From_int(static_cast< int >(result));
25423 return resultobj;
25424 fail:
25425 return NULL;
25426 }
25427
25428
25429 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25430 PyObject *resultobj = 0;
25431 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25432 int arg2 ;
25433 void *argp1 = 0 ;
25434 int res1 = 0 ;
25435 int val2 ;
25436 int ecode2 = 0 ;
25437 PyObject *swig_obj[2] ;
25438
25439 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
25440 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25441 if (!SWIG_IsOK(res1)) {
25442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25443 }
25444 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25445 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
25446 if (!SWIG_IsOK(ecode2)) {
25447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
25448 }
25449 arg2 = static_cast< int >(val2);
25450 if (arg1) (arg1)->m_y = arg2;
25451
25452 resultobj = SWIG_Py_Void();
25453 return resultobj;
25454 fail:
25455 return NULL;
25456 }
25457
25458
25459 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25460 PyObject *resultobj = 0;
25461 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25462 int result;
25463 void *argp1 = 0 ;
25464 int res1 = 0 ;
25465 PyObject *swig_obj[1] ;
25466
25467 if (!args) SWIG_fail;
25468 swig_obj[0] = args;
25469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25470 if (!SWIG_IsOK(res1)) {
25471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25472 }
25473 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25474 result = (int) ((arg1)->m_y);
25475 resultobj = SWIG_From_int(static_cast< int >(result));
25476 return resultobj;
25477 fail:
25478 return NULL;
25479 }
25480
25481
25482 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25483 PyObject *resultobj = 0;
25484 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25485 long arg2 ;
25486 void *argp1 = 0 ;
25487 int res1 = 0 ;
25488 long val2 ;
25489 int ecode2 = 0 ;
25490 PyObject *swig_obj[2] ;
25491
25492 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
25493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25494 if (!SWIG_IsOK(res1)) {
25495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25496 }
25497 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25498 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
25499 if (!SWIG_IsOK(ecode2)) {
25500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
25501 }
25502 arg2 = static_cast< long >(val2);
25503 if (arg1) (arg1)->m_keyCode = arg2;
25504
25505 resultobj = SWIG_Py_Void();
25506 return resultobj;
25507 fail:
25508 return NULL;
25509 }
25510
25511
25512 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25513 PyObject *resultobj = 0;
25514 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25515 long result;
25516 void *argp1 = 0 ;
25517 int res1 = 0 ;
25518 PyObject *swig_obj[1] ;
25519
25520 if (!args) SWIG_fail;
25521 swig_obj[0] = args;
25522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25523 if (!SWIG_IsOK(res1)) {
25524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25525 }
25526 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25527 result = (long) ((arg1)->m_keyCode);
25528 resultobj = SWIG_From_long(static_cast< long >(result));
25529 return resultobj;
25530 fail:
25531 return NULL;
25532 }
25533
25534
25535 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25536 PyObject *resultobj = 0;
25537 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25538 bool arg2 ;
25539 void *argp1 = 0 ;
25540 int res1 = 0 ;
25541 bool val2 ;
25542 int ecode2 = 0 ;
25543 PyObject *swig_obj[2] ;
25544
25545 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
25546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25547 if (!SWIG_IsOK(res1)) {
25548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25549 }
25550 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25551 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25552 if (!SWIG_IsOK(ecode2)) {
25553 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
25554 }
25555 arg2 = static_cast< bool >(val2);
25556 if (arg1) (arg1)->m_controlDown = arg2;
25557
25558 resultobj = SWIG_Py_Void();
25559 return resultobj;
25560 fail:
25561 return NULL;
25562 }
25563
25564
25565 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25566 PyObject *resultobj = 0;
25567 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25568 bool result;
25569 void *argp1 = 0 ;
25570 int res1 = 0 ;
25571 PyObject *swig_obj[1] ;
25572
25573 if (!args) SWIG_fail;
25574 swig_obj[0] = args;
25575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25576 if (!SWIG_IsOK(res1)) {
25577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25578 }
25579 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25580 result = (bool) ((arg1)->m_controlDown);
25581 {
25582 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25583 }
25584 return resultobj;
25585 fail:
25586 return NULL;
25587 }
25588
25589
25590 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25591 PyObject *resultobj = 0;
25592 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25593 bool arg2 ;
25594 void *argp1 = 0 ;
25595 int res1 = 0 ;
25596 bool val2 ;
25597 int ecode2 = 0 ;
25598 PyObject *swig_obj[2] ;
25599
25600 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
25601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25602 if (!SWIG_IsOK(res1)) {
25603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25604 }
25605 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25606 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25607 if (!SWIG_IsOK(ecode2)) {
25608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
25609 }
25610 arg2 = static_cast< bool >(val2);
25611 if (arg1) (arg1)->m_shiftDown = arg2;
25612
25613 resultobj = SWIG_Py_Void();
25614 return resultobj;
25615 fail:
25616 return NULL;
25617 }
25618
25619
25620 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25621 PyObject *resultobj = 0;
25622 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25623 bool result;
25624 void *argp1 = 0 ;
25625 int res1 = 0 ;
25626 PyObject *swig_obj[1] ;
25627
25628 if (!args) SWIG_fail;
25629 swig_obj[0] = args;
25630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25631 if (!SWIG_IsOK(res1)) {
25632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25633 }
25634 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25635 result = (bool) ((arg1)->m_shiftDown);
25636 {
25637 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25638 }
25639 return resultobj;
25640 fail:
25641 return NULL;
25642 }
25643
25644
25645 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25646 PyObject *resultobj = 0;
25647 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25648 bool arg2 ;
25649 void *argp1 = 0 ;
25650 int res1 = 0 ;
25651 bool val2 ;
25652 int ecode2 = 0 ;
25653 PyObject *swig_obj[2] ;
25654
25655 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
25656 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25657 if (!SWIG_IsOK(res1)) {
25658 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25659 }
25660 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25661 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25662 if (!SWIG_IsOK(ecode2)) {
25663 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
25664 }
25665 arg2 = static_cast< bool >(val2);
25666 if (arg1) (arg1)->m_altDown = arg2;
25667
25668 resultobj = SWIG_Py_Void();
25669 return resultobj;
25670 fail:
25671 return NULL;
25672 }
25673
25674
25675 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25676 PyObject *resultobj = 0;
25677 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25678 bool result;
25679 void *argp1 = 0 ;
25680 int res1 = 0 ;
25681 PyObject *swig_obj[1] ;
25682
25683 if (!args) SWIG_fail;
25684 swig_obj[0] = args;
25685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25686 if (!SWIG_IsOK(res1)) {
25687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25688 }
25689 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25690 result = (bool) ((arg1)->m_altDown);
25691 {
25692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25693 }
25694 return resultobj;
25695 fail:
25696 return NULL;
25697 }
25698
25699
25700 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25701 PyObject *resultobj = 0;
25702 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25703 bool arg2 ;
25704 void *argp1 = 0 ;
25705 int res1 = 0 ;
25706 bool val2 ;
25707 int ecode2 = 0 ;
25708 PyObject *swig_obj[2] ;
25709
25710 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
25711 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25712 if (!SWIG_IsOK(res1)) {
25713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25714 }
25715 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25716 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25717 if (!SWIG_IsOK(ecode2)) {
25718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
25719 }
25720 arg2 = static_cast< bool >(val2);
25721 if (arg1) (arg1)->m_metaDown = arg2;
25722
25723 resultobj = SWIG_Py_Void();
25724 return resultobj;
25725 fail:
25726 return NULL;
25727 }
25728
25729
25730 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25731 PyObject *resultobj = 0;
25732 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25733 bool result;
25734 void *argp1 = 0 ;
25735 int res1 = 0 ;
25736 PyObject *swig_obj[1] ;
25737
25738 if (!args) SWIG_fail;
25739 swig_obj[0] = args;
25740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25741 if (!SWIG_IsOK(res1)) {
25742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25743 }
25744 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25745 result = (bool) ((arg1)->m_metaDown);
25746 {
25747 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25748 }
25749 return resultobj;
25750 fail:
25751 return NULL;
25752 }
25753
25754
25755 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25756 PyObject *resultobj = 0;
25757 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25758 bool arg2 ;
25759 void *argp1 = 0 ;
25760 int res1 = 0 ;
25761 bool val2 ;
25762 int ecode2 = 0 ;
25763 PyObject *swig_obj[2] ;
25764
25765 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
25766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25767 if (!SWIG_IsOK(res1)) {
25768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25769 }
25770 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25771 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
25772 if (!SWIG_IsOK(ecode2)) {
25773 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
25774 }
25775 arg2 = static_cast< bool >(val2);
25776 if (arg1) (arg1)->m_scanCode = arg2;
25777
25778 resultobj = SWIG_Py_Void();
25779 return resultobj;
25780 fail:
25781 return NULL;
25782 }
25783
25784
25785 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25786 PyObject *resultobj = 0;
25787 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25788 bool result;
25789 void *argp1 = 0 ;
25790 int res1 = 0 ;
25791 PyObject *swig_obj[1] ;
25792
25793 if (!args) SWIG_fail;
25794 swig_obj[0] = args;
25795 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25796 if (!SWIG_IsOK(res1)) {
25797 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25798 }
25799 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25800 result = (bool) ((arg1)->m_scanCode);
25801 {
25802 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25803 }
25804 return resultobj;
25805 fail:
25806 return NULL;
25807 }
25808
25809
25810 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25811 PyObject *resultobj = 0;
25812 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25813 unsigned int arg2 ;
25814 void *argp1 = 0 ;
25815 int res1 = 0 ;
25816 unsigned int val2 ;
25817 int ecode2 = 0 ;
25818 PyObject *swig_obj[2] ;
25819
25820 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
25821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25822 if (!SWIG_IsOK(res1)) {
25823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25824 }
25825 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25826 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25827 if (!SWIG_IsOK(ecode2)) {
25828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
25829 }
25830 arg2 = static_cast< unsigned int >(val2);
25831 if (arg1) (arg1)->m_rawCode = arg2;
25832
25833 resultobj = SWIG_Py_Void();
25834 return resultobj;
25835 fail:
25836 return NULL;
25837 }
25838
25839
25840 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25841 PyObject *resultobj = 0;
25842 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25843 unsigned int result;
25844 void *argp1 = 0 ;
25845 int res1 = 0 ;
25846 PyObject *swig_obj[1] ;
25847
25848 if (!args) SWIG_fail;
25849 swig_obj[0] = args;
25850 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25851 if (!SWIG_IsOK(res1)) {
25852 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25853 }
25854 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25855 result = (unsigned int) ((arg1)->m_rawCode);
25856 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25857 return resultobj;
25858 fail:
25859 return NULL;
25860 }
25861
25862
25863 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25864 PyObject *resultobj = 0;
25865 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25866 unsigned int arg2 ;
25867 void *argp1 = 0 ;
25868 int res1 = 0 ;
25869 unsigned int val2 ;
25870 int ecode2 = 0 ;
25871 PyObject *swig_obj[2] ;
25872
25873 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
25874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25875 if (!SWIG_IsOK(res1)) {
25876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25877 }
25878 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25879 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
25880 if (!SWIG_IsOK(ecode2)) {
25881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
25882 }
25883 arg2 = static_cast< unsigned int >(val2);
25884 if (arg1) (arg1)->m_rawFlags = arg2;
25885
25886 resultobj = SWIG_Py_Void();
25887 return resultobj;
25888 fail:
25889 return NULL;
25890 }
25891
25892
25893 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25894 PyObject *resultobj = 0;
25895 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
25896 unsigned int result;
25897 void *argp1 = 0 ;
25898 int res1 = 0 ;
25899 PyObject *swig_obj[1] ;
25900
25901 if (!args) SWIG_fail;
25902 swig_obj[0] = args;
25903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
25904 if (!SWIG_IsOK(res1)) {
25905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
25906 }
25907 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
25908 result = (unsigned int) ((arg1)->m_rawFlags);
25909 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
25910 return resultobj;
25911 fail:
25912 return NULL;
25913 }
25914
25915
25916 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25917 PyObject *obj;
25918 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25919 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
25920 return SWIG_Py_Void();
25921 }
25922
25923 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25924 return SWIG_Python_InitShadowInstance(args);
25925 }
25926
25927 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25928 PyObject *resultobj = 0;
25929 wxSize const &arg1_defvalue = wxDefaultSize ;
25930 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
25931 int arg2 = (int) 0 ;
25932 wxSizeEvent *result = 0 ;
25933 wxSize temp1 ;
25934 int val2 ;
25935 int ecode2 = 0 ;
25936 PyObject * obj0 = 0 ;
25937 PyObject * obj1 = 0 ;
25938 char * kwnames[] = {
25939 (char *) "sz",(char *) "winid", NULL
25940 };
25941
25942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25943 if (obj0) {
25944 {
25945 arg1 = &temp1;
25946 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
25947 }
25948 }
25949 if (obj1) {
25950 ecode2 = SWIG_AsVal_int(obj1, &val2);
25951 if (!SWIG_IsOK(ecode2)) {
25952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
25953 }
25954 arg2 = static_cast< int >(val2);
25955 }
25956 {
25957 PyThreadState* __tstate = wxPyBeginAllowThreads();
25958 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
25959 wxPyEndAllowThreads(__tstate);
25960 if (PyErr_Occurred()) SWIG_fail;
25961 }
25962 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
25963 return resultobj;
25964 fail:
25965 return NULL;
25966 }
25967
25968
25969 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25970 PyObject *resultobj = 0;
25971 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
25972 wxSize result;
25973 void *argp1 = 0 ;
25974 int res1 = 0 ;
25975 PyObject *swig_obj[1] ;
25976
25977 if (!args) SWIG_fail;
25978 swig_obj[0] = args;
25979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
25980 if (!SWIG_IsOK(res1)) {
25981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
25982 }
25983 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
25984 {
25985 PyThreadState* __tstate = wxPyBeginAllowThreads();
25986 result = ((wxSizeEvent const *)arg1)->GetSize();
25987 wxPyEndAllowThreads(__tstate);
25988 if (PyErr_Occurred()) SWIG_fail;
25989 }
25990 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
25991 return resultobj;
25992 fail:
25993 return NULL;
25994 }
25995
25996
25997 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25998 PyObject *resultobj = 0;
25999 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26000 wxRect result;
26001 void *argp1 = 0 ;
26002 int res1 = 0 ;
26003 PyObject *swig_obj[1] ;
26004
26005 if (!args) SWIG_fail;
26006 swig_obj[0] = args;
26007 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26008 if (!SWIG_IsOK(res1)) {
26009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
26010 }
26011 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26012 {
26013 PyThreadState* __tstate = wxPyBeginAllowThreads();
26014 result = ((wxSizeEvent const *)arg1)->GetRect();
26015 wxPyEndAllowThreads(__tstate);
26016 if (PyErr_Occurred()) SWIG_fail;
26017 }
26018 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26019 return resultobj;
26020 fail:
26021 return NULL;
26022 }
26023
26024
26025 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26026 PyObject *resultobj = 0;
26027 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26028 wxRect arg2 ;
26029 void *argp1 = 0 ;
26030 int res1 = 0 ;
26031 void *argp2 ;
26032 int res2 = 0 ;
26033 PyObject * obj0 = 0 ;
26034 PyObject * obj1 = 0 ;
26035 char * kwnames[] = {
26036 (char *) "self",(char *) "rect", NULL
26037 };
26038
26039 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26040 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26041 if (!SWIG_IsOK(res1)) {
26042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26043 }
26044 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26045 {
26046 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
26047 if (!SWIG_IsOK(res2)) {
26048 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26049 }
26050 if (!argp2) {
26051 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
26052 } else {
26053 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
26054 arg2 = *temp;
26055 if (SWIG_IsNewObj(res2)) delete temp;
26056 }
26057 }
26058 {
26059 PyThreadState* __tstate = wxPyBeginAllowThreads();
26060 (arg1)->SetRect(arg2);
26061 wxPyEndAllowThreads(__tstate);
26062 if (PyErr_Occurred()) SWIG_fail;
26063 }
26064 resultobj = SWIG_Py_Void();
26065 return resultobj;
26066 fail:
26067 return NULL;
26068 }
26069
26070
26071 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26072 PyObject *resultobj = 0;
26073 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26074 wxSize arg2 ;
26075 void *argp1 = 0 ;
26076 int res1 = 0 ;
26077 void *argp2 ;
26078 int res2 = 0 ;
26079 PyObject * obj0 = 0 ;
26080 PyObject * obj1 = 0 ;
26081 char * kwnames[] = {
26082 (char *) "self",(char *) "size", NULL
26083 };
26084
26085 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
26086 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26087 if (!SWIG_IsOK(res1)) {
26088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26089 }
26090 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26091 {
26092 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
26093 if (!SWIG_IsOK(res2)) {
26094 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26095 }
26096 if (!argp2) {
26097 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
26098 } else {
26099 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
26100 arg2 = *temp;
26101 if (SWIG_IsNewObj(res2)) delete temp;
26102 }
26103 }
26104 {
26105 PyThreadState* __tstate = wxPyBeginAllowThreads();
26106 wxSizeEvent_SetSize(arg1,arg2);
26107 wxPyEndAllowThreads(__tstate);
26108 if (PyErr_Occurred()) SWIG_fail;
26109 }
26110 resultobj = SWIG_Py_Void();
26111 return resultobj;
26112 fail:
26113 return NULL;
26114 }
26115
26116
26117 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26118 PyObject *resultobj = 0;
26119 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26120 wxSize *arg2 = (wxSize *) 0 ;
26121 void *argp1 = 0 ;
26122 int res1 = 0 ;
26123 void *argp2 = 0 ;
26124 int res2 = 0 ;
26125 PyObject *swig_obj[2] ;
26126
26127 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
26128 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26129 if (!SWIG_IsOK(res1)) {
26130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26131 }
26132 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26133 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
26134 if (!SWIG_IsOK(res2)) {
26135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
26136 }
26137 arg2 = reinterpret_cast< wxSize * >(argp2);
26138 if (arg1) (arg1)->m_size = *arg2;
26139
26140 resultobj = SWIG_Py_Void();
26141 return resultobj;
26142 fail:
26143 return NULL;
26144 }
26145
26146
26147 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26148 PyObject *resultobj = 0;
26149 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26150 wxSize *result = 0 ;
26151 void *argp1 = 0 ;
26152 int res1 = 0 ;
26153 PyObject *swig_obj[1] ;
26154
26155 if (!args) SWIG_fail;
26156 swig_obj[0] = args;
26157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26158 if (!SWIG_IsOK(res1)) {
26159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26160 }
26161 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26162 result = (wxSize *)& ((arg1)->m_size);
26163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
26164 return resultobj;
26165 fail:
26166 return NULL;
26167 }
26168
26169
26170 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26171 PyObject *resultobj = 0;
26172 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26173 wxRect *arg2 = (wxRect *) 0 ;
26174 void *argp1 = 0 ;
26175 int res1 = 0 ;
26176 void *argp2 = 0 ;
26177 int res2 = 0 ;
26178 PyObject *swig_obj[2] ;
26179
26180 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
26181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26182 if (!SWIG_IsOK(res1)) {
26183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26184 }
26185 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26186 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
26187 if (!SWIG_IsOK(res2)) {
26188 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
26189 }
26190 arg2 = reinterpret_cast< wxRect * >(argp2);
26191 if (arg1) (arg1)->m_rect = *arg2;
26192
26193 resultobj = SWIG_Py_Void();
26194 return resultobj;
26195 fail:
26196 return NULL;
26197 }
26198
26199
26200 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26201 PyObject *resultobj = 0;
26202 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
26203 wxRect *result = 0 ;
26204 void *argp1 = 0 ;
26205 int res1 = 0 ;
26206 PyObject *swig_obj[1] ;
26207
26208 if (!args) SWIG_fail;
26209 swig_obj[0] = args;
26210 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
26211 if (!SWIG_IsOK(res1)) {
26212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
26213 }
26214 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
26215 result = (wxRect *)& ((arg1)->m_rect);
26216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
26217 return resultobj;
26218 fail:
26219 return NULL;
26220 }
26221
26222
26223 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26224 PyObject *obj;
26225 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26226 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
26227 return SWIG_Py_Void();
26228 }
26229
26230 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26231 return SWIG_Python_InitShadowInstance(args);
26232 }
26233
26234 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26235 PyObject *resultobj = 0;
26236 wxPoint const &arg1_defvalue = wxDefaultPosition ;
26237 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
26238 int arg2 = (int) 0 ;
26239 wxMoveEvent *result = 0 ;
26240 wxPoint temp1 ;
26241 int val2 ;
26242 int ecode2 = 0 ;
26243 PyObject * obj0 = 0 ;
26244 PyObject * obj1 = 0 ;
26245 char * kwnames[] = {
26246 (char *) "pos",(char *) "winid", NULL
26247 };
26248
26249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26250 if (obj0) {
26251 {
26252 arg1 = &temp1;
26253 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
26254 }
26255 }
26256 if (obj1) {
26257 ecode2 = SWIG_AsVal_int(obj1, &val2);
26258 if (!SWIG_IsOK(ecode2)) {
26259 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
26260 }
26261 arg2 = static_cast< int >(val2);
26262 }
26263 {
26264 PyThreadState* __tstate = wxPyBeginAllowThreads();
26265 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
26266 wxPyEndAllowThreads(__tstate);
26267 if (PyErr_Occurred()) SWIG_fail;
26268 }
26269 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
26270 return resultobj;
26271 fail:
26272 return NULL;
26273 }
26274
26275
26276 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26277 PyObject *resultobj = 0;
26278 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26279 wxPoint result;
26280 void *argp1 = 0 ;
26281 int res1 = 0 ;
26282 PyObject *swig_obj[1] ;
26283
26284 if (!args) SWIG_fail;
26285 swig_obj[0] = args;
26286 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26287 if (!SWIG_IsOK(res1)) {
26288 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26289 }
26290 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26291 {
26292 PyThreadState* __tstate = wxPyBeginAllowThreads();
26293 result = ((wxMoveEvent const *)arg1)->GetPosition();
26294 wxPyEndAllowThreads(__tstate);
26295 if (PyErr_Occurred()) SWIG_fail;
26296 }
26297 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
26298 return resultobj;
26299 fail:
26300 return NULL;
26301 }
26302
26303
26304 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26305 PyObject *resultobj = 0;
26306 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26307 wxRect result;
26308 void *argp1 = 0 ;
26309 int res1 = 0 ;
26310 PyObject *swig_obj[1] ;
26311
26312 if (!args) SWIG_fail;
26313 swig_obj[0] = args;
26314 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26315 if (!SWIG_IsOK(res1)) {
26316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
26317 }
26318 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26319 {
26320 PyThreadState* __tstate = wxPyBeginAllowThreads();
26321 result = ((wxMoveEvent const *)arg1)->GetRect();
26322 wxPyEndAllowThreads(__tstate);
26323 if (PyErr_Occurred()) SWIG_fail;
26324 }
26325 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
26326 return resultobj;
26327 fail:
26328 return NULL;
26329 }
26330
26331
26332 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26333 PyObject *resultobj = 0;
26334 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26335 wxRect *arg2 = 0 ;
26336 void *argp1 = 0 ;
26337 int res1 = 0 ;
26338 wxRect temp2 ;
26339 PyObject * obj0 = 0 ;
26340 PyObject * obj1 = 0 ;
26341 char * kwnames[] = {
26342 (char *) "self",(char *) "rect", NULL
26343 };
26344
26345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
26346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26347 if (!SWIG_IsOK(res1)) {
26348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26349 }
26350 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26351 {
26352 arg2 = &temp2;
26353 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
26354 }
26355 {
26356 PyThreadState* __tstate = wxPyBeginAllowThreads();
26357 (arg1)->SetRect((wxRect const &)*arg2);
26358 wxPyEndAllowThreads(__tstate);
26359 if (PyErr_Occurred()) SWIG_fail;
26360 }
26361 resultobj = SWIG_Py_Void();
26362 return resultobj;
26363 fail:
26364 return NULL;
26365 }
26366
26367
26368 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26369 PyObject *resultobj = 0;
26370 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
26371 wxPoint *arg2 = 0 ;
26372 void *argp1 = 0 ;
26373 int res1 = 0 ;
26374 wxPoint temp2 ;
26375 PyObject * obj0 = 0 ;
26376 PyObject * obj1 = 0 ;
26377 char * kwnames[] = {
26378 (char *) "self",(char *) "pos", NULL
26379 };
26380
26381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
26383 if (!SWIG_IsOK(res1)) {
26384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
26385 }
26386 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
26387 {
26388 arg2 = &temp2;
26389 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26390 }
26391 {
26392 PyThreadState* __tstate = wxPyBeginAllowThreads();
26393 (arg1)->SetPosition((wxPoint const &)*arg2);
26394 wxPyEndAllowThreads(__tstate);
26395 if (PyErr_Occurred()) SWIG_fail;
26396 }
26397 resultobj = SWIG_Py_Void();
26398 return resultobj;
26399 fail:
26400 return NULL;
26401 }
26402
26403
26404 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26405 PyObject *obj;
26406 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26407 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
26408 return SWIG_Py_Void();
26409 }
26410
26411 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26412 return SWIG_Python_InitShadowInstance(args);
26413 }
26414
26415 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26416 PyObject *resultobj = 0;
26417 int arg1 = (int) 0 ;
26418 wxPaintEvent *result = 0 ;
26419 int val1 ;
26420 int ecode1 = 0 ;
26421 PyObject * obj0 = 0 ;
26422 char * kwnames[] = {
26423 (char *) "Id", NULL
26424 };
26425
26426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
26427 if (obj0) {
26428 ecode1 = SWIG_AsVal_int(obj0, &val1);
26429 if (!SWIG_IsOK(ecode1)) {
26430 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
26431 }
26432 arg1 = static_cast< int >(val1);
26433 }
26434 {
26435 PyThreadState* __tstate = wxPyBeginAllowThreads();
26436 result = (wxPaintEvent *)new wxPaintEvent(arg1);
26437 wxPyEndAllowThreads(__tstate);
26438 if (PyErr_Occurred()) SWIG_fail;
26439 }
26440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
26441 return resultobj;
26442 fail:
26443 return NULL;
26444 }
26445
26446
26447 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26448 PyObject *obj;
26449 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26450 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
26451 return SWIG_Py_Void();
26452 }
26453
26454 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26455 return SWIG_Python_InitShadowInstance(args);
26456 }
26457
26458 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26459 PyObject *resultobj = 0;
26460 int arg1 = (int) 0 ;
26461 wxNcPaintEvent *result = 0 ;
26462 int val1 ;
26463 int ecode1 = 0 ;
26464 PyObject * obj0 = 0 ;
26465 char * kwnames[] = {
26466 (char *) "winid", NULL
26467 };
26468
26469 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
26470 if (obj0) {
26471 ecode1 = SWIG_AsVal_int(obj0, &val1);
26472 if (!SWIG_IsOK(ecode1)) {
26473 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
26474 }
26475 arg1 = static_cast< int >(val1);
26476 }
26477 {
26478 PyThreadState* __tstate = wxPyBeginAllowThreads();
26479 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
26480 wxPyEndAllowThreads(__tstate);
26481 if (PyErr_Occurred()) SWIG_fail;
26482 }
26483 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
26484 return resultobj;
26485 fail:
26486 return NULL;
26487 }
26488
26489
26490 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26491 PyObject *obj;
26492 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26493 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
26494 return SWIG_Py_Void();
26495 }
26496
26497 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26498 return SWIG_Python_InitShadowInstance(args);
26499 }
26500
26501 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26502 PyObject *resultobj = 0;
26503 int arg1 = (int) 0 ;
26504 wxDC *arg2 = (wxDC *) NULL ;
26505 wxEraseEvent *result = 0 ;
26506 int val1 ;
26507 int ecode1 = 0 ;
26508 void *argp2 = 0 ;
26509 int res2 = 0 ;
26510 PyObject * obj0 = 0 ;
26511 PyObject * obj1 = 0 ;
26512 char * kwnames[] = {
26513 (char *) "Id",(char *) "dc", NULL
26514 };
26515
26516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26517 if (obj0) {
26518 ecode1 = SWIG_AsVal_int(obj0, &val1);
26519 if (!SWIG_IsOK(ecode1)) {
26520 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
26521 }
26522 arg1 = static_cast< int >(val1);
26523 }
26524 if (obj1) {
26525 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
26526 if (!SWIG_IsOK(res2)) {
26527 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
26528 }
26529 arg2 = reinterpret_cast< wxDC * >(argp2);
26530 }
26531 {
26532 PyThreadState* __tstate = wxPyBeginAllowThreads();
26533 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
26534 wxPyEndAllowThreads(__tstate);
26535 if (PyErr_Occurred()) SWIG_fail;
26536 }
26537 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
26538 return resultobj;
26539 fail:
26540 return NULL;
26541 }
26542
26543
26544 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26545 PyObject *resultobj = 0;
26546 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
26547 wxDC *result = 0 ;
26548 void *argp1 = 0 ;
26549 int res1 = 0 ;
26550 PyObject *swig_obj[1] ;
26551
26552 if (!args) SWIG_fail;
26553 swig_obj[0] = args;
26554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
26555 if (!SWIG_IsOK(res1)) {
26556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
26557 }
26558 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
26559 {
26560 PyThreadState* __tstate = wxPyBeginAllowThreads();
26561 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
26562 wxPyEndAllowThreads(__tstate);
26563 if (PyErr_Occurred()) SWIG_fail;
26564 }
26565 {
26566 resultobj = wxPyMake_wxObject(result, (bool)0);
26567 }
26568 return resultobj;
26569 fail:
26570 return NULL;
26571 }
26572
26573
26574 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26575 PyObject *obj;
26576 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26577 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
26578 return SWIG_Py_Void();
26579 }
26580
26581 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26582 return SWIG_Python_InitShadowInstance(args);
26583 }
26584
26585 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26586 PyObject *resultobj = 0;
26587 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26588 int arg2 = (int) 0 ;
26589 wxFocusEvent *result = 0 ;
26590 int val1 ;
26591 int ecode1 = 0 ;
26592 int val2 ;
26593 int ecode2 = 0 ;
26594 PyObject * obj0 = 0 ;
26595 PyObject * obj1 = 0 ;
26596 char * kwnames[] = {
26597 (char *) "type",(char *) "winid", NULL
26598 };
26599
26600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26601 if (obj0) {
26602 ecode1 = SWIG_AsVal_int(obj0, &val1);
26603 if (!SWIG_IsOK(ecode1)) {
26604 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26605 }
26606 arg1 = static_cast< wxEventType >(val1);
26607 }
26608 if (obj1) {
26609 ecode2 = SWIG_AsVal_int(obj1, &val2);
26610 if (!SWIG_IsOK(ecode2)) {
26611 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
26612 }
26613 arg2 = static_cast< int >(val2);
26614 }
26615 {
26616 PyThreadState* __tstate = wxPyBeginAllowThreads();
26617 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
26618 wxPyEndAllowThreads(__tstate);
26619 if (PyErr_Occurred()) SWIG_fail;
26620 }
26621 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
26622 return resultobj;
26623 fail:
26624 return NULL;
26625 }
26626
26627
26628 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26629 PyObject *resultobj = 0;
26630 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26631 wxWindow *result = 0 ;
26632 void *argp1 = 0 ;
26633 int res1 = 0 ;
26634 PyObject *swig_obj[1] ;
26635
26636 if (!args) SWIG_fail;
26637 swig_obj[0] = args;
26638 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26639 if (!SWIG_IsOK(res1)) {
26640 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
26641 }
26642 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26643 {
26644 PyThreadState* __tstate = wxPyBeginAllowThreads();
26645 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
26646 wxPyEndAllowThreads(__tstate);
26647 if (PyErr_Occurred()) SWIG_fail;
26648 }
26649 {
26650 resultobj = wxPyMake_wxObject(result, (bool)0);
26651 }
26652 return resultobj;
26653 fail:
26654 return NULL;
26655 }
26656
26657
26658 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26659 PyObject *resultobj = 0;
26660 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
26661 wxWindow *arg2 = (wxWindow *) 0 ;
26662 void *argp1 = 0 ;
26663 int res1 = 0 ;
26664 void *argp2 = 0 ;
26665 int res2 = 0 ;
26666 PyObject * obj0 = 0 ;
26667 PyObject * obj1 = 0 ;
26668 char * kwnames[] = {
26669 (char *) "self",(char *) "win", NULL
26670 };
26671
26672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
26673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
26674 if (!SWIG_IsOK(res1)) {
26675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
26676 }
26677 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
26678 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26679 if (!SWIG_IsOK(res2)) {
26680 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
26681 }
26682 arg2 = reinterpret_cast< wxWindow * >(argp2);
26683 {
26684 PyThreadState* __tstate = wxPyBeginAllowThreads();
26685 (arg1)->SetWindow(arg2);
26686 wxPyEndAllowThreads(__tstate);
26687 if (PyErr_Occurred()) SWIG_fail;
26688 }
26689 resultobj = SWIG_Py_Void();
26690 return resultobj;
26691 fail:
26692 return NULL;
26693 }
26694
26695
26696 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26697 PyObject *obj;
26698 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26699 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
26700 return SWIG_Py_Void();
26701 }
26702
26703 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26704 return SWIG_Python_InitShadowInstance(args);
26705 }
26706
26707 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26708 PyObject *resultobj = 0;
26709 wxWindow *arg1 = (wxWindow *) NULL ;
26710 wxChildFocusEvent *result = 0 ;
26711 void *argp1 = 0 ;
26712 int res1 = 0 ;
26713 PyObject * obj0 = 0 ;
26714 char * kwnames[] = {
26715 (char *) "win", NULL
26716 };
26717
26718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
26719 if (obj0) {
26720 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26721 if (!SWIG_IsOK(res1)) {
26722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26723 }
26724 arg1 = reinterpret_cast< wxWindow * >(argp1);
26725 }
26726 {
26727 PyThreadState* __tstate = wxPyBeginAllowThreads();
26728 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
26729 wxPyEndAllowThreads(__tstate);
26730 if (PyErr_Occurred()) SWIG_fail;
26731 }
26732 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
26733 return resultobj;
26734 fail:
26735 return NULL;
26736 }
26737
26738
26739 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26740 PyObject *resultobj = 0;
26741 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
26742 wxWindow *result = 0 ;
26743 void *argp1 = 0 ;
26744 int res1 = 0 ;
26745 PyObject *swig_obj[1] ;
26746
26747 if (!args) SWIG_fail;
26748 swig_obj[0] = args;
26749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
26750 if (!SWIG_IsOK(res1)) {
26751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
26752 }
26753 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
26754 {
26755 PyThreadState* __tstate = wxPyBeginAllowThreads();
26756 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
26757 wxPyEndAllowThreads(__tstate);
26758 if (PyErr_Occurred()) SWIG_fail;
26759 }
26760 {
26761 resultobj = wxPyMake_wxObject(result, (bool)0);
26762 }
26763 return resultobj;
26764 fail:
26765 return NULL;
26766 }
26767
26768
26769 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26770 PyObject *obj;
26771 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26772 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
26773 return SWIG_Py_Void();
26774 }
26775
26776 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26777 return SWIG_Python_InitShadowInstance(args);
26778 }
26779
26780 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26781 PyObject *resultobj = 0;
26782 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26783 bool arg2 = (bool) true ;
26784 int arg3 = (int) 0 ;
26785 wxActivateEvent *result = 0 ;
26786 int val1 ;
26787 int ecode1 = 0 ;
26788 bool val2 ;
26789 int ecode2 = 0 ;
26790 int val3 ;
26791 int ecode3 = 0 ;
26792 PyObject * obj0 = 0 ;
26793 PyObject * obj1 = 0 ;
26794 PyObject * obj2 = 0 ;
26795 char * kwnames[] = {
26796 (char *) "type",(char *) "active",(char *) "Id", NULL
26797 };
26798
26799 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26800 if (obj0) {
26801 ecode1 = SWIG_AsVal_int(obj0, &val1);
26802 if (!SWIG_IsOK(ecode1)) {
26803 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26804 }
26805 arg1 = static_cast< wxEventType >(val1);
26806 }
26807 if (obj1) {
26808 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26809 if (!SWIG_IsOK(ecode2)) {
26810 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
26811 }
26812 arg2 = static_cast< bool >(val2);
26813 }
26814 if (obj2) {
26815 ecode3 = SWIG_AsVal_int(obj2, &val3);
26816 if (!SWIG_IsOK(ecode3)) {
26817 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
26818 }
26819 arg3 = static_cast< int >(val3);
26820 }
26821 {
26822 PyThreadState* __tstate = wxPyBeginAllowThreads();
26823 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
26824 wxPyEndAllowThreads(__tstate);
26825 if (PyErr_Occurred()) SWIG_fail;
26826 }
26827 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
26828 return resultobj;
26829 fail:
26830 return NULL;
26831 }
26832
26833
26834 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26835 PyObject *resultobj = 0;
26836 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
26837 bool result;
26838 void *argp1 = 0 ;
26839 int res1 = 0 ;
26840 PyObject *swig_obj[1] ;
26841
26842 if (!args) SWIG_fail;
26843 swig_obj[0] = args;
26844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
26845 if (!SWIG_IsOK(res1)) {
26846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
26847 }
26848 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
26849 {
26850 PyThreadState* __tstate = wxPyBeginAllowThreads();
26851 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
26852 wxPyEndAllowThreads(__tstate);
26853 if (PyErr_Occurred()) SWIG_fail;
26854 }
26855 {
26856 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26857 }
26858 return resultobj;
26859 fail:
26860 return NULL;
26861 }
26862
26863
26864 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26865 PyObject *obj;
26866 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26867 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
26868 return SWIG_Py_Void();
26869 }
26870
26871 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26872 return SWIG_Python_InitShadowInstance(args);
26873 }
26874
26875 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26876 PyObject *resultobj = 0;
26877 int arg1 = (int) 0 ;
26878 wxInitDialogEvent *result = 0 ;
26879 int val1 ;
26880 int ecode1 = 0 ;
26881 PyObject * obj0 = 0 ;
26882 char * kwnames[] = {
26883 (char *) "Id", NULL
26884 };
26885
26886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
26887 if (obj0) {
26888 ecode1 = SWIG_AsVal_int(obj0, &val1);
26889 if (!SWIG_IsOK(ecode1)) {
26890 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
26891 }
26892 arg1 = static_cast< int >(val1);
26893 }
26894 {
26895 PyThreadState* __tstate = wxPyBeginAllowThreads();
26896 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
26897 wxPyEndAllowThreads(__tstate);
26898 if (PyErr_Occurred()) SWIG_fail;
26899 }
26900 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
26901 return resultobj;
26902 fail:
26903 return NULL;
26904 }
26905
26906
26907 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26908 PyObject *obj;
26909 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26910 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
26911 return SWIG_Py_Void();
26912 }
26913
26914 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26915 return SWIG_Python_InitShadowInstance(args);
26916 }
26917
26918 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26919 PyObject *resultobj = 0;
26920 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26921 int arg2 = (int) 0 ;
26922 wxMenu *arg3 = (wxMenu *) NULL ;
26923 wxMenuEvent *result = 0 ;
26924 int val1 ;
26925 int ecode1 = 0 ;
26926 int val2 ;
26927 int ecode2 = 0 ;
26928 void *argp3 = 0 ;
26929 int res3 = 0 ;
26930 PyObject * obj0 = 0 ;
26931 PyObject * obj1 = 0 ;
26932 PyObject * obj2 = 0 ;
26933 char * kwnames[] = {
26934 (char *) "type",(char *) "winid",(char *) "menu", NULL
26935 };
26936
26937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26938 if (obj0) {
26939 ecode1 = SWIG_AsVal_int(obj0, &val1);
26940 if (!SWIG_IsOK(ecode1)) {
26941 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26942 }
26943 arg1 = static_cast< wxEventType >(val1);
26944 }
26945 if (obj1) {
26946 ecode2 = SWIG_AsVal_int(obj1, &val2);
26947 if (!SWIG_IsOK(ecode2)) {
26948 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
26949 }
26950 arg2 = static_cast< int >(val2);
26951 }
26952 if (obj2) {
26953 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
26954 if (!SWIG_IsOK(res3)) {
26955 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
26956 }
26957 arg3 = reinterpret_cast< wxMenu * >(argp3);
26958 }
26959 {
26960 PyThreadState* __tstate = wxPyBeginAllowThreads();
26961 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
26962 wxPyEndAllowThreads(__tstate);
26963 if (PyErr_Occurred()) SWIG_fail;
26964 }
26965 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
26966 return resultobj;
26967 fail:
26968 return NULL;
26969 }
26970
26971
26972 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26973 PyObject *resultobj = 0;
26974 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
26975 int result;
26976 void *argp1 = 0 ;
26977 int res1 = 0 ;
26978 PyObject *swig_obj[1] ;
26979
26980 if (!args) SWIG_fail;
26981 swig_obj[0] = args;
26982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
26983 if (!SWIG_IsOK(res1)) {
26984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
26985 }
26986 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
26987 {
26988 PyThreadState* __tstate = wxPyBeginAllowThreads();
26989 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
26990 wxPyEndAllowThreads(__tstate);
26991 if (PyErr_Occurred()) SWIG_fail;
26992 }
26993 resultobj = SWIG_From_int(static_cast< int >(result));
26994 return resultobj;
26995 fail:
26996 return NULL;
26997 }
26998
26999
27000 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27001 PyObject *resultobj = 0;
27002 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27003 bool result;
27004 void *argp1 = 0 ;
27005 int res1 = 0 ;
27006 PyObject *swig_obj[1] ;
27007
27008 if (!args) SWIG_fail;
27009 swig_obj[0] = args;
27010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27011 if (!SWIG_IsOK(res1)) {
27012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27013 }
27014 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27015 {
27016 PyThreadState* __tstate = wxPyBeginAllowThreads();
27017 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
27018 wxPyEndAllowThreads(__tstate);
27019 if (PyErr_Occurred()) SWIG_fail;
27020 }
27021 {
27022 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27023 }
27024 return resultobj;
27025 fail:
27026 return NULL;
27027 }
27028
27029
27030 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27031 PyObject *resultobj = 0;
27032 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
27033 wxMenu *result = 0 ;
27034 void *argp1 = 0 ;
27035 int res1 = 0 ;
27036 PyObject *swig_obj[1] ;
27037
27038 if (!args) SWIG_fail;
27039 swig_obj[0] = args;
27040 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
27041 if (!SWIG_IsOK(res1)) {
27042 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
27043 }
27044 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
27045 {
27046 PyThreadState* __tstate = wxPyBeginAllowThreads();
27047 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
27048 wxPyEndAllowThreads(__tstate);
27049 if (PyErr_Occurred()) SWIG_fail;
27050 }
27051 {
27052 resultobj = wxPyMake_wxObject(result, (bool)0);
27053 }
27054 return resultobj;
27055 fail:
27056 return NULL;
27057 }
27058
27059
27060 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27061 PyObject *obj;
27062 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27063 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
27064 return SWIG_Py_Void();
27065 }
27066
27067 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27068 return SWIG_Python_InitShadowInstance(args);
27069 }
27070
27071 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27072 PyObject *resultobj = 0;
27073 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
27074 int arg2 = (int) 0 ;
27075 wxCloseEvent *result = 0 ;
27076 int val1 ;
27077 int ecode1 = 0 ;
27078 int val2 ;
27079 int ecode2 = 0 ;
27080 PyObject * obj0 = 0 ;
27081 PyObject * obj1 = 0 ;
27082 char * kwnames[] = {
27083 (char *) "type",(char *) "winid", NULL
27084 };
27085
27086 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27087 if (obj0) {
27088 ecode1 = SWIG_AsVal_int(obj0, &val1);
27089 if (!SWIG_IsOK(ecode1)) {
27090 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
27091 }
27092 arg1 = static_cast< wxEventType >(val1);
27093 }
27094 if (obj1) {
27095 ecode2 = SWIG_AsVal_int(obj1, &val2);
27096 if (!SWIG_IsOK(ecode2)) {
27097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
27098 }
27099 arg2 = static_cast< int >(val2);
27100 }
27101 {
27102 PyThreadState* __tstate = wxPyBeginAllowThreads();
27103 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
27104 wxPyEndAllowThreads(__tstate);
27105 if (PyErr_Occurred()) SWIG_fail;
27106 }
27107 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
27108 return resultobj;
27109 fail:
27110 return NULL;
27111 }
27112
27113
27114 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27115 PyObject *resultobj = 0;
27116 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27117 bool arg2 ;
27118 void *argp1 = 0 ;
27119 int res1 = 0 ;
27120 bool val2 ;
27121 int ecode2 = 0 ;
27122 PyObject * obj0 = 0 ;
27123 PyObject * obj1 = 0 ;
27124 char * kwnames[] = {
27125 (char *) "self",(char *) "logOff", NULL
27126 };
27127
27128 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
27129 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27130 if (!SWIG_IsOK(res1)) {
27131 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27132 }
27133 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27134 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27135 if (!SWIG_IsOK(ecode2)) {
27136 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
27137 }
27138 arg2 = static_cast< bool >(val2);
27139 {
27140 PyThreadState* __tstate = wxPyBeginAllowThreads();
27141 (arg1)->SetLoggingOff(arg2);
27142 wxPyEndAllowThreads(__tstate);
27143 if (PyErr_Occurred()) SWIG_fail;
27144 }
27145 resultobj = SWIG_Py_Void();
27146 return resultobj;
27147 fail:
27148 return NULL;
27149 }
27150
27151
27152 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27153 PyObject *resultobj = 0;
27154 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27155 bool result;
27156 void *argp1 = 0 ;
27157 int res1 = 0 ;
27158 PyObject *swig_obj[1] ;
27159
27160 if (!args) SWIG_fail;
27161 swig_obj[0] = args;
27162 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27163 if (!SWIG_IsOK(res1)) {
27164 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27165 }
27166 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27167 {
27168 PyThreadState* __tstate = wxPyBeginAllowThreads();
27169 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
27170 wxPyEndAllowThreads(__tstate);
27171 if (PyErr_Occurred()) SWIG_fail;
27172 }
27173 {
27174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27175 }
27176 return resultobj;
27177 fail:
27178 return NULL;
27179 }
27180
27181
27182 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27183 PyObject *resultobj = 0;
27184 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27185 bool arg2 = (bool) true ;
27186 void *argp1 = 0 ;
27187 int res1 = 0 ;
27188 bool val2 ;
27189 int ecode2 = 0 ;
27190 PyObject * obj0 = 0 ;
27191 PyObject * obj1 = 0 ;
27192 char * kwnames[] = {
27193 (char *) "self",(char *) "veto", NULL
27194 };
27195
27196 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
27197 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27198 if (!SWIG_IsOK(res1)) {
27199 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27200 }
27201 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27202 if (obj1) {
27203 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27204 if (!SWIG_IsOK(ecode2)) {
27205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
27206 }
27207 arg2 = static_cast< bool >(val2);
27208 }
27209 {
27210 PyThreadState* __tstate = wxPyBeginAllowThreads();
27211 (arg1)->Veto(arg2);
27212 wxPyEndAllowThreads(__tstate);
27213 if (PyErr_Occurred()) SWIG_fail;
27214 }
27215 resultobj = SWIG_Py_Void();
27216 return resultobj;
27217 fail:
27218 return NULL;
27219 }
27220
27221
27222 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27223 PyObject *resultobj = 0;
27224 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27225 bool result;
27226 void *argp1 = 0 ;
27227 int res1 = 0 ;
27228 PyObject *swig_obj[1] ;
27229
27230 if (!args) SWIG_fail;
27231 swig_obj[0] = args;
27232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27233 if (!SWIG_IsOK(res1)) {
27234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27235 }
27236 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27237 {
27238 PyThreadState* __tstate = wxPyBeginAllowThreads();
27239 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
27240 wxPyEndAllowThreads(__tstate);
27241 if (PyErr_Occurred()) SWIG_fail;
27242 }
27243 {
27244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27245 }
27246 return resultobj;
27247 fail:
27248 return NULL;
27249 }
27250
27251
27252 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27253 PyObject *resultobj = 0;
27254 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27255 bool arg2 ;
27256 void *argp1 = 0 ;
27257 int res1 = 0 ;
27258 bool val2 ;
27259 int ecode2 = 0 ;
27260 PyObject * obj0 = 0 ;
27261 PyObject * obj1 = 0 ;
27262 char * kwnames[] = {
27263 (char *) "self",(char *) "canVeto", NULL
27264 };
27265
27266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
27267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27268 if (!SWIG_IsOK(res1)) {
27269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
27270 }
27271 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27272 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27273 if (!SWIG_IsOK(ecode2)) {
27274 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
27275 }
27276 arg2 = static_cast< bool >(val2);
27277 {
27278 PyThreadState* __tstate = wxPyBeginAllowThreads();
27279 (arg1)->SetCanVeto(arg2);
27280 wxPyEndAllowThreads(__tstate);
27281 if (PyErr_Occurred()) SWIG_fail;
27282 }
27283 resultobj = SWIG_Py_Void();
27284 return resultobj;
27285 fail:
27286 return NULL;
27287 }
27288
27289
27290 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27291 PyObject *resultobj = 0;
27292 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
27293 bool result;
27294 void *argp1 = 0 ;
27295 int res1 = 0 ;
27296 PyObject *swig_obj[1] ;
27297
27298 if (!args) SWIG_fail;
27299 swig_obj[0] = args;
27300 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
27301 if (!SWIG_IsOK(res1)) {
27302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
27303 }
27304 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
27305 {
27306 PyThreadState* __tstate = wxPyBeginAllowThreads();
27307 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
27308 wxPyEndAllowThreads(__tstate);
27309 if (PyErr_Occurred()) SWIG_fail;
27310 }
27311 {
27312 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27313 }
27314 return resultobj;
27315 fail:
27316 return NULL;
27317 }
27318
27319
27320 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27321 PyObject *obj;
27322 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27323 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
27324 return SWIG_Py_Void();
27325 }
27326
27327 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27328 return SWIG_Python_InitShadowInstance(args);
27329 }
27330
27331 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27332 PyObject *resultobj = 0;
27333 int arg1 = (int) 0 ;
27334 bool arg2 = (bool) false ;
27335 wxShowEvent *result = 0 ;
27336 int val1 ;
27337 int ecode1 = 0 ;
27338 bool val2 ;
27339 int ecode2 = 0 ;
27340 PyObject * obj0 = 0 ;
27341 PyObject * obj1 = 0 ;
27342 char * kwnames[] = {
27343 (char *) "winid",(char *) "show", NULL
27344 };
27345
27346 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27347 if (obj0) {
27348 ecode1 = SWIG_AsVal_int(obj0, &val1);
27349 if (!SWIG_IsOK(ecode1)) {
27350 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
27351 }
27352 arg1 = static_cast< int >(val1);
27353 }
27354 if (obj1) {
27355 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27356 if (!SWIG_IsOK(ecode2)) {
27357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
27358 }
27359 arg2 = static_cast< bool >(val2);
27360 }
27361 {
27362 PyThreadState* __tstate = wxPyBeginAllowThreads();
27363 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
27364 wxPyEndAllowThreads(__tstate);
27365 if (PyErr_Occurred()) SWIG_fail;
27366 }
27367 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
27368 return resultobj;
27369 fail:
27370 return NULL;
27371 }
27372
27373
27374 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27375 PyObject *resultobj = 0;
27376 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27377 bool arg2 ;
27378 void *argp1 = 0 ;
27379 int res1 = 0 ;
27380 bool val2 ;
27381 int ecode2 = 0 ;
27382 PyObject * obj0 = 0 ;
27383 PyObject * obj1 = 0 ;
27384 char * kwnames[] = {
27385 (char *) "self",(char *) "show", NULL
27386 };
27387
27388 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
27389 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27390 if (!SWIG_IsOK(res1)) {
27391 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
27392 }
27393 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27394 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27395 if (!SWIG_IsOK(ecode2)) {
27396 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
27397 }
27398 arg2 = static_cast< bool >(val2);
27399 {
27400 PyThreadState* __tstate = wxPyBeginAllowThreads();
27401 (arg1)->SetShow(arg2);
27402 wxPyEndAllowThreads(__tstate);
27403 if (PyErr_Occurred()) SWIG_fail;
27404 }
27405 resultobj = SWIG_Py_Void();
27406 return resultobj;
27407 fail:
27408 return NULL;
27409 }
27410
27411
27412 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27413 PyObject *resultobj = 0;
27414 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
27415 bool result;
27416 void *argp1 = 0 ;
27417 int res1 = 0 ;
27418 PyObject *swig_obj[1] ;
27419
27420 if (!args) SWIG_fail;
27421 swig_obj[0] = args;
27422 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
27423 if (!SWIG_IsOK(res1)) {
27424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
27425 }
27426 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
27427 {
27428 PyThreadState* __tstate = wxPyBeginAllowThreads();
27429 result = (bool)((wxShowEvent const *)arg1)->GetShow();
27430 wxPyEndAllowThreads(__tstate);
27431 if (PyErr_Occurred()) SWIG_fail;
27432 }
27433 {
27434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27435 }
27436 return resultobj;
27437 fail:
27438 return NULL;
27439 }
27440
27441
27442 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27443 PyObject *obj;
27444 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27445 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
27446 return SWIG_Py_Void();
27447 }
27448
27449 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27450 return SWIG_Python_InitShadowInstance(args);
27451 }
27452
27453 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27454 PyObject *resultobj = 0;
27455 int arg1 = (int) 0 ;
27456 bool arg2 = (bool) true ;
27457 wxIconizeEvent *result = 0 ;
27458 int val1 ;
27459 int ecode1 = 0 ;
27460 bool val2 ;
27461 int ecode2 = 0 ;
27462 PyObject * obj0 = 0 ;
27463 PyObject * obj1 = 0 ;
27464 char * kwnames[] = {
27465 (char *) "id",(char *) "iconized", NULL
27466 };
27467
27468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
27469 if (obj0) {
27470 ecode1 = SWIG_AsVal_int(obj0, &val1);
27471 if (!SWIG_IsOK(ecode1)) {
27472 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
27473 }
27474 arg1 = static_cast< int >(val1);
27475 }
27476 if (obj1) {
27477 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27478 if (!SWIG_IsOK(ecode2)) {
27479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
27480 }
27481 arg2 = static_cast< bool >(val2);
27482 }
27483 {
27484 PyThreadState* __tstate = wxPyBeginAllowThreads();
27485 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
27486 wxPyEndAllowThreads(__tstate);
27487 if (PyErr_Occurred()) SWIG_fail;
27488 }
27489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
27490 return resultobj;
27491 fail:
27492 return NULL;
27493 }
27494
27495
27496 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27497 PyObject *resultobj = 0;
27498 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
27499 bool result;
27500 void *argp1 = 0 ;
27501 int res1 = 0 ;
27502 PyObject *swig_obj[1] ;
27503
27504 if (!args) SWIG_fail;
27505 swig_obj[0] = args;
27506 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
27507 if (!SWIG_IsOK(res1)) {
27508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
27509 }
27510 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
27511 {
27512 PyThreadState* __tstate = wxPyBeginAllowThreads();
27513 result = (bool)(arg1)->Iconized();
27514 wxPyEndAllowThreads(__tstate);
27515 if (PyErr_Occurred()) SWIG_fail;
27516 }
27517 {
27518 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27519 }
27520 return resultobj;
27521 fail:
27522 return NULL;
27523 }
27524
27525
27526 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27527 PyObject *obj;
27528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27529 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
27530 return SWIG_Py_Void();
27531 }
27532
27533 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27534 return SWIG_Python_InitShadowInstance(args);
27535 }
27536
27537 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27538 PyObject *resultobj = 0;
27539 int arg1 = (int) 0 ;
27540 wxMaximizeEvent *result = 0 ;
27541 int val1 ;
27542 int ecode1 = 0 ;
27543 PyObject * obj0 = 0 ;
27544 char * kwnames[] = {
27545 (char *) "id", NULL
27546 };
27547
27548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
27549 if (obj0) {
27550 ecode1 = SWIG_AsVal_int(obj0, &val1);
27551 if (!SWIG_IsOK(ecode1)) {
27552 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
27553 }
27554 arg1 = static_cast< int >(val1);
27555 }
27556 {
27557 PyThreadState* __tstate = wxPyBeginAllowThreads();
27558 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
27559 wxPyEndAllowThreads(__tstate);
27560 if (PyErr_Occurred()) SWIG_fail;
27561 }
27562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
27563 return resultobj;
27564 fail:
27565 return NULL;
27566 }
27567
27568
27569 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27570 PyObject *obj;
27571 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27572 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
27573 return SWIG_Py_Void();
27574 }
27575
27576 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27577 return SWIG_Python_InitShadowInstance(args);
27578 }
27579
27580 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27581 PyObject *resultobj = 0;
27582 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27583 wxPoint result;
27584 void *argp1 = 0 ;
27585 int res1 = 0 ;
27586 PyObject *swig_obj[1] ;
27587
27588 if (!args) SWIG_fail;
27589 swig_obj[0] = args;
27590 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27591 if (!SWIG_IsOK(res1)) {
27592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27593 }
27594 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27595 {
27596 PyThreadState* __tstate = wxPyBeginAllowThreads();
27597 result = (arg1)->GetPosition();
27598 wxPyEndAllowThreads(__tstate);
27599 if (PyErr_Occurred()) SWIG_fail;
27600 }
27601 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
27602 return resultobj;
27603 fail:
27604 return NULL;
27605 }
27606
27607
27608 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27609 PyObject *resultobj = 0;
27610 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27611 int result;
27612 void *argp1 = 0 ;
27613 int res1 = 0 ;
27614 PyObject *swig_obj[1] ;
27615
27616 if (!args) SWIG_fail;
27617 swig_obj[0] = args;
27618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27619 if (!SWIG_IsOK(res1)) {
27620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27621 }
27622 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27623 {
27624 PyThreadState* __tstate = wxPyBeginAllowThreads();
27625 result = (int)(arg1)->GetNumberOfFiles();
27626 wxPyEndAllowThreads(__tstate);
27627 if (PyErr_Occurred()) SWIG_fail;
27628 }
27629 resultobj = SWIG_From_int(static_cast< int >(result));
27630 return resultobj;
27631 fail:
27632 return NULL;
27633 }
27634
27635
27636 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27637 PyObject *resultobj = 0;
27638 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
27639 PyObject *result = 0 ;
27640 void *argp1 = 0 ;
27641 int res1 = 0 ;
27642 PyObject *swig_obj[1] ;
27643
27644 if (!args) SWIG_fail;
27645 swig_obj[0] = args;
27646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
27647 if (!SWIG_IsOK(res1)) {
27648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
27649 }
27650 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
27651 {
27652 PyThreadState* __tstate = wxPyBeginAllowThreads();
27653 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
27654 wxPyEndAllowThreads(__tstate);
27655 if (PyErr_Occurred()) SWIG_fail;
27656 }
27657 resultobj = result;
27658 return resultobj;
27659 fail:
27660 return NULL;
27661 }
27662
27663
27664 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27665 PyObject *obj;
27666 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27667 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
27668 return SWIG_Py_Void();
27669 }
27670
27671 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27672 PyObject *resultobj = 0;
27673 int arg1 = (int) 0 ;
27674 wxUpdateUIEvent *result = 0 ;
27675 int val1 ;
27676 int ecode1 = 0 ;
27677 PyObject * obj0 = 0 ;
27678 char * kwnames[] = {
27679 (char *) "commandId", NULL
27680 };
27681
27682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
27683 if (obj0) {
27684 ecode1 = SWIG_AsVal_int(obj0, &val1);
27685 if (!SWIG_IsOK(ecode1)) {
27686 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
27687 }
27688 arg1 = static_cast< int >(val1);
27689 }
27690 {
27691 PyThreadState* __tstate = wxPyBeginAllowThreads();
27692 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
27693 wxPyEndAllowThreads(__tstate);
27694 if (PyErr_Occurred()) SWIG_fail;
27695 }
27696 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
27697 return resultobj;
27698 fail:
27699 return NULL;
27700 }
27701
27702
27703 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27704 PyObject *resultobj = 0;
27705 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27706 bool result;
27707 void *argp1 = 0 ;
27708 int res1 = 0 ;
27709 PyObject *swig_obj[1] ;
27710
27711 if (!args) SWIG_fail;
27712 swig_obj[0] = args;
27713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27714 if (!SWIG_IsOK(res1)) {
27715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27716 }
27717 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27718 {
27719 PyThreadState* __tstate = wxPyBeginAllowThreads();
27720 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
27721 wxPyEndAllowThreads(__tstate);
27722 if (PyErr_Occurred()) SWIG_fail;
27723 }
27724 {
27725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27726 }
27727 return resultobj;
27728 fail:
27729 return NULL;
27730 }
27731
27732
27733 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27734 PyObject *resultobj = 0;
27735 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27736 bool result;
27737 void *argp1 = 0 ;
27738 int res1 = 0 ;
27739 PyObject *swig_obj[1] ;
27740
27741 if (!args) SWIG_fail;
27742 swig_obj[0] = args;
27743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27744 if (!SWIG_IsOK(res1)) {
27745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27746 }
27747 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27748 {
27749 PyThreadState* __tstate = wxPyBeginAllowThreads();
27750 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
27751 wxPyEndAllowThreads(__tstate);
27752 if (PyErr_Occurred()) SWIG_fail;
27753 }
27754 {
27755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27756 }
27757 return resultobj;
27758 fail:
27759 return NULL;
27760 }
27761
27762
27763 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27764 PyObject *resultobj = 0;
27765 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27766 bool result;
27767 void *argp1 = 0 ;
27768 int res1 = 0 ;
27769 PyObject *swig_obj[1] ;
27770
27771 if (!args) SWIG_fail;
27772 swig_obj[0] = args;
27773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27774 if (!SWIG_IsOK(res1)) {
27775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27776 }
27777 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27778 {
27779 PyThreadState* __tstate = wxPyBeginAllowThreads();
27780 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
27781 wxPyEndAllowThreads(__tstate);
27782 if (PyErr_Occurred()) SWIG_fail;
27783 }
27784 {
27785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27786 }
27787 return resultobj;
27788 fail:
27789 return NULL;
27790 }
27791
27792
27793 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27794 PyObject *resultobj = 0;
27795 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27796 wxString result;
27797 void *argp1 = 0 ;
27798 int res1 = 0 ;
27799 PyObject *swig_obj[1] ;
27800
27801 if (!args) SWIG_fail;
27802 swig_obj[0] = args;
27803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27804 if (!SWIG_IsOK(res1)) {
27805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27806 }
27807 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27808 {
27809 PyThreadState* __tstate = wxPyBeginAllowThreads();
27810 result = ((wxUpdateUIEvent const *)arg1)->GetText();
27811 wxPyEndAllowThreads(__tstate);
27812 if (PyErr_Occurred()) SWIG_fail;
27813 }
27814 {
27815 #if wxUSE_UNICODE
27816 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27817 #else
27818 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27819 #endif
27820 }
27821 return resultobj;
27822 fail:
27823 return NULL;
27824 }
27825
27826
27827 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27828 PyObject *resultobj = 0;
27829 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27830 bool result;
27831 void *argp1 = 0 ;
27832 int res1 = 0 ;
27833 PyObject *swig_obj[1] ;
27834
27835 if (!args) SWIG_fail;
27836 swig_obj[0] = args;
27837 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27838 if (!SWIG_IsOK(res1)) {
27839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27840 }
27841 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27842 {
27843 PyThreadState* __tstate = wxPyBeginAllowThreads();
27844 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
27845 wxPyEndAllowThreads(__tstate);
27846 if (PyErr_Occurred()) SWIG_fail;
27847 }
27848 {
27849 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27850 }
27851 return resultobj;
27852 fail:
27853 return NULL;
27854 }
27855
27856
27857 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27858 PyObject *resultobj = 0;
27859 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27860 bool result;
27861 void *argp1 = 0 ;
27862 int res1 = 0 ;
27863 PyObject *swig_obj[1] ;
27864
27865 if (!args) SWIG_fail;
27866 swig_obj[0] = args;
27867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27868 if (!SWIG_IsOK(res1)) {
27869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27870 }
27871 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27872 {
27873 PyThreadState* __tstate = wxPyBeginAllowThreads();
27874 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
27875 wxPyEndAllowThreads(__tstate);
27876 if (PyErr_Occurred()) SWIG_fail;
27877 }
27878 {
27879 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27880 }
27881 return resultobj;
27882 fail:
27883 return NULL;
27884 }
27885
27886
27887 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27888 PyObject *resultobj = 0;
27889 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27890 bool result;
27891 void *argp1 = 0 ;
27892 int res1 = 0 ;
27893 PyObject *swig_obj[1] ;
27894
27895 if (!args) SWIG_fail;
27896 swig_obj[0] = args;
27897 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27898 if (!SWIG_IsOK(res1)) {
27899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27900 }
27901 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27902 {
27903 PyThreadState* __tstate = wxPyBeginAllowThreads();
27904 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
27905 wxPyEndAllowThreads(__tstate);
27906 if (PyErr_Occurred()) SWIG_fail;
27907 }
27908 {
27909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27910 }
27911 return resultobj;
27912 fail:
27913 return NULL;
27914 }
27915
27916
27917 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27918 PyObject *resultobj = 0;
27919 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27920 bool result;
27921 void *argp1 = 0 ;
27922 int res1 = 0 ;
27923 PyObject *swig_obj[1] ;
27924
27925 if (!args) SWIG_fail;
27926 swig_obj[0] = args;
27927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27928 if (!SWIG_IsOK(res1)) {
27929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
27930 }
27931 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27932 {
27933 PyThreadState* __tstate = wxPyBeginAllowThreads();
27934 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
27935 wxPyEndAllowThreads(__tstate);
27936 if (PyErr_Occurred()) SWIG_fail;
27937 }
27938 {
27939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27940 }
27941 return resultobj;
27942 fail:
27943 return NULL;
27944 }
27945
27946
27947 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27948 PyObject *resultobj = 0;
27949 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27950 bool arg2 ;
27951 void *argp1 = 0 ;
27952 int res1 = 0 ;
27953 bool val2 ;
27954 int ecode2 = 0 ;
27955 PyObject * obj0 = 0 ;
27956 PyObject * obj1 = 0 ;
27957 char * kwnames[] = {
27958 (char *) "self",(char *) "check", NULL
27959 };
27960
27961 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
27962 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
27963 if (!SWIG_IsOK(res1)) {
27964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
27965 }
27966 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
27967 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27968 if (!SWIG_IsOK(ecode2)) {
27969 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
27970 }
27971 arg2 = static_cast< bool >(val2);
27972 {
27973 PyThreadState* __tstate = wxPyBeginAllowThreads();
27974 (arg1)->Check(arg2);
27975 wxPyEndAllowThreads(__tstate);
27976 if (PyErr_Occurred()) SWIG_fail;
27977 }
27978 resultobj = SWIG_Py_Void();
27979 return resultobj;
27980 fail:
27981 return NULL;
27982 }
27983
27984
27985 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27986 PyObject *resultobj = 0;
27987 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
27988 bool arg2 ;
27989 void *argp1 = 0 ;
27990 int res1 = 0 ;
27991 bool val2 ;
27992 int ecode2 = 0 ;
27993 PyObject * obj0 = 0 ;
27994 PyObject * obj1 = 0 ;
27995 char * kwnames[] = {
27996 (char *) "self",(char *) "enable", NULL
27997 };
27998
27999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
28000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28001 if (!SWIG_IsOK(res1)) {
28002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28003 }
28004 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28005 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28006 if (!SWIG_IsOK(ecode2)) {
28007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
28008 }
28009 arg2 = static_cast< bool >(val2);
28010 {
28011 PyThreadState* __tstate = wxPyBeginAllowThreads();
28012 (arg1)->Enable(arg2);
28013 wxPyEndAllowThreads(__tstate);
28014 if (PyErr_Occurred()) SWIG_fail;
28015 }
28016 resultobj = SWIG_Py_Void();
28017 return resultobj;
28018 fail:
28019 return NULL;
28020 }
28021
28022
28023 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28024 PyObject *resultobj = 0;
28025 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28026 bool arg2 ;
28027 void *argp1 = 0 ;
28028 int res1 = 0 ;
28029 bool val2 ;
28030 int ecode2 = 0 ;
28031 PyObject * obj0 = 0 ;
28032 PyObject * obj1 = 0 ;
28033 char * kwnames[] = {
28034 (char *) "self",(char *) "show", NULL
28035 };
28036
28037 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
28038 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28039 if (!SWIG_IsOK(res1)) {
28040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28041 }
28042 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28043 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28044 if (!SWIG_IsOK(ecode2)) {
28045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
28046 }
28047 arg2 = static_cast< bool >(val2);
28048 {
28049 PyThreadState* __tstate = wxPyBeginAllowThreads();
28050 (arg1)->Show(arg2);
28051 wxPyEndAllowThreads(__tstate);
28052 if (PyErr_Occurred()) SWIG_fail;
28053 }
28054 resultobj = SWIG_Py_Void();
28055 return resultobj;
28056 fail:
28057 return NULL;
28058 }
28059
28060
28061 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28062 PyObject *resultobj = 0;
28063 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
28064 wxString *arg2 = 0 ;
28065 void *argp1 = 0 ;
28066 int res1 = 0 ;
28067 bool temp2 = false ;
28068 PyObject * obj0 = 0 ;
28069 PyObject * obj1 = 0 ;
28070 char * kwnames[] = {
28071 (char *) "self",(char *) "text", NULL
28072 };
28073
28074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
28075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
28076 if (!SWIG_IsOK(res1)) {
28077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
28078 }
28079 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
28080 {
28081 arg2 = wxString_in_helper(obj1);
28082 if (arg2 == NULL) SWIG_fail;
28083 temp2 = true;
28084 }
28085 {
28086 PyThreadState* __tstate = wxPyBeginAllowThreads();
28087 (arg1)->SetText((wxString const &)*arg2);
28088 wxPyEndAllowThreads(__tstate);
28089 if (PyErr_Occurred()) SWIG_fail;
28090 }
28091 resultobj = SWIG_Py_Void();
28092 {
28093 if (temp2)
28094 delete arg2;
28095 }
28096 return resultobj;
28097 fail:
28098 {
28099 if (temp2)
28100 delete arg2;
28101 }
28102 return NULL;
28103 }
28104
28105
28106 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28107 PyObject *resultobj = 0;
28108 long arg1 ;
28109 long val1 ;
28110 int ecode1 = 0 ;
28111 PyObject * obj0 = 0 ;
28112 char * kwnames[] = {
28113 (char *) "updateInterval", NULL
28114 };
28115
28116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
28117 ecode1 = SWIG_AsVal_long(obj0, &val1);
28118 if (!SWIG_IsOK(ecode1)) {
28119 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
28120 }
28121 arg1 = static_cast< long >(val1);
28122 {
28123 PyThreadState* __tstate = wxPyBeginAllowThreads();
28124 wxUpdateUIEvent::SetUpdateInterval(arg1);
28125 wxPyEndAllowThreads(__tstate);
28126 if (PyErr_Occurred()) SWIG_fail;
28127 }
28128 resultobj = SWIG_Py_Void();
28129 return resultobj;
28130 fail:
28131 return NULL;
28132 }
28133
28134
28135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28136 PyObject *resultobj = 0;
28137 long result;
28138
28139 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
28140 {
28141 PyThreadState* __tstate = wxPyBeginAllowThreads();
28142 result = (long)wxUpdateUIEvent::GetUpdateInterval();
28143 wxPyEndAllowThreads(__tstate);
28144 if (PyErr_Occurred()) SWIG_fail;
28145 }
28146 resultobj = SWIG_From_long(static_cast< long >(result));
28147 return resultobj;
28148 fail:
28149 return NULL;
28150 }
28151
28152
28153 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28154 PyObject *resultobj = 0;
28155 wxWindow *arg1 = (wxWindow *) 0 ;
28156 bool result;
28157 void *argp1 = 0 ;
28158 int res1 = 0 ;
28159 PyObject * obj0 = 0 ;
28160 char * kwnames[] = {
28161 (char *) "win", NULL
28162 };
28163
28164 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
28165 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28166 if (!SWIG_IsOK(res1)) {
28167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
28168 }
28169 arg1 = reinterpret_cast< wxWindow * >(argp1);
28170 {
28171 PyThreadState* __tstate = wxPyBeginAllowThreads();
28172 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
28173 wxPyEndAllowThreads(__tstate);
28174 if (PyErr_Occurred()) SWIG_fail;
28175 }
28176 {
28177 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28178 }
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28186 PyObject *resultobj = 0;
28187
28188 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
28189 {
28190 PyThreadState* __tstate = wxPyBeginAllowThreads();
28191 wxUpdateUIEvent::ResetUpdateTime();
28192 wxPyEndAllowThreads(__tstate);
28193 if (PyErr_Occurred()) SWIG_fail;
28194 }
28195 resultobj = SWIG_Py_Void();
28196 return resultobj;
28197 fail:
28198 return NULL;
28199 }
28200
28201
28202 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28203 PyObject *resultobj = 0;
28204 wxUpdateUIMode arg1 ;
28205 int val1 ;
28206 int ecode1 = 0 ;
28207 PyObject * obj0 = 0 ;
28208 char * kwnames[] = {
28209 (char *) "mode", NULL
28210 };
28211
28212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
28213 ecode1 = SWIG_AsVal_int(obj0, &val1);
28214 if (!SWIG_IsOK(ecode1)) {
28215 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
28216 }
28217 arg1 = static_cast< wxUpdateUIMode >(val1);
28218 {
28219 PyThreadState* __tstate = wxPyBeginAllowThreads();
28220 wxUpdateUIEvent::SetMode(arg1);
28221 wxPyEndAllowThreads(__tstate);
28222 if (PyErr_Occurred()) SWIG_fail;
28223 }
28224 resultobj = SWIG_Py_Void();
28225 return resultobj;
28226 fail:
28227 return NULL;
28228 }
28229
28230
28231 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28232 PyObject *resultobj = 0;
28233 wxUpdateUIMode result;
28234
28235 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
28236 {
28237 PyThreadState* __tstate = wxPyBeginAllowThreads();
28238 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
28239 wxPyEndAllowThreads(__tstate);
28240 if (PyErr_Occurred()) SWIG_fail;
28241 }
28242 resultobj = SWIG_From_int(static_cast< int >(result));
28243 return resultobj;
28244 fail:
28245 return NULL;
28246 }
28247
28248
28249 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28250 PyObject *obj;
28251 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28252 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
28253 return SWIG_Py_Void();
28254 }
28255
28256 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28257 return SWIG_Python_InitShadowInstance(args);
28258 }
28259
28260 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28261 PyObject *resultobj = 0;
28262 wxSysColourChangedEvent *result = 0 ;
28263
28264 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
28265 {
28266 PyThreadState* __tstate = wxPyBeginAllowThreads();
28267 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
28268 wxPyEndAllowThreads(__tstate);
28269 if (PyErr_Occurred()) SWIG_fail;
28270 }
28271 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
28272 return resultobj;
28273 fail:
28274 return NULL;
28275 }
28276
28277
28278 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28279 PyObject *obj;
28280 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28281 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
28282 return SWIG_Py_Void();
28283 }
28284
28285 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28286 return SWIG_Python_InitShadowInstance(args);
28287 }
28288
28289 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28290 PyObject *resultobj = 0;
28291 int arg1 = (int) 0 ;
28292 wxWindow *arg2 = (wxWindow *) NULL ;
28293 wxMouseCaptureChangedEvent *result = 0 ;
28294 int val1 ;
28295 int ecode1 = 0 ;
28296 void *argp2 = 0 ;
28297 int res2 = 0 ;
28298 PyObject * obj0 = 0 ;
28299 PyObject * obj1 = 0 ;
28300 char * kwnames[] = {
28301 (char *) "winid",(char *) "gainedCapture", NULL
28302 };
28303
28304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28305 if (obj0) {
28306 ecode1 = SWIG_AsVal_int(obj0, &val1);
28307 if (!SWIG_IsOK(ecode1)) {
28308 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
28309 }
28310 arg1 = static_cast< int >(val1);
28311 }
28312 if (obj1) {
28313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28314 if (!SWIG_IsOK(res2)) {
28315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
28316 }
28317 arg2 = reinterpret_cast< wxWindow * >(argp2);
28318 }
28319 {
28320 PyThreadState* __tstate = wxPyBeginAllowThreads();
28321 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
28322 wxPyEndAllowThreads(__tstate);
28323 if (PyErr_Occurred()) SWIG_fail;
28324 }
28325 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
28326 return resultobj;
28327 fail:
28328 return NULL;
28329 }
28330
28331
28332 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28333 PyObject *resultobj = 0;
28334 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
28335 wxWindow *result = 0 ;
28336 void *argp1 = 0 ;
28337 int res1 = 0 ;
28338 PyObject *swig_obj[1] ;
28339
28340 if (!args) SWIG_fail;
28341 swig_obj[0] = args;
28342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
28343 if (!SWIG_IsOK(res1)) {
28344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
28345 }
28346 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
28347 {
28348 PyThreadState* __tstate = wxPyBeginAllowThreads();
28349 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
28350 wxPyEndAllowThreads(__tstate);
28351 if (PyErr_Occurred()) SWIG_fail;
28352 }
28353 {
28354 resultobj = wxPyMake_wxObject(result, (bool)0);
28355 }
28356 return resultobj;
28357 fail:
28358 return NULL;
28359 }
28360
28361
28362 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28363 PyObject *obj;
28364 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28365 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
28366 return SWIG_Py_Void();
28367 }
28368
28369 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28370 return SWIG_Python_InitShadowInstance(args);
28371 }
28372
28373 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28374 PyObject *resultobj = 0;
28375 int arg1 = (int) 0 ;
28376 wxMouseCaptureLostEvent *result = 0 ;
28377 int val1 ;
28378 int ecode1 = 0 ;
28379 PyObject * obj0 = 0 ;
28380 char * kwnames[] = {
28381 (char *) "winid", NULL
28382 };
28383
28384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
28385 if (obj0) {
28386 ecode1 = SWIG_AsVal_int(obj0, &val1);
28387 if (!SWIG_IsOK(ecode1)) {
28388 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
28389 }
28390 arg1 = static_cast< int >(val1);
28391 }
28392 {
28393 PyThreadState* __tstate = wxPyBeginAllowThreads();
28394 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
28395 wxPyEndAllowThreads(__tstate);
28396 if (PyErr_Occurred()) SWIG_fail;
28397 }
28398 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
28399 return resultobj;
28400 fail:
28401 return NULL;
28402 }
28403
28404
28405 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28406 PyObject *obj;
28407 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28408 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
28409 return SWIG_Py_Void();
28410 }
28411
28412 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28413 return SWIG_Python_InitShadowInstance(args);
28414 }
28415
28416 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28417 PyObject *resultobj = 0;
28418 wxDisplayChangedEvent *result = 0 ;
28419
28420 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28435 PyObject *obj;
28436 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28437 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
28438 return SWIG_Py_Void();
28439 }
28440
28441 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28442 return SWIG_Python_InitShadowInstance(args);
28443 }
28444
28445 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28446 PyObject *resultobj = 0;
28447 int arg1 = (int) 0 ;
28448 wxPaletteChangedEvent *result = 0 ;
28449 int val1 ;
28450 int ecode1 = 0 ;
28451 PyObject * obj0 = 0 ;
28452 char * kwnames[] = {
28453 (char *) "id", NULL
28454 };
28455
28456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
28457 if (obj0) {
28458 ecode1 = SWIG_AsVal_int(obj0, &val1);
28459 if (!SWIG_IsOK(ecode1)) {
28460 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
28461 }
28462 arg1 = static_cast< int >(val1);
28463 }
28464 {
28465 PyThreadState* __tstate = wxPyBeginAllowThreads();
28466 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
28467 wxPyEndAllowThreads(__tstate);
28468 if (PyErr_Occurred()) SWIG_fail;
28469 }
28470 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
28471 return resultobj;
28472 fail:
28473 return NULL;
28474 }
28475
28476
28477 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28478 PyObject *resultobj = 0;
28479 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28480 wxWindow *arg2 = (wxWindow *) 0 ;
28481 void *argp1 = 0 ;
28482 int res1 = 0 ;
28483 void *argp2 = 0 ;
28484 int res2 = 0 ;
28485 PyObject * obj0 = 0 ;
28486 PyObject * obj1 = 0 ;
28487 char * kwnames[] = {
28488 (char *) "self",(char *) "win", NULL
28489 };
28490
28491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
28492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28493 if (!SWIG_IsOK(res1)) {
28494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28495 }
28496 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28497 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28498 if (!SWIG_IsOK(res2)) {
28499 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
28500 }
28501 arg2 = reinterpret_cast< wxWindow * >(argp2);
28502 {
28503 PyThreadState* __tstate = wxPyBeginAllowThreads();
28504 (arg1)->SetChangedWindow(arg2);
28505 wxPyEndAllowThreads(__tstate);
28506 if (PyErr_Occurred()) SWIG_fail;
28507 }
28508 resultobj = SWIG_Py_Void();
28509 return resultobj;
28510 fail:
28511 return NULL;
28512 }
28513
28514
28515 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28516 PyObject *resultobj = 0;
28517 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
28518 wxWindow *result = 0 ;
28519 void *argp1 = 0 ;
28520 int res1 = 0 ;
28521 PyObject *swig_obj[1] ;
28522
28523 if (!args) SWIG_fail;
28524 swig_obj[0] = args;
28525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
28526 if (!SWIG_IsOK(res1)) {
28527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
28528 }
28529 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
28530 {
28531 PyThreadState* __tstate = wxPyBeginAllowThreads();
28532 result = (wxWindow *)(arg1)->GetChangedWindow();
28533 wxPyEndAllowThreads(__tstate);
28534 if (PyErr_Occurred()) SWIG_fail;
28535 }
28536 {
28537 resultobj = wxPyMake_wxObject(result, (bool)0);
28538 }
28539 return resultobj;
28540 fail:
28541 return NULL;
28542 }
28543
28544
28545 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28546 PyObject *obj;
28547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28548 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
28549 return SWIG_Py_Void();
28550 }
28551
28552 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28553 return SWIG_Python_InitShadowInstance(args);
28554 }
28555
28556 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28557 PyObject *resultobj = 0;
28558 int arg1 = (int) 0 ;
28559 wxQueryNewPaletteEvent *result = 0 ;
28560 int val1 ;
28561 int ecode1 = 0 ;
28562 PyObject * obj0 = 0 ;
28563 char * kwnames[] = {
28564 (char *) "winid", NULL
28565 };
28566
28567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
28568 if (obj0) {
28569 ecode1 = SWIG_AsVal_int(obj0, &val1);
28570 if (!SWIG_IsOK(ecode1)) {
28571 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
28572 }
28573 arg1 = static_cast< int >(val1);
28574 }
28575 {
28576 PyThreadState* __tstate = wxPyBeginAllowThreads();
28577 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
28578 wxPyEndAllowThreads(__tstate);
28579 if (PyErr_Occurred()) SWIG_fail;
28580 }
28581 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
28582 return resultobj;
28583 fail:
28584 return NULL;
28585 }
28586
28587
28588 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28589 PyObject *resultobj = 0;
28590 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28591 bool arg2 ;
28592 void *argp1 = 0 ;
28593 int res1 = 0 ;
28594 bool val2 ;
28595 int ecode2 = 0 ;
28596 PyObject * obj0 = 0 ;
28597 PyObject * obj1 = 0 ;
28598 char * kwnames[] = {
28599 (char *) "self",(char *) "realized", NULL
28600 };
28601
28602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
28603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28604 if (!SWIG_IsOK(res1)) {
28605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
28606 }
28607 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28608 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28609 if (!SWIG_IsOK(ecode2)) {
28610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
28611 }
28612 arg2 = static_cast< bool >(val2);
28613 {
28614 PyThreadState* __tstate = wxPyBeginAllowThreads();
28615 (arg1)->SetPaletteRealized(arg2);
28616 wxPyEndAllowThreads(__tstate);
28617 if (PyErr_Occurred()) SWIG_fail;
28618 }
28619 resultobj = SWIG_Py_Void();
28620 return resultobj;
28621 fail:
28622 return NULL;
28623 }
28624
28625
28626 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28627 PyObject *resultobj = 0;
28628 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
28629 bool result;
28630 void *argp1 = 0 ;
28631 int res1 = 0 ;
28632 PyObject *swig_obj[1] ;
28633
28634 if (!args) SWIG_fail;
28635 swig_obj[0] = args;
28636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
28637 if (!SWIG_IsOK(res1)) {
28638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
28639 }
28640 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
28641 {
28642 PyThreadState* __tstate = wxPyBeginAllowThreads();
28643 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
28644 wxPyEndAllowThreads(__tstate);
28645 if (PyErr_Occurred()) SWIG_fail;
28646 }
28647 {
28648 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28649 }
28650 return resultobj;
28651 fail:
28652 return NULL;
28653 }
28654
28655
28656 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28657 PyObject *obj;
28658 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28659 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
28660 return SWIG_Py_Void();
28661 }
28662
28663 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28664 return SWIG_Python_InitShadowInstance(args);
28665 }
28666
28667 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28668 PyObject *resultobj = 0;
28669 wxNavigationKeyEvent *result = 0 ;
28670
28671 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
28672 {
28673 PyThreadState* __tstate = wxPyBeginAllowThreads();
28674 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
28675 wxPyEndAllowThreads(__tstate);
28676 if (PyErr_Occurred()) SWIG_fail;
28677 }
28678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
28679 return resultobj;
28680 fail:
28681 return NULL;
28682 }
28683
28684
28685 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28686 PyObject *resultobj = 0;
28687 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28688 bool result;
28689 void *argp1 = 0 ;
28690 int res1 = 0 ;
28691 PyObject *swig_obj[1] ;
28692
28693 if (!args) SWIG_fail;
28694 swig_obj[0] = args;
28695 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28696 if (!SWIG_IsOK(res1)) {
28697 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28698 }
28699 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28700 {
28701 PyThreadState* __tstate = wxPyBeginAllowThreads();
28702 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
28703 wxPyEndAllowThreads(__tstate);
28704 if (PyErr_Occurred()) SWIG_fail;
28705 }
28706 {
28707 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28708 }
28709 return resultobj;
28710 fail:
28711 return NULL;
28712 }
28713
28714
28715 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28716 PyObject *resultobj = 0;
28717 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28718 bool arg2 ;
28719 void *argp1 = 0 ;
28720 int res1 = 0 ;
28721 bool val2 ;
28722 int ecode2 = 0 ;
28723 PyObject * obj0 = 0 ;
28724 PyObject * obj1 = 0 ;
28725 char * kwnames[] = {
28726 (char *) "self",(char *) "forward", NULL
28727 };
28728
28729 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
28730 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28731 if (!SWIG_IsOK(res1)) {
28732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28733 }
28734 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28735 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28736 if (!SWIG_IsOK(ecode2)) {
28737 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
28738 }
28739 arg2 = static_cast< bool >(val2);
28740 {
28741 PyThreadState* __tstate = wxPyBeginAllowThreads();
28742 (arg1)->SetDirection(arg2);
28743 wxPyEndAllowThreads(__tstate);
28744 if (PyErr_Occurred()) SWIG_fail;
28745 }
28746 resultobj = SWIG_Py_Void();
28747 return resultobj;
28748 fail:
28749 return NULL;
28750 }
28751
28752
28753 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28754 PyObject *resultobj = 0;
28755 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28756 bool result;
28757 void *argp1 = 0 ;
28758 int res1 = 0 ;
28759 PyObject *swig_obj[1] ;
28760
28761 if (!args) SWIG_fail;
28762 swig_obj[0] = args;
28763 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28764 if (!SWIG_IsOK(res1)) {
28765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28766 }
28767 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28768 {
28769 PyThreadState* __tstate = wxPyBeginAllowThreads();
28770 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
28771 wxPyEndAllowThreads(__tstate);
28772 if (PyErr_Occurred()) SWIG_fail;
28773 }
28774 {
28775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28776 }
28777 return resultobj;
28778 fail:
28779 return NULL;
28780 }
28781
28782
28783 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28784 PyObject *resultobj = 0;
28785 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28786 bool arg2 ;
28787 void *argp1 = 0 ;
28788 int res1 = 0 ;
28789 bool val2 ;
28790 int ecode2 = 0 ;
28791 PyObject * obj0 = 0 ;
28792 PyObject * obj1 = 0 ;
28793 char * kwnames[] = {
28794 (char *) "self",(char *) "ischange", NULL
28795 };
28796
28797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
28798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28799 if (!SWIG_IsOK(res1)) {
28800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28801 }
28802 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28803 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28804 if (!SWIG_IsOK(ecode2)) {
28805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
28806 }
28807 arg2 = static_cast< bool >(val2);
28808 {
28809 PyThreadState* __tstate = wxPyBeginAllowThreads();
28810 (arg1)->SetWindowChange(arg2);
28811 wxPyEndAllowThreads(__tstate);
28812 if (PyErr_Occurred()) SWIG_fail;
28813 }
28814 resultobj = SWIG_Py_Void();
28815 return resultobj;
28816 fail:
28817 return NULL;
28818 }
28819
28820
28821 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28822 PyObject *resultobj = 0;
28823 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28824 bool result;
28825 void *argp1 = 0 ;
28826 int res1 = 0 ;
28827 PyObject *swig_obj[1] ;
28828
28829 if (!args) SWIG_fail;
28830 swig_obj[0] = args;
28831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28832 if (!SWIG_IsOK(res1)) {
28833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28834 }
28835 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28836 {
28837 PyThreadState* __tstate = wxPyBeginAllowThreads();
28838 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
28839 wxPyEndAllowThreads(__tstate);
28840 if (PyErr_Occurred()) SWIG_fail;
28841 }
28842 {
28843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28844 }
28845 return resultobj;
28846 fail:
28847 return NULL;
28848 }
28849
28850
28851 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28852 PyObject *resultobj = 0;
28853 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28854 bool arg2 ;
28855 void *argp1 = 0 ;
28856 int res1 = 0 ;
28857 bool val2 ;
28858 int ecode2 = 0 ;
28859 PyObject * obj0 = 0 ;
28860 PyObject * obj1 = 0 ;
28861 char * kwnames[] = {
28862 (char *) "self",(char *) "bIs", NULL
28863 };
28864
28865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
28866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28867 if (!SWIG_IsOK(res1)) {
28868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28869 }
28870 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28871 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28872 if (!SWIG_IsOK(ecode2)) {
28873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
28874 }
28875 arg2 = static_cast< bool >(val2);
28876 {
28877 PyThreadState* __tstate = wxPyBeginAllowThreads();
28878 (arg1)->SetFromTab(arg2);
28879 wxPyEndAllowThreads(__tstate);
28880 if (PyErr_Occurred()) SWIG_fail;
28881 }
28882 resultobj = SWIG_Py_Void();
28883 return resultobj;
28884 fail:
28885 return NULL;
28886 }
28887
28888
28889 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28890 PyObject *resultobj = 0;
28891 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28892 long arg2 ;
28893 void *argp1 = 0 ;
28894 int res1 = 0 ;
28895 long val2 ;
28896 int ecode2 = 0 ;
28897 PyObject * obj0 = 0 ;
28898 PyObject * obj1 = 0 ;
28899 char * kwnames[] = {
28900 (char *) "self",(char *) "flags", NULL
28901 };
28902
28903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
28904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28905 if (!SWIG_IsOK(res1)) {
28906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28907 }
28908 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28909 ecode2 = SWIG_AsVal_long(obj1, &val2);
28910 if (!SWIG_IsOK(ecode2)) {
28911 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
28912 }
28913 arg2 = static_cast< long >(val2);
28914 {
28915 PyThreadState* __tstate = wxPyBeginAllowThreads();
28916 (arg1)->SetFlags(arg2);
28917 wxPyEndAllowThreads(__tstate);
28918 if (PyErr_Occurred()) SWIG_fail;
28919 }
28920 resultobj = SWIG_Py_Void();
28921 return resultobj;
28922 fail:
28923 return NULL;
28924 }
28925
28926
28927 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28928 PyObject *resultobj = 0;
28929 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28930 wxWindow *result = 0 ;
28931 void *argp1 = 0 ;
28932 int res1 = 0 ;
28933 PyObject *swig_obj[1] ;
28934
28935 if (!args) SWIG_fail;
28936 swig_obj[0] = args;
28937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28938 if (!SWIG_IsOK(res1)) {
28939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
28940 }
28941 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28942 {
28943 PyThreadState* __tstate = wxPyBeginAllowThreads();
28944 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
28945 wxPyEndAllowThreads(__tstate);
28946 if (PyErr_Occurred()) SWIG_fail;
28947 }
28948 {
28949 resultobj = wxPyMake_wxObject(result, (bool)0);
28950 }
28951 return resultobj;
28952 fail:
28953 return NULL;
28954 }
28955
28956
28957 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28958 PyObject *resultobj = 0;
28959 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
28960 wxWindow *arg2 = (wxWindow *) 0 ;
28961 void *argp1 = 0 ;
28962 int res1 = 0 ;
28963 void *argp2 = 0 ;
28964 int res2 = 0 ;
28965 PyObject * obj0 = 0 ;
28966 PyObject * obj1 = 0 ;
28967 char * kwnames[] = {
28968 (char *) "self",(char *) "win", NULL
28969 };
28970
28971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
28972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
28973 if (!SWIG_IsOK(res1)) {
28974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
28975 }
28976 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
28977 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
28978 if (!SWIG_IsOK(res2)) {
28979 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
28980 }
28981 arg2 = reinterpret_cast< wxWindow * >(argp2);
28982 {
28983 PyThreadState* __tstate = wxPyBeginAllowThreads();
28984 (arg1)->SetCurrentFocus(arg2);
28985 wxPyEndAllowThreads(__tstate);
28986 if (PyErr_Occurred()) SWIG_fail;
28987 }
28988 resultobj = SWIG_Py_Void();
28989 return resultobj;
28990 fail:
28991 return NULL;
28992 }
28993
28994
28995 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28996 PyObject *obj;
28997 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28998 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
28999 return SWIG_Py_Void();
29000 }
29001
29002 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29003 return SWIG_Python_InitShadowInstance(args);
29004 }
29005
29006 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29007 PyObject *resultobj = 0;
29008 wxWindow *arg1 = (wxWindow *) NULL ;
29009 wxWindowCreateEvent *result = 0 ;
29010 void *argp1 = 0 ;
29011 int res1 = 0 ;
29012 PyObject * obj0 = 0 ;
29013 char * kwnames[] = {
29014 (char *) "win", NULL
29015 };
29016
29017 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
29018 if (obj0) {
29019 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29020 if (!SWIG_IsOK(res1)) {
29021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29022 }
29023 arg1 = reinterpret_cast< wxWindow * >(argp1);
29024 }
29025 {
29026 PyThreadState* __tstate = wxPyBeginAllowThreads();
29027 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
29028 wxPyEndAllowThreads(__tstate);
29029 if (PyErr_Occurred()) SWIG_fail;
29030 }
29031 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
29032 return resultobj;
29033 fail:
29034 return NULL;
29035 }
29036
29037
29038 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29039 PyObject *resultobj = 0;
29040 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
29041 wxWindow *result = 0 ;
29042 void *argp1 = 0 ;
29043 int res1 = 0 ;
29044 PyObject *swig_obj[1] ;
29045
29046 if (!args) SWIG_fail;
29047 swig_obj[0] = args;
29048 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
29049 if (!SWIG_IsOK(res1)) {
29050 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
29051 }
29052 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
29053 {
29054 PyThreadState* __tstate = wxPyBeginAllowThreads();
29055 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
29056 wxPyEndAllowThreads(__tstate);
29057 if (PyErr_Occurred()) SWIG_fail;
29058 }
29059 {
29060 resultobj = wxPyMake_wxObject(result, (bool)0);
29061 }
29062 return resultobj;
29063 fail:
29064 return NULL;
29065 }
29066
29067
29068 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29069 PyObject *obj;
29070 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29071 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
29072 return SWIG_Py_Void();
29073 }
29074
29075 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29076 return SWIG_Python_InitShadowInstance(args);
29077 }
29078
29079 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29080 PyObject *resultobj = 0;
29081 wxWindow *arg1 = (wxWindow *) NULL ;
29082 wxWindowDestroyEvent *result = 0 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 PyObject * obj0 = 0 ;
29086 char * kwnames[] = {
29087 (char *) "win", NULL
29088 };
29089
29090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
29091 if (obj0) {
29092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29093 if (!SWIG_IsOK(res1)) {
29094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29095 }
29096 arg1 = reinterpret_cast< wxWindow * >(argp1);
29097 }
29098 {
29099 PyThreadState* __tstate = wxPyBeginAllowThreads();
29100 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
29101 wxPyEndAllowThreads(__tstate);
29102 if (PyErr_Occurred()) SWIG_fail;
29103 }
29104 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
29105 return resultobj;
29106 fail:
29107 return NULL;
29108 }
29109
29110
29111 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29112 PyObject *resultobj = 0;
29113 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
29114 wxWindow *result = 0 ;
29115 void *argp1 = 0 ;
29116 int res1 = 0 ;
29117 PyObject *swig_obj[1] ;
29118
29119 if (!args) SWIG_fail;
29120 swig_obj[0] = args;
29121 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
29122 if (!SWIG_IsOK(res1)) {
29123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
29124 }
29125 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
29126 {
29127 PyThreadState* __tstate = wxPyBeginAllowThreads();
29128 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
29129 wxPyEndAllowThreads(__tstate);
29130 if (PyErr_Occurred()) SWIG_fail;
29131 }
29132 {
29133 resultobj = wxPyMake_wxObject(result, (bool)0);
29134 }
29135 return resultobj;
29136 fail:
29137 return NULL;
29138 }
29139
29140
29141 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29142 PyObject *obj;
29143 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29144 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
29145 return SWIG_Py_Void();
29146 }
29147
29148 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29149 return SWIG_Python_InitShadowInstance(args);
29150 }
29151
29152 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29153 PyObject *resultobj = 0;
29154 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29155 int arg2 = (int) 0 ;
29156 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29157 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29158 wxContextMenuEvent *result = 0 ;
29159 int val1 ;
29160 int ecode1 = 0 ;
29161 int val2 ;
29162 int ecode2 = 0 ;
29163 wxPoint temp3 ;
29164 PyObject * obj0 = 0 ;
29165 PyObject * obj1 = 0 ;
29166 PyObject * obj2 = 0 ;
29167 char * kwnames[] = {
29168 (char *) "type",(char *) "winid",(char *) "pt", NULL
29169 };
29170
29171 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29172 if (obj0) {
29173 ecode1 = SWIG_AsVal_int(obj0, &val1);
29174 if (!SWIG_IsOK(ecode1)) {
29175 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29176 }
29177 arg1 = static_cast< wxEventType >(val1);
29178 }
29179 if (obj1) {
29180 ecode2 = SWIG_AsVal_int(obj1, &val2);
29181 if (!SWIG_IsOK(ecode2)) {
29182 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
29183 }
29184 arg2 = static_cast< int >(val2);
29185 }
29186 if (obj2) {
29187 {
29188 arg3 = &temp3;
29189 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29190 }
29191 }
29192 {
29193 PyThreadState* __tstate = wxPyBeginAllowThreads();
29194 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
29195 wxPyEndAllowThreads(__tstate);
29196 if (PyErr_Occurred()) SWIG_fail;
29197 }
29198 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
29199 return resultobj;
29200 fail:
29201 return NULL;
29202 }
29203
29204
29205 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29206 PyObject *resultobj = 0;
29207 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29208 wxPoint *result = 0 ;
29209 void *argp1 = 0 ;
29210 int res1 = 0 ;
29211 PyObject *swig_obj[1] ;
29212
29213 if (!args) SWIG_fail;
29214 swig_obj[0] = args;
29215 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29216 if (!SWIG_IsOK(res1)) {
29217 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
29218 }
29219 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29220 {
29221 PyThreadState* __tstate = wxPyBeginAllowThreads();
29222 {
29223 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
29224 result = (wxPoint *) &_result_ref;
29225 }
29226 wxPyEndAllowThreads(__tstate);
29227 if (PyErr_Occurred()) SWIG_fail;
29228 }
29229 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
29230 return resultobj;
29231 fail:
29232 return NULL;
29233 }
29234
29235
29236 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29237 PyObject *resultobj = 0;
29238 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
29239 wxPoint *arg2 = 0 ;
29240 void *argp1 = 0 ;
29241 int res1 = 0 ;
29242 wxPoint temp2 ;
29243 PyObject * obj0 = 0 ;
29244 PyObject * obj1 = 0 ;
29245 char * kwnames[] = {
29246 (char *) "self",(char *) "pos", NULL
29247 };
29248
29249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
29250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
29251 if (!SWIG_IsOK(res1)) {
29252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
29253 }
29254 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
29255 {
29256 arg2 = &temp2;
29257 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
29258 }
29259 {
29260 PyThreadState* __tstate = wxPyBeginAllowThreads();
29261 (arg1)->SetPosition((wxPoint const &)*arg2);
29262 wxPyEndAllowThreads(__tstate);
29263 if (PyErr_Occurred()) SWIG_fail;
29264 }
29265 resultobj = SWIG_Py_Void();
29266 return resultobj;
29267 fail:
29268 return NULL;
29269 }
29270
29271
29272 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29273 PyObject *obj;
29274 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29275 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
29276 return SWIG_Py_Void();
29277 }
29278
29279 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29280 return SWIG_Python_InitShadowInstance(args);
29281 }
29282
29283 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29284 PyObject *resultobj = 0;
29285 wxIdleEvent *result = 0 ;
29286
29287 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
29288 {
29289 PyThreadState* __tstate = wxPyBeginAllowThreads();
29290 result = (wxIdleEvent *)new wxIdleEvent();
29291 wxPyEndAllowThreads(__tstate);
29292 if (PyErr_Occurred()) SWIG_fail;
29293 }
29294 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
29295 return resultobj;
29296 fail:
29297 return NULL;
29298 }
29299
29300
29301 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29302 PyObject *resultobj = 0;
29303 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29304 bool arg2 = (bool) true ;
29305 void *argp1 = 0 ;
29306 int res1 = 0 ;
29307 bool val2 ;
29308 int ecode2 = 0 ;
29309 PyObject * obj0 = 0 ;
29310 PyObject * obj1 = 0 ;
29311 char * kwnames[] = {
29312 (char *) "self",(char *) "needMore", NULL
29313 };
29314
29315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
29316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29317 if (!SWIG_IsOK(res1)) {
29318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
29319 }
29320 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29321 if (obj1) {
29322 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29323 if (!SWIG_IsOK(ecode2)) {
29324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
29325 }
29326 arg2 = static_cast< bool >(val2);
29327 }
29328 {
29329 PyThreadState* __tstate = wxPyBeginAllowThreads();
29330 (arg1)->RequestMore(arg2);
29331 wxPyEndAllowThreads(__tstate);
29332 if (PyErr_Occurred()) SWIG_fail;
29333 }
29334 resultobj = SWIG_Py_Void();
29335 return resultobj;
29336 fail:
29337 return NULL;
29338 }
29339
29340
29341 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29342 PyObject *resultobj = 0;
29343 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
29344 bool result;
29345 void *argp1 = 0 ;
29346 int res1 = 0 ;
29347 PyObject *swig_obj[1] ;
29348
29349 if (!args) SWIG_fail;
29350 swig_obj[0] = args;
29351 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
29352 if (!SWIG_IsOK(res1)) {
29353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
29354 }
29355 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 {
29363 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29364 }
29365 return resultobj;
29366 fail:
29367 return NULL;
29368 }
29369
29370
29371 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29372 PyObject *resultobj = 0;
29373 wxIdleMode arg1 ;
29374 int val1 ;
29375 int ecode1 = 0 ;
29376 PyObject * obj0 = 0 ;
29377 char * kwnames[] = {
29378 (char *) "mode", NULL
29379 };
29380
29381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
29382 ecode1 = SWIG_AsVal_int(obj0, &val1);
29383 if (!SWIG_IsOK(ecode1)) {
29384 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
29385 }
29386 arg1 = static_cast< wxIdleMode >(val1);
29387 {
29388 PyThreadState* __tstate = wxPyBeginAllowThreads();
29389 wxIdleEvent::SetMode(arg1);
29390 wxPyEndAllowThreads(__tstate);
29391 if (PyErr_Occurred()) SWIG_fail;
29392 }
29393 resultobj = SWIG_Py_Void();
29394 return resultobj;
29395 fail:
29396 return NULL;
29397 }
29398
29399
29400 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29401 PyObject *resultobj = 0;
29402 wxIdleMode result;
29403
29404 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
29405 {
29406 PyThreadState* __tstate = wxPyBeginAllowThreads();
29407 result = (wxIdleMode)wxIdleEvent::GetMode();
29408 wxPyEndAllowThreads(__tstate);
29409 if (PyErr_Occurred()) SWIG_fail;
29410 }
29411 resultobj = SWIG_From_int(static_cast< int >(result));
29412 return resultobj;
29413 fail:
29414 return NULL;
29415 }
29416
29417
29418 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29419 PyObject *resultobj = 0;
29420 wxWindow *arg1 = (wxWindow *) 0 ;
29421 bool result;
29422 void *argp1 = 0 ;
29423 int res1 = 0 ;
29424 PyObject * obj0 = 0 ;
29425 char * kwnames[] = {
29426 (char *) "win", NULL
29427 };
29428
29429 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
29430 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29431 if (!SWIG_IsOK(res1)) {
29432 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
29433 }
29434 arg1 = reinterpret_cast< wxWindow * >(argp1);
29435 {
29436 PyThreadState* __tstate = wxPyBeginAllowThreads();
29437 result = (bool)wxIdleEvent::CanSend(arg1);
29438 wxPyEndAllowThreads(__tstate);
29439 if (PyErr_Occurred()) SWIG_fail;
29440 }
29441 {
29442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29443 }
29444 return resultobj;
29445 fail:
29446 return NULL;
29447 }
29448
29449
29450 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29451 PyObject *obj;
29452 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29453 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
29454 return SWIG_Py_Void();
29455 }
29456
29457 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29458 return SWIG_Python_InitShadowInstance(args);
29459 }
29460
29461 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29462 PyObject *resultobj = 0;
29463 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29464 int arg2 = (int) 0 ;
29465 wxClipboardTextEvent *result = 0 ;
29466 int val1 ;
29467 int ecode1 = 0 ;
29468 int val2 ;
29469 int ecode2 = 0 ;
29470 PyObject * obj0 = 0 ;
29471 PyObject * obj1 = 0 ;
29472 char * kwnames[] = {
29473 (char *) "type",(char *) "winid", NULL
29474 };
29475
29476 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29477 if (obj0) {
29478 ecode1 = SWIG_AsVal_int(obj0, &val1);
29479 if (!SWIG_IsOK(ecode1)) {
29480 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29481 }
29482 arg1 = static_cast< wxEventType >(val1);
29483 }
29484 if (obj1) {
29485 ecode2 = SWIG_AsVal_int(obj1, &val2);
29486 if (!SWIG_IsOK(ecode2)) {
29487 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
29488 }
29489 arg2 = static_cast< int >(val2);
29490 }
29491 {
29492 PyThreadState* __tstate = wxPyBeginAllowThreads();
29493 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
29494 wxPyEndAllowThreads(__tstate);
29495 if (PyErr_Occurred()) SWIG_fail;
29496 }
29497 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
29498 return resultobj;
29499 fail:
29500 return NULL;
29501 }
29502
29503
29504 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29505 PyObject *obj;
29506 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29507 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
29508 return SWIG_Py_Void();
29509 }
29510
29511 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29512 return SWIG_Python_InitShadowInstance(args);
29513 }
29514
29515 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29516 PyObject *resultobj = 0;
29517 int arg1 = (int) 0 ;
29518 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
29519 wxPyEvent *result = 0 ;
29520 int val1 ;
29521 int ecode1 = 0 ;
29522 int val2 ;
29523 int ecode2 = 0 ;
29524 PyObject * obj0 = 0 ;
29525 PyObject * obj1 = 0 ;
29526 char * kwnames[] = {
29527 (char *) "winid",(char *) "eventType", NULL
29528 };
29529
29530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29531 if (obj0) {
29532 ecode1 = SWIG_AsVal_int(obj0, &val1);
29533 if (!SWIG_IsOK(ecode1)) {
29534 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
29535 }
29536 arg1 = static_cast< int >(val1);
29537 }
29538 if (obj1) {
29539 ecode2 = SWIG_AsVal_int(obj1, &val2);
29540 if (!SWIG_IsOK(ecode2)) {
29541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
29542 }
29543 arg2 = static_cast< wxEventType >(val2);
29544 }
29545 {
29546 PyThreadState* __tstate = wxPyBeginAllowThreads();
29547 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
29548 wxPyEndAllowThreads(__tstate);
29549 if (PyErr_Occurred()) SWIG_fail;
29550 }
29551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
29552 return resultobj;
29553 fail:
29554 return NULL;
29555 }
29556
29557
29558 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29559 PyObject *resultobj = 0;
29560 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29561 void *argp1 = 0 ;
29562 int res1 = 0 ;
29563 PyObject *swig_obj[1] ;
29564
29565 if (!args) SWIG_fail;
29566 swig_obj[0] = args;
29567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
29568 if (!SWIG_IsOK(res1)) {
29569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29570 }
29571 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29572 {
29573 PyThreadState* __tstate = wxPyBeginAllowThreads();
29574 delete arg1;
29575
29576 wxPyEndAllowThreads(__tstate);
29577 if (PyErr_Occurred()) SWIG_fail;
29578 }
29579 resultobj = SWIG_Py_Void();
29580 return resultobj;
29581 fail:
29582 return NULL;
29583 }
29584
29585
29586 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29587 PyObject *resultobj = 0;
29588 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29589 PyObject *arg2 = (PyObject *) 0 ;
29590 void *argp1 = 0 ;
29591 int res1 = 0 ;
29592 PyObject * obj0 = 0 ;
29593 PyObject * obj1 = 0 ;
29594 char * kwnames[] = {
29595 (char *) "self",(char *) "self", NULL
29596 };
29597
29598 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29599 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29600 if (!SWIG_IsOK(res1)) {
29601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29602 }
29603 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29604 arg2 = obj1;
29605 {
29606 PyThreadState* __tstate = wxPyBeginAllowThreads();
29607 (arg1)->SetSelf(arg2);
29608 wxPyEndAllowThreads(__tstate);
29609 if (PyErr_Occurred()) SWIG_fail;
29610 }
29611 resultobj = SWIG_Py_Void();
29612 return resultobj;
29613 fail:
29614 return NULL;
29615 }
29616
29617
29618 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29619 PyObject *resultobj = 0;
29620 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
29621 PyObject *result = 0 ;
29622 void *argp1 = 0 ;
29623 int res1 = 0 ;
29624 PyObject *swig_obj[1] ;
29625
29626 if (!args) SWIG_fail;
29627 swig_obj[0] = args;
29628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
29629 if (!SWIG_IsOK(res1)) {
29630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
29631 }
29632 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
29633 {
29634 PyThreadState* __tstate = wxPyBeginAllowThreads();
29635 result = (PyObject *)(arg1)->GetSelf();
29636 wxPyEndAllowThreads(__tstate);
29637 if (PyErr_Occurred()) SWIG_fail;
29638 }
29639 resultobj = result;
29640 return resultobj;
29641 fail:
29642 return NULL;
29643 }
29644
29645
29646 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29647 PyObject *obj;
29648 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29649 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
29650 return SWIG_Py_Void();
29651 }
29652
29653 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29654 return SWIG_Python_InitShadowInstance(args);
29655 }
29656
29657 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29658 PyObject *resultobj = 0;
29659 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
29660 int arg2 = (int) 0 ;
29661 wxPyCommandEvent *result = 0 ;
29662 int val1 ;
29663 int ecode1 = 0 ;
29664 int val2 ;
29665 int ecode2 = 0 ;
29666 PyObject * obj0 = 0 ;
29667 PyObject * obj1 = 0 ;
29668 char * kwnames[] = {
29669 (char *) "eventType",(char *) "id", NULL
29670 };
29671
29672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
29673 if (obj0) {
29674 ecode1 = SWIG_AsVal_int(obj0, &val1);
29675 if (!SWIG_IsOK(ecode1)) {
29676 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
29677 }
29678 arg1 = static_cast< wxEventType >(val1);
29679 }
29680 if (obj1) {
29681 ecode2 = SWIG_AsVal_int(obj1, &val2);
29682 if (!SWIG_IsOK(ecode2)) {
29683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
29684 }
29685 arg2 = static_cast< int >(val2);
29686 }
29687 {
29688 PyThreadState* __tstate = wxPyBeginAllowThreads();
29689 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
29690 wxPyEndAllowThreads(__tstate);
29691 if (PyErr_Occurred()) SWIG_fail;
29692 }
29693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
29694 return resultobj;
29695 fail:
29696 return NULL;
29697 }
29698
29699
29700 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29701 PyObject *resultobj = 0;
29702 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29703 void *argp1 = 0 ;
29704 int res1 = 0 ;
29705 PyObject *swig_obj[1] ;
29706
29707 if (!args) SWIG_fail;
29708 swig_obj[0] = args;
29709 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
29710 if (!SWIG_IsOK(res1)) {
29711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29712 }
29713 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29714 {
29715 PyThreadState* __tstate = wxPyBeginAllowThreads();
29716 delete arg1;
29717
29718 wxPyEndAllowThreads(__tstate);
29719 if (PyErr_Occurred()) SWIG_fail;
29720 }
29721 resultobj = SWIG_Py_Void();
29722 return resultobj;
29723 fail:
29724 return NULL;
29725 }
29726
29727
29728 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29729 PyObject *resultobj = 0;
29730 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29731 PyObject *arg2 = (PyObject *) 0 ;
29732 void *argp1 = 0 ;
29733 int res1 = 0 ;
29734 PyObject * obj0 = 0 ;
29735 PyObject * obj1 = 0 ;
29736 char * kwnames[] = {
29737 (char *) "self",(char *) "self", NULL
29738 };
29739
29740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
29741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29742 if (!SWIG_IsOK(res1)) {
29743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29744 }
29745 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29746 arg2 = obj1;
29747 {
29748 PyThreadState* __tstate = wxPyBeginAllowThreads();
29749 (arg1)->SetSelf(arg2);
29750 wxPyEndAllowThreads(__tstate);
29751 if (PyErr_Occurred()) SWIG_fail;
29752 }
29753 resultobj = SWIG_Py_Void();
29754 return resultobj;
29755 fail:
29756 return NULL;
29757 }
29758
29759
29760 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29761 PyObject *resultobj = 0;
29762 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
29763 PyObject *result = 0 ;
29764 void *argp1 = 0 ;
29765 int res1 = 0 ;
29766 PyObject *swig_obj[1] ;
29767
29768 if (!args) SWIG_fail;
29769 swig_obj[0] = args;
29770 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
29771 if (!SWIG_IsOK(res1)) {
29772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
29773 }
29774 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
29775 {
29776 PyThreadState* __tstate = wxPyBeginAllowThreads();
29777 result = (PyObject *)(arg1)->GetSelf();
29778 wxPyEndAllowThreads(__tstate);
29779 if (PyErr_Occurred()) SWIG_fail;
29780 }
29781 resultobj = result;
29782 return resultobj;
29783 fail:
29784 return NULL;
29785 }
29786
29787
29788 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29789 PyObject *obj;
29790 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29791 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
29792 return SWIG_Py_Void();
29793 }
29794
29795 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29796 return SWIG_Python_InitShadowInstance(args);
29797 }
29798
29799 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29800 PyObject *resultobj = 0;
29801 wxWindow *arg1 = (wxWindow *) 0 ;
29802 wxDateTime *arg2 = 0 ;
29803 wxEventType arg3 ;
29804 wxDateEvent *result = 0 ;
29805 void *argp1 = 0 ;
29806 int res1 = 0 ;
29807 void *argp2 = 0 ;
29808 int res2 = 0 ;
29809 int val3 ;
29810 int ecode3 = 0 ;
29811 PyObject * obj0 = 0 ;
29812 PyObject * obj1 = 0 ;
29813 PyObject * obj2 = 0 ;
29814 char * kwnames[] = {
29815 (char *) "win",(char *) "dt",(char *) "type", NULL
29816 };
29817
29818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29820 if (!SWIG_IsOK(res1)) {
29821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
29822 }
29823 arg1 = reinterpret_cast< wxWindow * >(argp1);
29824 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29825 if (!SWIG_IsOK(res2)) {
29826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29827 }
29828 if (!argp2) {
29829 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29830 }
29831 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29832 ecode3 = SWIG_AsVal_int(obj2, &val3);
29833 if (!SWIG_IsOK(ecode3)) {
29834 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
29835 }
29836 arg3 = static_cast< wxEventType >(val3);
29837 {
29838 PyThreadState* __tstate = wxPyBeginAllowThreads();
29839 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
29840 wxPyEndAllowThreads(__tstate);
29841 if (PyErr_Occurred()) SWIG_fail;
29842 }
29843 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
29844 return resultobj;
29845 fail:
29846 return NULL;
29847 }
29848
29849
29850 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29851 PyObject *resultobj = 0;
29852 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29853 wxDateTime *result = 0 ;
29854 void *argp1 = 0 ;
29855 int res1 = 0 ;
29856 PyObject *swig_obj[1] ;
29857
29858 if (!args) SWIG_fail;
29859 swig_obj[0] = args;
29860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29861 if (!SWIG_IsOK(res1)) {
29862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
29863 }
29864 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29865 {
29866 PyThreadState* __tstate = wxPyBeginAllowThreads();
29867 {
29868 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
29869 result = (wxDateTime *) &_result_ref;
29870 }
29871 wxPyEndAllowThreads(__tstate);
29872 if (PyErr_Occurred()) SWIG_fail;
29873 }
29874 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
29875 return resultobj;
29876 fail:
29877 return NULL;
29878 }
29879
29880
29881 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29882 PyObject *resultobj = 0;
29883 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
29884 wxDateTime *arg2 = 0 ;
29885 void *argp1 = 0 ;
29886 int res1 = 0 ;
29887 void *argp2 = 0 ;
29888 int res2 = 0 ;
29889 PyObject * obj0 = 0 ;
29890 PyObject * obj1 = 0 ;
29891 char * kwnames[] = {
29892 (char *) "self",(char *) "date", NULL
29893 };
29894
29895 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
29896 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
29897 if (!SWIG_IsOK(res1)) {
29898 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
29899 }
29900 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
29901 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
29902 if (!SWIG_IsOK(res2)) {
29903 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29904 }
29905 if (!argp2) {
29906 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
29907 }
29908 arg2 = reinterpret_cast< wxDateTime * >(argp2);
29909 {
29910 PyThreadState* __tstate = wxPyBeginAllowThreads();
29911 (arg1)->SetDate((wxDateTime const &)*arg2);
29912 wxPyEndAllowThreads(__tstate);
29913 if (PyErr_Occurred()) SWIG_fail;
29914 }
29915 resultobj = SWIG_Py_Void();
29916 return resultobj;
29917 fail:
29918 return NULL;
29919 }
29920
29921
29922 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29923 PyObject *obj;
29924 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29925 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
29926 return SWIG_Py_Void();
29927 }
29928
29929 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29930 return SWIG_Python_InitShadowInstance(args);
29931 }
29932
29933 SWIGINTERN PyObject *_wrap_new_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29934 PyObject *resultobj = 0;
29935 wxWindow *arg1 = (wxWindow *) 0 ;
29936 wxEventType arg2 = (wxEventType) wxEVT_ANY ;
29937 wxEventBlocker *result = 0 ;
29938 void *argp1 = 0 ;
29939 int res1 = 0 ;
29940 int val2 ;
29941 int ecode2 = 0 ;
29942 PyObject * obj0 = 0 ;
29943 PyObject * obj1 = 0 ;
29944 char * kwnames[] = {
29945 (char *) "win",(char *) "type", NULL
29946 };
29947
29948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_EventBlocker",kwnames,&obj0,&obj1)) SWIG_fail;
29949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29950 if (!SWIG_IsOK(res1)) {
29951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventBlocker" "', expected argument " "1"" of type '" "wxWindow *""'");
29952 }
29953 arg1 = reinterpret_cast< wxWindow * >(argp1);
29954 if (obj1) {
29955 ecode2 = SWIG_AsVal_int(obj1, &val2);
29956 if (!SWIG_IsOK(ecode2)) {
29957 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EventBlocker" "', expected argument " "2"" of type '" "wxEventType""'");
29958 }
29959 arg2 = static_cast< wxEventType >(val2);
29960 }
29961 {
29962 PyThreadState* __tstate = wxPyBeginAllowThreads();
29963 result = (wxEventBlocker *)new wxEventBlocker(arg1,arg2);
29964 wxPyEndAllowThreads(__tstate);
29965 if (PyErr_Occurred()) SWIG_fail;
29966 }
29967 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_NEW | 0 );
29968 return resultobj;
29969 fail:
29970 return NULL;
29971 }
29972
29973
29974 SWIGINTERN PyObject *_wrap_delete_EventBlocker(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29975 PyObject *resultobj = 0;
29976 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
29977 void *argp1 = 0 ;
29978 int res1 = 0 ;
29979 PyObject *swig_obj[1] ;
29980
29981 if (!args) SWIG_fail;
29982 swig_obj[0] = args;
29983 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventBlocker, SWIG_POINTER_DISOWN | 0 );
29984 if (!SWIG_IsOK(res1)) {
29985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventBlocker" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
29986 }
29987 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
29988 {
29989 PyThreadState* __tstate = wxPyBeginAllowThreads();
29990 delete arg1;
29991
29992 wxPyEndAllowThreads(__tstate);
29993 if (PyErr_Occurred()) SWIG_fail;
29994 }
29995 resultobj = SWIG_Py_Void();
29996 return resultobj;
29997 fail:
29998 return NULL;
29999 }
30000
30001
30002 SWIGINTERN PyObject *_wrap_EventBlocker_Block(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30003 PyObject *resultobj = 0;
30004 wxEventBlocker *arg1 = (wxEventBlocker *) 0 ;
30005 wxEventType arg2 ;
30006 void *argp1 = 0 ;
30007 int res1 = 0 ;
30008 int val2 ;
30009 int ecode2 = 0 ;
30010 PyObject * obj0 = 0 ;
30011 PyObject * obj1 = 0 ;
30012 char * kwnames[] = {
30013 (char *) "self",(char *) "type", NULL
30014 };
30015
30016 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EventBlocker_Block",kwnames,&obj0,&obj1)) SWIG_fail;
30017 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventBlocker, 0 | 0 );
30018 if (!SWIG_IsOK(res1)) {
30019 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventBlocker_Block" "', expected argument " "1"" of type '" "wxEventBlocker *""'");
30020 }
30021 arg1 = reinterpret_cast< wxEventBlocker * >(argp1);
30022 ecode2 = SWIG_AsVal_int(obj1, &val2);
30023 if (!SWIG_IsOK(ecode2)) {
30024 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventBlocker_Block" "', expected argument " "2"" of type '" "wxEventType""'");
30025 }
30026 arg2 = static_cast< wxEventType >(val2);
30027 {
30028 PyThreadState* __tstate = wxPyBeginAllowThreads();
30029 (arg1)->Block(arg2);
30030 wxPyEndAllowThreads(__tstate);
30031 if (PyErr_Occurred()) SWIG_fail;
30032 }
30033 resultobj = SWIG_Py_Void();
30034 return resultobj;
30035 fail:
30036 return NULL;
30037 }
30038
30039
30040 SWIGINTERN PyObject *EventBlocker_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30041 PyObject *obj;
30042 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
30043 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventBlocker, SWIG_NewClientData(obj));
30044 return SWIG_Py_Void();
30045 }
30046
30047 SWIGINTERN PyObject *EventBlocker_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30048 return SWIG_Python_InitShadowInstance(args);
30049 }
30050
30051 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30052 PyObject *resultobj = 0;
30053 wxPyApp *result = 0 ;
30054
30055 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
30056 {
30057 PyThreadState* __tstate = wxPyBeginAllowThreads();
30058 result = (wxPyApp *)new_wxPyApp();
30059 wxPyEndAllowThreads(__tstate);
30060 if (PyErr_Occurred()) SWIG_fail;
30061 }
30062 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
30063 return resultobj;
30064 fail:
30065 return NULL;
30066 }
30067
30068
30069 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30070 PyObject *resultobj = 0;
30071 wxPyApp *arg1 = (wxPyApp *) 0 ;
30072 void *argp1 = 0 ;
30073 int res1 = 0 ;
30074 PyObject *swig_obj[1] ;
30075
30076 if (!args) SWIG_fail;
30077 swig_obj[0] = args;
30078 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
30079 if (!SWIG_IsOK(res1)) {
30080 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
30081 }
30082 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30083 {
30084 PyThreadState* __tstate = wxPyBeginAllowThreads();
30085 delete arg1;
30086
30087 wxPyEndAllowThreads(__tstate);
30088 if (PyErr_Occurred()) SWIG_fail;
30089 }
30090 resultobj = SWIG_Py_Void();
30091 return resultobj;
30092 fail:
30093 return NULL;
30094 }
30095
30096
30097 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30098 PyObject *resultobj = 0;
30099 wxPyApp *arg1 = (wxPyApp *) 0 ;
30100 PyObject *arg2 = (PyObject *) 0 ;
30101 PyObject *arg3 = (PyObject *) 0 ;
30102 bool arg4 = (bool) false ;
30103 void *argp1 = 0 ;
30104 int res1 = 0 ;
30105 bool val4 ;
30106 int ecode4 = 0 ;
30107 PyObject * obj0 = 0 ;
30108 PyObject * obj1 = 0 ;
30109 PyObject * obj2 = 0 ;
30110 PyObject * obj3 = 0 ;
30111 char * kwnames[] = {
30112 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
30113 };
30114
30115 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30116 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30117 if (!SWIG_IsOK(res1)) {
30118 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
30119 }
30120 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30121 arg2 = obj1;
30122 arg3 = obj2;
30123 if (obj3) {
30124 ecode4 = SWIG_AsVal_bool(obj3, &val4);
30125 if (!SWIG_IsOK(ecode4)) {
30126 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
30127 }
30128 arg4 = static_cast< bool >(val4);
30129 }
30130 {
30131 PyThreadState* __tstate = wxPyBeginAllowThreads();
30132 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
30133 wxPyEndAllowThreads(__tstate);
30134 if (PyErr_Occurred()) SWIG_fail;
30135 }
30136 resultobj = SWIG_Py_Void();
30137 return resultobj;
30138 fail:
30139 return NULL;
30140 }
30141
30142
30143 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30144 PyObject *resultobj = 0;
30145 wxPyApp *arg1 = (wxPyApp *) 0 ;
30146 wxString result;
30147 void *argp1 = 0 ;
30148 int res1 = 0 ;
30149 PyObject *swig_obj[1] ;
30150
30151 if (!args) SWIG_fail;
30152 swig_obj[0] = args;
30153 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30154 if (!SWIG_IsOK(res1)) {
30155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30156 }
30157 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30158 {
30159 PyThreadState* __tstate = wxPyBeginAllowThreads();
30160 result = ((wxPyApp const *)arg1)->GetAppName();
30161 wxPyEndAllowThreads(__tstate);
30162 if (PyErr_Occurred()) SWIG_fail;
30163 }
30164 {
30165 #if wxUSE_UNICODE
30166 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30167 #else
30168 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30169 #endif
30170 }
30171 return resultobj;
30172 fail:
30173 return NULL;
30174 }
30175
30176
30177 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30178 PyObject *resultobj = 0;
30179 wxPyApp *arg1 = (wxPyApp *) 0 ;
30180 wxString *arg2 = 0 ;
30181 void *argp1 = 0 ;
30182 int res1 = 0 ;
30183 bool temp2 = false ;
30184 PyObject * obj0 = 0 ;
30185 PyObject * obj1 = 0 ;
30186 char * kwnames[] = {
30187 (char *) "self",(char *) "name", NULL
30188 };
30189
30190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
30191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30192 if (!SWIG_IsOK(res1)) {
30193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30194 }
30195 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30196 {
30197 arg2 = wxString_in_helper(obj1);
30198 if (arg2 == NULL) SWIG_fail;
30199 temp2 = true;
30200 }
30201 {
30202 PyThreadState* __tstate = wxPyBeginAllowThreads();
30203 (arg1)->SetAppName((wxString const &)*arg2);
30204 wxPyEndAllowThreads(__tstate);
30205 if (PyErr_Occurred()) SWIG_fail;
30206 }
30207 resultobj = SWIG_Py_Void();
30208 {
30209 if (temp2)
30210 delete arg2;
30211 }
30212 return resultobj;
30213 fail:
30214 {
30215 if (temp2)
30216 delete arg2;
30217 }
30218 return NULL;
30219 }
30220
30221
30222 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30223 PyObject *resultobj = 0;
30224 wxPyApp *arg1 = (wxPyApp *) 0 ;
30225 wxString result;
30226 void *argp1 = 0 ;
30227 int res1 = 0 ;
30228 PyObject *swig_obj[1] ;
30229
30230 if (!args) SWIG_fail;
30231 swig_obj[0] = args;
30232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30233 if (!SWIG_IsOK(res1)) {
30234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30235 }
30236 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30237 {
30238 PyThreadState* __tstate = wxPyBeginAllowThreads();
30239 result = ((wxPyApp const *)arg1)->GetClassName();
30240 wxPyEndAllowThreads(__tstate);
30241 if (PyErr_Occurred()) SWIG_fail;
30242 }
30243 {
30244 #if wxUSE_UNICODE
30245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30246 #else
30247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30248 #endif
30249 }
30250 return resultobj;
30251 fail:
30252 return NULL;
30253 }
30254
30255
30256 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30257 PyObject *resultobj = 0;
30258 wxPyApp *arg1 = (wxPyApp *) 0 ;
30259 wxString *arg2 = 0 ;
30260 void *argp1 = 0 ;
30261 int res1 = 0 ;
30262 bool temp2 = false ;
30263 PyObject * obj0 = 0 ;
30264 PyObject * obj1 = 0 ;
30265 char * kwnames[] = {
30266 (char *) "self",(char *) "name", NULL
30267 };
30268
30269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
30270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30271 if (!SWIG_IsOK(res1)) {
30272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30273 }
30274 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30275 {
30276 arg2 = wxString_in_helper(obj1);
30277 if (arg2 == NULL) SWIG_fail;
30278 temp2 = true;
30279 }
30280 {
30281 PyThreadState* __tstate = wxPyBeginAllowThreads();
30282 (arg1)->SetClassName((wxString const &)*arg2);
30283 wxPyEndAllowThreads(__tstate);
30284 if (PyErr_Occurred()) SWIG_fail;
30285 }
30286 resultobj = SWIG_Py_Void();
30287 {
30288 if (temp2)
30289 delete arg2;
30290 }
30291 return resultobj;
30292 fail:
30293 {
30294 if (temp2)
30295 delete arg2;
30296 }
30297 return NULL;
30298 }
30299
30300
30301 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30302 PyObject *resultobj = 0;
30303 wxPyApp *arg1 = (wxPyApp *) 0 ;
30304 wxString *result = 0 ;
30305 void *argp1 = 0 ;
30306 int res1 = 0 ;
30307 PyObject *swig_obj[1] ;
30308
30309 if (!args) SWIG_fail;
30310 swig_obj[0] = args;
30311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30312 if (!SWIG_IsOK(res1)) {
30313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30314 }
30315 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30316 {
30317 PyThreadState* __tstate = wxPyBeginAllowThreads();
30318 {
30319 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
30320 result = (wxString *) &_result_ref;
30321 }
30322 wxPyEndAllowThreads(__tstate);
30323 if (PyErr_Occurred()) SWIG_fail;
30324 }
30325 {
30326 #if wxUSE_UNICODE
30327 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
30328 #else
30329 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
30330 #endif
30331 }
30332 return resultobj;
30333 fail:
30334 return NULL;
30335 }
30336
30337
30338 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30339 PyObject *resultobj = 0;
30340 wxPyApp *arg1 = (wxPyApp *) 0 ;
30341 wxString *arg2 = 0 ;
30342 void *argp1 = 0 ;
30343 int res1 = 0 ;
30344 bool temp2 = false ;
30345 PyObject * obj0 = 0 ;
30346 PyObject * obj1 = 0 ;
30347 char * kwnames[] = {
30348 (char *) "self",(char *) "name", NULL
30349 };
30350
30351 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
30352 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30353 if (!SWIG_IsOK(res1)) {
30354 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
30355 }
30356 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30357 {
30358 arg2 = wxString_in_helper(obj1);
30359 if (arg2 == NULL) SWIG_fail;
30360 temp2 = true;
30361 }
30362 {
30363 PyThreadState* __tstate = wxPyBeginAllowThreads();
30364 (arg1)->SetVendorName((wxString const &)*arg2);
30365 wxPyEndAllowThreads(__tstate);
30366 if (PyErr_Occurred()) SWIG_fail;
30367 }
30368 resultobj = SWIG_Py_Void();
30369 {
30370 if (temp2)
30371 delete arg2;
30372 }
30373 return resultobj;
30374 fail:
30375 {
30376 if (temp2)
30377 delete arg2;
30378 }
30379 return NULL;
30380 }
30381
30382
30383 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30384 PyObject *resultobj = 0;
30385 wxPyApp *arg1 = (wxPyApp *) 0 ;
30386 wxAppTraits *result = 0 ;
30387 void *argp1 = 0 ;
30388 int res1 = 0 ;
30389 PyObject *swig_obj[1] ;
30390
30391 if (!args) SWIG_fail;
30392 swig_obj[0] = args;
30393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30394 if (!SWIG_IsOK(res1)) {
30395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
30396 }
30397 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30398 {
30399 PyThreadState* __tstate = wxPyBeginAllowThreads();
30400 result = (wxAppTraits *)(arg1)->GetTraits();
30401 wxPyEndAllowThreads(__tstate);
30402 if (PyErr_Occurred()) SWIG_fail;
30403 }
30404 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
30405 return resultobj;
30406 fail:
30407 return NULL;
30408 }
30409
30410
30411 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30412 PyObject *resultobj = 0;
30413 wxPyApp *arg1 = (wxPyApp *) 0 ;
30414 void *argp1 = 0 ;
30415 int res1 = 0 ;
30416 PyObject *swig_obj[1] ;
30417
30418 if (!args) SWIG_fail;
30419 swig_obj[0] = args;
30420 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30421 if (!SWIG_IsOK(res1)) {
30422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30423 }
30424 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30425 {
30426 PyThreadState* __tstate = wxPyBeginAllowThreads();
30427 (arg1)->ProcessPendingEvents();
30428 wxPyEndAllowThreads(__tstate);
30429 if (PyErr_Occurred()) SWIG_fail;
30430 }
30431 resultobj = SWIG_Py_Void();
30432 return resultobj;
30433 fail:
30434 return NULL;
30435 }
30436
30437
30438 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30439 PyObject *resultobj = 0;
30440 wxPyApp *arg1 = (wxPyApp *) 0 ;
30441 bool arg2 = (bool) false ;
30442 bool result;
30443 void *argp1 = 0 ;
30444 int res1 = 0 ;
30445 bool val2 ;
30446 int ecode2 = 0 ;
30447 PyObject * obj0 = 0 ;
30448 PyObject * obj1 = 0 ;
30449 char * kwnames[] = {
30450 (char *) "self",(char *) "onlyIfNeeded", NULL
30451 };
30452
30453 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
30454 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30455 if (!SWIG_IsOK(res1)) {
30456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
30457 }
30458 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30459 if (obj1) {
30460 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30461 if (!SWIG_IsOK(ecode2)) {
30462 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
30463 }
30464 arg2 = static_cast< bool >(val2);
30465 }
30466 {
30467 PyThreadState* __tstate = wxPyBeginAllowThreads();
30468 result = (bool)(arg1)->Yield(arg2);
30469 wxPyEndAllowThreads(__tstate);
30470 if (PyErr_Occurred()) SWIG_fail;
30471 }
30472 {
30473 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30474 }
30475 return resultobj;
30476 fail:
30477 return NULL;
30478 }
30479
30480
30481 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30482 PyObject *resultobj = 0;
30483 wxPyApp *arg1 = (wxPyApp *) 0 ;
30484 void *argp1 = 0 ;
30485 int res1 = 0 ;
30486 PyObject *swig_obj[1] ;
30487
30488 if (!args) SWIG_fail;
30489 swig_obj[0] = args;
30490 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30491 if (!SWIG_IsOK(res1)) {
30492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30493 }
30494 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30495 {
30496 PyThreadState* __tstate = wxPyBeginAllowThreads();
30497 (arg1)->WakeUpIdle();
30498 wxPyEndAllowThreads(__tstate);
30499 if (PyErr_Occurred()) SWIG_fail;
30500 }
30501 resultobj = SWIG_Py_Void();
30502 return resultobj;
30503 fail:
30504 return NULL;
30505 }
30506
30507
30508 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30509 PyObject *resultobj = 0;
30510 bool result;
30511
30512 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
30513 {
30514 PyThreadState* __tstate = wxPyBeginAllowThreads();
30515 result = (bool)wxPyApp::IsMainLoopRunning();
30516 wxPyEndAllowThreads(__tstate);
30517 if (PyErr_Occurred()) SWIG_fail;
30518 }
30519 {
30520 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30521 }
30522 return resultobj;
30523 fail:
30524 return NULL;
30525 }
30526
30527
30528 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30529 PyObject *resultobj = 0;
30530 wxPyApp *arg1 = (wxPyApp *) 0 ;
30531 int result;
30532 void *argp1 = 0 ;
30533 int res1 = 0 ;
30534 PyObject *swig_obj[1] ;
30535
30536 if (!args) SWIG_fail;
30537 swig_obj[0] = args;
30538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30539 if (!SWIG_IsOK(res1)) {
30540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30541 }
30542 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30543 {
30544 PyThreadState* __tstate = wxPyBeginAllowThreads();
30545 result = (int)(arg1)->MainLoop();
30546 wxPyEndAllowThreads(__tstate);
30547 if (PyErr_Occurred()) SWIG_fail;
30548 }
30549 resultobj = SWIG_From_int(static_cast< int >(result));
30550 return resultobj;
30551 fail:
30552 return NULL;
30553 }
30554
30555
30556 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30557 PyObject *resultobj = 0;
30558 wxPyApp *arg1 = (wxPyApp *) 0 ;
30559 void *argp1 = 0 ;
30560 int res1 = 0 ;
30561 PyObject *swig_obj[1] ;
30562
30563 if (!args) SWIG_fail;
30564 swig_obj[0] = args;
30565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30566 if (!SWIG_IsOK(res1)) {
30567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
30568 }
30569 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30570 {
30571 PyThreadState* __tstate = wxPyBeginAllowThreads();
30572 (arg1)->Exit();
30573 wxPyEndAllowThreads(__tstate);
30574 if (PyErr_Occurred()) SWIG_fail;
30575 }
30576 resultobj = SWIG_Py_Void();
30577 return resultobj;
30578 fail:
30579 return NULL;
30580 }
30581
30582
30583 SWIGINTERN PyObject *_wrap_PyApp_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30584 PyObject *resultobj = 0;
30585 wxPyApp *arg1 = (wxPyApp *) 0 ;
30586 wxLayoutDirection result;
30587 void *argp1 = 0 ;
30588 int res1 = 0 ;
30589 PyObject *swig_obj[1] ;
30590
30591 if (!args) SWIG_fail;
30592 swig_obj[0] = args;
30593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30594 if (!SWIG_IsOK(res1)) {
30595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetLayoutDirection" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30596 }
30597 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30598 {
30599 PyThreadState* __tstate = wxPyBeginAllowThreads();
30600 result = (wxLayoutDirection)((wxPyApp const *)arg1)->GetLayoutDirection();
30601 wxPyEndAllowThreads(__tstate);
30602 if (PyErr_Occurred()) SWIG_fail;
30603 }
30604 resultobj = SWIG_From_int(static_cast< int >(result));
30605 return resultobj;
30606 fail:
30607 return NULL;
30608 }
30609
30610
30611 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30612 PyObject *resultobj = 0;
30613 wxPyApp *arg1 = (wxPyApp *) 0 ;
30614 void *argp1 = 0 ;
30615 int res1 = 0 ;
30616 PyObject *swig_obj[1] ;
30617
30618 if (!args) SWIG_fail;
30619 swig_obj[0] = args;
30620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30621 if (!SWIG_IsOK(res1)) {
30622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
30623 }
30624 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30625 {
30626 PyThreadState* __tstate = wxPyBeginAllowThreads();
30627 (arg1)->ExitMainLoop();
30628 wxPyEndAllowThreads(__tstate);
30629 if (PyErr_Occurred()) SWIG_fail;
30630 }
30631 resultobj = SWIG_Py_Void();
30632 return resultobj;
30633 fail:
30634 return NULL;
30635 }
30636
30637
30638 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30639 PyObject *resultobj = 0;
30640 wxPyApp *arg1 = (wxPyApp *) 0 ;
30641 bool result;
30642 void *argp1 = 0 ;
30643 int res1 = 0 ;
30644 PyObject *swig_obj[1] ;
30645
30646 if (!args) SWIG_fail;
30647 swig_obj[0] = args;
30648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30649 if (!SWIG_IsOK(res1)) {
30650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
30651 }
30652 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30653 {
30654 PyThreadState* __tstate = wxPyBeginAllowThreads();
30655 result = (bool)(arg1)->Pending();
30656 wxPyEndAllowThreads(__tstate);
30657 if (PyErr_Occurred()) SWIG_fail;
30658 }
30659 {
30660 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30661 }
30662 return resultobj;
30663 fail:
30664 return NULL;
30665 }
30666
30667
30668 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30669 PyObject *resultobj = 0;
30670 wxPyApp *arg1 = (wxPyApp *) 0 ;
30671 bool result;
30672 void *argp1 = 0 ;
30673 int res1 = 0 ;
30674 PyObject *swig_obj[1] ;
30675
30676 if (!args) SWIG_fail;
30677 swig_obj[0] = args;
30678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30679 if (!SWIG_IsOK(res1)) {
30680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
30681 }
30682 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30683 {
30684 PyThreadState* __tstate = wxPyBeginAllowThreads();
30685 result = (bool)(arg1)->Dispatch();
30686 wxPyEndAllowThreads(__tstate);
30687 if (PyErr_Occurred()) SWIG_fail;
30688 }
30689 {
30690 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30691 }
30692 return resultobj;
30693 fail:
30694 return NULL;
30695 }
30696
30697
30698 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30699 PyObject *resultobj = 0;
30700 wxPyApp *arg1 = (wxPyApp *) 0 ;
30701 bool result;
30702 void *argp1 = 0 ;
30703 int res1 = 0 ;
30704 PyObject *swig_obj[1] ;
30705
30706 if (!args) SWIG_fail;
30707 swig_obj[0] = args;
30708 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30709 if (!SWIG_IsOK(res1)) {
30710 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
30711 }
30712 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30713 {
30714 PyThreadState* __tstate = wxPyBeginAllowThreads();
30715 result = (bool)(arg1)->ProcessIdle();
30716 wxPyEndAllowThreads(__tstate);
30717 if (PyErr_Occurred()) SWIG_fail;
30718 }
30719 {
30720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30721 }
30722 return resultobj;
30723 fail:
30724 return NULL;
30725 }
30726
30727
30728 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30729 PyObject *resultobj = 0;
30730 wxPyApp *arg1 = (wxPyApp *) 0 ;
30731 wxWindow *arg2 = (wxWindow *) 0 ;
30732 wxIdleEvent *arg3 = 0 ;
30733 bool result;
30734 void *argp1 = 0 ;
30735 int res1 = 0 ;
30736 void *argp2 = 0 ;
30737 int res2 = 0 ;
30738 void *argp3 = 0 ;
30739 int res3 = 0 ;
30740 PyObject * obj0 = 0 ;
30741 PyObject * obj1 = 0 ;
30742 PyObject * obj2 = 0 ;
30743 char * kwnames[] = {
30744 (char *) "self",(char *) "win",(char *) "event", NULL
30745 };
30746
30747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30749 if (!SWIG_IsOK(res1)) {
30750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
30751 }
30752 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30753 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30754 if (!SWIG_IsOK(res2)) {
30755 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
30756 }
30757 arg2 = reinterpret_cast< wxWindow * >(argp2);
30758 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
30759 if (!SWIG_IsOK(res3)) {
30760 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30761 }
30762 if (!argp3) {
30763 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
30764 }
30765 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
30766 {
30767 PyThreadState* __tstate = wxPyBeginAllowThreads();
30768 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
30769 wxPyEndAllowThreads(__tstate);
30770 if (PyErr_Occurred()) SWIG_fail;
30771 }
30772 {
30773 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30774 }
30775 return resultobj;
30776 fail:
30777 return NULL;
30778 }
30779
30780
30781 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30782 PyObject *resultobj = 0;
30783 wxPyApp *arg1 = (wxPyApp *) 0 ;
30784 bool result;
30785 void *argp1 = 0 ;
30786 int res1 = 0 ;
30787 PyObject *swig_obj[1] ;
30788
30789 if (!args) SWIG_fail;
30790 swig_obj[0] = args;
30791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30792 if (!SWIG_IsOK(res1)) {
30793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30794 }
30795 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30796 {
30797 PyThreadState* __tstate = wxPyBeginAllowThreads();
30798 result = (bool)((wxPyApp const *)arg1)->IsActive();
30799 wxPyEndAllowThreads(__tstate);
30800 if (PyErr_Occurred()) SWIG_fail;
30801 }
30802 {
30803 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30804 }
30805 return resultobj;
30806 fail:
30807 return NULL;
30808 }
30809
30810
30811 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30812 PyObject *resultobj = 0;
30813 wxPyApp *arg1 = (wxPyApp *) 0 ;
30814 wxWindow *arg2 = (wxWindow *) 0 ;
30815 void *argp1 = 0 ;
30816 int res1 = 0 ;
30817 void *argp2 = 0 ;
30818 int res2 = 0 ;
30819 PyObject * obj0 = 0 ;
30820 PyObject * obj1 = 0 ;
30821 char * kwnames[] = {
30822 (char *) "self",(char *) "win", NULL
30823 };
30824
30825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
30826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30827 if (!SWIG_IsOK(res1)) {
30828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
30829 }
30830 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
30832 if (!SWIG_IsOK(res2)) {
30833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
30834 }
30835 arg2 = reinterpret_cast< wxWindow * >(argp2);
30836 {
30837 PyThreadState* __tstate = wxPyBeginAllowThreads();
30838 (arg1)->SetTopWindow(arg2);
30839 wxPyEndAllowThreads(__tstate);
30840 if (PyErr_Occurred()) SWIG_fail;
30841 }
30842 resultobj = SWIG_Py_Void();
30843 return resultobj;
30844 fail:
30845 return NULL;
30846 }
30847
30848
30849 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30850 PyObject *resultobj = 0;
30851 wxPyApp *arg1 = (wxPyApp *) 0 ;
30852 wxWindow *result = 0 ;
30853 void *argp1 = 0 ;
30854 int res1 = 0 ;
30855 PyObject *swig_obj[1] ;
30856
30857 if (!args) SWIG_fail;
30858 swig_obj[0] = args;
30859 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30860 if (!SWIG_IsOK(res1)) {
30861 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30862 }
30863 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30864 {
30865 PyThreadState* __tstate = wxPyBeginAllowThreads();
30866 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
30867 wxPyEndAllowThreads(__tstate);
30868 if (PyErr_Occurred()) SWIG_fail;
30869 }
30870 {
30871 resultobj = wxPyMake_wxObject(result, (bool)0);
30872 }
30873 return resultobj;
30874 fail:
30875 return NULL;
30876 }
30877
30878
30879 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30880 PyObject *resultobj = 0;
30881 wxPyApp *arg1 = (wxPyApp *) 0 ;
30882 bool arg2 ;
30883 void *argp1 = 0 ;
30884 int res1 = 0 ;
30885 bool val2 ;
30886 int ecode2 = 0 ;
30887 PyObject * obj0 = 0 ;
30888 PyObject * obj1 = 0 ;
30889 char * kwnames[] = {
30890 (char *) "self",(char *) "flag", NULL
30891 };
30892
30893 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
30894 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30895 if (!SWIG_IsOK(res1)) {
30896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
30897 }
30898 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30899 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30900 if (!SWIG_IsOK(ecode2)) {
30901 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
30902 }
30903 arg2 = static_cast< bool >(val2);
30904 {
30905 PyThreadState* __tstate = wxPyBeginAllowThreads();
30906 (arg1)->SetExitOnFrameDelete(arg2);
30907 wxPyEndAllowThreads(__tstate);
30908 if (PyErr_Occurred()) SWIG_fail;
30909 }
30910 resultobj = SWIG_Py_Void();
30911 return resultobj;
30912 fail:
30913 return NULL;
30914 }
30915
30916
30917 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30918 PyObject *resultobj = 0;
30919 wxPyApp *arg1 = (wxPyApp *) 0 ;
30920 bool result;
30921 void *argp1 = 0 ;
30922 int res1 = 0 ;
30923 PyObject *swig_obj[1] ;
30924
30925 if (!args) SWIG_fail;
30926 swig_obj[0] = args;
30927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30928 if (!SWIG_IsOK(res1)) {
30929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
30930 }
30931 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30932 {
30933 PyThreadState* __tstate = wxPyBeginAllowThreads();
30934 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
30935 wxPyEndAllowThreads(__tstate);
30936 if (PyErr_Occurred()) SWIG_fail;
30937 }
30938 {
30939 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
30940 }
30941 return resultobj;
30942 fail:
30943 return NULL;
30944 }
30945
30946
30947 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30948 PyObject *resultobj = 0;
30949 wxPyApp *arg1 = (wxPyApp *) 0 ;
30950 bool arg2 ;
30951 bool arg3 = (bool) false ;
30952 void *argp1 = 0 ;
30953 int res1 = 0 ;
30954 bool val2 ;
30955 int ecode2 = 0 ;
30956 bool val3 ;
30957 int ecode3 = 0 ;
30958 PyObject * obj0 = 0 ;
30959 PyObject * obj1 = 0 ;
30960 PyObject * obj2 = 0 ;
30961 char * kwnames[] = {
30962 (char *) "self",(char *) "flag",(char *) "forceTrueColour", NULL
30963 };
30964
30965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
30967 if (!SWIG_IsOK(res1)) {
30968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
30969 }
30970 arg1 = reinterpret_cast< wxPyApp * >(argp1);
30971 ecode2 = SWIG_AsVal_bool(obj1, &val2);
30972 if (!SWIG_IsOK(ecode2)) {
30973 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
30974 }
30975 arg2 = static_cast< bool >(val2);
30976 if (obj2) {
30977 ecode3 = SWIG_AsVal_bool(obj2, &val3);
30978 if (!SWIG_IsOK(ecode3)) {
30979 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "3"" of type '" "bool""'");
30980 }
30981 arg3 = static_cast< bool >(val3);
30982 }
30983 {
30984 PyThreadState* __tstate = wxPyBeginAllowThreads();
30985 (arg1)->SetUseBestVisual(arg2,arg3);
30986 wxPyEndAllowThreads(__tstate);
30987 if (PyErr_Occurred()) SWIG_fail;
30988 }
30989 resultobj = SWIG_Py_Void();
30990 return resultobj;
30991 fail:
30992 return NULL;
30993 }
30994
30995
30996 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30997 PyObject *resultobj = 0;
30998 wxPyApp *arg1 = (wxPyApp *) 0 ;
30999 bool result;
31000 void *argp1 = 0 ;
31001 int res1 = 0 ;
31002 PyObject *swig_obj[1] ;
31003
31004 if (!args) SWIG_fail;
31005 swig_obj[0] = args;
31006 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31007 if (!SWIG_IsOK(res1)) {
31008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31009 }
31010 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31011 {
31012 PyThreadState* __tstate = wxPyBeginAllowThreads();
31013 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
31014 wxPyEndAllowThreads(__tstate);
31015 if (PyErr_Occurred()) SWIG_fail;
31016 }
31017 {
31018 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31019 }
31020 return resultobj;
31021 fail:
31022 return NULL;
31023 }
31024
31025
31026 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31027 PyObject *resultobj = 0;
31028 wxPyApp *arg1 = (wxPyApp *) 0 ;
31029 int arg2 ;
31030 void *argp1 = 0 ;
31031 int res1 = 0 ;
31032 int val2 ;
31033 int ecode2 = 0 ;
31034 PyObject * obj0 = 0 ;
31035 PyObject * obj1 = 0 ;
31036 char * kwnames[] = {
31037 (char *) "self",(char *) "mode", NULL
31038 };
31039
31040 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
31041 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31042 if (!SWIG_IsOK(res1)) {
31043 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31044 }
31045 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31046 ecode2 = SWIG_AsVal_int(obj1, &val2);
31047 if (!SWIG_IsOK(ecode2)) {
31048 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
31049 }
31050 arg2 = static_cast< int >(val2);
31051 {
31052 PyThreadState* __tstate = wxPyBeginAllowThreads();
31053 (arg1)->SetPrintMode(arg2);
31054 wxPyEndAllowThreads(__tstate);
31055 if (PyErr_Occurred()) SWIG_fail;
31056 }
31057 resultobj = SWIG_Py_Void();
31058 return resultobj;
31059 fail:
31060 return NULL;
31061 }
31062
31063
31064 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31065 PyObject *resultobj = 0;
31066 wxPyApp *arg1 = (wxPyApp *) 0 ;
31067 int result;
31068 void *argp1 = 0 ;
31069 int res1 = 0 ;
31070 PyObject *swig_obj[1] ;
31071
31072 if (!args) SWIG_fail;
31073 swig_obj[0] = args;
31074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31075 if (!SWIG_IsOK(res1)) {
31076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
31077 }
31078 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31079 {
31080 PyThreadState* __tstate = wxPyBeginAllowThreads();
31081 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
31082 wxPyEndAllowThreads(__tstate);
31083 if (PyErr_Occurred()) SWIG_fail;
31084 }
31085 resultobj = SWIG_From_int(static_cast< int >(result));
31086 return resultobj;
31087 fail:
31088 return NULL;
31089 }
31090
31091
31092 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31093 PyObject *resultobj = 0;
31094 wxPyApp *arg1 = (wxPyApp *) 0 ;
31095 int arg2 ;
31096 void *argp1 = 0 ;
31097 int res1 = 0 ;
31098 int val2 ;
31099 int ecode2 = 0 ;
31100 PyObject * obj0 = 0 ;
31101 PyObject * obj1 = 0 ;
31102 char * kwnames[] = {
31103 (char *) "self",(char *) "mode", NULL
31104 };
31105
31106 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
31107 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31108 if (!SWIG_IsOK(res1)) {
31109 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31110 }
31111 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31112 ecode2 = SWIG_AsVal_int(obj1, &val2);
31113 if (!SWIG_IsOK(ecode2)) {
31114 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
31115 }
31116 arg2 = static_cast< int >(val2);
31117 {
31118 PyThreadState* __tstate = wxPyBeginAllowThreads();
31119 (arg1)->SetAssertMode(arg2);
31120 wxPyEndAllowThreads(__tstate);
31121 if (PyErr_Occurred()) SWIG_fail;
31122 }
31123 resultobj = SWIG_Py_Void();
31124 return resultobj;
31125 fail:
31126 return NULL;
31127 }
31128
31129
31130 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31131 PyObject *resultobj = 0;
31132 wxPyApp *arg1 = (wxPyApp *) 0 ;
31133 int result;
31134 void *argp1 = 0 ;
31135 int res1 = 0 ;
31136 PyObject *swig_obj[1] ;
31137
31138 if (!args) SWIG_fail;
31139 swig_obj[0] = args;
31140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31141 if (!SWIG_IsOK(res1)) {
31142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
31143 }
31144 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31145 {
31146 PyThreadState* __tstate = wxPyBeginAllowThreads();
31147 result = (int)(arg1)->GetAssertMode();
31148 wxPyEndAllowThreads(__tstate);
31149 if (PyErr_Occurred()) SWIG_fail;
31150 }
31151 resultobj = SWIG_From_int(static_cast< int >(result));
31152 return resultobj;
31153 fail:
31154 return NULL;
31155 }
31156
31157
31158 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31159 PyObject *resultobj = 0;
31160 bool result;
31161
31162 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
31163 {
31164 PyThreadState* __tstate = wxPyBeginAllowThreads();
31165 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
31166 wxPyEndAllowThreads(__tstate);
31167 if (PyErr_Occurred()) SWIG_fail;
31168 }
31169 {
31170 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31171 }
31172 return resultobj;
31173 fail:
31174 return NULL;
31175 }
31176
31177
31178 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31179 PyObject *resultobj = 0;
31180 long result;
31181
31182 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
31183 {
31184 PyThreadState* __tstate = wxPyBeginAllowThreads();
31185 result = (long)wxPyApp::GetMacAboutMenuItemId();
31186 wxPyEndAllowThreads(__tstate);
31187 if (PyErr_Occurred()) SWIG_fail;
31188 }
31189 resultobj = SWIG_From_long(static_cast< long >(result));
31190 return resultobj;
31191 fail:
31192 return NULL;
31193 }
31194
31195
31196 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31197 PyObject *resultobj = 0;
31198 long result;
31199
31200 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
31201 {
31202 PyThreadState* __tstate = wxPyBeginAllowThreads();
31203 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
31204 wxPyEndAllowThreads(__tstate);
31205 if (PyErr_Occurred()) SWIG_fail;
31206 }
31207 resultobj = SWIG_From_long(static_cast< long >(result));
31208 return resultobj;
31209 fail:
31210 return NULL;
31211 }
31212
31213
31214 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31215 PyObject *resultobj = 0;
31216 long result;
31217
31218 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
31219 {
31220 PyThreadState* __tstate = wxPyBeginAllowThreads();
31221 result = (long)wxPyApp::GetMacExitMenuItemId();
31222 wxPyEndAllowThreads(__tstate);
31223 if (PyErr_Occurred()) SWIG_fail;
31224 }
31225 resultobj = SWIG_From_long(static_cast< long >(result));
31226 return resultobj;
31227 fail:
31228 return NULL;
31229 }
31230
31231
31232 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31233 PyObject *resultobj = 0;
31234 wxString result;
31235
31236 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
31237 {
31238 PyThreadState* __tstate = wxPyBeginAllowThreads();
31239 result = wxPyApp::GetMacHelpMenuTitleName();
31240 wxPyEndAllowThreads(__tstate);
31241 if (PyErr_Occurred()) SWIG_fail;
31242 }
31243 {
31244 #if wxUSE_UNICODE
31245 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
31246 #else
31247 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
31248 #endif
31249 }
31250 return resultobj;
31251 fail:
31252 return NULL;
31253 }
31254
31255
31256 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31257 PyObject *resultobj = 0;
31258 bool arg1 ;
31259 bool val1 ;
31260 int ecode1 = 0 ;
31261 PyObject * obj0 = 0 ;
31262 char * kwnames[] = {
31263 (char *) "val", NULL
31264 };
31265
31266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
31267 ecode1 = SWIG_AsVal_bool(obj0, &val1);
31268 if (!SWIG_IsOK(ecode1)) {
31269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
31270 }
31271 arg1 = static_cast< bool >(val1);
31272 {
31273 PyThreadState* __tstate = wxPyBeginAllowThreads();
31274 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
31275 wxPyEndAllowThreads(__tstate);
31276 if (PyErr_Occurred()) SWIG_fail;
31277 }
31278 resultobj = SWIG_Py_Void();
31279 return resultobj;
31280 fail:
31281 return NULL;
31282 }
31283
31284
31285 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31286 PyObject *resultobj = 0;
31287 long arg1 ;
31288 long val1 ;
31289 int ecode1 = 0 ;
31290 PyObject * obj0 = 0 ;
31291 char * kwnames[] = {
31292 (char *) "val", NULL
31293 };
31294
31295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
31296 ecode1 = SWIG_AsVal_long(obj0, &val1);
31297 if (!SWIG_IsOK(ecode1)) {
31298 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
31299 }
31300 arg1 = static_cast< long >(val1);
31301 {
31302 PyThreadState* __tstate = wxPyBeginAllowThreads();
31303 wxPyApp::SetMacAboutMenuItemId(arg1);
31304 wxPyEndAllowThreads(__tstate);
31305 if (PyErr_Occurred()) SWIG_fail;
31306 }
31307 resultobj = SWIG_Py_Void();
31308 return resultobj;
31309 fail:
31310 return NULL;
31311 }
31312
31313
31314 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31315 PyObject *resultobj = 0;
31316 long arg1 ;
31317 long val1 ;
31318 int ecode1 = 0 ;
31319 PyObject * obj0 = 0 ;
31320 char * kwnames[] = {
31321 (char *) "val", NULL
31322 };
31323
31324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
31325 ecode1 = SWIG_AsVal_long(obj0, &val1);
31326 if (!SWIG_IsOK(ecode1)) {
31327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
31328 }
31329 arg1 = static_cast< long >(val1);
31330 {
31331 PyThreadState* __tstate = wxPyBeginAllowThreads();
31332 wxPyApp::SetMacPreferencesMenuItemId(arg1);
31333 wxPyEndAllowThreads(__tstate);
31334 if (PyErr_Occurred()) SWIG_fail;
31335 }
31336 resultobj = SWIG_Py_Void();
31337 return resultobj;
31338 fail:
31339 return NULL;
31340 }
31341
31342
31343 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31344 PyObject *resultobj = 0;
31345 long arg1 ;
31346 long val1 ;
31347 int ecode1 = 0 ;
31348 PyObject * obj0 = 0 ;
31349 char * kwnames[] = {
31350 (char *) "val", NULL
31351 };
31352
31353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
31354 ecode1 = SWIG_AsVal_long(obj0, &val1);
31355 if (!SWIG_IsOK(ecode1)) {
31356 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
31357 }
31358 arg1 = static_cast< long >(val1);
31359 {
31360 PyThreadState* __tstate = wxPyBeginAllowThreads();
31361 wxPyApp::SetMacExitMenuItemId(arg1);
31362 wxPyEndAllowThreads(__tstate);
31363 if (PyErr_Occurred()) SWIG_fail;
31364 }
31365 resultobj = SWIG_Py_Void();
31366 return resultobj;
31367 fail:
31368 return NULL;
31369 }
31370
31371
31372 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31373 PyObject *resultobj = 0;
31374 wxString *arg1 = 0 ;
31375 bool temp1 = false ;
31376 PyObject * obj0 = 0 ;
31377 char * kwnames[] = {
31378 (char *) "val", NULL
31379 };
31380
31381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
31382 {
31383 arg1 = wxString_in_helper(obj0);
31384 if (arg1 == NULL) SWIG_fail;
31385 temp1 = true;
31386 }
31387 {
31388 PyThreadState* __tstate = wxPyBeginAllowThreads();
31389 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
31390 wxPyEndAllowThreads(__tstate);
31391 if (PyErr_Occurred()) SWIG_fail;
31392 }
31393 resultobj = SWIG_Py_Void();
31394 {
31395 if (temp1)
31396 delete arg1;
31397 }
31398 return resultobj;
31399 fail:
31400 {
31401 if (temp1)
31402 delete arg1;
31403 }
31404 return NULL;
31405 }
31406
31407
31408 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31409 PyObject *resultobj = 0;
31410 wxPyApp *arg1 = (wxPyApp *) 0 ;
31411 void *argp1 = 0 ;
31412 int res1 = 0 ;
31413 PyObject *swig_obj[1] ;
31414
31415 if (!args) SWIG_fail;
31416 swig_obj[0] = args;
31417 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
31418 if (!SWIG_IsOK(res1)) {
31419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
31420 }
31421 arg1 = reinterpret_cast< wxPyApp * >(argp1);
31422 {
31423 PyThreadState* __tstate = wxPyBeginAllowThreads();
31424 (arg1)->_BootstrapApp();
31425 wxPyEndAllowThreads(__tstate);
31426 if (PyErr_Occurred()) SWIG_fail;
31427 }
31428 resultobj = SWIG_Py_Void();
31429 return resultobj;
31430 fail:
31431 return NULL;
31432 }
31433
31434
31435 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31436 PyObject *resultobj = 0;
31437 int result;
31438
31439 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
31440 {
31441 PyThreadState* __tstate = wxPyBeginAllowThreads();
31442 result = (int)wxPyApp_GetComCtl32Version();
31443 wxPyEndAllowThreads(__tstate);
31444 if (PyErr_Occurred()) SWIG_fail;
31445 }
31446 resultobj = SWIG_From_int(static_cast< int >(result));
31447 return resultobj;
31448 fail:
31449 return NULL;
31450 }
31451
31452
31453 SWIGINTERN PyObject *_wrap_PyApp_IsDisplayAvailable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31454 PyObject *resultobj = 0;
31455 bool result;
31456
31457 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsDisplayAvailable",0,0,0)) SWIG_fail;
31458 {
31459 PyThreadState* __tstate = wxPyBeginAllowThreads();
31460 result = (bool)wxPyApp_IsDisplayAvailable();
31461 wxPyEndAllowThreads(__tstate);
31462 if (PyErr_Occurred()) SWIG_fail;
31463 }
31464 {
31465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31466 }
31467 return resultobj;
31468 fail:
31469 return NULL;
31470 }
31471
31472
31473 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31474 PyObject *obj;
31475 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31476 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
31477 return SWIG_Py_Void();
31478 }
31479
31480 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31481 return SWIG_Python_InitShadowInstance(args);
31482 }
31483
31484 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31485 PyObject *resultobj = 0;
31486
31487 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
31488 {
31489 PyThreadState* __tstate = wxPyBeginAllowThreads();
31490 wxExit();
31491 wxPyEndAllowThreads(__tstate);
31492 if (PyErr_Occurred()) SWIG_fail;
31493 }
31494 resultobj = SWIG_Py_Void();
31495 return resultobj;
31496 fail:
31497 return NULL;
31498 }
31499
31500
31501 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31502 PyObject *resultobj = 0;
31503 bool result;
31504
31505 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
31506 {
31507 PyThreadState* __tstate = wxPyBeginAllowThreads();
31508 result = (bool)wxYield();
31509 wxPyEndAllowThreads(__tstate);
31510 if (PyErr_Occurred()) SWIG_fail;
31511 }
31512 {
31513 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31514 }
31515 return resultobj;
31516 fail:
31517 return NULL;
31518 }
31519
31520
31521 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31522 PyObject *resultobj = 0;
31523 bool result;
31524
31525 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
31526 {
31527 PyThreadState* __tstate = wxPyBeginAllowThreads();
31528 result = (bool)wxYieldIfNeeded();
31529 wxPyEndAllowThreads(__tstate);
31530 if (PyErr_Occurred()) SWIG_fail;
31531 }
31532 {
31533 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31534 }
31535 return resultobj;
31536 fail:
31537 return NULL;
31538 }
31539
31540
31541 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31542 PyObject *resultobj = 0;
31543 wxWindow *arg1 = (wxWindow *) NULL ;
31544 bool arg2 = (bool) false ;
31545 bool result;
31546 void *argp1 = 0 ;
31547 int res1 = 0 ;
31548 bool val2 ;
31549 int ecode2 = 0 ;
31550 PyObject * obj0 = 0 ;
31551 PyObject * obj1 = 0 ;
31552 char * kwnames[] = {
31553 (char *) "win",(char *) "onlyIfNeeded", NULL
31554 };
31555
31556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
31557 if (obj0) {
31558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31559 if (!SWIG_IsOK(res1)) {
31560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
31561 }
31562 arg1 = reinterpret_cast< wxWindow * >(argp1);
31563 }
31564 if (obj1) {
31565 ecode2 = SWIG_AsVal_bool(obj1, &val2);
31566 if (!SWIG_IsOK(ecode2)) {
31567 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
31568 }
31569 arg2 = static_cast< bool >(val2);
31570 }
31571 {
31572 PyThreadState* __tstate = wxPyBeginAllowThreads();
31573 result = (bool)wxSafeYield(arg1,arg2);
31574 wxPyEndAllowThreads(__tstate);
31575 if (PyErr_Occurred()) SWIG_fail;
31576 }
31577 {
31578 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31579 }
31580 return resultobj;
31581 fail:
31582 return NULL;
31583 }
31584
31585
31586 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31587 PyObject *resultobj = 0;
31588
31589 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
31590 {
31591 PyThreadState* __tstate = wxPyBeginAllowThreads();
31592 wxWakeUpIdle();
31593 wxPyEndAllowThreads(__tstate);
31594 if (PyErr_Occurred()) SWIG_fail;
31595 }
31596 resultobj = SWIG_Py_Void();
31597 return resultobj;
31598 fail:
31599 return NULL;
31600 }
31601
31602
31603 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31604 PyObject *resultobj = 0;
31605 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
31606 wxEvent *arg2 = 0 ;
31607 void *argp1 = 0 ;
31608 int res1 = 0 ;
31609 void *argp2 = 0 ;
31610 int res2 = 0 ;
31611 PyObject * obj0 = 0 ;
31612 PyObject * obj1 = 0 ;
31613 char * kwnames[] = {
31614 (char *) "dest",(char *) "event", NULL
31615 };
31616
31617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
31618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
31619 if (!SWIG_IsOK(res1)) {
31620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
31621 }
31622 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
31623 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
31624 if (!SWIG_IsOK(res2)) {
31625 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31626 }
31627 if (!argp2) {
31628 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
31629 }
31630 arg2 = reinterpret_cast< wxEvent * >(argp2);
31631 {
31632 PyThreadState* __tstate = wxPyBeginAllowThreads();
31633 wxPostEvent(arg1,*arg2);
31634 wxPyEndAllowThreads(__tstate);
31635 if (PyErr_Occurred()) SWIG_fail;
31636 }
31637 resultobj = SWIG_Py_Void();
31638 return resultobj;
31639 fail:
31640 return NULL;
31641 }
31642
31643
31644 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31645 PyObject *resultobj = 0;
31646
31647 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
31648 {
31649 PyThreadState* __tstate = wxPyBeginAllowThreads();
31650 wxApp_CleanUp();
31651 wxPyEndAllowThreads(__tstate);
31652 if (PyErr_Occurred()) SWIG_fail;
31653 }
31654 resultobj = SWIG_Py_Void();
31655 return resultobj;
31656 fail:
31657 return NULL;
31658 }
31659
31660
31661 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31662 PyObject *resultobj = 0;
31663 wxPyApp *result = 0 ;
31664
31665 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
31666 {
31667 PyThreadState* __tstate = wxPyBeginAllowThreads();
31668 result = (wxPyApp *)wxPyGetApp();
31669 wxPyEndAllowThreads(__tstate);
31670 if (PyErr_Occurred()) SWIG_fail;
31671 }
31672 {
31673 resultobj = wxPyMake_wxObject(result, 0);
31674 }
31675 return resultobj;
31676 fail:
31677 return NULL;
31678 }
31679
31680
31681 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31682 PyObject *resultobj = 0;
31683 char *arg1 = (char *) 0 ;
31684 int res1 ;
31685 char *buf1 = 0 ;
31686 int alloc1 = 0 ;
31687 PyObject * obj0 = 0 ;
31688 char * kwnames[] = {
31689 (char *) "encoding", NULL
31690 };
31691
31692 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
31693 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
31694 if (!SWIG_IsOK(res1)) {
31695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
31696 }
31697 arg1 = buf1;
31698 {
31699 PyThreadState* __tstate = wxPyBeginAllowThreads();
31700 wxSetDefaultPyEncoding((char const *)arg1);
31701 wxPyEndAllowThreads(__tstate);
31702 if (PyErr_Occurred()) SWIG_fail;
31703 }
31704 resultobj = SWIG_Py_Void();
31705 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31706 return resultobj;
31707 fail:
31708 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
31709 return NULL;
31710 }
31711
31712
31713 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31714 PyObject *resultobj = 0;
31715 char *result = 0 ;
31716
31717 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
31718 {
31719 PyThreadState* __tstate = wxPyBeginAllowThreads();
31720 result = (char *)wxGetDefaultPyEncoding();
31721 wxPyEndAllowThreads(__tstate);
31722 if (PyErr_Occurred()) SWIG_fail;
31723 }
31724 resultobj = SWIG_FromCharPtr(result);
31725 return resultobj;
31726 fail:
31727 return NULL;
31728 }
31729
31730
31731 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31732 PyObject *resultobj = 0;
31733 wxEventLoop *result = 0 ;
31734
31735 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
31736 {
31737 PyThreadState* __tstate = wxPyBeginAllowThreads();
31738 result = (wxEventLoop *)new wxEventLoop();
31739 wxPyEndAllowThreads(__tstate);
31740 if (PyErr_Occurred()) SWIG_fail;
31741 }
31742 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
31743 return resultobj;
31744 fail:
31745 return NULL;
31746 }
31747
31748
31749 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31750 PyObject *resultobj = 0;
31751 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31752 void *argp1 = 0 ;
31753 int res1 = 0 ;
31754 PyObject *swig_obj[1] ;
31755
31756 if (!args) SWIG_fail;
31757 swig_obj[0] = args;
31758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
31759 if (!SWIG_IsOK(res1)) {
31760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31761 }
31762 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31763 {
31764 PyThreadState* __tstate = wxPyBeginAllowThreads();
31765 delete arg1;
31766
31767 wxPyEndAllowThreads(__tstate);
31768 if (PyErr_Occurred()) SWIG_fail;
31769 }
31770 resultobj = SWIG_Py_Void();
31771 return resultobj;
31772 fail:
31773 return NULL;
31774 }
31775
31776
31777 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31778 PyObject *resultobj = 0;
31779 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31780 int result;
31781 void *argp1 = 0 ;
31782 int res1 = 0 ;
31783 PyObject *swig_obj[1] ;
31784
31785 if (!args) SWIG_fail;
31786 swig_obj[0] = args;
31787 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31788 if (!SWIG_IsOK(res1)) {
31789 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31790 }
31791 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31792 {
31793 PyThreadState* __tstate = wxPyBeginAllowThreads();
31794 result = (int)(arg1)->Run();
31795 wxPyEndAllowThreads(__tstate);
31796 if (PyErr_Occurred()) SWIG_fail;
31797 }
31798 resultobj = SWIG_From_int(static_cast< int >(result));
31799 return resultobj;
31800 fail:
31801 return NULL;
31802 }
31803
31804
31805 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31806 PyObject *resultobj = 0;
31807 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31808 int arg2 = (int) 0 ;
31809 void *argp1 = 0 ;
31810 int res1 = 0 ;
31811 int val2 ;
31812 int ecode2 = 0 ;
31813 PyObject * obj0 = 0 ;
31814 PyObject * obj1 = 0 ;
31815 char * kwnames[] = {
31816 (char *) "self",(char *) "rc", NULL
31817 };
31818
31819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
31820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31821 if (!SWIG_IsOK(res1)) {
31822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31823 }
31824 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31825 if (obj1) {
31826 ecode2 = SWIG_AsVal_int(obj1, &val2);
31827 if (!SWIG_IsOK(ecode2)) {
31828 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
31829 }
31830 arg2 = static_cast< int >(val2);
31831 }
31832 {
31833 PyThreadState* __tstate = wxPyBeginAllowThreads();
31834 (arg1)->Exit(arg2);
31835 wxPyEndAllowThreads(__tstate);
31836 if (PyErr_Occurred()) SWIG_fail;
31837 }
31838 resultobj = SWIG_Py_Void();
31839 return resultobj;
31840 fail:
31841 return NULL;
31842 }
31843
31844
31845 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31846 PyObject *resultobj = 0;
31847 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31848 bool result;
31849 void *argp1 = 0 ;
31850 int res1 = 0 ;
31851 PyObject *swig_obj[1] ;
31852
31853 if (!args) SWIG_fail;
31854 swig_obj[0] = args;
31855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31856 if (!SWIG_IsOK(res1)) {
31857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31858 }
31859 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31860 {
31861 PyThreadState* __tstate = wxPyBeginAllowThreads();
31862 result = (bool)((wxEventLoop const *)arg1)->Pending();
31863 wxPyEndAllowThreads(__tstate);
31864 if (PyErr_Occurred()) SWIG_fail;
31865 }
31866 {
31867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31868 }
31869 return resultobj;
31870 fail:
31871 return NULL;
31872 }
31873
31874
31875 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31876 PyObject *resultobj = 0;
31877 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31878 bool result;
31879 void *argp1 = 0 ;
31880 int res1 = 0 ;
31881 PyObject *swig_obj[1] ;
31882
31883 if (!args) SWIG_fail;
31884 swig_obj[0] = args;
31885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31886 if (!SWIG_IsOK(res1)) {
31887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31888 }
31889 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31890 {
31891 PyThreadState* __tstate = wxPyBeginAllowThreads();
31892 result = (bool)(arg1)->Dispatch();
31893 wxPyEndAllowThreads(__tstate);
31894 if (PyErr_Occurred()) SWIG_fail;
31895 }
31896 {
31897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31898 }
31899 return resultobj;
31900 fail:
31901 return NULL;
31902 }
31903
31904
31905 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31906 PyObject *resultobj = 0;
31907 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31908 bool result;
31909 void *argp1 = 0 ;
31910 int res1 = 0 ;
31911 PyObject *swig_obj[1] ;
31912
31913 if (!args) SWIG_fail;
31914 swig_obj[0] = args;
31915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31916 if (!SWIG_IsOK(res1)) {
31917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
31918 }
31919 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31920 {
31921 PyThreadState* __tstate = wxPyBeginAllowThreads();
31922 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
31923 wxPyEndAllowThreads(__tstate);
31924 if (PyErr_Occurred()) SWIG_fail;
31925 }
31926 {
31927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
31928 }
31929 return resultobj;
31930 fail:
31931 return NULL;
31932 }
31933
31934
31935 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31936 PyObject *resultobj = 0;
31937 wxEventLoop *result = 0 ;
31938
31939 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
31940 {
31941 PyThreadState* __tstate = wxPyBeginAllowThreads();
31942 result = (wxEventLoop *)wxEventLoop::GetActive();
31943 wxPyEndAllowThreads(__tstate);
31944 if (PyErr_Occurred()) SWIG_fail;
31945 }
31946 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
31947 return resultobj;
31948 fail:
31949 return NULL;
31950 }
31951
31952
31953 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31954 PyObject *resultobj = 0;
31955 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31956 void *argp1 = 0 ;
31957 int res1 = 0 ;
31958 PyObject * obj0 = 0 ;
31959 char * kwnames[] = {
31960 (char *) "loop", NULL
31961 };
31962
31963 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
31964 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
31965 if (!SWIG_IsOK(res1)) {
31966 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
31967 }
31968 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
31969 {
31970 PyThreadState* __tstate = wxPyBeginAllowThreads();
31971 wxEventLoop::SetActive(arg1);
31972 wxPyEndAllowThreads(__tstate);
31973 if (PyErr_Occurred()) SWIG_fail;
31974 }
31975 resultobj = SWIG_Py_Void();
31976 return resultobj;
31977 fail:
31978 return NULL;
31979 }
31980
31981
31982 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31983 PyObject *obj;
31984 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
31985 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
31986 return SWIG_Py_Void();
31987 }
31988
31989 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31990 return SWIG_Python_InitShadowInstance(args);
31991 }
31992
31993 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31994 PyObject *resultobj = 0;
31995 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
31996 wxEventLoopActivator *result = 0 ;
31997 void *argp1 = 0 ;
31998 int res1 = 0 ;
31999 PyObject * obj0 = 0 ;
32000 char * kwnames[] = {
32001 (char *) "evtLoop", NULL
32002 };
32003
32004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
32005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
32006 if (!SWIG_IsOK(res1)) {
32007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
32008 }
32009 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
32010 {
32011 PyThreadState* __tstate = wxPyBeginAllowThreads();
32012 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
32013 wxPyEndAllowThreads(__tstate);
32014 if (PyErr_Occurred()) SWIG_fail;
32015 }
32016 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
32017 return resultobj;
32018 fail:
32019 return NULL;
32020 }
32021
32022
32023 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32024 PyObject *resultobj = 0;
32025 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
32026 void *argp1 = 0 ;
32027 int res1 = 0 ;
32028 PyObject *swig_obj[1] ;
32029
32030 if (!args) SWIG_fail;
32031 swig_obj[0] = args;
32032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
32033 if (!SWIG_IsOK(res1)) {
32034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
32035 }
32036 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
32037 {
32038 PyThreadState* __tstate = wxPyBeginAllowThreads();
32039 delete arg1;
32040
32041 wxPyEndAllowThreads(__tstate);
32042 if (PyErr_Occurred()) SWIG_fail;
32043 }
32044 resultobj = SWIG_Py_Void();
32045 return resultobj;
32046 fail:
32047 return NULL;
32048 }
32049
32050
32051 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32052 PyObject *obj;
32053 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32054 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
32055 return SWIG_Py_Void();
32056 }
32057
32058 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32059 return SWIG_Python_InitShadowInstance(args);
32060 }
32061
32062 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32063 PyObject *resultobj = 0;
32064 int arg1 = (int) 0 ;
32065 int arg2 = (int) 0 ;
32066 int arg3 = (int) 0 ;
32067 wxAcceleratorEntry *result = 0 ;
32068 int val1 ;
32069 int ecode1 = 0 ;
32070 int val2 ;
32071 int ecode2 = 0 ;
32072 int val3 ;
32073 int ecode3 = 0 ;
32074 PyObject * obj0 = 0 ;
32075 PyObject * obj1 = 0 ;
32076 PyObject * obj2 = 0 ;
32077 char * kwnames[] = {
32078 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
32079 };
32080
32081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32082 if (obj0) {
32083 ecode1 = SWIG_AsVal_int(obj0, &val1);
32084 if (!SWIG_IsOK(ecode1)) {
32085 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
32086 }
32087 arg1 = static_cast< int >(val1);
32088 }
32089 if (obj1) {
32090 ecode2 = SWIG_AsVal_int(obj1, &val2);
32091 if (!SWIG_IsOK(ecode2)) {
32092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
32093 }
32094 arg2 = static_cast< int >(val2);
32095 }
32096 if (obj2) {
32097 ecode3 = SWIG_AsVal_int(obj2, &val3);
32098 if (!SWIG_IsOK(ecode3)) {
32099 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
32100 }
32101 arg3 = static_cast< int >(val3);
32102 }
32103 {
32104 PyThreadState* __tstate = wxPyBeginAllowThreads();
32105 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
32106 wxPyEndAllowThreads(__tstate);
32107 if (PyErr_Occurred()) SWIG_fail;
32108 }
32109 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
32110 return resultobj;
32111 fail:
32112 return NULL;
32113 }
32114
32115
32116 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32117 PyObject *resultobj = 0;
32118 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32119 void *argp1 = 0 ;
32120 int res1 = 0 ;
32121 PyObject *swig_obj[1] ;
32122
32123 if (!args) SWIG_fail;
32124 swig_obj[0] = args;
32125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
32126 if (!SWIG_IsOK(res1)) {
32127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32128 }
32129 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32130 {
32131 PyThreadState* __tstate = wxPyBeginAllowThreads();
32132 delete arg1;
32133
32134 wxPyEndAllowThreads(__tstate);
32135 if (PyErr_Occurred()) SWIG_fail;
32136 }
32137 resultobj = SWIG_Py_Void();
32138 return resultobj;
32139 fail:
32140 return NULL;
32141 }
32142
32143
32144 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32145 PyObject *resultobj = 0;
32146 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32147 int arg2 ;
32148 int arg3 ;
32149 int arg4 ;
32150 void *argp1 = 0 ;
32151 int res1 = 0 ;
32152 int val2 ;
32153 int ecode2 = 0 ;
32154 int val3 ;
32155 int ecode3 = 0 ;
32156 int val4 ;
32157 int ecode4 = 0 ;
32158 PyObject * obj0 = 0 ;
32159 PyObject * obj1 = 0 ;
32160 PyObject * obj2 = 0 ;
32161 PyObject * obj3 = 0 ;
32162 char * kwnames[] = {
32163 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
32164 };
32165
32166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
32167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32168 if (!SWIG_IsOK(res1)) {
32169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32170 }
32171 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32172 ecode2 = SWIG_AsVal_int(obj1, &val2);
32173 if (!SWIG_IsOK(ecode2)) {
32174 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
32175 }
32176 arg2 = static_cast< int >(val2);
32177 ecode3 = SWIG_AsVal_int(obj2, &val3);
32178 if (!SWIG_IsOK(ecode3)) {
32179 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
32180 }
32181 arg3 = static_cast< int >(val3);
32182 ecode4 = SWIG_AsVal_int(obj3, &val4);
32183 if (!SWIG_IsOK(ecode4)) {
32184 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
32185 }
32186 arg4 = static_cast< int >(val4);
32187 {
32188 PyThreadState* __tstate = wxPyBeginAllowThreads();
32189 (arg1)->Set(arg2,arg3,arg4);
32190 wxPyEndAllowThreads(__tstate);
32191 if (PyErr_Occurred()) SWIG_fail;
32192 }
32193 resultobj = SWIG_Py_Void();
32194 return resultobj;
32195 fail:
32196 return NULL;
32197 }
32198
32199
32200 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32201 PyObject *resultobj = 0;
32202 wxString *arg1 = 0 ;
32203 wxAcceleratorEntry *result = 0 ;
32204 bool temp1 = false ;
32205 PyObject * obj0 = 0 ;
32206 char * kwnames[] = {
32207 (char *) "str", NULL
32208 };
32209
32210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:AcceleratorEntry_Create",kwnames,&obj0)) SWIG_fail;
32211 {
32212 arg1 = wxString_in_helper(obj0);
32213 if (arg1 == NULL) SWIG_fail;
32214 temp1 = true;
32215 }
32216 {
32217 PyThreadState* __tstate = wxPyBeginAllowThreads();
32218 result = (wxAcceleratorEntry *)wxAcceleratorEntry::Create((wxString const &)*arg1);
32219 wxPyEndAllowThreads(__tstate);
32220 if (PyErr_Occurred()) SWIG_fail;
32221 }
32222 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_OWN | 0 );
32223 {
32224 if (temp1)
32225 delete arg1;
32226 }
32227 return resultobj;
32228 fail:
32229 {
32230 if (temp1)
32231 delete arg1;
32232 }
32233 return NULL;
32234 }
32235
32236
32237 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32238 PyObject *resultobj = 0;
32239 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32240 int result;
32241 void *argp1 = 0 ;
32242 int res1 = 0 ;
32243 PyObject *swig_obj[1] ;
32244
32245 if (!args) SWIG_fail;
32246 swig_obj[0] = args;
32247 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32248 if (!SWIG_IsOK(res1)) {
32249 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32250 }
32251 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32252 {
32253 PyThreadState* __tstate = wxPyBeginAllowThreads();
32254 result = (int)(arg1)->GetFlags();
32255 wxPyEndAllowThreads(__tstate);
32256 if (PyErr_Occurred()) SWIG_fail;
32257 }
32258 resultobj = SWIG_From_int(static_cast< int >(result));
32259 return resultobj;
32260 fail:
32261 return NULL;
32262 }
32263
32264
32265 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32266 PyObject *resultobj = 0;
32267 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32268 int result;
32269 void *argp1 = 0 ;
32270 int res1 = 0 ;
32271 PyObject *swig_obj[1] ;
32272
32273 if (!args) SWIG_fail;
32274 swig_obj[0] = args;
32275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32276 if (!SWIG_IsOK(res1)) {
32277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32278 }
32279 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32280 {
32281 PyThreadState* __tstate = wxPyBeginAllowThreads();
32282 result = (int)(arg1)->GetKeyCode();
32283 wxPyEndAllowThreads(__tstate);
32284 if (PyErr_Occurred()) SWIG_fail;
32285 }
32286 resultobj = SWIG_From_int(static_cast< int >(result));
32287 return resultobj;
32288 fail:
32289 return NULL;
32290 }
32291
32292
32293 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32294 PyObject *resultobj = 0;
32295 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32296 int result;
32297 void *argp1 = 0 ;
32298 int res1 = 0 ;
32299 PyObject *swig_obj[1] ;
32300
32301 if (!args) SWIG_fail;
32302 swig_obj[0] = args;
32303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32304 if (!SWIG_IsOK(res1)) {
32305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32306 }
32307 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32308 {
32309 PyThreadState* __tstate = wxPyBeginAllowThreads();
32310 result = (int)(arg1)->GetCommand();
32311 wxPyEndAllowThreads(__tstate);
32312 if (PyErr_Occurred()) SWIG_fail;
32313 }
32314 resultobj = SWIG_From_int(static_cast< int >(result));
32315 return resultobj;
32316 fail:
32317 return NULL;
32318 }
32319
32320
32321 SWIGINTERN PyObject *_wrap_AcceleratorEntry_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32322 PyObject *resultobj = 0;
32323 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32324 bool result;
32325 void *argp1 = 0 ;
32326 int res1 = 0 ;
32327 PyObject *swig_obj[1] ;
32328
32329 if (!args) SWIG_fail;
32330 swig_obj[0] = args;
32331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32332 if (!SWIG_IsOK(res1)) {
32333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32334 }
32335 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (bool)((wxAcceleratorEntry const *)arg1)->IsOk();
32339 wxPyEndAllowThreads(__tstate);
32340 if (PyErr_Occurred()) SWIG_fail;
32341 }
32342 {
32343 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32344 }
32345 return resultobj;
32346 fail:
32347 return NULL;
32348 }
32349
32350
32351 SWIGINTERN PyObject *_wrap_AcceleratorEntry_ToString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32352 PyObject *resultobj = 0;
32353 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32354 wxString result;
32355 void *argp1 = 0 ;
32356 int res1 = 0 ;
32357 PyObject *swig_obj[1] ;
32358
32359 if (!args) SWIG_fail;
32360 swig_obj[0] = args;
32361 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32362 if (!SWIG_IsOK(res1)) {
32363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_ToString" "', expected argument " "1"" of type '" "wxAcceleratorEntry const *""'");
32364 }
32365 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32366 {
32367 PyThreadState* __tstate = wxPyBeginAllowThreads();
32368 result = ((wxAcceleratorEntry const *)arg1)->ToString();
32369 wxPyEndAllowThreads(__tstate);
32370 if (PyErr_Occurred()) SWIG_fail;
32371 }
32372 {
32373 #if wxUSE_UNICODE
32374 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
32375 #else
32376 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
32377 #endif
32378 }
32379 return resultobj;
32380 fail:
32381 return NULL;
32382 }
32383
32384
32385 SWIGINTERN PyObject *_wrap_AcceleratorEntry_FromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32386 PyObject *resultobj = 0;
32387 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
32388 wxString *arg2 = 0 ;
32389 bool result;
32390 void *argp1 = 0 ;
32391 int res1 = 0 ;
32392 bool temp2 = false ;
32393 PyObject * obj0 = 0 ;
32394 PyObject * obj1 = 0 ;
32395 char * kwnames[] = {
32396 (char *) "self",(char *) "str", NULL
32397 };
32398
32399 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:AcceleratorEntry_FromString",kwnames,&obj0,&obj1)) SWIG_fail;
32400 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32401 if (!SWIG_IsOK(res1)) {
32402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_FromString" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
32403 }
32404 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
32405 {
32406 arg2 = wxString_in_helper(obj1);
32407 if (arg2 == NULL) SWIG_fail;
32408 temp2 = true;
32409 }
32410 {
32411 PyThreadState* __tstate = wxPyBeginAllowThreads();
32412 result = (bool)(arg1)->FromString((wxString const &)*arg2);
32413 wxPyEndAllowThreads(__tstate);
32414 if (PyErr_Occurred()) SWIG_fail;
32415 }
32416 {
32417 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32418 }
32419 {
32420 if (temp2)
32421 delete arg2;
32422 }
32423 return resultobj;
32424 fail:
32425 {
32426 if (temp2)
32427 delete arg2;
32428 }
32429 return NULL;
32430 }
32431
32432
32433 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32434 PyObject *obj;
32435 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32436 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
32437 return SWIG_Py_Void();
32438 }
32439
32440 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32441 return SWIG_Python_InitShadowInstance(args);
32442 }
32443
32444 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32445 PyObject *resultobj = 0;
32446 int arg1 ;
32447 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
32448 wxAcceleratorTable *result = 0 ;
32449 PyObject * obj0 = 0 ;
32450 char * kwnames[] = {
32451 (char *) "n", NULL
32452 };
32453
32454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
32455 {
32456 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
32457 if (arg2) arg1 = PyList_Size(obj0);
32458 else arg1 = 0;
32459 }
32460 {
32461 PyThreadState* __tstate = wxPyBeginAllowThreads();
32462 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
32463 wxPyEndAllowThreads(__tstate);
32464 if (PyErr_Occurred()) SWIG_fail;
32465 }
32466 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
32467 return resultobj;
32468 fail:
32469 return NULL;
32470 }
32471
32472
32473 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32474 PyObject *resultobj = 0;
32475 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32476 void *argp1 = 0 ;
32477 int res1 = 0 ;
32478 PyObject *swig_obj[1] ;
32479
32480 if (!args) SWIG_fail;
32481 swig_obj[0] = args;
32482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
32483 if (!SWIG_IsOK(res1)) {
32484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
32485 }
32486 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32487 {
32488 PyThreadState* __tstate = wxPyBeginAllowThreads();
32489 delete arg1;
32490
32491 wxPyEndAllowThreads(__tstate);
32492 if (PyErr_Occurred()) SWIG_fail;
32493 }
32494 resultobj = SWIG_Py_Void();
32495 return resultobj;
32496 fail:
32497 return NULL;
32498 }
32499
32500
32501 SWIGINTERN PyObject *_wrap_AcceleratorTable_IsOk(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32502 PyObject *resultobj = 0;
32503 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
32504 bool result;
32505 void *argp1 = 0 ;
32506 int res1 = 0 ;
32507 PyObject *swig_obj[1] ;
32508
32509 if (!args) SWIG_fail;
32510 swig_obj[0] = args;
32511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
32512 if (!SWIG_IsOK(res1)) {
32513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_IsOk" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
32514 }
32515 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
32516 {
32517 PyThreadState* __tstate = wxPyBeginAllowThreads();
32518 result = (bool)((wxAcceleratorTable const *)arg1)->IsOk();
32519 wxPyEndAllowThreads(__tstate);
32520 if (PyErr_Occurred()) SWIG_fail;
32521 }
32522 {
32523 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32524 }
32525 return resultobj;
32526 fail:
32527 return NULL;
32528 }
32529
32530
32531 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32532 PyObject *obj;
32533 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32534 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
32535 return SWIG_Py_Void();
32536 }
32537
32538 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32539 return SWIG_Python_InitShadowInstance(args);
32540 }
32541
32542 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
32543 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
32544 return 1;
32545 }
32546
32547
32548 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
32549 PyObject *pyobj = 0;
32550
32551 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
32552 return pyobj;
32553 }
32554
32555
32556 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32557 PyObject *resultobj = 0;
32558 wxString *arg1 = 0 ;
32559 wxAcceleratorEntry *result = 0 ;
32560 bool temp1 = false ;
32561 PyObject * obj0 = 0 ;
32562 char * kwnames[] = {
32563 (char *) "label", NULL
32564 };
32565
32566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
32567 {
32568 arg1 = wxString_in_helper(obj0);
32569 if (arg1 == NULL) SWIG_fail;
32570 temp1 = true;
32571 }
32572 {
32573 PyThreadState* __tstate = wxPyBeginAllowThreads();
32574 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
32575 wxPyEndAllowThreads(__tstate);
32576 if (PyErr_Occurred()) SWIG_fail;
32577 }
32578 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
32579 {
32580 if (temp1)
32581 delete arg1;
32582 }
32583 return resultobj;
32584 fail:
32585 {
32586 if (temp1)
32587 delete arg1;
32588 }
32589 return NULL;
32590 }
32591
32592
32593 SWIGINTERN int PanelNameStr_set(PyObject *) {
32594 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
32595 return 1;
32596 }
32597
32598
32599 SWIGINTERN PyObject *PanelNameStr_get(void) {
32600 PyObject *pyobj = 0;
32601
32602 {
32603 #if wxUSE_UNICODE
32604 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32605 #else
32606 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
32607 #endif
32608 }
32609 return pyobj;
32610 }
32611
32612
32613 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32614 PyObject *resultobj = 0;
32615 wxVisualAttributes *result = 0 ;
32616
32617 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
32618 {
32619 PyThreadState* __tstate = wxPyBeginAllowThreads();
32620 result = (wxVisualAttributes *)new_wxVisualAttributes();
32621 wxPyEndAllowThreads(__tstate);
32622 if (PyErr_Occurred()) SWIG_fail;
32623 }
32624 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
32625 return resultobj;
32626 fail:
32627 return NULL;
32628 }
32629
32630
32631 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32632 PyObject *resultobj = 0;
32633 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32634 void *argp1 = 0 ;
32635 int res1 = 0 ;
32636 PyObject *swig_obj[1] ;
32637
32638 if (!args) SWIG_fail;
32639 swig_obj[0] = args;
32640 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
32641 if (!SWIG_IsOK(res1)) {
32642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32643 }
32644 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32645 {
32646 PyThreadState* __tstate = wxPyBeginAllowThreads();
32647 delete_wxVisualAttributes(arg1);
32648
32649 wxPyEndAllowThreads(__tstate);
32650 if (PyErr_Occurred()) SWIG_fail;
32651 }
32652 resultobj = SWIG_Py_Void();
32653 return resultobj;
32654 fail:
32655 return NULL;
32656 }
32657
32658
32659 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32660 PyObject *resultobj = 0;
32661 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32662 wxFont *arg2 = (wxFont *) 0 ;
32663 void *argp1 = 0 ;
32664 int res1 = 0 ;
32665 void *argp2 = 0 ;
32666 int res2 = 0 ;
32667 PyObject *swig_obj[2] ;
32668
32669 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
32670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32671 if (!SWIG_IsOK(res1)) {
32672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32673 }
32674 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32675 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
32676 if (!SWIG_IsOK(res2)) {
32677 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
32678 }
32679 arg2 = reinterpret_cast< wxFont * >(argp2);
32680 if (arg1) (arg1)->font = *arg2;
32681
32682 resultobj = SWIG_Py_Void();
32683 return resultobj;
32684 fail:
32685 return NULL;
32686 }
32687
32688
32689 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32690 PyObject *resultobj = 0;
32691 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32692 wxFont *result = 0 ;
32693 void *argp1 = 0 ;
32694 int res1 = 0 ;
32695 PyObject *swig_obj[1] ;
32696
32697 if (!args) SWIG_fail;
32698 swig_obj[0] = args;
32699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32700 if (!SWIG_IsOK(res1)) {
32701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32702 }
32703 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32704 result = (wxFont *)& ((arg1)->font);
32705 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
32706 return resultobj;
32707 fail:
32708 return NULL;
32709 }
32710
32711
32712 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32713 PyObject *resultobj = 0;
32714 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32715 wxColour *arg2 = (wxColour *) 0 ;
32716 void *argp1 = 0 ;
32717 int res1 = 0 ;
32718 void *argp2 = 0 ;
32719 int res2 = 0 ;
32720 PyObject *swig_obj[2] ;
32721
32722 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
32723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32724 if (!SWIG_IsOK(res1)) {
32725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32726 }
32727 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32728 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32729 if (!SWIG_IsOK(res2)) {
32730 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32731 }
32732 arg2 = reinterpret_cast< wxColour * >(argp2);
32733 if (arg1) (arg1)->colFg = *arg2;
32734
32735 resultobj = SWIG_Py_Void();
32736 return resultobj;
32737 fail:
32738 return NULL;
32739 }
32740
32741
32742 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32743 PyObject *resultobj = 0;
32744 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32745 wxColour *result = 0 ;
32746 void *argp1 = 0 ;
32747 int res1 = 0 ;
32748 PyObject *swig_obj[1] ;
32749
32750 if (!args) SWIG_fail;
32751 swig_obj[0] = args;
32752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32753 if (!SWIG_IsOK(res1)) {
32754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32755 }
32756 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32757 result = (wxColour *)& ((arg1)->colFg);
32758 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32759 return resultobj;
32760 fail:
32761 return NULL;
32762 }
32763
32764
32765 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32766 PyObject *resultobj = 0;
32767 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32768 wxColour *arg2 = (wxColour *) 0 ;
32769 void *argp1 = 0 ;
32770 int res1 = 0 ;
32771 void *argp2 = 0 ;
32772 int res2 = 0 ;
32773 PyObject *swig_obj[2] ;
32774
32775 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
32776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32777 if (!SWIG_IsOK(res1)) {
32778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32779 }
32780 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32781 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
32782 if (!SWIG_IsOK(res2)) {
32783 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
32784 }
32785 arg2 = reinterpret_cast< wxColour * >(argp2);
32786 if (arg1) (arg1)->colBg = *arg2;
32787
32788 resultobj = SWIG_Py_Void();
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32796 PyObject *resultobj = 0;
32797 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
32798 wxColour *result = 0 ;
32799 void *argp1 = 0 ;
32800 int res1 = 0 ;
32801 PyObject *swig_obj[1] ;
32802
32803 if (!args) SWIG_fail;
32804 swig_obj[0] = args;
32805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
32806 if (!SWIG_IsOK(res1)) {
32807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
32808 }
32809 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
32810 result = (wxColour *)& ((arg1)->colBg);
32811 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
32812 return resultobj;
32813 fail:
32814 return NULL;
32815 }
32816
32817
32818 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32819 PyObject *obj;
32820 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
32821 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
32822 return SWIG_Py_Void();
32823 }
32824
32825 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32826 return SWIG_Python_InitShadowInstance(args);
32827 }
32828
32829 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32830 PyObject *resultobj = 0;
32831 wxWindow *arg1 = (wxWindow *) 0 ;
32832 int arg2 = (int) (int)-1 ;
32833 wxPoint const &arg3_defvalue = wxDefaultPosition ;
32834 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
32835 wxSize const &arg4_defvalue = wxDefaultSize ;
32836 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
32837 long arg5 = (long) 0 ;
32838 wxString const &arg6_defvalue = wxPyPanelNameStr ;
32839 wxString *arg6 = (wxString *) &arg6_defvalue ;
32840 wxWindow *result = 0 ;
32841 void *argp1 = 0 ;
32842 int res1 = 0 ;
32843 int val2 ;
32844 int ecode2 = 0 ;
32845 wxPoint temp3 ;
32846 wxSize temp4 ;
32847 long val5 ;
32848 int ecode5 = 0 ;
32849 bool temp6 = false ;
32850 PyObject * obj0 = 0 ;
32851 PyObject * obj1 = 0 ;
32852 PyObject * obj2 = 0 ;
32853 PyObject * obj3 = 0 ;
32854 PyObject * obj4 = 0 ;
32855 PyObject * obj5 = 0 ;
32856 char * kwnames[] = {
32857 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32858 };
32859
32860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
32861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32862 if (!SWIG_IsOK(res1)) {
32863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
32864 }
32865 arg1 = reinterpret_cast< wxWindow * >(argp1);
32866 if (obj1) {
32867 ecode2 = SWIG_AsVal_int(obj1, &val2);
32868 if (!SWIG_IsOK(ecode2)) {
32869 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
32870 }
32871 arg2 = static_cast< int >(val2);
32872 }
32873 if (obj2) {
32874 {
32875 arg3 = &temp3;
32876 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
32877 }
32878 }
32879 if (obj3) {
32880 {
32881 arg4 = &temp4;
32882 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
32883 }
32884 }
32885 if (obj4) {
32886 ecode5 = SWIG_AsVal_long(obj4, &val5);
32887 if (!SWIG_IsOK(ecode5)) {
32888 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
32889 }
32890 arg5 = static_cast< long >(val5);
32891 }
32892 if (obj5) {
32893 {
32894 arg6 = wxString_in_helper(obj5);
32895 if (arg6 == NULL) SWIG_fail;
32896 temp6 = true;
32897 }
32898 }
32899 {
32900 if (!wxPyCheckForApp()) SWIG_fail;
32901 PyThreadState* __tstate = wxPyBeginAllowThreads();
32902 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
32903 wxPyEndAllowThreads(__tstate);
32904 if (PyErr_Occurred()) SWIG_fail;
32905 }
32906 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
32907 {
32908 if (temp6)
32909 delete arg6;
32910 }
32911 return resultobj;
32912 fail:
32913 {
32914 if (temp6)
32915 delete arg6;
32916 }
32917 return NULL;
32918 }
32919
32920
32921 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32922 PyObject *resultobj = 0;
32923 wxWindow *result = 0 ;
32924
32925 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
32926 {
32927 if (!wxPyCheckForApp()) SWIG_fail;
32928 PyThreadState* __tstate = wxPyBeginAllowThreads();
32929 result = (wxWindow *)new wxWindow();
32930 wxPyEndAllowThreads(__tstate);
32931 if (PyErr_Occurred()) SWIG_fail;
32932 }
32933 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
32934 return resultobj;
32935 fail:
32936 return NULL;
32937 }
32938
32939
32940 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32941 PyObject *resultobj = 0;
32942 wxWindow *arg1 = (wxWindow *) 0 ;
32943 wxWindow *arg2 = (wxWindow *) 0 ;
32944 int arg3 = (int) (int)-1 ;
32945 wxPoint const &arg4_defvalue = wxDefaultPosition ;
32946 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
32947 wxSize const &arg5_defvalue = wxDefaultSize ;
32948 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
32949 long arg6 = (long) 0 ;
32950 wxString const &arg7_defvalue = wxPyPanelNameStr ;
32951 wxString *arg7 = (wxString *) &arg7_defvalue ;
32952 bool result;
32953 void *argp1 = 0 ;
32954 int res1 = 0 ;
32955 void *argp2 = 0 ;
32956 int res2 = 0 ;
32957 int val3 ;
32958 int ecode3 = 0 ;
32959 wxPoint temp4 ;
32960 wxSize temp5 ;
32961 long val6 ;
32962 int ecode6 = 0 ;
32963 bool temp7 = false ;
32964 PyObject * obj0 = 0 ;
32965 PyObject * obj1 = 0 ;
32966 PyObject * obj2 = 0 ;
32967 PyObject * obj3 = 0 ;
32968 PyObject * obj4 = 0 ;
32969 PyObject * obj5 = 0 ;
32970 PyObject * obj6 = 0 ;
32971 char * kwnames[] = {
32972 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
32973 };
32974
32975 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
32976 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32977 if (!SWIG_IsOK(res1)) {
32978 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
32979 }
32980 arg1 = reinterpret_cast< wxWindow * >(argp1);
32981 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32982 if (!SWIG_IsOK(res2)) {
32983 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
32984 }
32985 arg2 = reinterpret_cast< wxWindow * >(argp2);
32986 if (obj2) {
32987 ecode3 = SWIG_AsVal_int(obj2, &val3);
32988 if (!SWIG_IsOK(ecode3)) {
32989 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
32990 }
32991 arg3 = static_cast< int >(val3);
32992 }
32993 if (obj3) {
32994 {
32995 arg4 = &temp4;
32996 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
32997 }
32998 }
32999 if (obj4) {
33000 {
33001 arg5 = &temp5;
33002 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
33003 }
33004 }
33005 if (obj5) {
33006 ecode6 = SWIG_AsVal_long(obj5, &val6);
33007 if (!SWIG_IsOK(ecode6)) {
33008 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
33009 }
33010 arg6 = static_cast< long >(val6);
33011 }
33012 if (obj6) {
33013 {
33014 arg7 = wxString_in_helper(obj6);
33015 if (arg7 == NULL) SWIG_fail;
33016 temp7 = true;
33017 }
33018 }
33019 {
33020 PyThreadState* __tstate = wxPyBeginAllowThreads();
33021 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
33022 wxPyEndAllowThreads(__tstate);
33023 if (PyErr_Occurred()) SWIG_fail;
33024 }
33025 {
33026 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33027 }
33028 {
33029 if (temp7)
33030 delete arg7;
33031 }
33032 return resultobj;
33033 fail:
33034 {
33035 if (temp7)
33036 delete arg7;
33037 }
33038 return NULL;
33039 }
33040
33041
33042 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33043 PyObject *resultobj = 0;
33044 wxWindow *arg1 = (wxWindow *) 0 ;
33045 bool arg2 = (bool) false ;
33046 bool result;
33047 void *argp1 = 0 ;
33048 int res1 = 0 ;
33049 bool val2 ;
33050 int ecode2 = 0 ;
33051 PyObject * obj0 = 0 ;
33052 PyObject * obj1 = 0 ;
33053 char * kwnames[] = {
33054 (char *) "self",(char *) "force", NULL
33055 };
33056
33057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
33058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33059 if (!SWIG_IsOK(res1)) {
33060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
33061 }
33062 arg1 = reinterpret_cast< wxWindow * >(argp1);
33063 if (obj1) {
33064 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33065 if (!SWIG_IsOK(ecode2)) {
33066 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
33067 }
33068 arg2 = static_cast< bool >(val2);
33069 }
33070 {
33071 PyThreadState* __tstate = wxPyBeginAllowThreads();
33072 result = (bool)(arg1)->Close(arg2);
33073 wxPyEndAllowThreads(__tstate);
33074 if (PyErr_Occurred()) SWIG_fail;
33075 }
33076 {
33077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33078 }
33079 return resultobj;
33080 fail:
33081 return NULL;
33082 }
33083
33084
33085 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33086 PyObject *resultobj = 0;
33087 wxWindow *arg1 = (wxWindow *) 0 ;
33088 bool result;
33089 void *argp1 = 0 ;
33090 int res1 = 0 ;
33091 PyObject *swig_obj[1] ;
33092
33093 if (!args) SWIG_fail;
33094 swig_obj[0] = args;
33095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33096 if (!SWIG_IsOK(res1)) {
33097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
33098 }
33099 arg1 = reinterpret_cast< wxWindow * >(argp1);
33100 {
33101 PyThreadState* __tstate = wxPyBeginAllowThreads();
33102 result = (bool)(arg1)->Destroy();
33103 wxPyEndAllowThreads(__tstate);
33104 if (PyErr_Occurred()) SWIG_fail;
33105 }
33106 {
33107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33108 }
33109 return resultobj;
33110 fail:
33111 return NULL;
33112 }
33113
33114
33115 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33116 PyObject *resultobj = 0;
33117 wxWindow *arg1 = (wxWindow *) 0 ;
33118 bool result;
33119 void *argp1 = 0 ;
33120 int res1 = 0 ;
33121 PyObject *swig_obj[1] ;
33122
33123 if (!args) SWIG_fail;
33124 swig_obj[0] = args;
33125 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33126 if (!SWIG_IsOK(res1)) {
33127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33128 }
33129 arg1 = reinterpret_cast< wxWindow * >(argp1);
33130 {
33131 PyThreadState* __tstate = wxPyBeginAllowThreads();
33132 result = (bool)(arg1)->DestroyChildren();
33133 wxPyEndAllowThreads(__tstate);
33134 if (PyErr_Occurred()) SWIG_fail;
33135 }
33136 {
33137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33138 }
33139 return resultobj;
33140 fail:
33141 return NULL;
33142 }
33143
33144
33145 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33146 PyObject *resultobj = 0;
33147 wxWindow *arg1 = (wxWindow *) 0 ;
33148 bool result;
33149 void *argp1 = 0 ;
33150 int res1 = 0 ;
33151 PyObject *swig_obj[1] ;
33152
33153 if (!args) SWIG_fail;
33154 swig_obj[0] = args;
33155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33156 if (!SWIG_IsOK(res1)) {
33157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
33158 }
33159 arg1 = reinterpret_cast< wxWindow * >(argp1);
33160 {
33161 PyThreadState* __tstate = wxPyBeginAllowThreads();
33162 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
33163 wxPyEndAllowThreads(__tstate);
33164 if (PyErr_Occurred()) SWIG_fail;
33165 }
33166 {
33167 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33168 }
33169 return resultobj;
33170 fail:
33171 return NULL;
33172 }
33173
33174
33175 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33176 PyObject *resultobj = 0;
33177 wxWindow *arg1 = (wxWindow *) 0 ;
33178 wxString *arg2 = 0 ;
33179 void *argp1 = 0 ;
33180 int res1 = 0 ;
33181 bool temp2 = false ;
33182 PyObject * obj0 = 0 ;
33183 PyObject * obj1 = 0 ;
33184 char * kwnames[] = {
33185 (char *) "self",(char *) "label", NULL
33186 };
33187
33188 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
33189 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33190 if (!SWIG_IsOK(res1)) {
33191 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
33192 }
33193 arg1 = reinterpret_cast< wxWindow * >(argp1);
33194 {
33195 arg2 = wxString_in_helper(obj1);
33196 if (arg2 == NULL) SWIG_fail;
33197 temp2 = true;
33198 }
33199 {
33200 PyThreadState* __tstate = wxPyBeginAllowThreads();
33201 (arg1)->SetLabel((wxString const &)*arg2);
33202 wxPyEndAllowThreads(__tstate);
33203 if (PyErr_Occurred()) SWIG_fail;
33204 }
33205 resultobj = SWIG_Py_Void();
33206 {
33207 if (temp2)
33208 delete arg2;
33209 }
33210 return resultobj;
33211 fail:
33212 {
33213 if (temp2)
33214 delete arg2;
33215 }
33216 return NULL;
33217 }
33218
33219
33220 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33221 PyObject *resultobj = 0;
33222 wxWindow *arg1 = (wxWindow *) 0 ;
33223 wxString result;
33224 void *argp1 = 0 ;
33225 int res1 = 0 ;
33226 PyObject *swig_obj[1] ;
33227
33228 if (!args) SWIG_fail;
33229 swig_obj[0] = args;
33230 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33231 if (!SWIG_IsOK(res1)) {
33232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33233 }
33234 arg1 = reinterpret_cast< wxWindow * >(argp1);
33235 {
33236 PyThreadState* __tstate = wxPyBeginAllowThreads();
33237 result = ((wxWindow const *)arg1)->GetLabel();
33238 wxPyEndAllowThreads(__tstate);
33239 if (PyErr_Occurred()) SWIG_fail;
33240 }
33241 {
33242 #if wxUSE_UNICODE
33243 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33244 #else
33245 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33246 #endif
33247 }
33248 return resultobj;
33249 fail:
33250 return NULL;
33251 }
33252
33253
33254 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33255 PyObject *resultobj = 0;
33256 wxWindow *arg1 = (wxWindow *) 0 ;
33257 wxString *arg2 = 0 ;
33258 void *argp1 = 0 ;
33259 int res1 = 0 ;
33260 bool temp2 = false ;
33261 PyObject * obj0 = 0 ;
33262 PyObject * obj1 = 0 ;
33263 char * kwnames[] = {
33264 (char *) "self",(char *) "name", NULL
33265 };
33266
33267 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
33268 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33269 if (!SWIG_IsOK(res1)) {
33270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
33271 }
33272 arg1 = reinterpret_cast< wxWindow * >(argp1);
33273 {
33274 arg2 = wxString_in_helper(obj1);
33275 if (arg2 == NULL) SWIG_fail;
33276 temp2 = true;
33277 }
33278 {
33279 PyThreadState* __tstate = wxPyBeginAllowThreads();
33280 (arg1)->SetName((wxString const &)*arg2);
33281 wxPyEndAllowThreads(__tstate);
33282 if (PyErr_Occurred()) SWIG_fail;
33283 }
33284 resultobj = SWIG_Py_Void();
33285 {
33286 if (temp2)
33287 delete arg2;
33288 }
33289 return resultobj;
33290 fail:
33291 {
33292 if (temp2)
33293 delete arg2;
33294 }
33295 return NULL;
33296 }
33297
33298
33299 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33300 PyObject *resultobj = 0;
33301 wxWindow *arg1 = (wxWindow *) 0 ;
33302 wxString result;
33303 void *argp1 = 0 ;
33304 int res1 = 0 ;
33305 PyObject *swig_obj[1] ;
33306
33307 if (!args) SWIG_fail;
33308 swig_obj[0] = args;
33309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33310 if (!SWIG_IsOK(res1)) {
33311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
33312 }
33313 arg1 = reinterpret_cast< wxWindow * >(argp1);
33314 {
33315 PyThreadState* __tstate = wxPyBeginAllowThreads();
33316 result = ((wxWindow const *)arg1)->GetName();
33317 wxPyEndAllowThreads(__tstate);
33318 if (PyErr_Occurred()) SWIG_fail;
33319 }
33320 {
33321 #if wxUSE_UNICODE
33322 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
33323 #else
33324 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
33325 #endif
33326 }
33327 return resultobj;
33328 fail:
33329 return NULL;
33330 }
33331
33332
33333 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33334 PyObject *resultobj = 0;
33335 wxWindow *arg1 = (wxWindow *) 0 ;
33336 wxWindowVariant arg2 ;
33337 void *argp1 = 0 ;
33338 int res1 = 0 ;
33339 int val2 ;
33340 int ecode2 = 0 ;
33341 PyObject * obj0 = 0 ;
33342 PyObject * obj1 = 0 ;
33343 char * kwnames[] = {
33344 (char *) "self",(char *) "variant", NULL
33345 };
33346
33347 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
33348 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33349 if (!SWIG_IsOK(res1)) {
33350 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
33351 }
33352 arg1 = reinterpret_cast< wxWindow * >(argp1);
33353 ecode2 = SWIG_AsVal_int(obj1, &val2);
33354 if (!SWIG_IsOK(ecode2)) {
33355 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
33356 }
33357 arg2 = static_cast< wxWindowVariant >(val2);
33358 {
33359 PyThreadState* __tstate = wxPyBeginAllowThreads();
33360 (arg1)->SetWindowVariant(arg2);
33361 wxPyEndAllowThreads(__tstate);
33362 if (PyErr_Occurred()) SWIG_fail;
33363 }
33364 resultobj = SWIG_Py_Void();
33365 return resultobj;
33366 fail:
33367 return NULL;
33368 }
33369
33370
33371 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33372 PyObject *resultobj = 0;
33373 wxWindow *arg1 = (wxWindow *) 0 ;
33374 wxWindowVariant result;
33375 void *argp1 = 0 ;
33376 int res1 = 0 ;
33377 PyObject *swig_obj[1] ;
33378
33379 if (!args) SWIG_fail;
33380 swig_obj[0] = args;
33381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33382 if (!SWIG_IsOK(res1)) {
33383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
33384 }
33385 arg1 = reinterpret_cast< wxWindow * >(argp1);
33386 {
33387 PyThreadState* __tstate = wxPyBeginAllowThreads();
33388 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
33389 wxPyEndAllowThreads(__tstate);
33390 if (PyErr_Occurred()) SWIG_fail;
33391 }
33392 resultobj = SWIG_From_int(static_cast< int >(result));
33393 return resultobj;
33394 fail:
33395 return NULL;
33396 }
33397
33398
33399 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33400 PyObject *resultobj = 0;
33401 wxWindow *arg1 = (wxWindow *) 0 ;
33402 int arg2 ;
33403 void *argp1 = 0 ;
33404 int res1 = 0 ;
33405 int val2 ;
33406 int ecode2 = 0 ;
33407 PyObject * obj0 = 0 ;
33408 PyObject * obj1 = 0 ;
33409 char * kwnames[] = {
33410 (char *) "self",(char *) "winid", NULL
33411 };
33412
33413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
33414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33415 if (!SWIG_IsOK(res1)) {
33416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
33417 }
33418 arg1 = reinterpret_cast< wxWindow * >(argp1);
33419 ecode2 = SWIG_AsVal_int(obj1, &val2);
33420 if (!SWIG_IsOK(ecode2)) {
33421 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
33422 }
33423 arg2 = static_cast< int >(val2);
33424 {
33425 PyThreadState* __tstate = wxPyBeginAllowThreads();
33426 (arg1)->SetId(arg2);
33427 wxPyEndAllowThreads(__tstate);
33428 if (PyErr_Occurred()) SWIG_fail;
33429 }
33430 resultobj = SWIG_Py_Void();
33431 return resultobj;
33432 fail:
33433 return NULL;
33434 }
33435
33436
33437 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33438 PyObject *resultobj = 0;
33439 wxWindow *arg1 = (wxWindow *) 0 ;
33440 int result;
33441 void *argp1 = 0 ;
33442 int res1 = 0 ;
33443 PyObject *swig_obj[1] ;
33444
33445 if (!args) SWIG_fail;
33446 swig_obj[0] = args;
33447 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33448 if (!SWIG_IsOK(res1)) {
33449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
33450 }
33451 arg1 = reinterpret_cast< wxWindow * >(argp1);
33452 {
33453 PyThreadState* __tstate = wxPyBeginAllowThreads();
33454 result = (int)((wxWindow const *)arg1)->GetId();
33455 wxPyEndAllowThreads(__tstate);
33456 if (PyErr_Occurred()) SWIG_fail;
33457 }
33458 resultobj = SWIG_From_int(static_cast< int >(result));
33459 return resultobj;
33460 fail:
33461 return NULL;
33462 }
33463
33464
33465 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33466 PyObject *resultobj = 0;
33467 int result;
33468
33469 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
33470 {
33471 PyThreadState* __tstate = wxPyBeginAllowThreads();
33472 result = (int)wxWindow::NewControlId();
33473 wxPyEndAllowThreads(__tstate);
33474 if (PyErr_Occurred()) SWIG_fail;
33475 }
33476 resultobj = SWIG_From_int(static_cast< int >(result));
33477 return resultobj;
33478 fail:
33479 return NULL;
33480 }
33481
33482
33483 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33484 PyObject *resultobj = 0;
33485 int arg1 ;
33486 int result;
33487 int val1 ;
33488 int ecode1 = 0 ;
33489 PyObject * obj0 = 0 ;
33490 char * kwnames[] = {
33491 (char *) "winid", NULL
33492 };
33493
33494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
33495 ecode1 = SWIG_AsVal_int(obj0, &val1);
33496 if (!SWIG_IsOK(ecode1)) {
33497 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
33498 }
33499 arg1 = static_cast< int >(val1);
33500 {
33501 PyThreadState* __tstate = wxPyBeginAllowThreads();
33502 result = (int)wxWindow::NextControlId(arg1);
33503 wxPyEndAllowThreads(__tstate);
33504 if (PyErr_Occurred()) SWIG_fail;
33505 }
33506 resultobj = SWIG_From_int(static_cast< int >(result));
33507 return resultobj;
33508 fail:
33509 return NULL;
33510 }
33511
33512
33513 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33514 PyObject *resultobj = 0;
33515 int arg1 ;
33516 int result;
33517 int val1 ;
33518 int ecode1 = 0 ;
33519 PyObject * obj0 = 0 ;
33520 char * kwnames[] = {
33521 (char *) "winid", NULL
33522 };
33523
33524 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
33525 ecode1 = SWIG_AsVal_int(obj0, &val1);
33526 if (!SWIG_IsOK(ecode1)) {
33527 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
33528 }
33529 arg1 = static_cast< int >(val1);
33530 {
33531 PyThreadState* __tstate = wxPyBeginAllowThreads();
33532 result = (int)wxWindow::PrevControlId(arg1);
33533 wxPyEndAllowThreads(__tstate);
33534 if (PyErr_Occurred()) SWIG_fail;
33535 }
33536 resultobj = SWIG_From_int(static_cast< int >(result));
33537 return resultobj;
33538 fail:
33539 return NULL;
33540 }
33541
33542
33543 SWIGINTERN PyObject *_wrap_Window_GetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33544 PyObject *resultobj = 0;
33545 wxWindow *arg1 = (wxWindow *) 0 ;
33546 wxLayoutDirection result;
33547 void *argp1 = 0 ;
33548 int res1 = 0 ;
33549 PyObject *swig_obj[1] ;
33550
33551 if (!args) SWIG_fail;
33552 swig_obj[0] = args;
33553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33554 if (!SWIG_IsOK(res1)) {
33555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33556 }
33557 arg1 = reinterpret_cast< wxWindow * >(argp1);
33558 {
33559 PyThreadState* __tstate = wxPyBeginAllowThreads();
33560 result = (wxLayoutDirection)((wxWindow const *)arg1)->GetLayoutDirection();
33561 wxPyEndAllowThreads(__tstate);
33562 if (PyErr_Occurred()) SWIG_fail;
33563 }
33564 resultobj = SWIG_From_int(static_cast< int >(result));
33565 return resultobj;
33566 fail:
33567 return NULL;
33568 }
33569
33570
33571 SWIGINTERN PyObject *_wrap_Window_SetLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33572 PyObject *resultobj = 0;
33573 wxWindow *arg1 = (wxWindow *) 0 ;
33574 wxLayoutDirection arg2 ;
33575 void *argp1 = 0 ;
33576 int res1 = 0 ;
33577 int val2 ;
33578 int ecode2 = 0 ;
33579 PyObject * obj0 = 0 ;
33580 PyObject * obj1 = 0 ;
33581 char * kwnames[] = {
33582 (char *) "self",(char *) "dir", NULL
33583 };
33584
33585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLayoutDirection",kwnames,&obj0,&obj1)) SWIG_fail;
33586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33587 if (!SWIG_IsOK(res1)) {
33588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLayoutDirection" "', expected argument " "1"" of type '" "wxWindow *""'");
33589 }
33590 arg1 = reinterpret_cast< wxWindow * >(argp1);
33591 ecode2 = SWIG_AsVal_int(obj1, &val2);
33592 if (!SWIG_IsOK(ecode2)) {
33593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetLayoutDirection" "', expected argument " "2"" of type '" "wxLayoutDirection""'");
33594 }
33595 arg2 = static_cast< wxLayoutDirection >(val2);
33596 {
33597 PyThreadState* __tstate = wxPyBeginAllowThreads();
33598 (arg1)->SetLayoutDirection(arg2);
33599 wxPyEndAllowThreads(__tstate);
33600 if (PyErr_Occurred()) SWIG_fail;
33601 }
33602 resultobj = SWIG_Py_Void();
33603 return resultobj;
33604 fail:
33605 return NULL;
33606 }
33607
33608
33609 SWIGINTERN PyObject *_wrap_Window_AdjustForLayoutDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33610 PyObject *resultobj = 0;
33611 wxWindow *arg1 = (wxWindow *) 0 ;
33612 int arg2 ;
33613 int arg3 ;
33614 int arg4 ;
33615 int result;
33616 void *argp1 = 0 ;
33617 int res1 = 0 ;
33618 int val2 ;
33619 int ecode2 = 0 ;
33620 int val3 ;
33621 int ecode3 = 0 ;
33622 int val4 ;
33623 int ecode4 = 0 ;
33624 PyObject * obj0 = 0 ;
33625 PyObject * obj1 = 0 ;
33626 PyObject * obj2 = 0 ;
33627 PyObject * obj3 = 0 ;
33628 char * kwnames[] = {
33629 (char *) "self",(char *) "x",(char *) "width",(char *) "widthTotal", NULL
33630 };
33631
33632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_AdjustForLayoutDirection",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33634 if (!SWIG_IsOK(res1)) {
33635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "1"" of type '" "wxWindow const *""'");
33636 }
33637 arg1 = reinterpret_cast< wxWindow * >(argp1);
33638 ecode2 = SWIG_AsVal_int(obj1, &val2);
33639 if (!SWIG_IsOK(ecode2)) {
33640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "2"" of type '" "int""'");
33641 }
33642 arg2 = static_cast< int >(val2);
33643 ecode3 = SWIG_AsVal_int(obj2, &val3);
33644 if (!SWIG_IsOK(ecode3)) {
33645 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "3"" of type '" "int""'");
33646 }
33647 arg3 = static_cast< int >(val3);
33648 ecode4 = SWIG_AsVal_int(obj3, &val4);
33649 if (!SWIG_IsOK(ecode4)) {
33650 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_AdjustForLayoutDirection" "', expected argument " "4"" of type '" "int""'");
33651 }
33652 arg4 = static_cast< int >(val4);
33653 {
33654 PyThreadState* __tstate = wxPyBeginAllowThreads();
33655 result = (int)((wxWindow const *)arg1)->AdjustForLayoutDirection(arg2,arg3,arg4);
33656 wxPyEndAllowThreads(__tstate);
33657 if (PyErr_Occurred()) SWIG_fail;
33658 }
33659 resultobj = SWIG_From_int(static_cast< int >(result));
33660 return resultobj;
33661 fail:
33662 return NULL;
33663 }
33664
33665
33666 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33667 PyObject *resultobj = 0;
33668 wxWindow *arg1 = (wxWindow *) 0 ;
33669 wxSize *arg2 = 0 ;
33670 void *argp1 = 0 ;
33671 int res1 = 0 ;
33672 wxSize temp2 ;
33673 PyObject * obj0 = 0 ;
33674 PyObject * obj1 = 0 ;
33675 char * kwnames[] = {
33676 (char *) "self",(char *) "size", NULL
33677 };
33678
33679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
33680 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33681 if (!SWIG_IsOK(res1)) {
33682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33683 }
33684 arg1 = reinterpret_cast< wxWindow * >(argp1);
33685 {
33686 arg2 = &temp2;
33687 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
33688 }
33689 {
33690 PyThreadState* __tstate = wxPyBeginAllowThreads();
33691 (arg1)->SetSize((wxSize const &)*arg2);
33692 wxPyEndAllowThreads(__tstate);
33693 if (PyErr_Occurred()) SWIG_fail;
33694 }
33695 resultobj = SWIG_Py_Void();
33696 return resultobj;
33697 fail:
33698 return NULL;
33699 }
33700
33701
33702 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33703 PyObject *resultobj = 0;
33704 wxWindow *arg1 = (wxWindow *) 0 ;
33705 int arg2 ;
33706 int arg3 ;
33707 int arg4 ;
33708 int arg5 ;
33709 int arg6 = (int) wxSIZE_AUTO ;
33710 void *argp1 = 0 ;
33711 int res1 = 0 ;
33712 int val2 ;
33713 int ecode2 = 0 ;
33714 int val3 ;
33715 int ecode3 = 0 ;
33716 int val4 ;
33717 int ecode4 = 0 ;
33718 int val5 ;
33719 int ecode5 = 0 ;
33720 int val6 ;
33721 int ecode6 = 0 ;
33722 PyObject * obj0 = 0 ;
33723 PyObject * obj1 = 0 ;
33724 PyObject * obj2 = 0 ;
33725 PyObject * obj3 = 0 ;
33726 PyObject * obj4 = 0 ;
33727 PyObject * obj5 = 0 ;
33728 char * kwnames[] = {
33729 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
33730 };
33731
33732 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
33733 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33734 if (!SWIG_IsOK(res1)) {
33735 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
33736 }
33737 arg1 = reinterpret_cast< wxWindow * >(argp1);
33738 ecode2 = SWIG_AsVal_int(obj1, &val2);
33739 if (!SWIG_IsOK(ecode2)) {
33740 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
33741 }
33742 arg2 = static_cast< int >(val2);
33743 ecode3 = SWIG_AsVal_int(obj2, &val3);
33744 if (!SWIG_IsOK(ecode3)) {
33745 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
33746 }
33747 arg3 = static_cast< int >(val3);
33748 ecode4 = SWIG_AsVal_int(obj3, &val4);
33749 if (!SWIG_IsOK(ecode4)) {
33750 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
33751 }
33752 arg4 = static_cast< int >(val4);
33753 ecode5 = SWIG_AsVal_int(obj4, &val5);
33754 if (!SWIG_IsOK(ecode5)) {
33755 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
33756 }
33757 arg5 = static_cast< int >(val5);
33758 if (obj5) {
33759 ecode6 = SWIG_AsVal_int(obj5, &val6);
33760 if (!SWIG_IsOK(ecode6)) {
33761 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
33762 }
33763 arg6 = static_cast< int >(val6);
33764 }
33765 {
33766 PyThreadState* __tstate = wxPyBeginAllowThreads();
33767 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
33768 wxPyEndAllowThreads(__tstate);
33769 if (PyErr_Occurred()) SWIG_fail;
33770 }
33771 resultobj = SWIG_Py_Void();
33772 return resultobj;
33773 fail:
33774 return NULL;
33775 }
33776
33777
33778 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33779 PyObject *resultobj = 0;
33780 wxWindow *arg1 = (wxWindow *) 0 ;
33781 wxRect *arg2 = 0 ;
33782 int arg3 = (int) wxSIZE_AUTO ;
33783 void *argp1 = 0 ;
33784 int res1 = 0 ;
33785 wxRect temp2 ;
33786 int val3 ;
33787 int ecode3 = 0 ;
33788 PyObject * obj0 = 0 ;
33789 PyObject * obj1 = 0 ;
33790 PyObject * obj2 = 0 ;
33791 char * kwnames[] = {
33792 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
33793 };
33794
33795 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33796 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33797 if (!SWIG_IsOK(res1)) {
33798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
33799 }
33800 arg1 = reinterpret_cast< wxWindow * >(argp1);
33801 {
33802 arg2 = &temp2;
33803 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
33804 }
33805 if (obj2) {
33806 ecode3 = SWIG_AsVal_int(obj2, &val3);
33807 if (!SWIG_IsOK(ecode3)) {
33808 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
33809 }
33810 arg3 = static_cast< int >(val3);
33811 }
33812 {
33813 PyThreadState* __tstate = wxPyBeginAllowThreads();
33814 (arg1)->SetSize((wxRect const &)*arg2,arg3);
33815 wxPyEndAllowThreads(__tstate);
33816 if (PyErr_Occurred()) SWIG_fail;
33817 }
33818 resultobj = SWIG_Py_Void();
33819 return resultobj;
33820 fail:
33821 return NULL;
33822 }
33823
33824
33825 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33826 PyObject *resultobj = 0;
33827 wxWindow *arg1 = (wxWindow *) 0 ;
33828 int arg2 ;
33829 int arg3 ;
33830 void *argp1 = 0 ;
33831 int res1 = 0 ;
33832 int val2 ;
33833 int ecode2 = 0 ;
33834 int val3 ;
33835 int ecode3 = 0 ;
33836 PyObject * obj0 = 0 ;
33837 PyObject * obj1 = 0 ;
33838 PyObject * obj2 = 0 ;
33839 char * kwnames[] = {
33840 (char *) "self",(char *) "width",(char *) "height", NULL
33841 };
33842
33843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33845 if (!SWIG_IsOK(res1)) {
33846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
33847 }
33848 arg1 = reinterpret_cast< wxWindow * >(argp1);
33849 ecode2 = SWIG_AsVal_int(obj1, &val2);
33850 if (!SWIG_IsOK(ecode2)) {
33851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
33852 }
33853 arg2 = static_cast< int >(val2);
33854 ecode3 = SWIG_AsVal_int(obj2, &val3);
33855 if (!SWIG_IsOK(ecode3)) {
33856 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
33857 }
33858 arg3 = static_cast< int >(val3);
33859 {
33860 PyThreadState* __tstate = wxPyBeginAllowThreads();
33861 (arg1)->SetSize(arg2,arg3);
33862 wxPyEndAllowThreads(__tstate);
33863 if (PyErr_Occurred()) SWIG_fail;
33864 }
33865 resultobj = SWIG_Py_Void();
33866 return resultobj;
33867 fail:
33868 return NULL;
33869 }
33870
33871
33872 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33873 PyObject *resultobj = 0;
33874 wxWindow *arg1 = (wxWindow *) 0 ;
33875 wxPoint *arg2 = 0 ;
33876 int arg3 = (int) wxSIZE_USE_EXISTING ;
33877 void *argp1 = 0 ;
33878 int res1 = 0 ;
33879 wxPoint temp2 ;
33880 int val3 ;
33881 int ecode3 = 0 ;
33882 PyObject * obj0 = 0 ;
33883 PyObject * obj1 = 0 ;
33884 PyObject * obj2 = 0 ;
33885 char * kwnames[] = {
33886 (char *) "self",(char *) "pt",(char *) "flags", NULL
33887 };
33888
33889 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
33890 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33891 if (!SWIG_IsOK(res1)) {
33892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
33893 }
33894 arg1 = reinterpret_cast< wxWindow * >(argp1);
33895 {
33896 arg2 = &temp2;
33897 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33898 }
33899 if (obj2) {
33900 ecode3 = SWIG_AsVal_int(obj2, &val3);
33901 if (!SWIG_IsOK(ecode3)) {
33902 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
33903 }
33904 arg3 = static_cast< int >(val3);
33905 }
33906 {
33907 PyThreadState* __tstate = wxPyBeginAllowThreads();
33908 (arg1)->Move((wxPoint const &)*arg2,arg3);
33909 wxPyEndAllowThreads(__tstate);
33910 if (PyErr_Occurred()) SWIG_fail;
33911 }
33912 resultobj = SWIG_Py_Void();
33913 return resultobj;
33914 fail:
33915 return NULL;
33916 }
33917
33918
33919 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33920 PyObject *resultobj = 0;
33921 wxWindow *arg1 = (wxWindow *) 0 ;
33922 int arg2 ;
33923 int arg3 ;
33924 int arg4 = (int) wxSIZE_USE_EXISTING ;
33925 void *argp1 = 0 ;
33926 int res1 = 0 ;
33927 int val2 ;
33928 int ecode2 = 0 ;
33929 int val3 ;
33930 int ecode3 = 0 ;
33931 int val4 ;
33932 int ecode4 = 0 ;
33933 PyObject * obj0 = 0 ;
33934 PyObject * obj1 = 0 ;
33935 PyObject * obj2 = 0 ;
33936 PyObject * obj3 = 0 ;
33937 char * kwnames[] = {
33938 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
33939 };
33940
33941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33942 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33943 if (!SWIG_IsOK(res1)) {
33944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
33945 }
33946 arg1 = reinterpret_cast< wxWindow * >(argp1);
33947 ecode2 = SWIG_AsVal_int(obj1, &val2);
33948 if (!SWIG_IsOK(ecode2)) {
33949 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
33950 }
33951 arg2 = static_cast< int >(val2);
33952 ecode3 = SWIG_AsVal_int(obj2, &val3);
33953 if (!SWIG_IsOK(ecode3)) {
33954 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
33955 }
33956 arg3 = static_cast< int >(val3);
33957 if (obj3) {
33958 ecode4 = SWIG_AsVal_int(obj3, &val4);
33959 if (!SWIG_IsOK(ecode4)) {
33960 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
33961 }
33962 arg4 = static_cast< int >(val4);
33963 }
33964 {
33965 PyThreadState* __tstate = wxPyBeginAllowThreads();
33966 (arg1)->Move(arg2,arg3,arg4);
33967 wxPyEndAllowThreads(__tstate);
33968 if (PyErr_Occurred()) SWIG_fail;
33969 }
33970 resultobj = SWIG_Py_Void();
33971 return resultobj;
33972 fail:
33973 return NULL;
33974 }
33975
33976
33977 SWIGINTERN PyObject *_wrap_Window_SetInitialSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33978 PyObject *resultobj = 0;
33979 wxWindow *arg1 = (wxWindow *) 0 ;
33980 wxSize const &arg2_defvalue = wxDefaultSize ;
33981 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
33982 void *argp1 = 0 ;
33983 int res1 = 0 ;
33984 wxSize temp2 ;
33985 PyObject * obj0 = 0 ;
33986 PyObject * obj1 = 0 ;
33987 char * kwnames[] = {
33988 (char *) "self",(char *) "size", NULL
33989 };
33990
33991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetInitialSize",kwnames,&obj0,&obj1)) SWIG_fail;
33992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33993 if (!SWIG_IsOK(res1)) {
33994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetInitialSize" "', expected argument " "1"" of type '" "wxWindow *""'");
33995 }
33996 arg1 = reinterpret_cast< wxWindow * >(argp1);
33997 if (obj1) {
33998 {
33999 arg2 = &temp2;
34000 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34001 }
34002 }
34003 {
34004 PyThreadState* __tstate = wxPyBeginAllowThreads();
34005 (arg1)->SetInitialSize((wxSize const &)*arg2);
34006 wxPyEndAllowThreads(__tstate);
34007 if (PyErr_Occurred()) SWIG_fail;
34008 }
34009 resultobj = SWIG_Py_Void();
34010 return resultobj;
34011 fail:
34012 return NULL;
34013 }
34014
34015
34016 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34017 PyObject *resultobj = 0;
34018 wxWindow *arg1 = (wxWindow *) 0 ;
34019 void *argp1 = 0 ;
34020 int res1 = 0 ;
34021 PyObject *swig_obj[1] ;
34022
34023 if (!args) SWIG_fail;
34024 swig_obj[0] = args;
34025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34026 if (!SWIG_IsOK(res1)) {
34027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
34028 }
34029 arg1 = reinterpret_cast< wxWindow * >(argp1);
34030 {
34031 PyThreadState* __tstate = wxPyBeginAllowThreads();
34032 (arg1)->Raise();
34033 wxPyEndAllowThreads(__tstate);
34034 if (PyErr_Occurred()) SWIG_fail;
34035 }
34036 resultobj = SWIG_Py_Void();
34037 return resultobj;
34038 fail:
34039 return NULL;
34040 }
34041
34042
34043 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34044 PyObject *resultobj = 0;
34045 wxWindow *arg1 = (wxWindow *) 0 ;
34046 void *argp1 = 0 ;
34047 int res1 = 0 ;
34048 PyObject *swig_obj[1] ;
34049
34050 if (!args) SWIG_fail;
34051 swig_obj[0] = args;
34052 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34053 if (!SWIG_IsOK(res1)) {
34054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
34055 }
34056 arg1 = reinterpret_cast< wxWindow * >(argp1);
34057 {
34058 PyThreadState* __tstate = wxPyBeginAllowThreads();
34059 (arg1)->Lower();
34060 wxPyEndAllowThreads(__tstate);
34061 if (PyErr_Occurred()) SWIG_fail;
34062 }
34063 resultobj = SWIG_Py_Void();
34064 return resultobj;
34065 fail:
34066 return NULL;
34067 }
34068
34069
34070 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34071 PyObject *resultobj = 0;
34072 wxWindow *arg1 = (wxWindow *) 0 ;
34073 wxSize *arg2 = 0 ;
34074 void *argp1 = 0 ;
34075 int res1 = 0 ;
34076 wxSize temp2 ;
34077 PyObject * obj0 = 0 ;
34078 PyObject * obj1 = 0 ;
34079 char * kwnames[] = {
34080 (char *) "self",(char *) "size", NULL
34081 };
34082
34083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
34084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34085 if (!SWIG_IsOK(res1)) {
34086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34087 }
34088 arg1 = reinterpret_cast< wxWindow * >(argp1);
34089 {
34090 arg2 = &temp2;
34091 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34092 }
34093 {
34094 PyThreadState* __tstate = wxPyBeginAllowThreads();
34095 (arg1)->SetClientSize((wxSize const &)*arg2);
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 resultobj = SWIG_Py_Void();
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34107 PyObject *resultobj = 0;
34108 wxWindow *arg1 = (wxWindow *) 0 ;
34109 int arg2 ;
34110 int arg3 ;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 int val2 ;
34114 int ecode2 = 0 ;
34115 int val3 ;
34116 int ecode3 = 0 ;
34117 PyObject * obj0 = 0 ;
34118 PyObject * obj1 = 0 ;
34119 PyObject * obj2 = 0 ;
34120 char * kwnames[] = {
34121 (char *) "self",(char *) "width",(char *) "height", NULL
34122 };
34123
34124 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34125 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34126 if (!SWIG_IsOK(res1)) {
34127 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
34128 }
34129 arg1 = reinterpret_cast< wxWindow * >(argp1);
34130 ecode2 = SWIG_AsVal_int(obj1, &val2);
34131 if (!SWIG_IsOK(ecode2)) {
34132 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
34133 }
34134 arg2 = static_cast< int >(val2);
34135 ecode3 = SWIG_AsVal_int(obj2, &val3);
34136 if (!SWIG_IsOK(ecode3)) {
34137 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
34138 }
34139 arg3 = static_cast< int >(val3);
34140 {
34141 PyThreadState* __tstate = wxPyBeginAllowThreads();
34142 (arg1)->SetClientSize(arg2,arg3);
34143 wxPyEndAllowThreads(__tstate);
34144 if (PyErr_Occurred()) SWIG_fail;
34145 }
34146 resultobj = SWIG_Py_Void();
34147 return resultobj;
34148 fail:
34149 return NULL;
34150 }
34151
34152
34153 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34154 PyObject *resultobj = 0;
34155 wxWindow *arg1 = (wxWindow *) 0 ;
34156 wxRect *arg2 = 0 ;
34157 void *argp1 = 0 ;
34158 int res1 = 0 ;
34159 wxRect temp2 ;
34160 PyObject * obj0 = 0 ;
34161 PyObject * obj1 = 0 ;
34162 char * kwnames[] = {
34163 (char *) "self",(char *) "rect", NULL
34164 };
34165
34166 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
34167 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34168 if (!SWIG_IsOK(res1)) {
34169 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34170 }
34171 arg1 = reinterpret_cast< wxWindow * >(argp1);
34172 {
34173 arg2 = &temp2;
34174 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34175 }
34176 {
34177 PyThreadState* __tstate = wxPyBeginAllowThreads();
34178 (arg1)->SetClientSize((wxRect const &)*arg2);
34179 wxPyEndAllowThreads(__tstate);
34180 if (PyErr_Occurred()) SWIG_fail;
34181 }
34182 resultobj = SWIG_Py_Void();
34183 return resultobj;
34184 fail:
34185 return NULL;
34186 }
34187
34188
34189 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34190 PyObject *resultobj = 0;
34191 wxWindow *arg1 = (wxWindow *) 0 ;
34192 wxPoint result;
34193 void *argp1 = 0 ;
34194 int res1 = 0 ;
34195 PyObject *swig_obj[1] ;
34196
34197 if (!args) SWIG_fail;
34198 swig_obj[0] = args;
34199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34200 if (!SWIG_IsOK(res1)) {
34201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34202 }
34203 arg1 = reinterpret_cast< wxWindow * >(argp1);
34204 {
34205 PyThreadState* __tstate = wxPyBeginAllowThreads();
34206 result = ((wxWindow const *)arg1)->GetPosition();
34207 wxPyEndAllowThreads(__tstate);
34208 if (PyErr_Occurred()) SWIG_fail;
34209 }
34210 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34211 return resultobj;
34212 fail:
34213 return NULL;
34214 }
34215
34216
34217 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34218 PyObject *resultobj = 0;
34219 wxWindow *arg1 = (wxWindow *) 0 ;
34220 int *arg2 = (int *) 0 ;
34221 int *arg3 = (int *) 0 ;
34222 void *argp1 = 0 ;
34223 int res1 = 0 ;
34224 int temp2 ;
34225 int res2 = SWIG_TMPOBJ ;
34226 int temp3 ;
34227 int res3 = SWIG_TMPOBJ ;
34228 PyObject *swig_obj[1] ;
34229
34230 arg2 = &temp2;
34231 arg3 = &temp3;
34232 if (!args) SWIG_fail;
34233 swig_obj[0] = args;
34234 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34235 if (!SWIG_IsOK(res1)) {
34236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34237 }
34238 arg1 = reinterpret_cast< wxWindow * >(argp1);
34239 {
34240 PyThreadState* __tstate = wxPyBeginAllowThreads();
34241 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
34242 wxPyEndAllowThreads(__tstate);
34243 if (PyErr_Occurred()) SWIG_fail;
34244 }
34245 resultobj = SWIG_Py_Void();
34246 if (SWIG_IsTmpObj(res2)) {
34247 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34248 } else {
34249 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34250 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34251 }
34252 if (SWIG_IsTmpObj(res3)) {
34253 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34254 } else {
34255 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34256 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34257 }
34258 return resultobj;
34259 fail:
34260 return NULL;
34261 }
34262
34263
34264 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34265 PyObject *resultobj = 0;
34266 wxWindow *arg1 = (wxWindow *) 0 ;
34267 wxPoint result;
34268 void *argp1 = 0 ;
34269 int res1 = 0 ;
34270 PyObject *swig_obj[1] ;
34271
34272 if (!args) SWIG_fail;
34273 swig_obj[0] = args;
34274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34275 if (!SWIG_IsOK(res1)) {
34276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
34277 }
34278 arg1 = reinterpret_cast< wxWindow * >(argp1);
34279 {
34280 PyThreadState* __tstate = wxPyBeginAllowThreads();
34281 result = ((wxWindow const *)arg1)->GetScreenPosition();
34282 wxPyEndAllowThreads(__tstate);
34283 if (PyErr_Occurred()) SWIG_fail;
34284 }
34285 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34286 return resultobj;
34287 fail:
34288 return NULL;
34289 }
34290
34291
34292 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34293 PyObject *resultobj = 0;
34294 wxWindow *arg1 = (wxWindow *) 0 ;
34295 int *arg2 = (int *) 0 ;
34296 int *arg3 = (int *) 0 ;
34297 void *argp1 = 0 ;
34298 int res1 = 0 ;
34299 int temp2 ;
34300 int res2 = SWIG_TMPOBJ ;
34301 int temp3 ;
34302 int res3 = SWIG_TMPOBJ ;
34303 PyObject *swig_obj[1] ;
34304
34305 arg2 = &temp2;
34306 arg3 = &temp3;
34307 if (!args) SWIG_fail;
34308 swig_obj[0] = args;
34309 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34310 if (!SWIG_IsOK(res1)) {
34311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34312 }
34313 arg1 = reinterpret_cast< wxWindow * >(argp1);
34314 {
34315 PyThreadState* __tstate = wxPyBeginAllowThreads();
34316 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
34317 wxPyEndAllowThreads(__tstate);
34318 if (PyErr_Occurred()) SWIG_fail;
34319 }
34320 resultobj = SWIG_Py_Void();
34321 if (SWIG_IsTmpObj(res2)) {
34322 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34323 } else {
34324 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34325 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34326 }
34327 if (SWIG_IsTmpObj(res3)) {
34328 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34329 } else {
34330 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34331 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34332 }
34333 return resultobj;
34334 fail:
34335 return NULL;
34336 }
34337
34338
34339 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34340 PyObject *resultobj = 0;
34341 wxWindow *arg1 = (wxWindow *) 0 ;
34342 wxRect result;
34343 void *argp1 = 0 ;
34344 int res1 = 0 ;
34345 PyObject *swig_obj[1] ;
34346
34347 if (!args) SWIG_fail;
34348 swig_obj[0] = args;
34349 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34350 if (!SWIG_IsOK(res1)) {
34351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34352 }
34353 arg1 = reinterpret_cast< wxWindow * >(argp1);
34354 {
34355 PyThreadState* __tstate = wxPyBeginAllowThreads();
34356 result = ((wxWindow const *)arg1)->GetScreenRect();
34357 wxPyEndAllowThreads(__tstate);
34358 if (PyErr_Occurred()) SWIG_fail;
34359 }
34360 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34361 return resultobj;
34362 fail:
34363 return NULL;
34364 }
34365
34366
34367 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34368 PyObject *resultobj = 0;
34369 wxWindow *arg1 = (wxWindow *) 0 ;
34370 wxSize result;
34371 void *argp1 = 0 ;
34372 int res1 = 0 ;
34373 PyObject *swig_obj[1] ;
34374
34375 if (!args) SWIG_fail;
34376 swig_obj[0] = args;
34377 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34378 if (!SWIG_IsOK(res1)) {
34379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34380 }
34381 arg1 = reinterpret_cast< wxWindow * >(argp1);
34382 {
34383 PyThreadState* __tstate = wxPyBeginAllowThreads();
34384 result = ((wxWindow const *)arg1)->GetSize();
34385 wxPyEndAllowThreads(__tstate);
34386 if (PyErr_Occurred()) SWIG_fail;
34387 }
34388 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34389 return resultobj;
34390 fail:
34391 return NULL;
34392 }
34393
34394
34395 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34396 PyObject *resultobj = 0;
34397 wxWindow *arg1 = (wxWindow *) 0 ;
34398 int *arg2 = (int *) 0 ;
34399 int *arg3 = (int *) 0 ;
34400 void *argp1 = 0 ;
34401 int res1 = 0 ;
34402 int temp2 ;
34403 int res2 = SWIG_TMPOBJ ;
34404 int temp3 ;
34405 int res3 = SWIG_TMPOBJ ;
34406 PyObject *swig_obj[1] ;
34407
34408 arg2 = &temp2;
34409 arg3 = &temp3;
34410 if (!args) SWIG_fail;
34411 swig_obj[0] = args;
34412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34413 if (!SWIG_IsOK(res1)) {
34414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34415 }
34416 arg1 = reinterpret_cast< wxWindow * >(argp1);
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
34420 wxPyEndAllowThreads(__tstate);
34421 if (PyErr_Occurred()) SWIG_fail;
34422 }
34423 resultobj = SWIG_Py_Void();
34424 if (SWIG_IsTmpObj(res2)) {
34425 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34426 } else {
34427 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34428 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34429 }
34430 if (SWIG_IsTmpObj(res3)) {
34431 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34432 } else {
34433 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34434 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34435 }
34436 return resultobj;
34437 fail:
34438 return NULL;
34439 }
34440
34441
34442 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34443 PyObject *resultobj = 0;
34444 wxWindow *arg1 = (wxWindow *) 0 ;
34445 wxRect result;
34446 void *argp1 = 0 ;
34447 int res1 = 0 ;
34448 PyObject *swig_obj[1] ;
34449
34450 if (!args) SWIG_fail;
34451 swig_obj[0] = args;
34452 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34453 if (!SWIG_IsOK(res1)) {
34454 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34455 }
34456 arg1 = reinterpret_cast< wxWindow * >(argp1);
34457 {
34458 PyThreadState* __tstate = wxPyBeginAllowThreads();
34459 result = ((wxWindow const *)arg1)->GetRect();
34460 wxPyEndAllowThreads(__tstate);
34461 if (PyErr_Occurred()) SWIG_fail;
34462 }
34463 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34464 return resultobj;
34465 fail:
34466 return NULL;
34467 }
34468
34469
34470 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34471 PyObject *resultobj = 0;
34472 wxWindow *arg1 = (wxWindow *) 0 ;
34473 wxSize result;
34474 void *argp1 = 0 ;
34475 int res1 = 0 ;
34476 PyObject *swig_obj[1] ;
34477
34478 if (!args) SWIG_fail;
34479 swig_obj[0] = args;
34480 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34481 if (!SWIG_IsOK(res1)) {
34482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34483 }
34484 arg1 = reinterpret_cast< wxWindow * >(argp1);
34485 {
34486 PyThreadState* __tstate = wxPyBeginAllowThreads();
34487 result = ((wxWindow const *)arg1)->GetClientSize();
34488 wxPyEndAllowThreads(__tstate);
34489 if (PyErr_Occurred()) SWIG_fail;
34490 }
34491 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34492 return resultobj;
34493 fail:
34494 return NULL;
34495 }
34496
34497
34498 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34499 PyObject *resultobj = 0;
34500 wxWindow *arg1 = (wxWindow *) 0 ;
34501 int *arg2 = (int *) 0 ;
34502 int *arg3 = (int *) 0 ;
34503 void *argp1 = 0 ;
34504 int res1 = 0 ;
34505 int temp2 ;
34506 int res2 = SWIG_TMPOBJ ;
34507 int temp3 ;
34508 int res3 = SWIG_TMPOBJ ;
34509 PyObject *swig_obj[1] ;
34510
34511 arg2 = &temp2;
34512 arg3 = &temp3;
34513 if (!args) SWIG_fail;
34514 swig_obj[0] = args;
34515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34516 if (!SWIG_IsOK(res1)) {
34517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34518 }
34519 arg1 = reinterpret_cast< wxWindow * >(argp1);
34520 {
34521 PyThreadState* __tstate = wxPyBeginAllowThreads();
34522 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
34523 wxPyEndAllowThreads(__tstate);
34524 if (PyErr_Occurred()) SWIG_fail;
34525 }
34526 resultobj = SWIG_Py_Void();
34527 if (SWIG_IsTmpObj(res2)) {
34528 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34529 } else {
34530 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34531 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34532 }
34533 if (SWIG_IsTmpObj(res3)) {
34534 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34535 } else {
34536 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34537 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34538 }
34539 return resultobj;
34540 fail:
34541 return NULL;
34542 }
34543
34544
34545 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34546 PyObject *resultobj = 0;
34547 wxWindow *arg1 = (wxWindow *) 0 ;
34548 wxPoint result;
34549 void *argp1 = 0 ;
34550 int res1 = 0 ;
34551 PyObject *swig_obj[1] ;
34552
34553 if (!args) SWIG_fail;
34554 swig_obj[0] = args;
34555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34556 if (!SWIG_IsOK(res1)) {
34557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
34558 }
34559 arg1 = reinterpret_cast< wxWindow * >(argp1);
34560 {
34561 PyThreadState* __tstate = wxPyBeginAllowThreads();
34562 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
34563 wxPyEndAllowThreads(__tstate);
34564 if (PyErr_Occurred()) SWIG_fail;
34565 }
34566 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34567 return resultobj;
34568 fail:
34569 return NULL;
34570 }
34571
34572
34573 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34574 PyObject *resultobj = 0;
34575 wxWindow *arg1 = (wxWindow *) 0 ;
34576 wxRect result;
34577 void *argp1 = 0 ;
34578 int res1 = 0 ;
34579 PyObject *swig_obj[1] ;
34580
34581 if (!args) SWIG_fail;
34582 swig_obj[0] = args;
34583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34584 if (!SWIG_IsOK(res1)) {
34585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34586 }
34587 arg1 = reinterpret_cast< wxWindow * >(argp1);
34588 {
34589 PyThreadState* __tstate = wxPyBeginAllowThreads();
34590 result = ((wxWindow const *)arg1)->GetClientRect();
34591 wxPyEndAllowThreads(__tstate);
34592 if (PyErr_Occurred()) SWIG_fail;
34593 }
34594 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34595 return resultobj;
34596 fail:
34597 return NULL;
34598 }
34599
34600
34601 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34602 PyObject *resultobj = 0;
34603 wxWindow *arg1 = (wxWindow *) 0 ;
34604 wxSize result;
34605 void *argp1 = 0 ;
34606 int res1 = 0 ;
34607 PyObject *swig_obj[1] ;
34608
34609 if (!args) SWIG_fail;
34610 swig_obj[0] = args;
34611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34612 if (!SWIG_IsOK(res1)) {
34613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34614 }
34615 arg1 = reinterpret_cast< wxWindow * >(argp1);
34616 {
34617 PyThreadState* __tstate = wxPyBeginAllowThreads();
34618 result = ((wxWindow const *)arg1)->GetBestSize();
34619 wxPyEndAllowThreads(__tstate);
34620 if (PyErr_Occurred()) SWIG_fail;
34621 }
34622 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34623 return resultobj;
34624 fail:
34625 return NULL;
34626 }
34627
34628
34629 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34630 PyObject *resultobj = 0;
34631 wxWindow *arg1 = (wxWindow *) 0 ;
34632 int *arg2 = (int *) 0 ;
34633 int *arg3 = (int *) 0 ;
34634 void *argp1 = 0 ;
34635 int res1 = 0 ;
34636 int temp2 ;
34637 int res2 = SWIG_TMPOBJ ;
34638 int temp3 ;
34639 int res3 = SWIG_TMPOBJ ;
34640 PyObject *swig_obj[1] ;
34641
34642 arg2 = &temp2;
34643 arg3 = &temp3;
34644 if (!args) SWIG_fail;
34645 swig_obj[0] = args;
34646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34647 if (!SWIG_IsOK(res1)) {
34648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
34649 }
34650 arg1 = reinterpret_cast< wxWindow * >(argp1);
34651 {
34652 PyThreadState* __tstate = wxPyBeginAllowThreads();
34653 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
34654 wxPyEndAllowThreads(__tstate);
34655 if (PyErr_Occurred()) SWIG_fail;
34656 }
34657 resultobj = SWIG_Py_Void();
34658 if (SWIG_IsTmpObj(res2)) {
34659 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
34660 } else {
34661 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34662 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
34663 }
34664 if (SWIG_IsTmpObj(res3)) {
34665 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
34666 } else {
34667 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
34668 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
34669 }
34670 return resultobj;
34671 fail:
34672 return NULL;
34673 }
34674
34675
34676 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34677 PyObject *resultobj = 0;
34678 wxWindow *arg1 = (wxWindow *) 0 ;
34679 void *argp1 = 0 ;
34680 int res1 = 0 ;
34681 PyObject *swig_obj[1] ;
34682
34683 if (!args) SWIG_fail;
34684 swig_obj[0] = args;
34685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34686 if (!SWIG_IsOK(res1)) {
34687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
34688 }
34689 arg1 = reinterpret_cast< wxWindow * >(argp1);
34690 {
34691 PyThreadState* __tstate = wxPyBeginAllowThreads();
34692 (arg1)->InvalidateBestSize();
34693 wxPyEndAllowThreads(__tstate);
34694 if (PyErr_Occurred()) SWIG_fail;
34695 }
34696 resultobj = SWIG_Py_Void();
34697 return resultobj;
34698 fail:
34699 return NULL;
34700 }
34701
34702
34703 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34704 PyObject *resultobj = 0;
34705 wxWindow *arg1 = (wxWindow *) 0 ;
34706 wxSize *arg2 = 0 ;
34707 void *argp1 = 0 ;
34708 int res1 = 0 ;
34709 wxSize temp2 ;
34710 PyObject * obj0 = 0 ;
34711 PyObject * obj1 = 0 ;
34712 char * kwnames[] = {
34713 (char *) "self",(char *) "size", NULL
34714 };
34715
34716 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
34717 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34718 if (!SWIG_IsOK(res1)) {
34719 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34720 }
34721 arg1 = reinterpret_cast< wxWindow * >(argp1);
34722 {
34723 arg2 = &temp2;
34724 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34725 }
34726 {
34727 PyThreadState* __tstate = wxPyBeginAllowThreads();
34728 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
34729 wxPyEndAllowThreads(__tstate);
34730 if (PyErr_Occurred()) SWIG_fail;
34731 }
34732 resultobj = SWIG_Py_Void();
34733 return resultobj;
34734 fail:
34735 return NULL;
34736 }
34737
34738
34739 SWIGINTERN PyObject *_wrap_Window_GetEffectiveMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34740 PyObject *resultobj = 0;
34741 wxWindow *arg1 = (wxWindow *) 0 ;
34742 wxSize result;
34743 void *argp1 = 0 ;
34744 int res1 = 0 ;
34745 PyObject *swig_obj[1] ;
34746
34747 if (!args) SWIG_fail;
34748 swig_obj[0] = args;
34749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34750 if (!SWIG_IsOK(res1)) {
34751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEffectiveMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
34752 }
34753 arg1 = reinterpret_cast< wxWindow * >(argp1);
34754 {
34755 PyThreadState* __tstate = wxPyBeginAllowThreads();
34756 result = ((wxWindow const *)arg1)->GetEffectiveMinSize();
34757 wxPyEndAllowThreads(__tstate);
34758 if (PyErr_Occurred()) SWIG_fail;
34759 }
34760 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34761 return resultobj;
34762 fail:
34763 return NULL;
34764 }
34765
34766
34767 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34768 PyObject *resultobj = 0;
34769 wxWindow *arg1 = (wxWindow *) 0 ;
34770 int arg2 = (int) wxBOTH ;
34771 void *argp1 = 0 ;
34772 int res1 = 0 ;
34773 int val2 ;
34774 int ecode2 = 0 ;
34775 PyObject * obj0 = 0 ;
34776 PyObject * obj1 = 0 ;
34777 char * kwnames[] = {
34778 (char *) "self",(char *) "direction", NULL
34779 };
34780
34781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
34782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34783 if (!SWIG_IsOK(res1)) {
34784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
34785 }
34786 arg1 = reinterpret_cast< wxWindow * >(argp1);
34787 if (obj1) {
34788 ecode2 = SWIG_AsVal_int(obj1, &val2);
34789 if (!SWIG_IsOK(ecode2)) {
34790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
34791 }
34792 arg2 = static_cast< int >(val2);
34793 }
34794 {
34795 PyThreadState* __tstate = wxPyBeginAllowThreads();
34796 (arg1)->Center(arg2);
34797 wxPyEndAllowThreads(__tstate);
34798 if (PyErr_Occurred()) SWIG_fail;
34799 }
34800 resultobj = SWIG_Py_Void();
34801 return resultobj;
34802 fail:
34803 return NULL;
34804 }
34805
34806
34807 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34808 PyObject *resultobj = 0;
34809 wxWindow *arg1 = (wxWindow *) 0 ;
34810 int arg2 = (int) wxBOTH ;
34811 void *argp1 = 0 ;
34812 int res1 = 0 ;
34813 int val2 ;
34814 int ecode2 = 0 ;
34815 PyObject * obj0 = 0 ;
34816 PyObject * obj1 = 0 ;
34817 char * kwnames[] = {
34818 (char *) "self",(char *) "dir", NULL
34819 };
34820
34821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
34822 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34823 if (!SWIG_IsOK(res1)) {
34824 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
34825 }
34826 arg1 = reinterpret_cast< wxWindow * >(argp1);
34827 if (obj1) {
34828 ecode2 = SWIG_AsVal_int(obj1, &val2);
34829 if (!SWIG_IsOK(ecode2)) {
34830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
34831 }
34832 arg2 = static_cast< int >(val2);
34833 }
34834 {
34835 PyThreadState* __tstate = wxPyBeginAllowThreads();
34836 (arg1)->CenterOnParent(arg2);
34837 wxPyEndAllowThreads(__tstate);
34838 if (PyErr_Occurred()) SWIG_fail;
34839 }
34840 resultobj = SWIG_Py_Void();
34841 return resultobj;
34842 fail:
34843 return NULL;
34844 }
34845
34846
34847 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34848 PyObject *resultobj = 0;
34849 wxWindow *arg1 = (wxWindow *) 0 ;
34850 void *argp1 = 0 ;
34851 int res1 = 0 ;
34852 PyObject *swig_obj[1] ;
34853
34854 if (!args) SWIG_fail;
34855 swig_obj[0] = args;
34856 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34857 if (!SWIG_IsOK(res1)) {
34858 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
34859 }
34860 arg1 = reinterpret_cast< wxWindow * >(argp1);
34861 {
34862 PyThreadState* __tstate = wxPyBeginAllowThreads();
34863 (arg1)->Fit();
34864 wxPyEndAllowThreads(__tstate);
34865 if (PyErr_Occurred()) SWIG_fail;
34866 }
34867 resultobj = SWIG_Py_Void();
34868 return resultobj;
34869 fail:
34870 return NULL;
34871 }
34872
34873
34874 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34875 PyObject *resultobj = 0;
34876 wxWindow *arg1 = (wxWindow *) 0 ;
34877 void *argp1 = 0 ;
34878 int res1 = 0 ;
34879 PyObject *swig_obj[1] ;
34880
34881 if (!args) SWIG_fail;
34882 swig_obj[0] = args;
34883 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34884 if (!SWIG_IsOK(res1)) {
34885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
34886 }
34887 arg1 = reinterpret_cast< wxWindow * >(argp1);
34888 {
34889 PyThreadState* __tstate = wxPyBeginAllowThreads();
34890 (arg1)->FitInside();
34891 wxPyEndAllowThreads(__tstate);
34892 if (PyErr_Occurred()) SWIG_fail;
34893 }
34894 resultobj = SWIG_Py_Void();
34895 return resultobj;
34896 fail:
34897 return NULL;
34898 }
34899
34900
34901 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34902 PyObject *resultobj = 0;
34903 wxWindow *arg1 = (wxWindow *) 0 ;
34904 int arg2 ;
34905 int arg3 ;
34906 int arg4 = (int) -1 ;
34907 int arg5 = (int) -1 ;
34908 int arg6 = (int) -1 ;
34909 int arg7 = (int) -1 ;
34910 void *argp1 = 0 ;
34911 int res1 = 0 ;
34912 int val2 ;
34913 int ecode2 = 0 ;
34914 int val3 ;
34915 int ecode3 = 0 ;
34916 int val4 ;
34917 int ecode4 = 0 ;
34918 int val5 ;
34919 int ecode5 = 0 ;
34920 int val6 ;
34921 int ecode6 = 0 ;
34922 int val7 ;
34923 int ecode7 = 0 ;
34924 PyObject * obj0 = 0 ;
34925 PyObject * obj1 = 0 ;
34926 PyObject * obj2 = 0 ;
34927 PyObject * obj3 = 0 ;
34928 PyObject * obj4 = 0 ;
34929 PyObject * obj5 = 0 ;
34930 PyObject * obj6 = 0 ;
34931 char * kwnames[] = {
34932 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
34933 };
34934
34935 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
34936 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34937 if (!SWIG_IsOK(res1)) {
34938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
34939 }
34940 arg1 = reinterpret_cast< wxWindow * >(argp1);
34941 ecode2 = SWIG_AsVal_int(obj1, &val2);
34942 if (!SWIG_IsOK(ecode2)) {
34943 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
34944 }
34945 arg2 = static_cast< int >(val2);
34946 ecode3 = SWIG_AsVal_int(obj2, &val3);
34947 if (!SWIG_IsOK(ecode3)) {
34948 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
34949 }
34950 arg3 = static_cast< int >(val3);
34951 if (obj3) {
34952 ecode4 = SWIG_AsVal_int(obj3, &val4);
34953 if (!SWIG_IsOK(ecode4)) {
34954 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
34955 }
34956 arg4 = static_cast< int >(val4);
34957 }
34958 if (obj4) {
34959 ecode5 = SWIG_AsVal_int(obj4, &val5);
34960 if (!SWIG_IsOK(ecode5)) {
34961 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
34962 }
34963 arg5 = static_cast< int >(val5);
34964 }
34965 if (obj5) {
34966 ecode6 = SWIG_AsVal_int(obj5, &val6);
34967 if (!SWIG_IsOK(ecode6)) {
34968 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
34969 }
34970 arg6 = static_cast< int >(val6);
34971 }
34972 if (obj6) {
34973 ecode7 = SWIG_AsVal_int(obj6, &val7);
34974 if (!SWIG_IsOK(ecode7)) {
34975 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
34976 }
34977 arg7 = static_cast< int >(val7);
34978 }
34979 {
34980 PyThreadState* __tstate = wxPyBeginAllowThreads();
34981 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
34982 wxPyEndAllowThreads(__tstate);
34983 if (PyErr_Occurred()) SWIG_fail;
34984 }
34985 resultobj = SWIG_Py_Void();
34986 return resultobj;
34987 fail:
34988 return NULL;
34989 }
34990
34991
34992 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34993 PyObject *resultobj = 0;
34994 wxWindow *arg1 = (wxWindow *) 0 ;
34995 wxSize *arg2 = 0 ;
34996 wxSize const &arg3_defvalue = wxDefaultSize ;
34997 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
34998 wxSize const &arg4_defvalue = wxDefaultSize ;
34999 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
35000 void *argp1 = 0 ;
35001 int res1 = 0 ;
35002 wxSize temp2 ;
35003 wxSize temp3 ;
35004 wxSize temp4 ;
35005 PyObject * obj0 = 0 ;
35006 PyObject * obj1 = 0 ;
35007 PyObject * obj2 = 0 ;
35008 PyObject * obj3 = 0 ;
35009 char * kwnames[] = {
35010 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
35011 };
35012
35013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
35014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35015 if (!SWIG_IsOK(res1)) {
35016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35017 }
35018 arg1 = reinterpret_cast< wxWindow * >(argp1);
35019 {
35020 arg2 = &temp2;
35021 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35022 }
35023 if (obj2) {
35024 {
35025 arg3 = &temp3;
35026 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35027 }
35028 }
35029 if (obj3) {
35030 {
35031 arg4 = &temp4;
35032 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
35033 }
35034 }
35035 {
35036 PyThreadState* __tstate = wxPyBeginAllowThreads();
35037 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
35038 wxPyEndAllowThreads(__tstate);
35039 if (PyErr_Occurred()) SWIG_fail;
35040 }
35041 resultobj = SWIG_Py_Void();
35042 return resultobj;
35043 fail:
35044 return NULL;
35045 }
35046
35047
35048 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35049 PyObject *resultobj = 0;
35050 wxWindow *arg1 = (wxWindow *) 0 ;
35051 int arg2 ;
35052 int arg3 ;
35053 int arg4 = (int) -1 ;
35054 int arg5 = (int) -1 ;
35055 void *argp1 = 0 ;
35056 int res1 = 0 ;
35057 int val2 ;
35058 int ecode2 = 0 ;
35059 int val3 ;
35060 int ecode3 = 0 ;
35061 int val4 ;
35062 int ecode4 = 0 ;
35063 int val5 ;
35064 int ecode5 = 0 ;
35065 PyObject * obj0 = 0 ;
35066 PyObject * obj1 = 0 ;
35067 PyObject * obj2 = 0 ;
35068 PyObject * obj3 = 0 ;
35069 PyObject * obj4 = 0 ;
35070 char * kwnames[] = {
35071 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
35072 };
35073
35074 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
35075 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35076 if (!SWIG_IsOK(res1)) {
35077 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
35078 }
35079 arg1 = reinterpret_cast< wxWindow * >(argp1);
35080 ecode2 = SWIG_AsVal_int(obj1, &val2);
35081 if (!SWIG_IsOK(ecode2)) {
35082 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
35083 }
35084 arg2 = static_cast< int >(val2);
35085 ecode3 = SWIG_AsVal_int(obj2, &val3);
35086 if (!SWIG_IsOK(ecode3)) {
35087 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
35088 }
35089 arg3 = static_cast< int >(val3);
35090 if (obj3) {
35091 ecode4 = SWIG_AsVal_int(obj3, &val4);
35092 if (!SWIG_IsOK(ecode4)) {
35093 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
35094 }
35095 arg4 = static_cast< int >(val4);
35096 }
35097 if (obj4) {
35098 ecode5 = SWIG_AsVal_int(obj4, &val5);
35099 if (!SWIG_IsOK(ecode5)) {
35100 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
35101 }
35102 arg5 = static_cast< int >(val5);
35103 }
35104 {
35105 PyThreadState* __tstate = wxPyBeginAllowThreads();
35106 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
35107 wxPyEndAllowThreads(__tstate);
35108 if (PyErr_Occurred()) SWIG_fail;
35109 }
35110 resultobj = SWIG_Py_Void();
35111 return resultobj;
35112 fail:
35113 return NULL;
35114 }
35115
35116
35117 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35118 PyObject *resultobj = 0;
35119 wxWindow *arg1 = (wxWindow *) 0 ;
35120 wxSize *arg2 = 0 ;
35121 wxSize const &arg3_defvalue = wxDefaultSize ;
35122 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
35123 void *argp1 = 0 ;
35124 int res1 = 0 ;
35125 wxSize temp2 ;
35126 wxSize temp3 ;
35127 PyObject * obj0 = 0 ;
35128 PyObject * obj1 = 0 ;
35129 PyObject * obj2 = 0 ;
35130 char * kwnames[] = {
35131 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
35132 };
35133
35134 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35135 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35136 if (!SWIG_IsOK(res1)) {
35137 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
35138 }
35139 arg1 = reinterpret_cast< wxWindow * >(argp1);
35140 {
35141 arg2 = &temp2;
35142 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35143 }
35144 if (obj2) {
35145 {
35146 arg3 = &temp3;
35147 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
35148 }
35149 }
35150 {
35151 PyThreadState* __tstate = wxPyBeginAllowThreads();
35152 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
35153 wxPyEndAllowThreads(__tstate);
35154 if (PyErr_Occurred()) SWIG_fail;
35155 }
35156 resultobj = SWIG_Py_Void();
35157 return resultobj;
35158 fail:
35159 return NULL;
35160 }
35161
35162
35163 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35164 PyObject *resultobj = 0;
35165 wxWindow *arg1 = (wxWindow *) 0 ;
35166 wxSize result;
35167 void *argp1 = 0 ;
35168 int res1 = 0 ;
35169 PyObject *swig_obj[1] ;
35170
35171 if (!args) SWIG_fail;
35172 swig_obj[0] = args;
35173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35174 if (!SWIG_IsOK(res1)) {
35175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35176 }
35177 arg1 = reinterpret_cast< wxWindow * >(argp1);
35178 {
35179 PyThreadState* __tstate = wxPyBeginAllowThreads();
35180 result = ((wxWindow const *)arg1)->GetMaxSize();
35181 wxPyEndAllowThreads(__tstate);
35182 if (PyErr_Occurred()) SWIG_fail;
35183 }
35184 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35185 return resultobj;
35186 fail:
35187 return NULL;
35188 }
35189
35190
35191 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35192 PyObject *resultobj = 0;
35193 wxWindow *arg1 = (wxWindow *) 0 ;
35194 wxSize result;
35195 void *argp1 = 0 ;
35196 int res1 = 0 ;
35197 PyObject *swig_obj[1] ;
35198
35199 if (!args) SWIG_fail;
35200 swig_obj[0] = args;
35201 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35202 if (!SWIG_IsOK(res1)) {
35203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35204 }
35205 arg1 = reinterpret_cast< wxWindow * >(argp1);
35206 {
35207 PyThreadState* __tstate = wxPyBeginAllowThreads();
35208 result = ((wxWindow const *)arg1)->GetMinSize();
35209 wxPyEndAllowThreads(__tstate);
35210 if (PyErr_Occurred()) SWIG_fail;
35211 }
35212 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35213 return resultobj;
35214 fail:
35215 return NULL;
35216 }
35217
35218
35219 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35220 PyObject *resultobj = 0;
35221 wxWindow *arg1 = (wxWindow *) 0 ;
35222 wxSize *arg2 = 0 ;
35223 void *argp1 = 0 ;
35224 int res1 = 0 ;
35225 wxSize temp2 ;
35226 PyObject * obj0 = 0 ;
35227 PyObject * obj1 = 0 ;
35228 char * kwnames[] = {
35229 (char *) "self",(char *) "minSize", NULL
35230 };
35231
35232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
35233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35234 if (!SWIG_IsOK(res1)) {
35235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35236 }
35237 arg1 = reinterpret_cast< wxWindow * >(argp1);
35238 {
35239 arg2 = &temp2;
35240 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35241 }
35242 {
35243 PyThreadState* __tstate = wxPyBeginAllowThreads();
35244 (arg1)->SetMinSize((wxSize const &)*arg2);
35245 wxPyEndAllowThreads(__tstate);
35246 if (PyErr_Occurred()) SWIG_fail;
35247 }
35248 resultobj = SWIG_Py_Void();
35249 return resultobj;
35250 fail:
35251 return NULL;
35252 }
35253
35254
35255 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35256 PyObject *resultobj = 0;
35257 wxWindow *arg1 = (wxWindow *) 0 ;
35258 wxSize *arg2 = 0 ;
35259 void *argp1 = 0 ;
35260 int res1 = 0 ;
35261 wxSize temp2 ;
35262 PyObject * obj0 = 0 ;
35263 PyObject * obj1 = 0 ;
35264 char * kwnames[] = {
35265 (char *) "self",(char *) "maxSize", NULL
35266 };
35267
35268 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
35269 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35270 if (!SWIG_IsOK(res1)) {
35271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35272 }
35273 arg1 = reinterpret_cast< wxWindow * >(argp1);
35274 {
35275 arg2 = &temp2;
35276 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35277 }
35278 {
35279 PyThreadState* __tstate = wxPyBeginAllowThreads();
35280 (arg1)->SetMaxSize((wxSize const &)*arg2);
35281 wxPyEndAllowThreads(__tstate);
35282 if (PyErr_Occurred()) SWIG_fail;
35283 }
35284 resultobj = SWIG_Py_Void();
35285 return resultobj;
35286 fail:
35287 return NULL;
35288 }
35289
35290
35291 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35292 PyObject *resultobj = 0;
35293 wxWindow *arg1 = (wxWindow *) 0 ;
35294 int result;
35295 void *argp1 = 0 ;
35296 int res1 = 0 ;
35297 PyObject *swig_obj[1] ;
35298
35299 if (!args) SWIG_fail;
35300 swig_obj[0] = args;
35301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35302 if (!SWIG_IsOK(res1)) {
35303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35304 }
35305 arg1 = reinterpret_cast< wxWindow * >(argp1);
35306 {
35307 PyThreadState* __tstate = wxPyBeginAllowThreads();
35308 result = (int)((wxWindow const *)arg1)->GetMinWidth();
35309 wxPyEndAllowThreads(__tstate);
35310 if (PyErr_Occurred()) SWIG_fail;
35311 }
35312 resultobj = SWIG_From_int(static_cast< int >(result));
35313 return resultobj;
35314 fail:
35315 return NULL;
35316 }
35317
35318
35319 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35320 PyObject *resultobj = 0;
35321 wxWindow *arg1 = (wxWindow *) 0 ;
35322 int result;
35323 void *argp1 = 0 ;
35324 int res1 = 0 ;
35325 PyObject *swig_obj[1] ;
35326
35327 if (!args) SWIG_fail;
35328 swig_obj[0] = args;
35329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35330 if (!SWIG_IsOK(res1)) {
35331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35332 }
35333 arg1 = reinterpret_cast< wxWindow * >(argp1);
35334 {
35335 PyThreadState* __tstate = wxPyBeginAllowThreads();
35336 result = (int)((wxWindow const *)arg1)->GetMinHeight();
35337 wxPyEndAllowThreads(__tstate);
35338 if (PyErr_Occurred()) SWIG_fail;
35339 }
35340 resultobj = SWIG_From_int(static_cast< int >(result));
35341 return resultobj;
35342 fail:
35343 return NULL;
35344 }
35345
35346
35347 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35348 PyObject *resultobj = 0;
35349 wxWindow *arg1 = (wxWindow *) 0 ;
35350 int result;
35351 void *argp1 = 0 ;
35352 int res1 = 0 ;
35353 PyObject *swig_obj[1] ;
35354
35355 if (!args) SWIG_fail;
35356 swig_obj[0] = args;
35357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35358 if (!SWIG_IsOK(res1)) {
35359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35360 }
35361 arg1 = reinterpret_cast< wxWindow * >(argp1);
35362 {
35363 PyThreadState* __tstate = wxPyBeginAllowThreads();
35364 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
35365 wxPyEndAllowThreads(__tstate);
35366 if (PyErr_Occurred()) SWIG_fail;
35367 }
35368 resultobj = SWIG_From_int(static_cast< int >(result));
35369 return resultobj;
35370 fail:
35371 return NULL;
35372 }
35373
35374
35375 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35376 PyObject *resultobj = 0;
35377 wxWindow *arg1 = (wxWindow *) 0 ;
35378 int result;
35379 void *argp1 = 0 ;
35380 int res1 = 0 ;
35381 PyObject *swig_obj[1] ;
35382
35383 if (!args) SWIG_fail;
35384 swig_obj[0] = args;
35385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35386 if (!SWIG_IsOK(res1)) {
35387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35388 }
35389 arg1 = reinterpret_cast< wxWindow * >(argp1);
35390 {
35391 PyThreadState* __tstate = wxPyBeginAllowThreads();
35392 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
35393 wxPyEndAllowThreads(__tstate);
35394 if (PyErr_Occurred()) SWIG_fail;
35395 }
35396 resultobj = SWIG_From_int(static_cast< int >(result));
35397 return resultobj;
35398 fail:
35399 return NULL;
35400 }
35401
35402
35403 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35404 PyObject *resultobj = 0;
35405 wxWindow *arg1 = (wxWindow *) 0 ;
35406 wxSize *arg2 = 0 ;
35407 void *argp1 = 0 ;
35408 int res1 = 0 ;
35409 wxSize temp2 ;
35410 PyObject * obj0 = 0 ;
35411 PyObject * obj1 = 0 ;
35412 char * kwnames[] = {
35413 (char *) "self",(char *) "size", NULL
35414 };
35415
35416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
35417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35418 if (!SWIG_IsOK(res1)) {
35419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
35420 }
35421 arg1 = reinterpret_cast< wxWindow * >(argp1);
35422 {
35423 arg2 = &temp2;
35424 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
35425 }
35426 {
35427 PyThreadState* __tstate = wxPyBeginAllowThreads();
35428 (arg1)->SetVirtualSize((wxSize const &)*arg2);
35429 wxPyEndAllowThreads(__tstate);
35430 if (PyErr_Occurred()) SWIG_fail;
35431 }
35432 resultobj = SWIG_Py_Void();
35433 return resultobj;
35434 fail:
35435 return NULL;
35436 }
35437
35438
35439 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35440 PyObject *resultobj = 0;
35441 wxWindow *arg1 = (wxWindow *) 0 ;
35442 int arg2 ;
35443 int arg3 ;
35444 void *argp1 = 0 ;
35445 int res1 = 0 ;
35446 int val2 ;
35447 int ecode2 = 0 ;
35448 int val3 ;
35449 int ecode3 = 0 ;
35450 PyObject * obj0 = 0 ;
35451 PyObject * obj1 = 0 ;
35452 PyObject * obj2 = 0 ;
35453 char * kwnames[] = {
35454 (char *) "self",(char *) "w",(char *) "h", NULL
35455 };
35456
35457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35459 if (!SWIG_IsOK(res1)) {
35460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
35461 }
35462 arg1 = reinterpret_cast< wxWindow * >(argp1);
35463 ecode2 = SWIG_AsVal_int(obj1, &val2);
35464 if (!SWIG_IsOK(ecode2)) {
35465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
35466 }
35467 arg2 = static_cast< int >(val2);
35468 ecode3 = SWIG_AsVal_int(obj2, &val3);
35469 if (!SWIG_IsOK(ecode3)) {
35470 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
35471 }
35472 arg3 = static_cast< int >(val3);
35473 {
35474 PyThreadState* __tstate = wxPyBeginAllowThreads();
35475 (arg1)->SetVirtualSize(arg2,arg3);
35476 wxPyEndAllowThreads(__tstate);
35477 if (PyErr_Occurred()) SWIG_fail;
35478 }
35479 resultobj = SWIG_Py_Void();
35480 return resultobj;
35481 fail:
35482 return NULL;
35483 }
35484
35485
35486 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35487 PyObject *resultobj = 0;
35488 wxWindow *arg1 = (wxWindow *) 0 ;
35489 wxSize result;
35490 void *argp1 = 0 ;
35491 int res1 = 0 ;
35492 PyObject *swig_obj[1] ;
35493
35494 if (!args) SWIG_fail;
35495 swig_obj[0] = args;
35496 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35497 if (!SWIG_IsOK(res1)) {
35498 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35499 }
35500 arg1 = reinterpret_cast< wxWindow * >(argp1);
35501 {
35502 PyThreadState* __tstate = wxPyBeginAllowThreads();
35503 result = ((wxWindow const *)arg1)->GetVirtualSize();
35504 wxPyEndAllowThreads(__tstate);
35505 if (PyErr_Occurred()) SWIG_fail;
35506 }
35507 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35508 return resultobj;
35509 fail:
35510 return NULL;
35511 }
35512
35513
35514 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35515 PyObject *resultobj = 0;
35516 wxWindow *arg1 = (wxWindow *) 0 ;
35517 int *arg2 = (int *) 0 ;
35518 int *arg3 = (int *) 0 ;
35519 void *argp1 = 0 ;
35520 int res1 = 0 ;
35521 int temp2 ;
35522 int res2 = SWIG_TMPOBJ ;
35523 int temp3 ;
35524 int res3 = SWIG_TMPOBJ ;
35525 PyObject *swig_obj[1] ;
35526
35527 arg2 = &temp2;
35528 arg3 = &temp3;
35529 if (!args) SWIG_fail;
35530 swig_obj[0] = args;
35531 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35532 if (!SWIG_IsOK(res1)) {
35533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
35534 }
35535 arg1 = reinterpret_cast< wxWindow * >(argp1);
35536 {
35537 PyThreadState* __tstate = wxPyBeginAllowThreads();
35538 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
35539 wxPyEndAllowThreads(__tstate);
35540 if (PyErr_Occurred()) SWIG_fail;
35541 }
35542 resultobj = SWIG_Py_Void();
35543 if (SWIG_IsTmpObj(res2)) {
35544 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35545 } else {
35546 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35547 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35548 }
35549 if (SWIG_IsTmpObj(res3)) {
35550 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35551 } else {
35552 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35553 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35554 }
35555 return resultobj;
35556 fail:
35557 return NULL;
35558 }
35559
35560
35561 SWIGINTERN PyObject *_wrap_Window_GetWindowBorderSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35562 PyObject *resultobj = 0;
35563 wxWindow *arg1 = (wxWindow *) 0 ;
35564 wxSize result;
35565 void *argp1 = 0 ;
35566 int res1 = 0 ;
35567 PyObject *swig_obj[1] ;
35568
35569 if (!args) SWIG_fail;
35570 swig_obj[0] = args;
35571 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35572 if (!SWIG_IsOK(res1)) {
35573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowBorderSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35574 }
35575 arg1 = reinterpret_cast< wxWindow * >(argp1);
35576 {
35577 PyThreadState* __tstate = wxPyBeginAllowThreads();
35578 result = ((wxWindow const *)arg1)->GetWindowBorderSize();
35579 wxPyEndAllowThreads(__tstate);
35580 if (PyErr_Occurred()) SWIG_fail;
35581 }
35582 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35583 return resultobj;
35584 fail:
35585 return NULL;
35586 }
35587
35588
35589 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35590 PyObject *resultobj = 0;
35591 wxWindow *arg1 = (wxWindow *) 0 ;
35592 wxSize result;
35593 void *argp1 = 0 ;
35594 int res1 = 0 ;
35595 PyObject *swig_obj[1] ;
35596
35597 if (!args) SWIG_fail;
35598 swig_obj[0] = args;
35599 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35600 if (!SWIG_IsOK(res1)) {
35601 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
35602 }
35603 arg1 = reinterpret_cast< wxWindow * >(argp1);
35604 {
35605 PyThreadState* __tstate = wxPyBeginAllowThreads();
35606 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
35607 wxPyEndAllowThreads(__tstate);
35608 if (PyErr_Occurred()) SWIG_fail;
35609 }
35610 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
35611 return resultobj;
35612 fail:
35613 return NULL;
35614 }
35615
35616
35617 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35618 PyObject *resultobj = 0;
35619 wxWindow *arg1 = (wxWindow *) 0 ;
35620 bool arg2 = (bool) true ;
35621 bool result;
35622 void *argp1 = 0 ;
35623 int res1 = 0 ;
35624 bool val2 ;
35625 int ecode2 = 0 ;
35626 PyObject * obj0 = 0 ;
35627 PyObject * obj1 = 0 ;
35628 char * kwnames[] = {
35629 (char *) "self",(char *) "show", NULL
35630 };
35631
35632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
35633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35634 if (!SWIG_IsOK(res1)) {
35635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
35636 }
35637 arg1 = reinterpret_cast< wxWindow * >(argp1);
35638 if (obj1) {
35639 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35640 if (!SWIG_IsOK(ecode2)) {
35641 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
35642 }
35643 arg2 = static_cast< bool >(val2);
35644 }
35645 {
35646 PyThreadState* __tstate = wxPyBeginAllowThreads();
35647 result = (bool)(arg1)->Show(arg2);
35648 wxPyEndAllowThreads(__tstate);
35649 if (PyErr_Occurred()) SWIG_fail;
35650 }
35651 {
35652 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35653 }
35654 return resultobj;
35655 fail:
35656 return NULL;
35657 }
35658
35659
35660 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35661 PyObject *resultobj = 0;
35662 wxWindow *arg1 = (wxWindow *) 0 ;
35663 bool result;
35664 void *argp1 = 0 ;
35665 int res1 = 0 ;
35666 PyObject *swig_obj[1] ;
35667
35668 if (!args) SWIG_fail;
35669 swig_obj[0] = args;
35670 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35671 if (!SWIG_IsOK(res1)) {
35672 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
35673 }
35674 arg1 = reinterpret_cast< wxWindow * >(argp1);
35675 {
35676 PyThreadState* __tstate = wxPyBeginAllowThreads();
35677 result = (bool)(arg1)->Hide();
35678 wxPyEndAllowThreads(__tstate);
35679 if (PyErr_Occurred()) SWIG_fail;
35680 }
35681 {
35682 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35683 }
35684 return resultobj;
35685 fail:
35686 return NULL;
35687 }
35688
35689
35690 SWIGINTERN PyObject *_wrap_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35691 PyObject *resultobj = 0;
35692 wxWindow *arg1 = (wxWindow *) 0 ;
35693 bool arg2 = (bool) true ;
35694 bool result;
35695 void *argp1 = 0 ;
35696 int res1 = 0 ;
35697 bool val2 ;
35698 int ecode2 = 0 ;
35699 PyObject * obj0 = 0 ;
35700 PyObject * obj1 = 0 ;
35701 char * kwnames[] = {
35702 (char *) "self",(char *) "enable", NULL
35703 };
35704
35705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
35706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35707 if (!SWIG_IsOK(res1)) {
35708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
35709 }
35710 arg1 = reinterpret_cast< wxWindow * >(argp1);
35711 if (obj1) {
35712 ecode2 = SWIG_AsVal_bool(obj1, &val2);
35713 if (!SWIG_IsOK(ecode2)) {
35714 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
35715 }
35716 arg2 = static_cast< bool >(val2);
35717 }
35718 {
35719 PyThreadState* __tstate = wxPyBeginAllowThreads();
35720 result = (bool)(arg1)->Enable(arg2);
35721 wxPyEndAllowThreads(__tstate);
35722 if (PyErr_Occurred()) SWIG_fail;
35723 }
35724 {
35725 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35726 }
35727 return resultobj;
35728 fail:
35729 return NULL;
35730 }
35731
35732
35733 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35734 PyObject *resultobj = 0;
35735 wxWindow *arg1 = (wxWindow *) 0 ;
35736 bool result;
35737 void *argp1 = 0 ;
35738 int res1 = 0 ;
35739 PyObject *swig_obj[1] ;
35740
35741 if (!args) SWIG_fail;
35742 swig_obj[0] = args;
35743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35744 if (!SWIG_IsOK(res1)) {
35745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
35746 }
35747 arg1 = reinterpret_cast< wxWindow * >(argp1);
35748 {
35749 PyThreadState* __tstate = wxPyBeginAllowThreads();
35750 result = (bool)(arg1)->Disable();
35751 wxPyEndAllowThreads(__tstate);
35752 if (PyErr_Occurred()) SWIG_fail;
35753 }
35754 {
35755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35756 }
35757 return resultobj;
35758 fail:
35759 return NULL;
35760 }
35761
35762
35763 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35764 PyObject *resultobj = 0;
35765 wxWindow *arg1 = (wxWindow *) 0 ;
35766 bool result;
35767 void *argp1 = 0 ;
35768 int res1 = 0 ;
35769 PyObject *swig_obj[1] ;
35770
35771 if (!args) SWIG_fail;
35772 swig_obj[0] = args;
35773 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35774 if (!SWIG_IsOK(res1)) {
35775 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
35776 }
35777 arg1 = reinterpret_cast< wxWindow * >(argp1);
35778 {
35779 PyThreadState* __tstate = wxPyBeginAllowThreads();
35780 result = (bool)((wxWindow const *)arg1)->IsShown();
35781 wxPyEndAllowThreads(__tstate);
35782 if (PyErr_Occurred()) SWIG_fail;
35783 }
35784 {
35785 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35786 }
35787 return resultobj;
35788 fail:
35789 return NULL;
35790 }
35791
35792
35793 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35794 PyObject *resultobj = 0;
35795 wxWindow *arg1 = (wxWindow *) 0 ;
35796 bool result;
35797 void *argp1 = 0 ;
35798 int res1 = 0 ;
35799 PyObject *swig_obj[1] ;
35800
35801 if (!args) SWIG_fail;
35802 swig_obj[0] = args;
35803 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35804 if (!SWIG_IsOK(res1)) {
35805 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
35806 }
35807 arg1 = reinterpret_cast< wxWindow * >(argp1);
35808 {
35809 PyThreadState* __tstate = wxPyBeginAllowThreads();
35810 result = (bool)((wxWindow const *)arg1)->IsEnabled();
35811 wxPyEndAllowThreads(__tstate);
35812 if (PyErr_Occurred()) SWIG_fail;
35813 }
35814 {
35815 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35816 }
35817 return resultobj;
35818 fail:
35819 return NULL;
35820 }
35821
35822
35823 SWIGINTERN PyObject *_wrap_Window_IsShownOnScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35824 PyObject *resultobj = 0;
35825 wxWindow *arg1 = (wxWindow *) 0 ;
35826 bool result;
35827 void *argp1 = 0 ;
35828 int res1 = 0 ;
35829 PyObject *swig_obj[1] ;
35830
35831 if (!args) SWIG_fail;
35832 swig_obj[0] = args;
35833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35834 if (!SWIG_IsOK(res1)) {
35835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShownOnScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35836 }
35837 arg1 = reinterpret_cast< wxWindow * >(argp1);
35838 {
35839 PyThreadState* __tstate = wxPyBeginAllowThreads();
35840 result = (bool)((wxWindow const *)arg1)->IsShownOnScreen();
35841 wxPyEndAllowThreads(__tstate);
35842 if (PyErr_Occurred()) SWIG_fail;
35843 }
35844 {
35845 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35846 }
35847 return resultobj;
35848 fail:
35849 return NULL;
35850 }
35851
35852
35853 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35854 PyObject *resultobj = 0;
35855 wxWindow *arg1 = (wxWindow *) 0 ;
35856 long arg2 ;
35857 void *argp1 = 0 ;
35858 int res1 = 0 ;
35859 long val2 ;
35860 int ecode2 = 0 ;
35861 PyObject * obj0 = 0 ;
35862 PyObject * obj1 = 0 ;
35863 char * kwnames[] = {
35864 (char *) "self",(char *) "style", NULL
35865 };
35866
35867 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35868 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35869 if (!SWIG_IsOK(res1)) {
35870 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
35871 }
35872 arg1 = reinterpret_cast< wxWindow * >(argp1);
35873 ecode2 = SWIG_AsVal_long(obj1, &val2);
35874 if (!SWIG_IsOK(ecode2)) {
35875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
35876 }
35877 arg2 = static_cast< long >(val2);
35878 {
35879 PyThreadState* __tstate = wxPyBeginAllowThreads();
35880 (arg1)->SetWindowStyleFlag(arg2);
35881 wxPyEndAllowThreads(__tstate);
35882 if (PyErr_Occurred()) SWIG_fail;
35883 }
35884 resultobj = SWIG_Py_Void();
35885 return resultobj;
35886 fail:
35887 return NULL;
35888 }
35889
35890
35891 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35892 PyObject *resultobj = 0;
35893 wxWindow *arg1 = (wxWindow *) 0 ;
35894 long result;
35895 void *argp1 = 0 ;
35896 int res1 = 0 ;
35897 PyObject *swig_obj[1] ;
35898
35899 if (!args) SWIG_fail;
35900 swig_obj[0] = args;
35901 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35902 if (!SWIG_IsOK(res1)) {
35903 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35904 }
35905 arg1 = reinterpret_cast< wxWindow * >(argp1);
35906 {
35907 PyThreadState* __tstate = wxPyBeginAllowThreads();
35908 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
35909 wxPyEndAllowThreads(__tstate);
35910 if (PyErr_Occurred()) SWIG_fail;
35911 }
35912 resultobj = SWIG_From_long(static_cast< long >(result));
35913 return resultobj;
35914 fail:
35915 return NULL;
35916 }
35917
35918
35919 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35920 PyObject *resultobj = 0;
35921 wxWindow *arg1 = (wxWindow *) 0 ;
35922 int arg2 ;
35923 bool result;
35924 void *argp1 = 0 ;
35925 int res1 = 0 ;
35926 int val2 ;
35927 int ecode2 = 0 ;
35928 PyObject * obj0 = 0 ;
35929 PyObject * obj1 = 0 ;
35930 char * kwnames[] = {
35931 (char *) "self",(char *) "flag", NULL
35932 };
35933
35934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
35935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35936 if (!SWIG_IsOK(res1)) {
35937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
35938 }
35939 arg1 = reinterpret_cast< wxWindow * >(argp1);
35940 ecode2 = SWIG_AsVal_int(obj1, &val2);
35941 if (!SWIG_IsOK(ecode2)) {
35942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
35943 }
35944 arg2 = static_cast< int >(val2);
35945 {
35946 PyThreadState* __tstate = wxPyBeginAllowThreads();
35947 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
35948 wxPyEndAllowThreads(__tstate);
35949 if (PyErr_Occurred()) SWIG_fail;
35950 }
35951 {
35952 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35953 }
35954 return resultobj;
35955 fail:
35956 return NULL;
35957 }
35958
35959
35960 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35961 PyObject *resultobj = 0;
35962 wxWindow *arg1 = (wxWindow *) 0 ;
35963 bool result;
35964 void *argp1 = 0 ;
35965 int res1 = 0 ;
35966 PyObject *swig_obj[1] ;
35967
35968 if (!args) SWIG_fail;
35969 swig_obj[0] = args;
35970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35971 if (!SWIG_IsOK(res1)) {
35972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
35973 }
35974 arg1 = reinterpret_cast< wxWindow * >(argp1);
35975 {
35976 PyThreadState* __tstate = wxPyBeginAllowThreads();
35977 result = (bool)((wxWindow const *)arg1)->IsRetained();
35978 wxPyEndAllowThreads(__tstate);
35979 if (PyErr_Occurred()) SWIG_fail;
35980 }
35981 {
35982 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35983 }
35984 return resultobj;
35985 fail:
35986 return NULL;
35987 }
35988
35989
35990 SWIGINTERN PyObject *_wrap_Window_ToggleWindowStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35991 PyObject *resultobj = 0;
35992 wxWindow *arg1 = (wxWindow *) 0 ;
35993 int arg2 ;
35994 bool result;
35995 void *argp1 = 0 ;
35996 int res1 = 0 ;
35997 int val2 ;
35998 int ecode2 = 0 ;
35999 PyObject * obj0 = 0 ;
36000 PyObject * obj1 = 0 ;
36001 char * kwnames[] = {
36002 (char *) "self",(char *) "flag", NULL
36003 };
36004
36005 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ToggleWindowStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36006 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36007 if (!SWIG_IsOK(res1)) {
36008 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ToggleWindowStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36009 }
36010 arg1 = reinterpret_cast< wxWindow * >(argp1);
36011 ecode2 = SWIG_AsVal_int(obj1, &val2);
36012 if (!SWIG_IsOK(ecode2)) {
36013 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ToggleWindowStyle" "', expected argument " "2"" of type '" "int""'");
36014 }
36015 arg2 = static_cast< int >(val2);
36016 {
36017 PyThreadState* __tstate = wxPyBeginAllowThreads();
36018 result = (bool)(arg1)->ToggleWindowStyle(arg2);
36019 wxPyEndAllowThreads(__tstate);
36020 if (PyErr_Occurred()) SWIG_fail;
36021 }
36022 {
36023 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36024 }
36025 return resultobj;
36026 fail:
36027 return NULL;
36028 }
36029
36030
36031 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36032 PyObject *resultobj = 0;
36033 wxWindow *arg1 = (wxWindow *) 0 ;
36034 long arg2 ;
36035 void *argp1 = 0 ;
36036 int res1 = 0 ;
36037 long val2 ;
36038 int ecode2 = 0 ;
36039 PyObject * obj0 = 0 ;
36040 PyObject * obj1 = 0 ;
36041 char * kwnames[] = {
36042 (char *) "self",(char *) "exStyle", NULL
36043 };
36044
36045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
36046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36047 if (!SWIG_IsOK(res1)) {
36048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
36049 }
36050 arg1 = reinterpret_cast< wxWindow * >(argp1);
36051 ecode2 = SWIG_AsVal_long(obj1, &val2);
36052 if (!SWIG_IsOK(ecode2)) {
36053 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
36054 }
36055 arg2 = static_cast< long >(val2);
36056 {
36057 PyThreadState* __tstate = wxPyBeginAllowThreads();
36058 (arg1)->SetExtraStyle(arg2);
36059 wxPyEndAllowThreads(__tstate);
36060 if (PyErr_Occurred()) SWIG_fail;
36061 }
36062 resultobj = SWIG_Py_Void();
36063 return resultobj;
36064 fail:
36065 return NULL;
36066 }
36067
36068
36069 SWIGINTERN PyObject *_wrap_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36070 PyObject *resultobj = 0;
36071 wxWindow *arg1 = (wxWindow *) 0 ;
36072 long result;
36073 void *argp1 = 0 ;
36074 int res1 = 0 ;
36075 PyObject *swig_obj[1] ;
36076
36077 if (!args) SWIG_fail;
36078 swig_obj[0] = args;
36079 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36080 if (!SWIG_IsOK(res1)) {
36081 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
36082 }
36083 arg1 = reinterpret_cast< wxWindow * >(argp1);
36084 {
36085 PyThreadState* __tstate = wxPyBeginAllowThreads();
36086 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
36087 wxPyEndAllowThreads(__tstate);
36088 if (PyErr_Occurred()) SWIG_fail;
36089 }
36090 resultobj = SWIG_From_long(static_cast< long >(result));
36091 return resultobj;
36092 fail:
36093 return NULL;
36094 }
36095
36096
36097 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36098 PyObject *resultobj = 0;
36099 wxWindow *arg1 = (wxWindow *) 0 ;
36100 bool arg2 = (bool) true ;
36101 void *argp1 = 0 ;
36102 int res1 = 0 ;
36103 bool val2 ;
36104 int ecode2 = 0 ;
36105 PyObject * obj0 = 0 ;
36106 PyObject * obj1 = 0 ;
36107 char * kwnames[] = {
36108 (char *) "self",(char *) "modal", NULL
36109 };
36110
36111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
36112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36113 if (!SWIG_IsOK(res1)) {
36114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
36115 }
36116 arg1 = reinterpret_cast< wxWindow * >(argp1);
36117 if (obj1) {
36118 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36119 if (!SWIG_IsOK(ecode2)) {
36120 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
36121 }
36122 arg2 = static_cast< bool >(val2);
36123 }
36124 {
36125 PyThreadState* __tstate = wxPyBeginAllowThreads();
36126 (arg1)->MakeModal(arg2);
36127 wxPyEndAllowThreads(__tstate);
36128 if (PyErr_Occurred()) SWIG_fail;
36129 }
36130 resultobj = SWIG_Py_Void();
36131 return resultobj;
36132 fail:
36133 return NULL;
36134 }
36135
36136
36137 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36138 PyObject *resultobj = 0;
36139 wxWindow *arg1 = (wxWindow *) 0 ;
36140 bool arg2 ;
36141 void *argp1 = 0 ;
36142 int res1 = 0 ;
36143 bool val2 ;
36144 int ecode2 = 0 ;
36145 PyObject * obj0 = 0 ;
36146 PyObject * obj1 = 0 ;
36147 char * kwnames[] = {
36148 (char *) "self",(char *) "enableTheme", NULL
36149 };
36150
36151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
36152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36153 if (!SWIG_IsOK(res1)) {
36154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
36155 }
36156 arg1 = reinterpret_cast< wxWindow * >(argp1);
36157 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36158 if (!SWIG_IsOK(ecode2)) {
36159 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
36160 }
36161 arg2 = static_cast< bool >(val2);
36162 {
36163 PyThreadState* __tstate = wxPyBeginAllowThreads();
36164 (arg1)->SetThemeEnabled(arg2);
36165 wxPyEndAllowThreads(__tstate);
36166 if (PyErr_Occurred()) SWIG_fail;
36167 }
36168 resultobj = SWIG_Py_Void();
36169 return resultobj;
36170 fail:
36171 return NULL;
36172 }
36173
36174
36175 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36176 PyObject *resultobj = 0;
36177 wxWindow *arg1 = (wxWindow *) 0 ;
36178 bool result;
36179 void *argp1 = 0 ;
36180 int res1 = 0 ;
36181 PyObject *swig_obj[1] ;
36182
36183 if (!args) SWIG_fail;
36184 swig_obj[0] = args;
36185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36186 if (!SWIG_IsOK(res1)) {
36187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
36188 }
36189 arg1 = reinterpret_cast< wxWindow * >(argp1);
36190 {
36191 PyThreadState* __tstate = wxPyBeginAllowThreads();
36192 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
36193 wxPyEndAllowThreads(__tstate);
36194 if (PyErr_Occurred()) SWIG_fail;
36195 }
36196 {
36197 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36198 }
36199 return resultobj;
36200 fail:
36201 return NULL;
36202 }
36203
36204
36205 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36206 PyObject *resultobj = 0;
36207 wxWindow *arg1 = (wxWindow *) 0 ;
36208 void *argp1 = 0 ;
36209 int res1 = 0 ;
36210 PyObject *swig_obj[1] ;
36211
36212 if (!args) SWIG_fail;
36213 swig_obj[0] = args;
36214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36215 if (!SWIG_IsOK(res1)) {
36216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
36217 }
36218 arg1 = reinterpret_cast< wxWindow * >(argp1);
36219 {
36220 PyThreadState* __tstate = wxPyBeginAllowThreads();
36221 (arg1)->SetFocus();
36222 wxPyEndAllowThreads(__tstate);
36223 if (PyErr_Occurred()) SWIG_fail;
36224 }
36225 resultobj = SWIG_Py_Void();
36226 return resultobj;
36227 fail:
36228 return NULL;
36229 }
36230
36231
36232 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36233 PyObject *resultobj = 0;
36234 wxWindow *arg1 = (wxWindow *) 0 ;
36235 void *argp1 = 0 ;
36236 int res1 = 0 ;
36237 PyObject *swig_obj[1] ;
36238
36239 if (!args) SWIG_fail;
36240 swig_obj[0] = args;
36241 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36242 if (!SWIG_IsOK(res1)) {
36243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
36244 }
36245 arg1 = reinterpret_cast< wxWindow * >(argp1);
36246 {
36247 PyThreadState* __tstate = wxPyBeginAllowThreads();
36248 (arg1)->SetFocusFromKbd();
36249 wxPyEndAllowThreads(__tstate);
36250 if (PyErr_Occurred()) SWIG_fail;
36251 }
36252 resultobj = SWIG_Py_Void();
36253 return resultobj;
36254 fail:
36255 return NULL;
36256 }
36257
36258
36259 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36260 PyObject *resultobj = 0;
36261 wxWindow *result = 0 ;
36262
36263 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
36264 {
36265 if (!wxPyCheckForApp()) SWIG_fail;
36266 PyThreadState* __tstate = wxPyBeginAllowThreads();
36267 result = (wxWindow *)wxWindow::FindFocus();
36268 wxPyEndAllowThreads(__tstate);
36269 if (PyErr_Occurred()) SWIG_fail;
36270 }
36271 {
36272 resultobj = wxPyMake_wxObject(result, 0);
36273 }
36274 return resultobj;
36275 fail:
36276 return NULL;
36277 }
36278
36279
36280 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36281 PyObject *resultobj = 0;
36282 wxWindow *arg1 = (wxWindow *) 0 ;
36283 bool result;
36284 void *argp1 = 0 ;
36285 int res1 = 0 ;
36286 PyObject *swig_obj[1] ;
36287
36288 if (!args) SWIG_fail;
36289 swig_obj[0] = args;
36290 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36291 if (!SWIG_IsOK(res1)) {
36292 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
36293 }
36294 arg1 = reinterpret_cast< wxWindow * >(argp1);
36295 {
36296 PyThreadState* __tstate = wxPyBeginAllowThreads();
36297 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
36298 wxPyEndAllowThreads(__tstate);
36299 if (PyErr_Occurred()) SWIG_fail;
36300 }
36301 {
36302 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36303 }
36304 return resultobj;
36305 fail:
36306 return NULL;
36307 }
36308
36309
36310 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36311 PyObject *resultobj = 0;
36312 wxWindow *arg1 = (wxWindow *) 0 ;
36313 bool result;
36314 void *argp1 = 0 ;
36315 int res1 = 0 ;
36316 PyObject *swig_obj[1] ;
36317
36318 if (!args) SWIG_fail;
36319 swig_obj[0] = args;
36320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36321 if (!SWIG_IsOK(res1)) {
36322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
36323 }
36324 arg1 = reinterpret_cast< wxWindow * >(argp1);
36325 {
36326 PyThreadState* __tstate = wxPyBeginAllowThreads();
36327 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
36328 wxPyEndAllowThreads(__tstate);
36329 if (PyErr_Occurred()) SWIG_fail;
36330 }
36331 {
36332 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36333 }
36334 return resultobj;
36335 fail:
36336 return NULL;
36337 }
36338
36339
36340 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36341 PyObject *resultobj = 0;
36342 wxWindow *arg1 = (wxWindow *) 0 ;
36343 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
36344 bool result;
36345 void *argp1 = 0 ;
36346 int res1 = 0 ;
36347 int val2 ;
36348 int ecode2 = 0 ;
36349 PyObject * obj0 = 0 ;
36350 PyObject * obj1 = 0 ;
36351 char * kwnames[] = {
36352 (char *) "self",(char *) "flags", NULL
36353 };
36354
36355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
36356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36357 if (!SWIG_IsOK(res1)) {
36358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
36359 }
36360 arg1 = reinterpret_cast< wxWindow * >(argp1);
36361 if (obj1) {
36362 ecode2 = SWIG_AsVal_int(obj1, &val2);
36363 if (!SWIG_IsOK(ecode2)) {
36364 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
36365 }
36366 arg2 = static_cast< int >(val2);
36367 }
36368 {
36369 PyThreadState* __tstate = wxPyBeginAllowThreads();
36370 result = (bool)(arg1)->Navigate(arg2);
36371 wxPyEndAllowThreads(__tstate);
36372 if (PyErr_Occurred()) SWIG_fail;
36373 }
36374 {
36375 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36376 }
36377 return resultobj;
36378 fail:
36379 return NULL;
36380 }
36381
36382
36383 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36384 PyObject *resultobj = 0;
36385 wxWindow *arg1 = (wxWindow *) 0 ;
36386 wxWindow *arg2 = (wxWindow *) 0 ;
36387 void *argp1 = 0 ;
36388 int res1 = 0 ;
36389 void *argp2 = 0 ;
36390 int res2 = 0 ;
36391 PyObject * obj0 = 0 ;
36392 PyObject * obj1 = 0 ;
36393 char * kwnames[] = {
36394 (char *) "self",(char *) "win", NULL
36395 };
36396
36397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36399 if (!SWIG_IsOK(res1)) {
36400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36401 }
36402 arg1 = reinterpret_cast< wxWindow * >(argp1);
36403 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36404 if (!SWIG_IsOK(res2)) {
36405 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36406 }
36407 arg2 = reinterpret_cast< wxWindow * >(argp2);
36408 {
36409 PyThreadState* __tstate = wxPyBeginAllowThreads();
36410 (arg1)->MoveAfterInTabOrder(arg2);
36411 wxPyEndAllowThreads(__tstate);
36412 if (PyErr_Occurred()) SWIG_fail;
36413 }
36414 resultobj = SWIG_Py_Void();
36415 return resultobj;
36416 fail:
36417 return NULL;
36418 }
36419
36420
36421 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36422 PyObject *resultobj = 0;
36423 wxWindow *arg1 = (wxWindow *) 0 ;
36424 wxWindow *arg2 = (wxWindow *) 0 ;
36425 void *argp1 = 0 ;
36426 int res1 = 0 ;
36427 void *argp2 = 0 ;
36428 int res2 = 0 ;
36429 PyObject * obj0 = 0 ;
36430 PyObject * obj1 = 0 ;
36431 char * kwnames[] = {
36432 (char *) "self",(char *) "win", NULL
36433 };
36434
36435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
36436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36437 if (!SWIG_IsOK(res1)) {
36438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
36439 }
36440 arg1 = reinterpret_cast< wxWindow * >(argp1);
36441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36442 if (!SWIG_IsOK(res2)) {
36443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
36444 }
36445 arg2 = reinterpret_cast< wxWindow * >(argp2);
36446 {
36447 PyThreadState* __tstate = wxPyBeginAllowThreads();
36448 (arg1)->MoveBeforeInTabOrder(arg2);
36449 wxPyEndAllowThreads(__tstate);
36450 if (PyErr_Occurred()) SWIG_fail;
36451 }
36452 resultobj = SWIG_Py_Void();
36453 return resultobj;
36454 fail:
36455 return NULL;
36456 }
36457
36458
36459 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36460 PyObject *resultobj = 0;
36461 wxWindow *arg1 = (wxWindow *) 0 ;
36462 PyObject *result = 0 ;
36463 void *argp1 = 0 ;
36464 int res1 = 0 ;
36465 PyObject *swig_obj[1] ;
36466
36467 if (!args) SWIG_fail;
36468 swig_obj[0] = args;
36469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36470 if (!SWIG_IsOK(res1)) {
36471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
36472 }
36473 arg1 = reinterpret_cast< wxWindow * >(argp1);
36474 {
36475 PyThreadState* __tstate = wxPyBeginAllowThreads();
36476 result = (PyObject *)wxWindow_GetChildren(arg1);
36477 wxPyEndAllowThreads(__tstate);
36478 if (PyErr_Occurred()) SWIG_fail;
36479 }
36480 resultobj = result;
36481 return resultobj;
36482 fail:
36483 return NULL;
36484 }
36485
36486
36487 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36488 PyObject *resultobj = 0;
36489 wxWindow *arg1 = (wxWindow *) 0 ;
36490 wxWindow *result = 0 ;
36491 void *argp1 = 0 ;
36492 int res1 = 0 ;
36493 PyObject *swig_obj[1] ;
36494
36495 if (!args) SWIG_fail;
36496 swig_obj[0] = args;
36497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36498 if (!SWIG_IsOK(res1)) {
36499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36500 }
36501 arg1 = reinterpret_cast< wxWindow * >(argp1);
36502 {
36503 PyThreadState* __tstate = wxPyBeginAllowThreads();
36504 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
36505 wxPyEndAllowThreads(__tstate);
36506 if (PyErr_Occurred()) SWIG_fail;
36507 }
36508 {
36509 resultobj = wxPyMake_wxObject(result, 0);
36510 }
36511 return resultobj;
36512 fail:
36513 return NULL;
36514 }
36515
36516
36517 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36518 PyObject *resultobj = 0;
36519 wxWindow *arg1 = (wxWindow *) 0 ;
36520 wxWindow *result = 0 ;
36521 void *argp1 = 0 ;
36522 int res1 = 0 ;
36523 PyObject *swig_obj[1] ;
36524
36525 if (!args) SWIG_fail;
36526 swig_obj[0] = args;
36527 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36528 if (!SWIG_IsOK(res1)) {
36529 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
36530 }
36531 arg1 = reinterpret_cast< wxWindow * >(argp1);
36532 {
36533 PyThreadState* __tstate = wxPyBeginAllowThreads();
36534 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
36535 wxPyEndAllowThreads(__tstate);
36536 if (PyErr_Occurred()) SWIG_fail;
36537 }
36538 {
36539 resultobj = wxPyMake_wxObject(result, 0);
36540 }
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36548 PyObject *resultobj = 0;
36549 wxWindow *arg1 = (wxWindow *) 0 ;
36550 bool result;
36551 void *argp1 = 0 ;
36552 int res1 = 0 ;
36553 PyObject *swig_obj[1] ;
36554
36555 if (!args) SWIG_fail;
36556 swig_obj[0] = args;
36557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36558 if (!SWIG_IsOK(res1)) {
36559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
36560 }
36561 arg1 = reinterpret_cast< wxWindow * >(argp1);
36562 {
36563 PyThreadState* __tstate = wxPyBeginAllowThreads();
36564 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
36565 wxPyEndAllowThreads(__tstate);
36566 if (PyErr_Occurred()) SWIG_fail;
36567 }
36568 {
36569 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36570 }
36571 return resultobj;
36572 fail:
36573 return NULL;
36574 }
36575
36576
36577 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36578 PyObject *resultobj = 0;
36579 wxWindow *arg1 = (wxWindow *) 0 ;
36580 wxWindow *arg2 = (wxWindow *) 0 ;
36581 bool result;
36582 void *argp1 = 0 ;
36583 int res1 = 0 ;
36584 void *argp2 = 0 ;
36585 int res2 = 0 ;
36586 PyObject * obj0 = 0 ;
36587 PyObject * obj1 = 0 ;
36588 char * kwnames[] = {
36589 (char *) "self",(char *) "newParent", NULL
36590 };
36591
36592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
36593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36594 if (!SWIG_IsOK(res1)) {
36595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
36596 }
36597 arg1 = reinterpret_cast< wxWindow * >(argp1);
36598 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36599 if (!SWIG_IsOK(res2)) {
36600 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
36601 }
36602 arg2 = reinterpret_cast< wxWindow * >(argp2);
36603 {
36604 PyThreadState* __tstate = wxPyBeginAllowThreads();
36605 result = (bool)(arg1)->Reparent(arg2);
36606 wxPyEndAllowThreads(__tstate);
36607 if (PyErr_Occurred()) SWIG_fail;
36608 }
36609 {
36610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36611 }
36612 return resultobj;
36613 fail:
36614 return NULL;
36615 }
36616
36617
36618 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36619 PyObject *resultobj = 0;
36620 wxWindow *arg1 = (wxWindow *) 0 ;
36621 wxWindow *arg2 = (wxWindow *) 0 ;
36622 void *argp1 = 0 ;
36623 int res1 = 0 ;
36624 void *argp2 = 0 ;
36625 int res2 = 0 ;
36626 PyObject * obj0 = 0 ;
36627 PyObject * obj1 = 0 ;
36628 char * kwnames[] = {
36629 (char *) "self",(char *) "child", NULL
36630 };
36631
36632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
36633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36634 if (!SWIG_IsOK(res1)) {
36635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36636 }
36637 arg1 = reinterpret_cast< wxWindow * >(argp1);
36638 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36639 if (!SWIG_IsOK(res2)) {
36640 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36641 }
36642 arg2 = reinterpret_cast< wxWindow * >(argp2);
36643 {
36644 PyThreadState* __tstate = wxPyBeginAllowThreads();
36645 (arg1)->AddChild(arg2);
36646 wxPyEndAllowThreads(__tstate);
36647 if (PyErr_Occurred()) SWIG_fail;
36648 }
36649 resultobj = SWIG_Py_Void();
36650 return resultobj;
36651 fail:
36652 return NULL;
36653 }
36654
36655
36656 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36657 PyObject *resultobj = 0;
36658 wxWindow *arg1 = (wxWindow *) 0 ;
36659 wxWindow *arg2 = (wxWindow *) 0 ;
36660 void *argp1 = 0 ;
36661 int res1 = 0 ;
36662 void *argp2 = 0 ;
36663 int res2 = 0 ;
36664 PyObject * obj0 = 0 ;
36665 PyObject * obj1 = 0 ;
36666 char * kwnames[] = {
36667 (char *) "self",(char *) "child", NULL
36668 };
36669
36670 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
36671 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36672 if (!SWIG_IsOK(res1)) {
36673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
36674 }
36675 arg1 = reinterpret_cast< wxWindow * >(argp1);
36676 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
36677 if (!SWIG_IsOK(res2)) {
36678 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
36679 }
36680 arg2 = reinterpret_cast< wxWindow * >(argp2);
36681 {
36682 PyThreadState* __tstate = wxPyBeginAllowThreads();
36683 (arg1)->RemoveChild(arg2);
36684 wxPyEndAllowThreads(__tstate);
36685 if (PyErr_Occurred()) SWIG_fail;
36686 }
36687 resultobj = SWIG_Py_Void();
36688 return resultobj;
36689 fail:
36690 return NULL;
36691 }
36692
36693
36694 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36695 PyObject *resultobj = 0;
36696 wxWindow *arg1 = (wxWindow *) 0 ;
36697 bool arg2 ;
36698 void *argp1 = 0 ;
36699 int res1 = 0 ;
36700 bool val2 ;
36701 int ecode2 = 0 ;
36702 PyObject * obj0 = 0 ;
36703 PyObject * obj1 = 0 ;
36704 char * kwnames[] = {
36705 (char *) "self",(char *) "on", NULL
36706 };
36707
36708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
36709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36710 if (!SWIG_IsOK(res1)) {
36711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
36712 }
36713 arg1 = reinterpret_cast< wxWindow * >(argp1);
36714 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36715 if (!SWIG_IsOK(ecode2)) {
36716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
36717 }
36718 arg2 = static_cast< bool >(val2);
36719 {
36720 PyThreadState* __tstate = wxPyBeginAllowThreads();
36721 wxWindow_SetDoubleBuffered(arg1,arg2);
36722 wxPyEndAllowThreads(__tstate);
36723 if (PyErr_Occurred()) SWIG_fail;
36724 }
36725 resultobj = SWIG_Py_Void();
36726 return resultobj;
36727 fail:
36728 return NULL;
36729 }
36730
36731
36732 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36733 PyObject *resultobj = 0;
36734 wxWindow *arg1 = (wxWindow *) 0 ;
36735 long arg2 ;
36736 wxWindow *result = 0 ;
36737 void *argp1 = 0 ;
36738 int res1 = 0 ;
36739 long val2 ;
36740 int ecode2 = 0 ;
36741 PyObject * obj0 = 0 ;
36742 PyObject * obj1 = 0 ;
36743 char * kwnames[] = {
36744 (char *) "self",(char *) "winid", NULL
36745 };
36746
36747 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
36748 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36749 if (!SWIG_IsOK(res1)) {
36750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
36751 }
36752 arg1 = reinterpret_cast< wxWindow * >(argp1);
36753 ecode2 = SWIG_AsVal_long(obj1, &val2);
36754 if (!SWIG_IsOK(ecode2)) {
36755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
36756 }
36757 arg2 = static_cast< long >(val2);
36758 {
36759 PyThreadState* __tstate = wxPyBeginAllowThreads();
36760 result = (wxWindow *)(arg1)->FindWindow(arg2);
36761 wxPyEndAllowThreads(__tstate);
36762 if (PyErr_Occurred()) SWIG_fail;
36763 }
36764 {
36765 resultobj = wxPyMake_wxObject(result, 0);
36766 }
36767 return resultobj;
36768 fail:
36769 return NULL;
36770 }
36771
36772
36773 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36774 PyObject *resultobj = 0;
36775 wxWindow *arg1 = (wxWindow *) 0 ;
36776 wxString *arg2 = 0 ;
36777 wxWindow *result = 0 ;
36778 void *argp1 = 0 ;
36779 int res1 = 0 ;
36780 bool temp2 = false ;
36781 PyObject * obj0 = 0 ;
36782 PyObject * obj1 = 0 ;
36783 char * kwnames[] = {
36784 (char *) "self",(char *) "name", NULL
36785 };
36786
36787 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
36788 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36789 if (!SWIG_IsOK(res1)) {
36790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
36791 }
36792 arg1 = reinterpret_cast< wxWindow * >(argp1);
36793 {
36794 arg2 = wxString_in_helper(obj1);
36795 if (arg2 == NULL) SWIG_fail;
36796 temp2 = true;
36797 }
36798 {
36799 PyThreadState* __tstate = wxPyBeginAllowThreads();
36800 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
36801 wxPyEndAllowThreads(__tstate);
36802 if (PyErr_Occurred()) SWIG_fail;
36803 }
36804 {
36805 resultobj = wxPyMake_wxObject(result, 0);
36806 }
36807 {
36808 if (temp2)
36809 delete arg2;
36810 }
36811 return resultobj;
36812 fail:
36813 {
36814 if (temp2)
36815 delete arg2;
36816 }
36817 return NULL;
36818 }
36819
36820
36821 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36822 PyObject *resultobj = 0;
36823 wxWindow *arg1 = (wxWindow *) 0 ;
36824 wxEvtHandler *result = 0 ;
36825 void *argp1 = 0 ;
36826 int res1 = 0 ;
36827 PyObject *swig_obj[1] ;
36828
36829 if (!args) SWIG_fail;
36830 swig_obj[0] = args;
36831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36832 if (!SWIG_IsOK(res1)) {
36833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
36834 }
36835 arg1 = reinterpret_cast< wxWindow * >(argp1);
36836 {
36837 PyThreadState* __tstate = wxPyBeginAllowThreads();
36838 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
36839 wxPyEndAllowThreads(__tstate);
36840 if (PyErr_Occurred()) SWIG_fail;
36841 }
36842 {
36843 resultobj = wxPyMake_wxObject(result, 0);
36844 }
36845 return resultobj;
36846 fail:
36847 return NULL;
36848 }
36849
36850
36851 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36852 PyObject *resultobj = 0;
36853 wxWindow *arg1 = (wxWindow *) 0 ;
36854 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36855 void *argp1 = 0 ;
36856 int res1 = 0 ;
36857 void *argp2 = 0 ;
36858 int res2 = 0 ;
36859 PyObject * obj0 = 0 ;
36860 PyObject * obj1 = 0 ;
36861 char * kwnames[] = {
36862 (char *) "self",(char *) "handler", NULL
36863 };
36864
36865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36867 if (!SWIG_IsOK(res1)) {
36868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36869 }
36870 arg1 = reinterpret_cast< wxWindow * >(argp1);
36871 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36872 if (!SWIG_IsOK(res2)) {
36873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36874 }
36875 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36876 {
36877 PyThreadState* __tstate = wxPyBeginAllowThreads();
36878 (arg1)->SetEventHandler(arg2);
36879 wxPyEndAllowThreads(__tstate);
36880 if (PyErr_Occurred()) SWIG_fail;
36881 }
36882 resultobj = SWIG_Py_Void();
36883 return resultobj;
36884 fail:
36885 return NULL;
36886 }
36887
36888
36889 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36890 PyObject *resultobj = 0;
36891 wxWindow *arg1 = (wxWindow *) 0 ;
36892 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36893 void *argp1 = 0 ;
36894 int res1 = 0 ;
36895 void *argp2 = 0 ;
36896 int res2 = 0 ;
36897 PyObject * obj0 = 0 ;
36898 PyObject * obj1 = 0 ;
36899 char * kwnames[] = {
36900 (char *) "self",(char *) "handler", NULL
36901 };
36902
36903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36904 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36905 if (!SWIG_IsOK(res1)) {
36906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36907 }
36908 arg1 = reinterpret_cast< wxWindow * >(argp1);
36909 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36910 if (!SWIG_IsOK(res2)) {
36911 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36912 }
36913 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36914 {
36915 PyThreadState* __tstate = wxPyBeginAllowThreads();
36916 (arg1)->PushEventHandler(arg2);
36917 wxPyEndAllowThreads(__tstate);
36918 if (PyErr_Occurred()) SWIG_fail;
36919 }
36920 resultobj = SWIG_Py_Void();
36921 return resultobj;
36922 fail:
36923 return NULL;
36924 }
36925
36926
36927 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36928 PyObject *resultobj = 0;
36929 wxWindow *arg1 = (wxWindow *) 0 ;
36930 bool arg2 = (bool) false ;
36931 wxEvtHandler *result = 0 ;
36932 void *argp1 = 0 ;
36933 int res1 = 0 ;
36934 bool val2 ;
36935 int ecode2 = 0 ;
36936 PyObject * obj0 = 0 ;
36937 PyObject * obj1 = 0 ;
36938 char * kwnames[] = {
36939 (char *) "self",(char *) "deleteHandler", NULL
36940 };
36941
36942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36944 if (!SWIG_IsOK(res1)) {
36945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36946 }
36947 arg1 = reinterpret_cast< wxWindow * >(argp1);
36948 if (obj1) {
36949 ecode2 = SWIG_AsVal_bool(obj1, &val2);
36950 if (!SWIG_IsOK(ecode2)) {
36951 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
36952 }
36953 arg2 = static_cast< bool >(val2);
36954 }
36955 {
36956 PyThreadState* __tstate = wxPyBeginAllowThreads();
36957 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
36958 wxPyEndAllowThreads(__tstate);
36959 if (PyErr_Occurred()) SWIG_fail;
36960 }
36961 {
36962 resultobj = wxPyMake_wxObject(result, 0);
36963 }
36964 return resultobj;
36965 fail:
36966 return NULL;
36967 }
36968
36969
36970 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36971 PyObject *resultobj = 0;
36972 wxWindow *arg1 = (wxWindow *) 0 ;
36973 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
36974 bool result;
36975 void *argp1 = 0 ;
36976 int res1 = 0 ;
36977 void *argp2 = 0 ;
36978 int res2 = 0 ;
36979 PyObject * obj0 = 0 ;
36980 PyObject * obj1 = 0 ;
36981 char * kwnames[] = {
36982 (char *) "self",(char *) "handler", NULL
36983 };
36984
36985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
36986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36987 if (!SWIG_IsOK(res1)) {
36988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
36989 }
36990 arg1 = reinterpret_cast< wxWindow * >(argp1);
36991 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
36992 if (!SWIG_IsOK(res2)) {
36993 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
36994 }
36995 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
36996 {
36997 PyThreadState* __tstate = wxPyBeginAllowThreads();
36998 result = (bool)(arg1)->RemoveEventHandler(arg2);
36999 wxPyEndAllowThreads(__tstate);
37000 if (PyErr_Occurred()) SWIG_fail;
37001 }
37002 {
37003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37004 }
37005 return resultobj;
37006 fail:
37007 return NULL;
37008 }
37009
37010
37011 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37012 PyObject *resultobj = 0;
37013 wxWindow *arg1 = (wxWindow *) 0 ;
37014 wxValidator *arg2 = 0 ;
37015 void *argp1 = 0 ;
37016 int res1 = 0 ;
37017 void *argp2 = 0 ;
37018 int res2 = 0 ;
37019 PyObject * obj0 = 0 ;
37020 PyObject * obj1 = 0 ;
37021 char * kwnames[] = {
37022 (char *) "self",(char *) "validator", NULL
37023 };
37024
37025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
37026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37027 if (!SWIG_IsOK(res1)) {
37028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37029 }
37030 arg1 = reinterpret_cast< wxWindow * >(argp1);
37031 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
37032 if (!SWIG_IsOK(res2)) {
37033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37034 }
37035 if (!argp2) {
37036 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
37037 }
37038 arg2 = reinterpret_cast< wxValidator * >(argp2);
37039 {
37040 PyThreadState* __tstate = wxPyBeginAllowThreads();
37041 (arg1)->SetValidator((wxValidator const &)*arg2);
37042 wxPyEndAllowThreads(__tstate);
37043 if (PyErr_Occurred()) SWIG_fail;
37044 }
37045 resultobj = SWIG_Py_Void();
37046 return resultobj;
37047 fail:
37048 return NULL;
37049 }
37050
37051
37052 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37053 PyObject *resultobj = 0;
37054 wxWindow *arg1 = (wxWindow *) 0 ;
37055 wxValidator *result = 0 ;
37056 void *argp1 = 0 ;
37057 int res1 = 0 ;
37058 PyObject *swig_obj[1] ;
37059
37060 if (!args) SWIG_fail;
37061 swig_obj[0] = args;
37062 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37063 if (!SWIG_IsOK(res1)) {
37064 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
37065 }
37066 arg1 = reinterpret_cast< wxWindow * >(argp1);
37067 {
37068 PyThreadState* __tstate = wxPyBeginAllowThreads();
37069 result = (wxValidator *)(arg1)->GetValidator();
37070 wxPyEndAllowThreads(__tstate);
37071 if (PyErr_Occurred()) SWIG_fail;
37072 }
37073 {
37074 resultobj = wxPyMake_wxObject(result, (bool)0);
37075 }
37076 return resultobj;
37077 fail:
37078 return NULL;
37079 }
37080
37081
37082 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37083 PyObject *resultobj = 0;
37084 wxWindow *arg1 = (wxWindow *) 0 ;
37085 bool result;
37086 void *argp1 = 0 ;
37087 int res1 = 0 ;
37088 PyObject *swig_obj[1] ;
37089
37090 if (!args) SWIG_fail;
37091 swig_obj[0] = args;
37092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37093 if (!SWIG_IsOK(res1)) {
37094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
37095 }
37096 arg1 = reinterpret_cast< wxWindow * >(argp1);
37097 {
37098 PyThreadState* __tstate = wxPyBeginAllowThreads();
37099 result = (bool)(arg1)->Validate();
37100 wxPyEndAllowThreads(__tstate);
37101 if (PyErr_Occurred()) SWIG_fail;
37102 }
37103 {
37104 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37105 }
37106 return resultobj;
37107 fail:
37108 return NULL;
37109 }
37110
37111
37112 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37113 PyObject *resultobj = 0;
37114 wxWindow *arg1 = (wxWindow *) 0 ;
37115 bool result;
37116 void *argp1 = 0 ;
37117 int res1 = 0 ;
37118 PyObject *swig_obj[1] ;
37119
37120 if (!args) SWIG_fail;
37121 swig_obj[0] = args;
37122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37123 if (!SWIG_IsOK(res1)) {
37124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37125 }
37126 arg1 = reinterpret_cast< wxWindow * >(argp1);
37127 {
37128 PyThreadState* __tstate = wxPyBeginAllowThreads();
37129 result = (bool)(arg1)->TransferDataToWindow();
37130 wxPyEndAllowThreads(__tstate);
37131 if (PyErr_Occurred()) SWIG_fail;
37132 }
37133 {
37134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37135 }
37136 return resultobj;
37137 fail:
37138 return NULL;
37139 }
37140
37141
37142 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37143 PyObject *resultobj = 0;
37144 wxWindow *arg1 = (wxWindow *) 0 ;
37145 bool result;
37146 void *argp1 = 0 ;
37147 int res1 = 0 ;
37148 PyObject *swig_obj[1] ;
37149
37150 if (!args) SWIG_fail;
37151 swig_obj[0] = args;
37152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37153 if (!SWIG_IsOK(res1)) {
37154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
37155 }
37156 arg1 = reinterpret_cast< wxWindow * >(argp1);
37157 {
37158 PyThreadState* __tstate = wxPyBeginAllowThreads();
37159 result = (bool)(arg1)->TransferDataFromWindow();
37160 wxPyEndAllowThreads(__tstate);
37161 if (PyErr_Occurred()) SWIG_fail;
37162 }
37163 {
37164 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37165 }
37166 return resultobj;
37167 fail:
37168 return NULL;
37169 }
37170
37171
37172 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37173 PyObject *resultobj = 0;
37174 wxWindow *arg1 = (wxWindow *) 0 ;
37175 void *argp1 = 0 ;
37176 int res1 = 0 ;
37177 PyObject *swig_obj[1] ;
37178
37179 if (!args) SWIG_fail;
37180 swig_obj[0] = args;
37181 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37182 if (!SWIG_IsOK(res1)) {
37183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37184 }
37185 arg1 = reinterpret_cast< wxWindow * >(argp1);
37186 {
37187 PyThreadState* __tstate = wxPyBeginAllowThreads();
37188 (arg1)->InitDialog();
37189 wxPyEndAllowThreads(__tstate);
37190 if (PyErr_Occurred()) SWIG_fail;
37191 }
37192 resultobj = SWIG_Py_Void();
37193 return resultobj;
37194 fail:
37195 return NULL;
37196 }
37197
37198
37199 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37200 PyObject *resultobj = 0;
37201 wxWindow *arg1 = (wxWindow *) 0 ;
37202 wxAcceleratorTable *arg2 = 0 ;
37203 void *argp1 = 0 ;
37204 int res1 = 0 ;
37205 void *argp2 = 0 ;
37206 int res2 = 0 ;
37207 PyObject * obj0 = 0 ;
37208 PyObject * obj1 = 0 ;
37209 char * kwnames[] = {
37210 (char *) "self",(char *) "accel", NULL
37211 };
37212
37213 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
37214 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37215 if (!SWIG_IsOK(res1)) {
37216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37217 }
37218 arg1 = reinterpret_cast< wxWindow * >(argp1);
37219 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
37220 if (!SWIG_IsOK(res2)) {
37221 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37222 }
37223 if (!argp2) {
37224 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
37225 }
37226 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
37227 {
37228 PyThreadState* __tstate = wxPyBeginAllowThreads();
37229 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
37230 wxPyEndAllowThreads(__tstate);
37231 if (PyErr_Occurred()) SWIG_fail;
37232 }
37233 resultobj = SWIG_Py_Void();
37234 return resultobj;
37235 fail:
37236 return NULL;
37237 }
37238
37239
37240 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37241 PyObject *resultobj = 0;
37242 wxWindow *arg1 = (wxWindow *) 0 ;
37243 wxAcceleratorTable *result = 0 ;
37244 void *argp1 = 0 ;
37245 int res1 = 0 ;
37246 PyObject *swig_obj[1] ;
37247
37248 if (!args) SWIG_fail;
37249 swig_obj[0] = args;
37250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37251 if (!SWIG_IsOK(res1)) {
37252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
37253 }
37254 arg1 = reinterpret_cast< wxWindow * >(argp1);
37255 {
37256 PyThreadState* __tstate = wxPyBeginAllowThreads();
37257 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
37258 wxPyEndAllowThreads(__tstate);
37259 if (PyErr_Occurred()) SWIG_fail;
37260 }
37261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
37262 return resultobj;
37263 fail:
37264 return NULL;
37265 }
37266
37267
37268 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37269 PyObject *resultobj = 0;
37270 wxWindow *arg1 = (wxWindow *) 0 ;
37271 int arg2 ;
37272 int arg3 ;
37273 int arg4 ;
37274 bool result;
37275 void *argp1 = 0 ;
37276 int res1 = 0 ;
37277 int val2 ;
37278 int ecode2 = 0 ;
37279 int val3 ;
37280 int ecode3 = 0 ;
37281 int val4 ;
37282 int ecode4 = 0 ;
37283 PyObject * obj0 = 0 ;
37284 PyObject * obj1 = 0 ;
37285 PyObject * obj2 = 0 ;
37286 PyObject * obj3 = 0 ;
37287 char * kwnames[] = {
37288 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
37289 };
37290
37291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
37292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37293 if (!SWIG_IsOK(res1)) {
37294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37295 }
37296 arg1 = reinterpret_cast< wxWindow * >(argp1);
37297 ecode2 = SWIG_AsVal_int(obj1, &val2);
37298 if (!SWIG_IsOK(ecode2)) {
37299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
37300 }
37301 arg2 = static_cast< int >(val2);
37302 ecode3 = SWIG_AsVal_int(obj2, &val3);
37303 if (!SWIG_IsOK(ecode3)) {
37304 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
37305 }
37306 arg3 = static_cast< int >(val3);
37307 ecode4 = SWIG_AsVal_int(obj3, &val4);
37308 if (!SWIG_IsOK(ecode4)) {
37309 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
37310 }
37311 arg4 = static_cast< int >(val4);
37312 {
37313 PyThreadState* __tstate = wxPyBeginAllowThreads();
37314 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
37315 wxPyEndAllowThreads(__tstate);
37316 if (PyErr_Occurred()) SWIG_fail;
37317 }
37318 {
37319 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37320 }
37321 return resultobj;
37322 fail:
37323 return NULL;
37324 }
37325
37326
37327 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37328 PyObject *resultobj = 0;
37329 wxWindow *arg1 = (wxWindow *) 0 ;
37330 int arg2 ;
37331 bool result;
37332 void *argp1 = 0 ;
37333 int res1 = 0 ;
37334 int val2 ;
37335 int ecode2 = 0 ;
37336 PyObject * obj0 = 0 ;
37337 PyObject * obj1 = 0 ;
37338 char * kwnames[] = {
37339 (char *) "self",(char *) "hotkeyId", NULL
37340 };
37341
37342 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
37343 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37344 if (!SWIG_IsOK(res1)) {
37345 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
37346 }
37347 arg1 = reinterpret_cast< wxWindow * >(argp1);
37348 ecode2 = SWIG_AsVal_int(obj1, &val2);
37349 if (!SWIG_IsOK(ecode2)) {
37350 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
37351 }
37352 arg2 = static_cast< int >(val2);
37353 {
37354 PyThreadState* __tstate = wxPyBeginAllowThreads();
37355 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
37356 wxPyEndAllowThreads(__tstate);
37357 if (PyErr_Occurred()) SWIG_fail;
37358 }
37359 {
37360 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37361 }
37362 return resultobj;
37363 fail:
37364 return NULL;
37365 }
37366
37367
37368 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37369 PyObject *resultobj = 0;
37370 wxWindow *arg1 = (wxWindow *) 0 ;
37371 wxPoint *arg2 = 0 ;
37372 wxPoint result;
37373 void *argp1 = 0 ;
37374 int res1 = 0 ;
37375 wxPoint temp2 ;
37376 PyObject * obj0 = 0 ;
37377 PyObject * obj1 = 0 ;
37378 char * kwnames[] = {
37379 (char *) "self",(char *) "pt", NULL
37380 };
37381
37382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37384 if (!SWIG_IsOK(res1)) {
37385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37386 }
37387 arg1 = reinterpret_cast< wxWindow * >(argp1);
37388 {
37389 arg2 = &temp2;
37390 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37391 }
37392 {
37393 PyThreadState* __tstate = wxPyBeginAllowThreads();
37394 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37395 wxPyEndAllowThreads(__tstate);
37396 if (PyErr_Occurred()) SWIG_fail;
37397 }
37398 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37399 return resultobj;
37400 fail:
37401 return NULL;
37402 }
37403
37404
37405 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37406 PyObject *resultobj = 0;
37407 wxWindow *arg1 = (wxWindow *) 0 ;
37408 wxSize *arg2 = 0 ;
37409 wxSize result;
37410 void *argp1 = 0 ;
37411 int res1 = 0 ;
37412 wxSize temp2 ;
37413 PyObject * obj0 = 0 ;
37414 PyObject * obj1 = 0 ;
37415 char * kwnames[] = {
37416 (char *) "self",(char *) "sz", NULL
37417 };
37418
37419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
37420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37421 if (!SWIG_IsOK(res1)) {
37422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
37423 }
37424 arg1 = reinterpret_cast< wxWindow * >(argp1);
37425 {
37426 arg2 = &temp2;
37427 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37428 }
37429 {
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37432 wxPyEndAllowThreads(__tstate);
37433 if (PyErr_Occurred()) SWIG_fail;
37434 }
37435 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37436 return resultobj;
37437 fail:
37438 return NULL;
37439 }
37440
37441
37442 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37443 PyObject *resultobj = 0;
37444 wxWindow *arg1 = (wxWindow *) 0 ;
37445 wxPoint *arg2 = 0 ;
37446 wxPoint result;
37447 void *argp1 = 0 ;
37448 int res1 = 0 ;
37449 wxPoint temp2 ;
37450 PyObject * obj0 = 0 ;
37451 PyObject * obj1 = 0 ;
37452 char * kwnames[] = {
37453 (char *) "self",(char *) "pt", NULL
37454 };
37455
37456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
37457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37458 if (!SWIG_IsOK(res1)) {
37459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
37460 }
37461 arg1 = reinterpret_cast< wxWindow * >(argp1);
37462 {
37463 arg2 = &temp2;
37464 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37465 }
37466 {
37467 PyThreadState* __tstate = wxPyBeginAllowThreads();
37468 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
37469 wxPyEndAllowThreads(__tstate);
37470 if (PyErr_Occurred()) SWIG_fail;
37471 }
37472 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37473 return resultobj;
37474 fail:
37475 return NULL;
37476 }
37477
37478
37479 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37480 PyObject *resultobj = 0;
37481 wxWindow *arg1 = (wxWindow *) 0 ;
37482 wxSize *arg2 = 0 ;
37483 wxSize result;
37484 void *argp1 = 0 ;
37485 int res1 = 0 ;
37486 wxSize temp2 ;
37487 PyObject * obj0 = 0 ;
37488 PyObject * obj1 = 0 ;
37489 char * kwnames[] = {
37490 (char *) "self",(char *) "sz", NULL
37491 };
37492
37493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",kwnames,&obj0,&obj1)) SWIG_fail;
37494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37495 if (!SWIG_IsOK(res1)) {
37496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_SZE" "', expected argument " "1"" of type '" "wxWindow *""'");
37497 }
37498 arg1 = reinterpret_cast< wxWindow * >(argp1);
37499 {
37500 arg2 = &temp2;
37501 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37502 }
37503 {
37504 PyThreadState* __tstate = wxPyBeginAllowThreads();
37505 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
37506 wxPyEndAllowThreads(__tstate);
37507 if (PyErr_Occurred()) SWIG_fail;
37508 }
37509 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37510 return resultobj;
37511 fail:
37512 return NULL;
37513 }
37514
37515
37516 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37517 PyObject *resultobj = 0;
37518 wxWindow *arg1 = (wxWindow *) 0 ;
37519 wxPoint *arg2 = 0 ;
37520 wxPoint result;
37521 void *argp1 = 0 ;
37522 int res1 = 0 ;
37523 wxPoint temp2 ;
37524 PyObject * obj0 = 0 ;
37525 PyObject * obj1 = 0 ;
37526 char * kwnames[] = {
37527 (char *) "self",(char *) "pt", NULL
37528 };
37529
37530 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37531 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37532 if (!SWIG_IsOK(res1)) {
37533 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37534 }
37535 arg1 = reinterpret_cast< wxWindow * >(argp1);
37536 {
37537 arg2 = &temp2;
37538 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37539 }
37540 {
37541 PyThreadState* __tstate = wxPyBeginAllowThreads();
37542 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
37543 wxPyEndAllowThreads(__tstate);
37544 if (PyErr_Occurred()) SWIG_fail;
37545 }
37546 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
37547 return resultobj;
37548 fail:
37549 return NULL;
37550 }
37551
37552
37553 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37554 PyObject *resultobj = 0;
37555 wxWindow *arg1 = (wxWindow *) 0 ;
37556 wxSize *arg2 = 0 ;
37557 wxSize result;
37558 void *argp1 = 0 ;
37559 int res1 = 0 ;
37560 wxSize temp2 ;
37561 PyObject * obj0 = 0 ;
37562 PyObject * obj1 = 0 ;
37563 char * kwnames[] = {
37564 (char *) "self",(char *) "sz", NULL
37565 };
37566
37567 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
37568 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37569 if (!SWIG_IsOK(res1)) {
37570 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
37571 }
37572 arg1 = reinterpret_cast< wxWindow * >(argp1);
37573 {
37574 arg2 = &temp2;
37575 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
37576 }
37577 {
37578 PyThreadState* __tstate = wxPyBeginAllowThreads();
37579 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
37580 wxPyEndAllowThreads(__tstate);
37581 if (PyErr_Occurred()) SWIG_fail;
37582 }
37583 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
37584 return resultobj;
37585 fail:
37586 return NULL;
37587 }
37588
37589
37590 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37591 PyObject *resultobj = 0;
37592 wxWindow *arg1 = (wxWindow *) 0 ;
37593 int arg2 ;
37594 int arg3 ;
37595 void *argp1 = 0 ;
37596 int res1 = 0 ;
37597 int val2 ;
37598 int ecode2 = 0 ;
37599 int val3 ;
37600 int ecode3 = 0 ;
37601 PyObject * obj0 = 0 ;
37602 PyObject * obj1 = 0 ;
37603 PyObject * obj2 = 0 ;
37604 char * kwnames[] = {
37605 (char *) "self",(char *) "x",(char *) "y", NULL
37606 };
37607
37608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37610 if (!SWIG_IsOK(res1)) {
37611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
37612 }
37613 arg1 = reinterpret_cast< wxWindow * >(argp1);
37614 ecode2 = SWIG_AsVal_int(obj1, &val2);
37615 if (!SWIG_IsOK(ecode2)) {
37616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
37617 }
37618 arg2 = static_cast< int >(val2);
37619 ecode3 = SWIG_AsVal_int(obj2, &val3);
37620 if (!SWIG_IsOK(ecode3)) {
37621 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
37622 }
37623 arg3 = static_cast< int >(val3);
37624 {
37625 PyThreadState* __tstate = wxPyBeginAllowThreads();
37626 (arg1)->WarpPointer(arg2,arg3);
37627 wxPyEndAllowThreads(__tstate);
37628 if (PyErr_Occurred()) SWIG_fail;
37629 }
37630 resultobj = SWIG_Py_Void();
37631 return resultobj;
37632 fail:
37633 return NULL;
37634 }
37635
37636
37637 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37638 PyObject *resultobj = 0;
37639 wxWindow *arg1 = (wxWindow *) 0 ;
37640 void *argp1 = 0 ;
37641 int res1 = 0 ;
37642 PyObject *swig_obj[1] ;
37643
37644 if (!args) SWIG_fail;
37645 swig_obj[0] = args;
37646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37647 if (!SWIG_IsOK(res1)) {
37648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37649 }
37650 arg1 = reinterpret_cast< wxWindow * >(argp1);
37651 {
37652 PyThreadState* __tstate = wxPyBeginAllowThreads();
37653 (arg1)->CaptureMouse();
37654 wxPyEndAllowThreads(__tstate);
37655 if (PyErr_Occurred()) SWIG_fail;
37656 }
37657 resultobj = SWIG_Py_Void();
37658 return resultobj;
37659 fail:
37660 return NULL;
37661 }
37662
37663
37664 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37665 PyObject *resultobj = 0;
37666 wxWindow *arg1 = (wxWindow *) 0 ;
37667 void *argp1 = 0 ;
37668 int res1 = 0 ;
37669 PyObject *swig_obj[1] ;
37670
37671 if (!args) SWIG_fail;
37672 swig_obj[0] = args;
37673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37674 if (!SWIG_IsOK(res1)) {
37675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
37676 }
37677 arg1 = reinterpret_cast< wxWindow * >(argp1);
37678 {
37679 PyThreadState* __tstate = wxPyBeginAllowThreads();
37680 (arg1)->ReleaseMouse();
37681 wxPyEndAllowThreads(__tstate);
37682 if (PyErr_Occurred()) SWIG_fail;
37683 }
37684 resultobj = SWIG_Py_Void();
37685 return resultobj;
37686 fail:
37687 return NULL;
37688 }
37689
37690
37691 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37692 PyObject *resultobj = 0;
37693 wxWindow *result = 0 ;
37694
37695 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
37696 {
37697 if (!wxPyCheckForApp()) SWIG_fail;
37698 PyThreadState* __tstate = wxPyBeginAllowThreads();
37699 result = (wxWindow *)wxWindow::GetCapture();
37700 wxPyEndAllowThreads(__tstate);
37701 if (PyErr_Occurred()) SWIG_fail;
37702 }
37703 {
37704 resultobj = wxPyMake_wxObject(result, 0);
37705 }
37706 return resultobj;
37707 fail:
37708 return NULL;
37709 }
37710
37711
37712 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37713 PyObject *resultobj = 0;
37714 wxWindow *arg1 = (wxWindow *) 0 ;
37715 bool result;
37716 void *argp1 = 0 ;
37717 int res1 = 0 ;
37718 PyObject *swig_obj[1] ;
37719
37720 if (!args) SWIG_fail;
37721 swig_obj[0] = args;
37722 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37723 if (!SWIG_IsOK(res1)) {
37724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
37725 }
37726 arg1 = reinterpret_cast< wxWindow * >(argp1);
37727 {
37728 PyThreadState* __tstate = wxPyBeginAllowThreads();
37729 result = (bool)((wxWindow const *)arg1)->HasCapture();
37730 wxPyEndAllowThreads(__tstate);
37731 if (PyErr_Occurred()) SWIG_fail;
37732 }
37733 {
37734 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37735 }
37736 return resultobj;
37737 fail:
37738 return NULL;
37739 }
37740
37741
37742 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37743 PyObject *resultobj = 0;
37744 wxWindow *arg1 = (wxWindow *) 0 ;
37745 bool arg2 = (bool) true ;
37746 wxRect *arg3 = (wxRect *) NULL ;
37747 void *argp1 = 0 ;
37748 int res1 = 0 ;
37749 bool val2 ;
37750 int ecode2 = 0 ;
37751 void *argp3 = 0 ;
37752 int res3 = 0 ;
37753 PyObject * obj0 = 0 ;
37754 PyObject * obj1 = 0 ;
37755 PyObject * obj2 = 0 ;
37756 char * kwnames[] = {
37757 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
37758 };
37759
37760 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37761 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37762 if (!SWIG_IsOK(res1)) {
37763 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
37764 }
37765 arg1 = reinterpret_cast< wxWindow * >(argp1);
37766 if (obj1) {
37767 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37768 if (!SWIG_IsOK(ecode2)) {
37769 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
37770 }
37771 arg2 = static_cast< bool >(val2);
37772 }
37773 if (obj2) {
37774 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
37775 if (!SWIG_IsOK(res3)) {
37776 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
37777 }
37778 arg3 = reinterpret_cast< wxRect * >(argp3);
37779 }
37780 {
37781 PyThreadState* __tstate = wxPyBeginAllowThreads();
37782 (arg1)->Refresh(arg2,(wxRect const *)arg3);
37783 wxPyEndAllowThreads(__tstate);
37784 if (PyErr_Occurred()) SWIG_fail;
37785 }
37786 resultobj = SWIG_Py_Void();
37787 return resultobj;
37788 fail:
37789 return NULL;
37790 }
37791
37792
37793 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37794 PyObject *resultobj = 0;
37795 wxWindow *arg1 = (wxWindow *) 0 ;
37796 wxRect *arg2 = 0 ;
37797 bool arg3 = (bool) true ;
37798 void *argp1 = 0 ;
37799 int res1 = 0 ;
37800 wxRect temp2 ;
37801 bool val3 ;
37802 int ecode3 = 0 ;
37803 PyObject * obj0 = 0 ;
37804 PyObject * obj1 = 0 ;
37805 PyObject * obj2 = 0 ;
37806 char * kwnames[] = {
37807 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
37808 };
37809
37810 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37811 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37812 if (!SWIG_IsOK(res1)) {
37813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
37814 }
37815 arg1 = reinterpret_cast< wxWindow * >(argp1);
37816 {
37817 arg2 = &temp2;
37818 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
37819 }
37820 if (obj2) {
37821 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37822 if (!SWIG_IsOK(ecode3)) {
37823 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
37824 }
37825 arg3 = static_cast< bool >(val3);
37826 }
37827 {
37828 PyThreadState* __tstate = wxPyBeginAllowThreads();
37829 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
37830 wxPyEndAllowThreads(__tstate);
37831 if (PyErr_Occurred()) SWIG_fail;
37832 }
37833 resultobj = SWIG_Py_Void();
37834 return resultobj;
37835 fail:
37836 return NULL;
37837 }
37838
37839
37840 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37841 PyObject *resultobj = 0;
37842 wxWindow *arg1 = (wxWindow *) 0 ;
37843 void *argp1 = 0 ;
37844 int res1 = 0 ;
37845 PyObject *swig_obj[1] ;
37846
37847 if (!args) SWIG_fail;
37848 swig_obj[0] = args;
37849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37850 if (!SWIG_IsOK(res1)) {
37851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
37852 }
37853 arg1 = reinterpret_cast< wxWindow * >(argp1);
37854 {
37855 PyThreadState* __tstate = wxPyBeginAllowThreads();
37856 (arg1)->Update();
37857 wxPyEndAllowThreads(__tstate);
37858 if (PyErr_Occurred()) SWIG_fail;
37859 }
37860 resultobj = SWIG_Py_Void();
37861 return resultobj;
37862 fail:
37863 return NULL;
37864 }
37865
37866
37867 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37868 PyObject *resultobj = 0;
37869 wxWindow *arg1 = (wxWindow *) 0 ;
37870 void *argp1 = 0 ;
37871 int res1 = 0 ;
37872 PyObject *swig_obj[1] ;
37873
37874 if (!args) SWIG_fail;
37875 swig_obj[0] = args;
37876 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37877 if (!SWIG_IsOK(res1)) {
37878 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
37879 }
37880 arg1 = reinterpret_cast< wxWindow * >(argp1);
37881 {
37882 PyThreadState* __tstate = wxPyBeginAllowThreads();
37883 (arg1)->ClearBackground();
37884 wxPyEndAllowThreads(__tstate);
37885 if (PyErr_Occurred()) SWIG_fail;
37886 }
37887 resultobj = SWIG_Py_Void();
37888 return resultobj;
37889 fail:
37890 return NULL;
37891 }
37892
37893
37894 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37895 PyObject *resultobj = 0;
37896 wxWindow *arg1 = (wxWindow *) 0 ;
37897 void *argp1 = 0 ;
37898 int res1 = 0 ;
37899 PyObject *swig_obj[1] ;
37900
37901 if (!args) SWIG_fail;
37902 swig_obj[0] = args;
37903 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37904 if (!SWIG_IsOK(res1)) {
37905 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
37906 }
37907 arg1 = reinterpret_cast< wxWindow * >(argp1);
37908 {
37909 PyThreadState* __tstate = wxPyBeginAllowThreads();
37910 (arg1)->Freeze();
37911 wxPyEndAllowThreads(__tstate);
37912 if (PyErr_Occurred()) SWIG_fail;
37913 }
37914 resultobj = SWIG_Py_Void();
37915 return resultobj;
37916 fail:
37917 return NULL;
37918 }
37919
37920
37921 SWIGINTERN PyObject *_wrap_Window_IsFrozen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37922 PyObject *resultobj = 0;
37923 wxWindow *arg1 = (wxWindow *) 0 ;
37924 bool result;
37925 void *argp1 = 0 ;
37926 int res1 = 0 ;
37927 PyObject *swig_obj[1] ;
37928
37929 if (!args) SWIG_fail;
37930 swig_obj[0] = args;
37931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37932 if (!SWIG_IsOK(res1)) {
37933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsFrozen" "', expected argument " "1"" of type '" "wxWindow const *""'");
37934 }
37935 arg1 = reinterpret_cast< wxWindow * >(argp1);
37936 {
37937 PyThreadState* __tstate = wxPyBeginAllowThreads();
37938 result = (bool)((wxWindow const *)arg1)->IsFrozen();
37939 wxPyEndAllowThreads(__tstate);
37940 if (PyErr_Occurred()) SWIG_fail;
37941 }
37942 {
37943 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37944 }
37945 return resultobj;
37946 fail:
37947 return NULL;
37948 }
37949
37950
37951 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37952 PyObject *resultobj = 0;
37953 wxWindow *arg1 = (wxWindow *) 0 ;
37954 void *argp1 = 0 ;
37955 int res1 = 0 ;
37956 PyObject *swig_obj[1] ;
37957
37958 if (!args) SWIG_fail;
37959 swig_obj[0] = args;
37960 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37961 if (!SWIG_IsOK(res1)) {
37962 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
37963 }
37964 arg1 = reinterpret_cast< wxWindow * >(argp1);
37965 {
37966 PyThreadState* __tstate = wxPyBeginAllowThreads();
37967 (arg1)->Thaw();
37968 wxPyEndAllowThreads(__tstate);
37969 if (PyErr_Occurred()) SWIG_fail;
37970 }
37971 resultobj = SWIG_Py_Void();
37972 return resultobj;
37973 fail:
37974 return NULL;
37975 }
37976
37977
37978 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37979 PyObject *resultobj = 0;
37980 wxWindow *arg1 = (wxWindow *) 0 ;
37981 wxDC *arg2 = 0 ;
37982 void *argp1 = 0 ;
37983 int res1 = 0 ;
37984 void *argp2 = 0 ;
37985 int res2 = 0 ;
37986 PyObject * obj0 = 0 ;
37987 PyObject * obj1 = 0 ;
37988 char * kwnames[] = {
37989 (char *) "self",(char *) "dc", NULL
37990 };
37991
37992 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
37993 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37994 if (!SWIG_IsOK(res1)) {
37995 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
37996 }
37997 arg1 = reinterpret_cast< wxWindow * >(argp1);
37998 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
37999 if (!SWIG_IsOK(res2)) {
38000 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38001 }
38002 if (!argp2) {
38003 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
38004 }
38005 arg2 = reinterpret_cast< wxDC * >(argp2);
38006 {
38007 PyThreadState* __tstate = wxPyBeginAllowThreads();
38008 (arg1)->PrepareDC(*arg2);
38009 wxPyEndAllowThreads(__tstate);
38010 if (PyErr_Occurred()) SWIG_fail;
38011 }
38012 resultobj = SWIG_Py_Void();
38013 return resultobj;
38014 fail:
38015 return NULL;
38016 }
38017
38018
38019 SWIGINTERN PyObject *_wrap_Window_IsDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38020 PyObject *resultobj = 0;
38021 wxWindow *arg1 = (wxWindow *) 0 ;
38022 bool result;
38023 void *argp1 = 0 ;
38024 int res1 = 0 ;
38025 PyObject *swig_obj[1] ;
38026
38027 if (!args) SWIG_fail;
38028 swig_obj[0] = args;
38029 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38030 if (!SWIG_IsOK(res1)) {
38031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow const *""'");
38032 }
38033 arg1 = reinterpret_cast< wxWindow * >(argp1);
38034 {
38035 PyThreadState* __tstate = wxPyBeginAllowThreads();
38036 result = (bool)((wxWindow const *)arg1)->IsDoubleBuffered();
38037 wxPyEndAllowThreads(__tstate);
38038 if (PyErr_Occurred()) SWIG_fail;
38039 }
38040 {
38041 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38042 }
38043 return resultobj;
38044 fail:
38045 return NULL;
38046 }
38047
38048
38049 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38050 PyObject *resultobj = 0;
38051 wxWindow *arg1 = (wxWindow *) 0 ;
38052 wxRegion *result = 0 ;
38053 void *argp1 = 0 ;
38054 int res1 = 0 ;
38055 PyObject *swig_obj[1] ;
38056
38057 if (!args) SWIG_fail;
38058 swig_obj[0] = args;
38059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38060 if (!SWIG_IsOK(res1)) {
38061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
38062 }
38063 arg1 = reinterpret_cast< wxWindow * >(argp1);
38064 {
38065 PyThreadState* __tstate = wxPyBeginAllowThreads();
38066 {
38067 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
38068 result = (wxRegion *) &_result_ref;
38069 }
38070 wxPyEndAllowThreads(__tstate);
38071 if (PyErr_Occurred()) SWIG_fail;
38072 }
38073 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
38074 return resultobj;
38075 fail:
38076 return NULL;
38077 }
38078
38079
38080 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38081 PyObject *resultobj = 0;
38082 wxWindow *arg1 = (wxWindow *) 0 ;
38083 wxRect result;
38084 void *argp1 = 0 ;
38085 int res1 = 0 ;
38086 PyObject *swig_obj[1] ;
38087
38088 if (!args) SWIG_fail;
38089 swig_obj[0] = args;
38090 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38091 if (!SWIG_IsOK(res1)) {
38092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38093 }
38094 arg1 = reinterpret_cast< wxWindow * >(argp1);
38095 {
38096 PyThreadState* __tstate = wxPyBeginAllowThreads();
38097 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
38098 wxPyEndAllowThreads(__tstate);
38099 if (PyErr_Occurred()) SWIG_fail;
38100 }
38101 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
38102 return resultobj;
38103 fail:
38104 return NULL;
38105 }
38106
38107
38108 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38109 PyObject *resultobj = 0;
38110 wxWindow *arg1 = (wxWindow *) 0 ;
38111 int arg2 ;
38112 int arg3 ;
38113 int arg4 = (int) 1 ;
38114 int arg5 = (int) 1 ;
38115 bool result;
38116 void *argp1 = 0 ;
38117 int res1 = 0 ;
38118 int val2 ;
38119 int ecode2 = 0 ;
38120 int val3 ;
38121 int ecode3 = 0 ;
38122 int val4 ;
38123 int ecode4 = 0 ;
38124 int val5 ;
38125 int ecode5 = 0 ;
38126 PyObject * obj0 = 0 ;
38127 PyObject * obj1 = 0 ;
38128 PyObject * obj2 = 0 ;
38129 PyObject * obj3 = 0 ;
38130 PyObject * obj4 = 0 ;
38131 char * kwnames[] = {
38132 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
38133 };
38134
38135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38136 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38137 if (!SWIG_IsOK(res1)) {
38138 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
38139 }
38140 arg1 = reinterpret_cast< wxWindow * >(argp1);
38141 ecode2 = SWIG_AsVal_int(obj1, &val2);
38142 if (!SWIG_IsOK(ecode2)) {
38143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
38144 }
38145 arg2 = static_cast< int >(val2);
38146 ecode3 = SWIG_AsVal_int(obj2, &val3);
38147 if (!SWIG_IsOK(ecode3)) {
38148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
38149 }
38150 arg3 = static_cast< int >(val3);
38151 if (obj3) {
38152 ecode4 = SWIG_AsVal_int(obj3, &val4);
38153 if (!SWIG_IsOK(ecode4)) {
38154 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
38155 }
38156 arg4 = static_cast< int >(val4);
38157 }
38158 if (obj4) {
38159 ecode5 = SWIG_AsVal_int(obj4, &val5);
38160 if (!SWIG_IsOK(ecode5)) {
38161 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
38162 }
38163 arg5 = static_cast< int >(val5);
38164 }
38165 {
38166 PyThreadState* __tstate = wxPyBeginAllowThreads();
38167 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
38168 wxPyEndAllowThreads(__tstate);
38169 if (PyErr_Occurred()) SWIG_fail;
38170 }
38171 {
38172 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38173 }
38174 return resultobj;
38175 fail:
38176 return NULL;
38177 }
38178
38179
38180 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38181 PyObject *resultobj = 0;
38182 wxWindow *arg1 = (wxWindow *) 0 ;
38183 wxPoint *arg2 = 0 ;
38184 bool result;
38185 void *argp1 = 0 ;
38186 int res1 = 0 ;
38187 wxPoint temp2 ;
38188 PyObject * obj0 = 0 ;
38189 PyObject * obj1 = 0 ;
38190 char * kwnames[] = {
38191 (char *) "self",(char *) "pt", NULL
38192 };
38193
38194 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
38195 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38196 if (!SWIG_IsOK(res1)) {
38197 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
38198 }
38199 arg1 = reinterpret_cast< wxWindow * >(argp1);
38200 {
38201 arg2 = &temp2;
38202 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
38203 }
38204 {
38205 PyThreadState* __tstate = wxPyBeginAllowThreads();
38206 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
38207 wxPyEndAllowThreads(__tstate);
38208 if (PyErr_Occurred()) SWIG_fail;
38209 }
38210 {
38211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38212 }
38213 return resultobj;
38214 fail:
38215 return NULL;
38216 }
38217
38218
38219 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38220 PyObject *resultobj = 0;
38221 wxWindow *arg1 = (wxWindow *) 0 ;
38222 wxRect *arg2 = 0 ;
38223 bool result;
38224 void *argp1 = 0 ;
38225 int res1 = 0 ;
38226 wxRect temp2 ;
38227 PyObject * obj0 = 0 ;
38228 PyObject * obj1 = 0 ;
38229 char * kwnames[] = {
38230 (char *) "self",(char *) "rect", NULL
38231 };
38232
38233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
38234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38235 if (!SWIG_IsOK(res1)) {
38236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
38237 }
38238 arg1 = reinterpret_cast< wxWindow * >(argp1);
38239 {
38240 arg2 = &temp2;
38241 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
38242 }
38243 {
38244 PyThreadState* __tstate = wxPyBeginAllowThreads();
38245 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
38246 wxPyEndAllowThreads(__tstate);
38247 if (PyErr_Occurred()) SWIG_fail;
38248 }
38249 {
38250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38251 }
38252 return resultobj;
38253 fail:
38254 return NULL;
38255 }
38256
38257
38258 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38259 PyObject *resultobj = 0;
38260 wxWindow *arg1 = (wxWindow *) 0 ;
38261 SwigValueWrapper<wxVisualAttributes > result;
38262 void *argp1 = 0 ;
38263 int res1 = 0 ;
38264 PyObject *swig_obj[1] ;
38265
38266 if (!args) SWIG_fail;
38267 swig_obj[0] = args;
38268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38269 if (!SWIG_IsOK(res1)) {
38270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
38271 }
38272 arg1 = reinterpret_cast< wxWindow * >(argp1);
38273 {
38274 PyThreadState* __tstate = wxPyBeginAllowThreads();
38275 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
38276 wxPyEndAllowThreads(__tstate);
38277 if (PyErr_Occurred()) SWIG_fail;
38278 }
38279 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38280 return resultobj;
38281 fail:
38282 return NULL;
38283 }
38284
38285
38286 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38287 PyObject *resultobj = 0;
38288 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
38289 SwigValueWrapper<wxVisualAttributes > result;
38290 int val1 ;
38291 int ecode1 = 0 ;
38292 PyObject * obj0 = 0 ;
38293 char * kwnames[] = {
38294 (char *) "variant", NULL
38295 };
38296
38297 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
38298 if (obj0) {
38299 ecode1 = SWIG_AsVal_int(obj0, &val1);
38300 if (!SWIG_IsOK(ecode1)) {
38301 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
38302 }
38303 arg1 = static_cast< wxWindowVariant >(val1);
38304 }
38305 {
38306 if (!wxPyCheckForApp()) SWIG_fail;
38307 PyThreadState* __tstate = wxPyBeginAllowThreads();
38308 result = wxWindow::GetClassDefaultAttributes(arg1);
38309 wxPyEndAllowThreads(__tstate);
38310 if (PyErr_Occurred()) SWIG_fail;
38311 }
38312 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
38313 return resultobj;
38314 fail:
38315 return NULL;
38316 }
38317
38318
38319 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38320 PyObject *resultobj = 0;
38321 wxWindow *arg1 = (wxWindow *) 0 ;
38322 wxColour *arg2 = 0 ;
38323 bool result;
38324 void *argp1 = 0 ;
38325 int res1 = 0 ;
38326 wxColour temp2 ;
38327 PyObject * obj0 = 0 ;
38328 PyObject * obj1 = 0 ;
38329 char * kwnames[] = {
38330 (char *) "self",(char *) "colour", NULL
38331 };
38332
38333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38335 if (!SWIG_IsOK(res1)) {
38336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38337 }
38338 arg1 = reinterpret_cast< wxWindow * >(argp1);
38339 {
38340 arg2 = &temp2;
38341 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38342 }
38343 {
38344 PyThreadState* __tstate = wxPyBeginAllowThreads();
38345 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
38346 wxPyEndAllowThreads(__tstate);
38347 if (PyErr_Occurred()) SWIG_fail;
38348 }
38349 {
38350 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38351 }
38352 return resultobj;
38353 fail:
38354 return NULL;
38355 }
38356
38357
38358 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38359 PyObject *resultobj = 0;
38360 wxWindow *arg1 = (wxWindow *) 0 ;
38361 wxColour *arg2 = 0 ;
38362 void *argp1 = 0 ;
38363 int res1 = 0 ;
38364 wxColour temp2 ;
38365 PyObject * obj0 = 0 ;
38366 PyObject * obj1 = 0 ;
38367 char * kwnames[] = {
38368 (char *) "self",(char *) "colour", NULL
38369 };
38370
38371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38373 if (!SWIG_IsOK(res1)) {
38374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38375 }
38376 arg1 = reinterpret_cast< wxWindow * >(argp1);
38377 {
38378 arg2 = &temp2;
38379 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38380 }
38381 {
38382 PyThreadState* __tstate = wxPyBeginAllowThreads();
38383 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
38384 wxPyEndAllowThreads(__tstate);
38385 if (PyErr_Occurred()) SWIG_fail;
38386 }
38387 resultobj = SWIG_Py_Void();
38388 return resultobj;
38389 fail:
38390 return NULL;
38391 }
38392
38393
38394 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38395 PyObject *resultobj = 0;
38396 wxWindow *arg1 = (wxWindow *) 0 ;
38397 wxColour *arg2 = 0 ;
38398 bool result;
38399 void *argp1 = 0 ;
38400 int res1 = 0 ;
38401 wxColour temp2 ;
38402 PyObject * obj0 = 0 ;
38403 PyObject * obj1 = 0 ;
38404 char * kwnames[] = {
38405 (char *) "self",(char *) "colour", NULL
38406 };
38407
38408 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38409 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38410 if (!SWIG_IsOK(res1)) {
38411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38412 }
38413 arg1 = reinterpret_cast< wxWindow * >(argp1);
38414 {
38415 arg2 = &temp2;
38416 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38417 }
38418 {
38419 PyThreadState* __tstate = wxPyBeginAllowThreads();
38420 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
38421 wxPyEndAllowThreads(__tstate);
38422 if (PyErr_Occurred()) SWIG_fail;
38423 }
38424 {
38425 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38426 }
38427 return resultobj;
38428 fail:
38429 return NULL;
38430 }
38431
38432
38433 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38434 PyObject *resultobj = 0;
38435 wxWindow *arg1 = (wxWindow *) 0 ;
38436 wxColour *arg2 = 0 ;
38437 void *argp1 = 0 ;
38438 int res1 = 0 ;
38439 wxColour temp2 ;
38440 PyObject * obj0 = 0 ;
38441 PyObject * obj1 = 0 ;
38442 char * kwnames[] = {
38443 (char *) "self",(char *) "colour", NULL
38444 };
38445
38446 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
38447 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38448 if (!SWIG_IsOK(res1)) {
38449 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
38450 }
38451 arg1 = reinterpret_cast< wxWindow * >(argp1);
38452 {
38453 arg2 = &temp2;
38454 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
38455 }
38456 {
38457 PyThreadState* __tstate = wxPyBeginAllowThreads();
38458 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
38459 wxPyEndAllowThreads(__tstate);
38460 if (PyErr_Occurred()) SWIG_fail;
38461 }
38462 resultobj = SWIG_Py_Void();
38463 return resultobj;
38464 fail:
38465 return NULL;
38466 }
38467
38468
38469 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38470 PyObject *resultobj = 0;
38471 wxWindow *arg1 = (wxWindow *) 0 ;
38472 wxColour result;
38473 void *argp1 = 0 ;
38474 int res1 = 0 ;
38475 PyObject *swig_obj[1] ;
38476
38477 if (!args) SWIG_fail;
38478 swig_obj[0] = args;
38479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38480 if (!SWIG_IsOK(res1)) {
38481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38482 }
38483 arg1 = reinterpret_cast< wxWindow * >(argp1);
38484 {
38485 PyThreadState* __tstate = wxPyBeginAllowThreads();
38486 result = ((wxWindow const *)arg1)->GetBackgroundColour();
38487 wxPyEndAllowThreads(__tstate);
38488 if (PyErr_Occurred()) SWIG_fail;
38489 }
38490 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38491 return resultobj;
38492 fail:
38493 return NULL;
38494 }
38495
38496
38497 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38498 PyObject *resultobj = 0;
38499 wxWindow *arg1 = (wxWindow *) 0 ;
38500 wxColour result;
38501 void *argp1 = 0 ;
38502 int res1 = 0 ;
38503 PyObject *swig_obj[1] ;
38504
38505 if (!args) SWIG_fail;
38506 swig_obj[0] = args;
38507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38508 if (!SWIG_IsOK(res1)) {
38509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38510 }
38511 arg1 = reinterpret_cast< wxWindow * >(argp1);
38512 {
38513 PyThreadState* __tstate = wxPyBeginAllowThreads();
38514 result = ((wxWindow const *)arg1)->GetForegroundColour();
38515 wxPyEndAllowThreads(__tstate);
38516 if (PyErr_Occurred()) SWIG_fail;
38517 }
38518 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
38519 return resultobj;
38520 fail:
38521 return NULL;
38522 }
38523
38524
38525 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38526 PyObject *resultobj = 0;
38527 wxWindow *arg1 = (wxWindow *) 0 ;
38528 bool result;
38529 void *argp1 = 0 ;
38530 int res1 = 0 ;
38531 PyObject *swig_obj[1] ;
38532
38533 if (!args) SWIG_fail;
38534 swig_obj[0] = args;
38535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38536 if (!SWIG_IsOK(res1)) {
38537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
38538 }
38539 arg1 = reinterpret_cast< wxWindow * >(argp1);
38540 {
38541 PyThreadState* __tstate = wxPyBeginAllowThreads();
38542 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
38543 wxPyEndAllowThreads(__tstate);
38544 if (PyErr_Occurred()) SWIG_fail;
38545 }
38546 {
38547 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38548 }
38549 return resultobj;
38550 fail:
38551 return NULL;
38552 }
38553
38554
38555 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38556 PyObject *resultobj = 0;
38557 wxWindow *arg1 = (wxWindow *) 0 ;
38558 bool result;
38559 void *argp1 = 0 ;
38560 int res1 = 0 ;
38561 PyObject *swig_obj[1] ;
38562
38563 if (!args) SWIG_fail;
38564 swig_obj[0] = args;
38565 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38566 if (!SWIG_IsOK(res1)) {
38567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
38568 }
38569 arg1 = reinterpret_cast< wxWindow * >(argp1);
38570 {
38571 PyThreadState* __tstate = wxPyBeginAllowThreads();
38572 result = (bool)((wxWindow const *)arg1)->UseBgCol();
38573 wxPyEndAllowThreads(__tstate);
38574 if (PyErr_Occurred()) SWIG_fail;
38575 }
38576 {
38577 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38578 }
38579 return resultobj;
38580 fail:
38581 return NULL;
38582 }
38583
38584
38585 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38586 PyObject *resultobj = 0;
38587 wxWindow *arg1 = (wxWindow *) 0 ;
38588 wxBackgroundStyle arg2 ;
38589 bool result;
38590 void *argp1 = 0 ;
38591 int res1 = 0 ;
38592 int val2 ;
38593 int ecode2 = 0 ;
38594 PyObject * obj0 = 0 ;
38595 PyObject * obj1 = 0 ;
38596 char * kwnames[] = {
38597 (char *) "self",(char *) "style", NULL
38598 };
38599
38600 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
38601 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38602 if (!SWIG_IsOK(res1)) {
38603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
38604 }
38605 arg1 = reinterpret_cast< wxWindow * >(argp1);
38606 ecode2 = SWIG_AsVal_int(obj1, &val2);
38607 if (!SWIG_IsOK(ecode2)) {
38608 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
38609 }
38610 arg2 = static_cast< wxBackgroundStyle >(val2);
38611 {
38612 PyThreadState* __tstate = wxPyBeginAllowThreads();
38613 result = (bool)(arg1)->SetBackgroundStyle(arg2);
38614 wxPyEndAllowThreads(__tstate);
38615 if (PyErr_Occurred()) SWIG_fail;
38616 }
38617 {
38618 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38619 }
38620 return resultobj;
38621 fail:
38622 return NULL;
38623 }
38624
38625
38626 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38627 PyObject *resultobj = 0;
38628 wxWindow *arg1 = (wxWindow *) 0 ;
38629 wxBackgroundStyle result;
38630 void *argp1 = 0 ;
38631 int res1 = 0 ;
38632 PyObject *swig_obj[1] ;
38633
38634 if (!args) SWIG_fail;
38635 swig_obj[0] = args;
38636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38637 if (!SWIG_IsOK(res1)) {
38638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
38639 }
38640 arg1 = reinterpret_cast< wxWindow * >(argp1);
38641 {
38642 PyThreadState* __tstate = wxPyBeginAllowThreads();
38643 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
38644 wxPyEndAllowThreads(__tstate);
38645 if (PyErr_Occurred()) SWIG_fail;
38646 }
38647 resultobj = SWIG_From_int(static_cast< int >(result));
38648 return resultobj;
38649 fail:
38650 return NULL;
38651 }
38652
38653
38654 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38655 PyObject *resultobj = 0;
38656 wxWindow *arg1 = (wxWindow *) 0 ;
38657 bool result;
38658 void *argp1 = 0 ;
38659 int res1 = 0 ;
38660 PyObject *swig_obj[1] ;
38661
38662 if (!args) SWIG_fail;
38663 swig_obj[0] = args;
38664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38665 if (!SWIG_IsOK(res1)) {
38666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
38667 }
38668 arg1 = reinterpret_cast< wxWindow * >(argp1);
38669 {
38670 PyThreadState* __tstate = wxPyBeginAllowThreads();
38671 result = (bool)(arg1)->HasTransparentBackground();
38672 wxPyEndAllowThreads(__tstate);
38673 if (PyErr_Occurred()) SWIG_fail;
38674 }
38675 {
38676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38677 }
38678 return resultobj;
38679 fail:
38680 return NULL;
38681 }
38682
38683
38684 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38685 PyObject *resultobj = 0;
38686 wxWindow *arg1 = (wxWindow *) 0 ;
38687 wxCursor *arg2 = 0 ;
38688 bool result;
38689 void *argp1 = 0 ;
38690 int res1 = 0 ;
38691 void *argp2 = 0 ;
38692 int res2 = 0 ;
38693 PyObject * obj0 = 0 ;
38694 PyObject * obj1 = 0 ;
38695 char * kwnames[] = {
38696 (char *) "self",(char *) "cursor", NULL
38697 };
38698
38699 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
38700 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38701 if (!SWIG_IsOK(res1)) {
38702 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38703 }
38704 arg1 = reinterpret_cast< wxWindow * >(argp1);
38705 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
38706 if (!SWIG_IsOK(res2)) {
38707 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38708 }
38709 if (!argp2) {
38710 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
38711 }
38712 arg2 = reinterpret_cast< wxCursor * >(argp2);
38713 {
38714 PyThreadState* __tstate = wxPyBeginAllowThreads();
38715 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
38716 wxPyEndAllowThreads(__tstate);
38717 if (PyErr_Occurred()) SWIG_fail;
38718 }
38719 {
38720 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38721 }
38722 return resultobj;
38723 fail:
38724 return NULL;
38725 }
38726
38727
38728 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38729 PyObject *resultobj = 0;
38730 wxWindow *arg1 = (wxWindow *) 0 ;
38731 wxCursor result;
38732 void *argp1 = 0 ;
38733 int res1 = 0 ;
38734 PyObject *swig_obj[1] ;
38735
38736 if (!args) SWIG_fail;
38737 swig_obj[0] = args;
38738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38739 if (!SWIG_IsOK(res1)) {
38740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
38741 }
38742 arg1 = reinterpret_cast< wxWindow * >(argp1);
38743 {
38744 PyThreadState* __tstate = wxPyBeginAllowThreads();
38745 result = (arg1)->GetCursor();
38746 wxPyEndAllowThreads(__tstate);
38747 if (PyErr_Occurred()) SWIG_fail;
38748 }
38749 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
38750 return resultobj;
38751 fail:
38752 return NULL;
38753 }
38754
38755
38756 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38757 PyObject *resultobj = 0;
38758 wxWindow *arg1 = (wxWindow *) 0 ;
38759 wxFont *arg2 = 0 ;
38760 bool result;
38761 void *argp1 = 0 ;
38762 int res1 = 0 ;
38763 void *argp2 = 0 ;
38764 int res2 = 0 ;
38765 PyObject * obj0 = 0 ;
38766 PyObject * obj1 = 0 ;
38767 char * kwnames[] = {
38768 (char *) "self",(char *) "font", NULL
38769 };
38770
38771 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
38772 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38773 if (!SWIG_IsOK(res1)) {
38774 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38775 }
38776 arg1 = reinterpret_cast< wxWindow * >(argp1);
38777 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38778 if (!SWIG_IsOK(res2)) {
38779 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38780 }
38781 if (!argp2) {
38782 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38783 }
38784 arg2 = reinterpret_cast< wxFont * >(argp2);
38785 {
38786 PyThreadState* __tstate = wxPyBeginAllowThreads();
38787 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
38788 wxPyEndAllowThreads(__tstate);
38789 if (PyErr_Occurred()) SWIG_fail;
38790 }
38791 {
38792 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38793 }
38794 return resultobj;
38795 fail:
38796 return NULL;
38797 }
38798
38799
38800 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38801 PyObject *resultobj = 0;
38802 wxWindow *arg1 = (wxWindow *) 0 ;
38803 wxFont *arg2 = 0 ;
38804 void *argp1 = 0 ;
38805 int res1 = 0 ;
38806 void *argp2 = 0 ;
38807 int res2 = 0 ;
38808 PyObject * obj0 = 0 ;
38809 PyObject * obj1 = 0 ;
38810 char * kwnames[] = {
38811 (char *) "self",(char *) "font", NULL
38812 };
38813
38814 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
38815 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38816 if (!SWIG_IsOK(res1)) {
38817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38818 }
38819 arg1 = reinterpret_cast< wxWindow * >(argp1);
38820 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
38821 if (!SWIG_IsOK(res2)) {
38822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38823 }
38824 if (!argp2) {
38825 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
38826 }
38827 arg2 = reinterpret_cast< wxFont * >(argp2);
38828 {
38829 PyThreadState* __tstate = wxPyBeginAllowThreads();
38830 (arg1)->SetOwnFont((wxFont const &)*arg2);
38831 wxPyEndAllowThreads(__tstate);
38832 if (PyErr_Occurred()) SWIG_fail;
38833 }
38834 resultobj = SWIG_Py_Void();
38835 return resultobj;
38836 fail:
38837 return NULL;
38838 }
38839
38840
38841 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38842 PyObject *resultobj = 0;
38843 wxWindow *arg1 = (wxWindow *) 0 ;
38844 wxFont result;
38845 void *argp1 = 0 ;
38846 int res1 = 0 ;
38847 PyObject *swig_obj[1] ;
38848
38849 if (!args) SWIG_fail;
38850 swig_obj[0] = args;
38851 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38852 if (!SWIG_IsOK(res1)) {
38853 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
38854 }
38855 arg1 = reinterpret_cast< wxWindow * >(argp1);
38856 {
38857 PyThreadState* __tstate = wxPyBeginAllowThreads();
38858 result = (arg1)->GetFont();
38859 wxPyEndAllowThreads(__tstate);
38860 if (PyErr_Occurred()) SWIG_fail;
38861 }
38862 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
38863 return resultobj;
38864 fail:
38865 return NULL;
38866 }
38867
38868
38869 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38870 PyObject *resultobj = 0;
38871 wxWindow *arg1 = (wxWindow *) 0 ;
38872 wxCaret *arg2 = (wxCaret *) 0 ;
38873 void *argp1 = 0 ;
38874 int res1 = 0 ;
38875 int res2 = 0 ;
38876 PyObject * obj0 = 0 ;
38877 PyObject * obj1 = 0 ;
38878 char * kwnames[] = {
38879 (char *) "self",(char *) "caret", NULL
38880 };
38881
38882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
38883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38884 if (!SWIG_IsOK(res1)) {
38885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
38886 }
38887 arg1 = reinterpret_cast< wxWindow * >(argp1);
38888 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
38889 if (!SWIG_IsOK(res2)) {
38890 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
38891 }
38892 {
38893 PyThreadState* __tstate = wxPyBeginAllowThreads();
38894 (arg1)->SetCaret(arg2);
38895 wxPyEndAllowThreads(__tstate);
38896 if (PyErr_Occurred()) SWIG_fail;
38897 }
38898 resultobj = SWIG_Py_Void();
38899 return resultobj;
38900 fail:
38901 return NULL;
38902 }
38903
38904
38905 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38906 PyObject *resultobj = 0;
38907 wxWindow *arg1 = (wxWindow *) 0 ;
38908 wxCaret *result = 0 ;
38909 void *argp1 = 0 ;
38910 int res1 = 0 ;
38911 PyObject *swig_obj[1] ;
38912
38913 if (!args) SWIG_fail;
38914 swig_obj[0] = args;
38915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38916 if (!SWIG_IsOK(res1)) {
38917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
38918 }
38919 arg1 = reinterpret_cast< wxWindow * >(argp1);
38920 {
38921 PyThreadState* __tstate = wxPyBeginAllowThreads();
38922 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
38923 wxPyEndAllowThreads(__tstate);
38924 if (PyErr_Occurred()) SWIG_fail;
38925 }
38926 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
38927 return resultobj;
38928 fail:
38929 return NULL;
38930 }
38931
38932
38933 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38934 PyObject *resultobj = 0;
38935 wxWindow *arg1 = (wxWindow *) 0 ;
38936 int result;
38937 void *argp1 = 0 ;
38938 int res1 = 0 ;
38939 PyObject *swig_obj[1] ;
38940
38941 if (!args) SWIG_fail;
38942 swig_obj[0] = args;
38943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38944 if (!SWIG_IsOK(res1)) {
38945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
38946 }
38947 arg1 = reinterpret_cast< wxWindow * >(argp1);
38948 {
38949 PyThreadState* __tstate = wxPyBeginAllowThreads();
38950 result = (int)((wxWindow const *)arg1)->GetCharHeight();
38951 wxPyEndAllowThreads(__tstate);
38952 if (PyErr_Occurred()) SWIG_fail;
38953 }
38954 resultobj = SWIG_From_int(static_cast< int >(result));
38955 return resultobj;
38956 fail:
38957 return NULL;
38958 }
38959
38960
38961 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38962 PyObject *resultobj = 0;
38963 wxWindow *arg1 = (wxWindow *) 0 ;
38964 int result;
38965 void *argp1 = 0 ;
38966 int res1 = 0 ;
38967 PyObject *swig_obj[1] ;
38968
38969 if (!args) SWIG_fail;
38970 swig_obj[0] = args;
38971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
38972 if (!SWIG_IsOK(res1)) {
38973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
38974 }
38975 arg1 = reinterpret_cast< wxWindow * >(argp1);
38976 {
38977 PyThreadState* __tstate = wxPyBeginAllowThreads();
38978 result = (int)((wxWindow const *)arg1)->GetCharWidth();
38979 wxPyEndAllowThreads(__tstate);
38980 if (PyErr_Occurred()) SWIG_fail;
38981 }
38982 resultobj = SWIG_From_int(static_cast< int >(result));
38983 return resultobj;
38984 fail:
38985 return NULL;
38986 }
38987
38988
38989 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38990 PyObject *resultobj = 0;
38991 wxWindow *arg1 = (wxWindow *) 0 ;
38992 wxString *arg2 = 0 ;
38993 int *arg3 = (int *) 0 ;
38994 int *arg4 = (int *) 0 ;
38995 void *argp1 = 0 ;
38996 int res1 = 0 ;
38997 bool temp2 = false ;
38998 int temp3 ;
38999 int res3 = SWIG_TMPOBJ ;
39000 int temp4 ;
39001 int res4 = SWIG_TMPOBJ ;
39002 PyObject * obj0 = 0 ;
39003 PyObject * obj1 = 0 ;
39004 char * kwnames[] = {
39005 (char *) "self",(char *) "string", NULL
39006 };
39007
39008 arg3 = &temp3;
39009 arg4 = &temp4;
39010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
39011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39012 if (!SWIG_IsOK(res1)) {
39013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39014 }
39015 arg1 = reinterpret_cast< wxWindow * >(argp1);
39016 {
39017 arg2 = wxString_in_helper(obj1);
39018 if (arg2 == NULL) SWIG_fail;
39019 temp2 = true;
39020 }
39021 {
39022 PyThreadState* __tstate = wxPyBeginAllowThreads();
39023 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
39024 wxPyEndAllowThreads(__tstate);
39025 if (PyErr_Occurred()) SWIG_fail;
39026 }
39027 resultobj = SWIG_Py_Void();
39028 if (SWIG_IsTmpObj(res3)) {
39029 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39030 } else {
39031 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39032 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39033 }
39034 if (SWIG_IsTmpObj(res4)) {
39035 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39036 } else {
39037 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39038 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39039 }
39040 {
39041 if (temp2)
39042 delete arg2;
39043 }
39044 return resultobj;
39045 fail:
39046 {
39047 if (temp2)
39048 delete arg2;
39049 }
39050 return NULL;
39051 }
39052
39053
39054 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39055 PyObject *resultobj = 0;
39056 wxWindow *arg1 = (wxWindow *) 0 ;
39057 wxString *arg2 = 0 ;
39058 int *arg3 = (int *) 0 ;
39059 int *arg4 = (int *) 0 ;
39060 int *arg5 = (int *) 0 ;
39061 int *arg6 = (int *) 0 ;
39062 wxFont *arg7 = (wxFont *) NULL ;
39063 void *argp1 = 0 ;
39064 int res1 = 0 ;
39065 bool temp2 = false ;
39066 int temp3 ;
39067 int res3 = SWIG_TMPOBJ ;
39068 int temp4 ;
39069 int res4 = SWIG_TMPOBJ ;
39070 int temp5 ;
39071 int res5 = SWIG_TMPOBJ ;
39072 int temp6 ;
39073 int res6 = SWIG_TMPOBJ ;
39074 void *argp7 = 0 ;
39075 int res7 = 0 ;
39076 PyObject * obj0 = 0 ;
39077 PyObject * obj1 = 0 ;
39078 PyObject * obj2 = 0 ;
39079 char * kwnames[] = {
39080 (char *) "self",(char *) "string",(char *) "font", NULL
39081 };
39082
39083 arg3 = &temp3;
39084 arg4 = &temp4;
39085 arg5 = &temp5;
39086 arg6 = &temp6;
39087 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39088 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39089 if (!SWIG_IsOK(res1)) {
39090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
39091 }
39092 arg1 = reinterpret_cast< wxWindow * >(argp1);
39093 {
39094 arg2 = wxString_in_helper(obj1);
39095 if (arg2 == NULL) SWIG_fail;
39096 temp2 = true;
39097 }
39098 if (obj2) {
39099 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
39100 if (!SWIG_IsOK(res7)) {
39101 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
39102 }
39103 arg7 = reinterpret_cast< wxFont * >(argp7);
39104 }
39105 {
39106 PyThreadState* __tstate = wxPyBeginAllowThreads();
39107 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
39108 wxPyEndAllowThreads(__tstate);
39109 if (PyErr_Occurred()) SWIG_fail;
39110 }
39111 resultobj = SWIG_Py_Void();
39112 if (SWIG_IsTmpObj(res3)) {
39113 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39114 } else {
39115 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39116 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39117 }
39118 if (SWIG_IsTmpObj(res4)) {
39119 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
39120 } else {
39121 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39122 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
39123 }
39124 if (SWIG_IsTmpObj(res5)) {
39125 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
39126 } else {
39127 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39128 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
39129 }
39130 if (SWIG_IsTmpObj(res6)) {
39131 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
39132 } else {
39133 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39134 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
39135 }
39136 {
39137 if (temp2)
39138 delete arg2;
39139 }
39140 return resultobj;
39141 fail:
39142 {
39143 if (temp2)
39144 delete arg2;
39145 }
39146 return NULL;
39147 }
39148
39149
39150 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39151 PyObject *resultobj = 0;
39152 wxWindow *arg1 = (wxWindow *) 0 ;
39153 int *arg2 = (int *) 0 ;
39154 int *arg3 = (int *) 0 ;
39155 void *argp1 = 0 ;
39156 int res1 = 0 ;
39157 int temp2 ;
39158 int res2 = 0 ;
39159 int temp3 ;
39160 int res3 = 0 ;
39161 PyObject * obj0 = 0 ;
39162 PyObject * obj1 = 0 ;
39163 PyObject * obj2 = 0 ;
39164 char * kwnames[] = {
39165 (char *) "self",(char *) "x",(char *) "y", NULL
39166 };
39167
39168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39170 if (!SWIG_IsOK(res1)) {
39171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39172 }
39173 arg1 = reinterpret_cast< wxWindow * >(argp1);
39174 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39175 int val;
39176 int ecode = SWIG_AsVal_int(obj1, &val);
39177 if (!SWIG_IsOK(ecode)) {
39178 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
39179 }
39180 temp2 = static_cast< int >(val);
39181 arg2 = &temp2;
39182 res2 = SWIG_AddTmpMask(ecode);
39183 }
39184 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39185 int val;
39186 int ecode = SWIG_AsVal_int(obj2, &val);
39187 if (!SWIG_IsOK(ecode)) {
39188 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
39189 }
39190 temp3 = static_cast< int >(val);
39191 arg3 = &temp3;
39192 res3 = SWIG_AddTmpMask(ecode);
39193 }
39194 {
39195 PyThreadState* __tstate = wxPyBeginAllowThreads();
39196 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
39197 wxPyEndAllowThreads(__tstate);
39198 if (PyErr_Occurred()) SWIG_fail;
39199 }
39200 resultobj = SWIG_Py_Void();
39201 if (SWIG_IsTmpObj(res2)) {
39202 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39203 } else {
39204 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39205 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39206 }
39207 if (SWIG_IsTmpObj(res3)) {
39208 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39209 } else {
39210 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39211 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39212 }
39213 return resultobj;
39214 fail:
39215 return NULL;
39216 }
39217
39218
39219 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39220 PyObject *resultobj = 0;
39221 wxWindow *arg1 = (wxWindow *) 0 ;
39222 int *arg2 = (int *) 0 ;
39223 int *arg3 = (int *) 0 ;
39224 void *argp1 = 0 ;
39225 int res1 = 0 ;
39226 int temp2 ;
39227 int res2 = 0 ;
39228 int temp3 ;
39229 int res3 = 0 ;
39230 PyObject * obj0 = 0 ;
39231 PyObject * obj1 = 0 ;
39232 PyObject * obj2 = 0 ;
39233 char * kwnames[] = {
39234 (char *) "self",(char *) "x",(char *) "y", NULL
39235 };
39236
39237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39239 if (!SWIG_IsOK(res1)) {
39240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39241 }
39242 arg1 = reinterpret_cast< wxWindow * >(argp1);
39243 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
39244 int val;
39245 int ecode = SWIG_AsVal_int(obj1, &val);
39246 if (!SWIG_IsOK(ecode)) {
39247 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
39248 }
39249 temp2 = static_cast< int >(val);
39250 arg2 = &temp2;
39251 res2 = SWIG_AddTmpMask(ecode);
39252 }
39253 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
39254 int val;
39255 int ecode = SWIG_AsVal_int(obj2, &val);
39256 if (!SWIG_IsOK(ecode)) {
39257 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
39258 }
39259 temp3 = static_cast< int >(val);
39260 arg3 = &temp3;
39261 res3 = SWIG_AddTmpMask(ecode);
39262 }
39263 {
39264 PyThreadState* __tstate = wxPyBeginAllowThreads();
39265 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
39266 wxPyEndAllowThreads(__tstate);
39267 if (PyErr_Occurred()) SWIG_fail;
39268 }
39269 resultobj = SWIG_Py_Void();
39270 if (SWIG_IsTmpObj(res2)) {
39271 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
39272 } else {
39273 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39274 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
39275 }
39276 if (SWIG_IsTmpObj(res3)) {
39277 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
39278 } else {
39279 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
39280 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
39281 }
39282 return resultobj;
39283 fail:
39284 return NULL;
39285 }
39286
39287
39288 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39289 PyObject *resultobj = 0;
39290 wxWindow *arg1 = (wxWindow *) 0 ;
39291 wxPoint *arg2 = 0 ;
39292 wxPoint result;
39293 void *argp1 = 0 ;
39294 int res1 = 0 ;
39295 wxPoint temp2 ;
39296 PyObject * obj0 = 0 ;
39297 PyObject * obj1 = 0 ;
39298 char * kwnames[] = {
39299 (char *) "self",(char *) "pt", NULL
39300 };
39301
39302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
39303 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39304 if (!SWIG_IsOK(res1)) {
39305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
39306 }
39307 arg1 = reinterpret_cast< wxWindow * >(argp1);
39308 {
39309 arg2 = &temp2;
39310 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39311 }
39312 {
39313 PyThreadState* __tstate = wxPyBeginAllowThreads();
39314 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
39315 wxPyEndAllowThreads(__tstate);
39316 if (PyErr_Occurred()) SWIG_fail;
39317 }
39318 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39319 return resultobj;
39320 fail:
39321 return NULL;
39322 }
39323
39324
39325 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39326 PyObject *resultobj = 0;
39327 wxWindow *arg1 = (wxWindow *) 0 ;
39328 wxPoint *arg2 = 0 ;
39329 wxPoint result;
39330 void *argp1 = 0 ;
39331 int res1 = 0 ;
39332 wxPoint temp2 ;
39333 PyObject * obj0 = 0 ;
39334 PyObject * obj1 = 0 ;
39335 char * kwnames[] = {
39336 (char *) "self",(char *) "pt", NULL
39337 };
39338
39339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
39340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39341 if (!SWIG_IsOK(res1)) {
39342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
39343 }
39344 arg1 = reinterpret_cast< wxWindow * >(argp1);
39345 {
39346 arg2 = &temp2;
39347 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39348 }
39349 {
39350 PyThreadState* __tstate = wxPyBeginAllowThreads();
39351 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
39352 wxPyEndAllowThreads(__tstate);
39353 if (PyErr_Occurred()) SWIG_fail;
39354 }
39355 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
39356 return resultobj;
39357 fail:
39358 return NULL;
39359 }
39360
39361
39362 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39363 PyObject *resultobj = 0;
39364 wxWindow *arg1 = (wxWindow *) 0 ;
39365 int arg2 ;
39366 int arg3 ;
39367 wxHitTest result;
39368 void *argp1 = 0 ;
39369 int res1 = 0 ;
39370 int val2 ;
39371 int ecode2 = 0 ;
39372 int val3 ;
39373 int ecode3 = 0 ;
39374 PyObject * obj0 = 0 ;
39375 PyObject * obj1 = 0 ;
39376 PyObject * obj2 = 0 ;
39377 char * kwnames[] = {
39378 (char *) "self",(char *) "x",(char *) "y", NULL
39379 };
39380
39381 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39382 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39383 if (!SWIG_IsOK(res1)) {
39384 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
39385 }
39386 arg1 = reinterpret_cast< wxWindow * >(argp1);
39387 ecode2 = SWIG_AsVal_int(obj1, &val2);
39388 if (!SWIG_IsOK(ecode2)) {
39389 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
39390 }
39391 arg2 = static_cast< int >(val2);
39392 ecode3 = SWIG_AsVal_int(obj2, &val3);
39393 if (!SWIG_IsOK(ecode3)) {
39394 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
39395 }
39396 arg3 = static_cast< int >(val3);
39397 {
39398 PyThreadState* __tstate = wxPyBeginAllowThreads();
39399 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
39400 wxPyEndAllowThreads(__tstate);
39401 if (PyErr_Occurred()) SWIG_fail;
39402 }
39403 resultobj = SWIG_From_int(static_cast< int >(result));
39404 return resultobj;
39405 fail:
39406 return NULL;
39407 }
39408
39409
39410 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39411 PyObject *resultobj = 0;
39412 wxWindow *arg1 = (wxWindow *) 0 ;
39413 wxPoint *arg2 = 0 ;
39414 wxHitTest result;
39415 void *argp1 = 0 ;
39416 int res1 = 0 ;
39417 wxPoint temp2 ;
39418 PyObject * obj0 = 0 ;
39419 PyObject * obj1 = 0 ;
39420 char * kwnames[] = {
39421 (char *) "self",(char *) "pt", NULL
39422 };
39423
39424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
39425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39426 if (!SWIG_IsOK(res1)) {
39427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
39428 }
39429 arg1 = reinterpret_cast< wxWindow * >(argp1);
39430 {
39431 arg2 = &temp2;
39432 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
39433 }
39434 {
39435 PyThreadState* __tstate = wxPyBeginAllowThreads();
39436 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
39437 wxPyEndAllowThreads(__tstate);
39438 if (PyErr_Occurred()) SWIG_fail;
39439 }
39440 resultobj = SWIG_From_int(static_cast< int >(result));
39441 return resultobj;
39442 fail:
39443 return NULL;
39444 }
39445
39446
39447 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39448 PyObject *resultobj = 0;
39449 wxWindow *arg1 = (wxWindow *) 0 ;
39450 long arg2 ;
39451 wxBorder result;
39452 void *argp1 = 0 ;
39453 int res1 = 0 ;
39454 long val2 ;
39455 int ecode2 = 0 ;
39456
39457 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
39458 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39459 if (!SWIG_IsOK(res1)) {
39460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39461 }
39462 arg1 = reinterpret_cast< wxWindow * >(argp1);
39463 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
39464 if (!SWIG_IsOK(ecode2)) {
39465 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
39466 }
39467 arg2 = static_cast< long >(val2);
39468 {
39469 PyThreadState* __tstate = wxPyBeginAllowThreads();
39470 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
39471 wxPyEndAllowThreads(__tstate);
39472 if (PyErr_Occurred()) SWIG_fail;
39473 }
39474 resultobj = SWIG_From_int(static_cast< int >(result));
39475 return resultobj;
39476 fail:
39477 return NULL;
39478 }
39479
39480
39481 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
39482 PyObject *resultobj = 0;
39483 wxWindow *arg1 = (wxWindow *) 0 ;
39484 wxBorder result;
39485 void *argp1 = 0 ;
39486 int res1 = 0 ;
39487
39488 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
39489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39490 if (!SWIG_IsOK(res1)) {
39491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
39492 }
39493 arg1 = reinterpret_cast< wxWindow * >(argp1);
39494 {
39495 PyThreadState* __tstate = wxPyBeginAllowThreads();
39496 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
39497 wxPyEndAllowThreads(__tstate);
39498 if (PyErr_Occurred()) SWIG_fail;
39499 }
39500 resultobj = SWIG_From_int(static_cast< int >(result));
39501 return resultobj;
39502 fail:
39503 return NULL;
39504 }
39505
39506
39507 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
39508 int argc;
39509 PyObject *argv[3];
39510
39511 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
39512 --argc;
39513 if (argc == 1) {
39514 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
39515 }
39516 if (argc == 2) {
39517 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
39518 }
39519
39520 fail:
39521 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
39522 return NULL;
39523 }
39524
39525
39526 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39527 PyObject *resultobj = 0;
39528 wxWindow *arg1 = (wxWindow *) 0 ;
39529 long arg2 = (long) wxUPDATE_UI_NONE ;
39530 void *argp1 = 0 ;
39531 int res1 = 0 ;
39532 long val2 ;
39533 int ecode2 = 0 ;
39534 PyObject * obj0 = 0 ;
39535 PyObject * obj1 = 0 ;
39536 char * kwnames[] = {
39537 (char *) "self",(char *) "flags", NULL
39538 };
39539
39540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
39541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39542 if (!SWIG_IsOK(res1)) {
39543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
39544 }
39545 arg1 = reinterpret_cast< wxWindow * >(argp1);
39546 if (obj1) {
39547 ecode2 = SWIG_AsVal_long(obj1, &val2);
39548 if (!SWIG_IsOK(ecode2)) {
39549 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
39550 }
39551 arg2 = static_cast< long >(val2);
39552 }
39553 {
39554 PyThreadState* __tstate = wxPyBeginAllowThreads();
39555 (arg1)->UpdateWindowUI(arg2);
39556 wxPyEndAllowThreads(__tstate);
39557 if (PyErr_Occurred()) SWIG_fail;
39558 }
39559 resultobj = SWIG_Py_Void();
39560 return resultobj;
39561 fail:
39562 return NULL;
39563 }
39564
39565
39566 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39567 PyObject *resultobj = 0;
39568 wxWindow *arg1 = (wxWindow *) 0 ;
39569 wxMenu *arg2 = (wxMenu *) 0 ;
39570 int arg3 = (int) -1 ;
39571 int arg4 = (int) -1 ;
39572 bool result;
39573 void *argp1 = 0 ;
39574 int res1 = 0 ;
39575 void *argp2 = 0 ;
39576 int res2 = 0 ;
39577 int val3 ;
39578 int ecode3 = 0 ;
39579 int val4 ;
39580 int ecode4 = 0 ;
39581 PyObject * obj0 = 0 ;
39582 PyObject * obj1 = 0 ;
39583 PyObject * obj2 = 0 ;
39584 PyObject * obj3 = 0 ;
39585 char * kwnames[] = {
39586 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
39587 };
39588
39589 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39590 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39591 if (!SWIG_IsOK(res1)) {
39592 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
39593 }
39594 arg1 = reinterpret_cast< wxWindow * >(argp1);
39595 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39596 if (!SWIG_IsOK(res2)) {
39597 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
39598 }
39599 arg2 = reinterpret_cast< wxMenu * >(argp2);
39600 if (obj2) {
39601 ecode3 = SWIG_AsVal_int(obj2, &val3);
39602 if (!SWIG_IsOK(ecode3)) {
39603 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
39604 }
39605 arg3 = static_cast< int >(val3);
39606 }
39607 if (obj3) {
39608 ecode4 = SWIG_AsVal_int(obj3, &val4);
39609 if (!SWIG_IsOK(ecode4)) {
39610 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
39611 }
39612 arg4 = static_cast< int >(val4);
39613 }
39614 {
39615 PyThreadState* __tstate = wxPyBeginAllowThreads();
39616 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
39617 wxPyEndAllowThreads(__tstate);
39618 if (PyErr_Occurred()) SWIG_fail;
39619 }
39620 {
39621 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39622 }
39623 return resultobj;
39624 fail:
39625 return NULL;
39626 }
39627
39628
39629 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39630 PyObject *resultobj = 0;
39631 wxWindow *arg1 = (wxWindow *) 0 ;
39632 wxMenu *arg2 = (wxMenu *) 0 ;
39633 wxPoint const &arg3_defvalue = wxDefaultPosition ;
39634 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
39635 bool result;
39636 void *argp1 = 0 ;
39637 int res1 = 0 ;
39638 void *argp2 = 0 ;
39639 int res2 = 0 ;
39640 wxPoint temp3 ;
39641 PyObject * obj0 = 0 ;
39642 PyObject * obj1 = 0 ;
39643 PyObject * obj2 = 0 ;
39644 char * kwnames[] = {
39645 (char *) "self",(char *) "menu",(char *) "pos", NULL
39646 };
39647
39648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
39649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39650 if (!SWIG_IsOK(res1)) {
39651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
39652 }
39653 arg1 = reinterpret_cast< wxWindow * >(argp1);
39654 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
39655 if (!SWIG_IsOK(res2)) {
39656 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
39657 }
39658 arg2 = reinterpret_cast< wxMenu * >(argp2);
39659 if (obj2) {
39660 {
39661 arg3 = &temp3;
39662 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
39663 }
39664 }
39665 {
39666 PyThreadState* __tstate = wxPyBeginAllowThreads();
39667 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
39668 wxPyEndAllowThreads(__tstate);
39669 if (PyErr_Occurred()) SWIG_fail;
39670 }
39671 {
39672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39673 }
39674 return resultobj;
39675 fail:
39676 return NULL;
39677 }
39678
39679
39680 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39681 PyObject *resultobj = 0;
39682 wxWindow *arg1 = (wxWindow *) 0 ;
39683 bool result;
39684 void *argp1 = 0 ;
39685 int res1 = 0 ;
39686 PyObject *swig_obj[1] ;
39687
39688 if (!args) SWIG_fail;
39689 swig_obj[0] = args;
39690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39691 if (!SWIG_IsOK(res1)) {
39692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
39693 }
39694 arg1 = reinterpret_cast< wxWindow * >(argp1);
39695 {
39696 PyThreadState* __tstate = wxPyBeginAllowThreads();
39697 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
39698 wxPyEndAllowThreads(__tstate);
39699 if (PyErr_Occurred()) SWIG_fail;
39700 }
39701 {
39702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39703 }
39704 return resultobj;
39705 fail:
39706 return NULL;
39707 }
39708
39709
39710 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39711 PyObject *resultobj = 0;
39712 wxWindow *arg1 = (wxWindow *) 0 ;
39713 long result;
39714 void *argp1 = 0 ;
39715 int res1 = 0 ;
39716 PyObject *swig_obj[1] ;
39717
39718 if (!args) SWIG_fail;
39719 swig_obj[0] = args;
39720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39721 if (!SWIG_IsOK(res1)) {
39722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39723 }
39724 arg1 = reinterpret_cast< wxWindow * >(argp1);
39725 {
39726 PyThreadState* __tstate = wxPyBeginAllowThreads();
39727 result = (long)wxWindow_GetHandle(arg1);
39728 wxPyEndAllowThreads(__tstate);
39729 if (PyErr_Occurred()) SWIG_fail;
39730 }
39731 resultobj = SWIG_From_long(static_cast< long >(result));
39732 return resultobj;
39733 fail:
39734 return NULL;
39735 }
39736
39737
39738 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39739 PyObject *resultobj = 0;
39740 wxWindow *arg1 = (wxWindow *) 0 ;
39741 long arg2 ;
39742 void *argp1 = 0 ;
39743 int res1 = 0 ;
39744 long val2 ;
39745 int ecode2 = 0 ;
39746 PyObject * obj0 = 0 ;
39747 PyObject * obj1 = 0 ;
39748 char * kwnames[] = {
39749 (char *) "self",(char *) "handle", NULL
39750 };
39751
39752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
39753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39754 if (!SWIG_IsOK(res1)) {
39755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39756 }
39757 arg1 = reinterpret_cast< wxWindow * >(argp1);
39758 ecode2 = SWIG_AsVal_long(obj1, &val2);
39759 if (!SWIG_IsOK(ecode2)) {
39760 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
39761 }
39762 arg2 = static_cast< long >(val2);
39763 {
39764 PyThreadState* __tstate = wxPyBeginAllowThreads();
39765 wxWindow_AssociateHandle(arg1,arg2);
39766 wxPyEndAllowThreads(__tstate);
39767 if (PyErr_Occurred()) SWIG_fail;
39768 }
39769 resultobj = SWIG_Py_Void();
39770 return resultobj;
39771 fail:
39772 return NULL;
39773 }
39774
39775
39776 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39777 PyObject *resultobj = 0;
39778 wxWindow *arg1 = (wxWindow *) 0 ;
39779 void *argp1 = 0 ;
39780 int res1 = 0 ;
39781 PyObject *swig_obj[1] ;
39782
39783 if (!args) SWIG_fail;
39784 swig_obj[0] = args;
39785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39786 if (!SWIG_IsOK(res1)) {
39787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
39788 }
39789 arg1 = reinterpret_cast< wxWindow * >(argp1);
39790 {
39791 PyThreadState* __tstate = wxPyBeginAllowThreads();
39792 (arg1)->DissociateHandle();
39793 wxPyEndAllowThreads(__tstate);
39794 if (PyErr_Occurred()) SWIG_fail;
39795 }
39796 resultobj = SWIG_Py_Void();
39797 return resultobj;
39798 fail:
39799 return NULL;
39800 }
39801
39802
39803 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39804 PyObject *resultobj = 0;
39805 wxWindow *arg1 = (wxWindow *) 0 ;
39806 int arg2 ;
39807 bool result;
39808 void *argp1 = 0 ;
39809 int res1 = 0 ;
39810 int val2 ;
39811 int ecode2 = 0 ;
39812 PyObject * obj0 = 0 ;
39813 PyObject * obj1 = 0 ;
39814 char * kwnames[] = {
39815 (char *) "self",(char *) "orient", NULL
39816 };
39817
39818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
39819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39820 if (!SWIG_IsOK(res1)) {
39821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
39822 }
39823 arg1 = reinterpret_cast< wxWindow * >(argp1);
39824 ecode2 = SWIG_AsVal_int(obj1, &val2);
39825 if (!SWIG_IsOK(ecode2)) {
39826 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
39827 }
39828 arg2 = static_cast< int >(val2);
39829 {
39830 PyThreadState* __tstate = wxPyBeginAllowThreads();
39831 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
39832 wxPyEndAllowThreads(__tstate);
39833 if (PyErr_Occurred()) SWIG_fail;
39834 }
39835 {
39836 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39837 }
39838 return resultobj;
39839 fail:
39840 return NULL;
39841 }
39842
39843
39844 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39845 PyObject *resultobj = 0;
39846 wxWindow *arg1 = (wxWindow *) 0 ;
39847 int arg2 ;
39848 int arg3 ;
39849 int arg4 ;
39850 int arg5 ;
39851 bool arg6 = (bool) true ;
39852 void *argp1 = 0 ;
39853 int res1 = 0 ;
39854 int val2 ;
39855 int ecode2 = 0 ;
39856 int val3 ;
39857 int ecode3 = 0 ;
39858 int val4 ;
39859 int ecode4 = 0 ;
39860 int val5 ;
39861 int ecode5 = 0 ;
39862 bool val6 ;
39863 int ecode6 = 0 ;
39864 PyObject * obj0 = 0 ;
39865 PyObject * obj1 = 0 ;
39866 PyObject * obj2 = 0 ;
39867 PyObject * obj3 = 0 ;
39868 PyObject * obj4 = 0 ;
39869 PyObject * obj5 = 0 ;
39870 char * kwnames[] = {
39871 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
39872 };
39873
39874 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39875 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39876 if (!SWIG_IsOK(res1)) {
39877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
39878 }
39879 arg1 = reinterpret_cast< wxWindow * >(argp1);
39880 ecode2 = SWIG_AsVal_int(obj1, &val2);
39881 if (!SWIG_IsOK(ecode2)) {
39882 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
39883 }
39884 arg2 = static_cast< int >(val2);
39885 ecode3 = SWIG_AsVal_int(obj2, &val3);
39886 if (!SWIG_IsOK(ecode3)) {
39887 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
39888 }
39889 arg3 = static_cast< int >(val3);
39890 ecode4 = SWIG_AsVal_int(obj3, &val4);
39891 if (!SWIG_IsOK(ecode4)) {
39892 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
39893 }
39894 arg4 = static_cast< int >(val4);
39895 ecode5 = SWIG_AsVal_int(obj4, &val5);
39896 if (!SWIG_IsOK(ecode5)) {
39897 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
39898 }
39899 arg5 = static_cast< int >(val5);
39900 if (obj5) {
39901 ecode6 = SWIG_AsVal_bool(obj5, &val6);
39902 if (!SWIG_IsOK(ecode6)) {
39903 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
39904 }
39905 arg6 = static_cast< bool >(val6);
39906 }
39907 {
39908 PyThreadState* __tstate = wxPyBeginAllowThreads();
39909 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
39910 wxPyEndAllowThreads(__tstate);
39911 if (PyErr_Occurred()) SWIG_fail;
39912 }
39913 resultobj = SWIG_Py_Void();
39914 return resultobj;
39915 fail:
39916 return NULL;
39917 }
39918
39919
39920 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39921 PyObject *resultobj = 0;
39922 wxWindow *arg1 = (wxWindow *) 0 ;
39923 int arg2 ;
39924 int arg3 ;
39925 bool arg4 = (bool) true ;
39926 void *argp1 = 0 ;
39927 int res1 = 0 ;
39928 int val2 ;
39929 int ecode2 = 0 ;
39930 int val3 ;
39931 int ecode3 = 0 ;
39932 bool val4 ;
39933 int ecode4 = 0 ;
39934 PyObject * obj0 = 0 ;
39935 PyObject * obj1 = 0 ;
39936 PyObject * obj2 = 0 ;
39937 PyObject * obj3 = 0 ;
39938 char * kwnames[] = {
39939 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
39940 };
39941
39942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39944 if (!SWIG_IsOK(res1)) {
39945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
39946 }
39947 arg1 = reinterpret_cast< wxWindow * >(argp1);
39948 ecode2 = SWIG_AsVal_int(obj1, &val2);
39949 if (!SWIG_IsOK(ecode2)) {
39950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
39951 }
39952 arg2 = static_cast< int >(val2);
39953 ecode3 = SWIG_AsVal_int(obj2, &val3);
39954 if (!SWIG_IsOK(ecode3)) {
39955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
39956 }
39957 arg3 = static_cast< int >(val3);
39958 if (obj3) {
39959 ecode4 = SWIG_AsVal_bool(obj3, &val4);
39960 if (!SWIG_IsOK(ecode4)) {
39961 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
39962 }
39963 arg4 = static_cast< bool >(val4);
39964 }
39965 {
39966 PyThreadState* __tstate = wxPyBeginAllowThreads();
39967 (arg1)->SetScrollPos(arg2,arg3,arg4);
39968 wxPyEndAllowThreads(__tstate);
39969 if (PyErr_Occurred()) SWIG_fail;
39970 }
39971 resultobj = SWIG_Py_Void();
39972 return resultobj;
39973 fail:
39974 return NULL;
39975 }
39976
39977
39978 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39979 PyObject *resultobj = 0;
39980 wxWindow *arg1 = (wxWindow *) 0 ;
39981 int arg2 ;
39982 int result;
39983 void *argp1 = 0 ;
39984 int res1 = 0 ;
39985 int val2 ;
39986 int ecode2 = 0 ;
39987 PyObject * obj0 = 0 ;
39988 PyObject * obj1 = 0 ;
39989 char * kwnames[] = {
39990 (char *) "self",(char *) "orientation", NULL
39991 };
39992
39993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
39994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
39995 if (!SWIG_IsOK(res1)) {
39996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
39997 }
39998 arg1 = reinterpret_cast< wxWindow * >(argp1);
39999 ecode2 = SWIG_AsVal_int(obj1, &val2);
40000 if (!SWIG_IsOK(ecode2)) {
40001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
40002 }
40003 arg2 = static_cast< int >(val2);
40004 {
40005 PyThreadState* __tstate = wxPyBeginAllowThreads();
40006 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
40007 wxPyEndAllowThreads(__tstate);
40008 if (PyErr_Occurred()) SWIG_fail;
40009 }
40010 resultobj = SWIG_From_int(static_cast< int >(result));
40011 return resultobj;
40012 fail:
40013 return NULL;
40014 }
40015
40016
40017 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40018 PyObject *resultobj = 0;
40019 wxWindow *arg1 = (wxWindow *) 0 ;
40020 int arg2 ;
40021 int result;
40022 void *argp1 = 0 ;
40023 int res1 = 0 ;
40024 int val2 ;
40025 int ecode2 = 0 ;
40026 PyObject * obj0 = 0 ;
40027 PyObject * obj1 = 0 ;
40028 char * kwnames[] = {
40029 (char *) "self",(char *) "orientation", NULL
40030 };
40031
40032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
40033 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40034 if (!SWIG_IsOK(res1)) {
40035 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
40036 }
40037 arg1 = reinterpret_cast< wxWindow * >(argp1);
40038 ecode2 = SWIG_AsVal_int(obj1, &val2);
40039 if (!SWIG_IsOK(ecode2)) {
40040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
40041 }
40042 arg2 = static_cast< int >(val2);
40043 {
40044 PyThreadState* __tstate = wxPyBeginAllowThreads();
40045 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
40046 wxPyEndAllowThreads(__tstate);
40047 if (PyErr_Occurred()) SWIG_fail;
40048 }
40049 resultobj = SWIG_From_int(static_cast< int >(result));
40050 return resultobj;
40051 fail:
40052 return NULL;
40053 }
40054
40055
40056 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40057 PyObject *resultobj = 0;
40058 wxWindow *arg1 = (wxWindow *) 0 ;
40059 int arg2 ;
40060 int result;
40061 void *argp1 = 0 ;
40062 int res1 = 0 ;
40063 int val2 ;
40064 int ecode2 = 0 ;
40065 PyObject * obj0 = 0 ;
40066 PyObject * obj1 = 0 ;
40067 char * kwnames[] = {
40068 (char *) "self",(char *) "orientation", NULL
40069 };
40070
40071 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
40072 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40073 if (!SWIG_IsOK(res1)) {
40074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
40075 }
40076 arg1 = reinterpret_cast< wxWindow * >(argp1);
40077 ecode2 = SWIG_AsVal_int(obj1, &val2);
40078 if (!SWIG_IsOK(ecode2)) {
40079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
40080 }
40081 arg2 = static_cast< int >(val2);
40082 {
40083 PyThreadState* __tstate = wxPyBeginAllowThreads();
40084 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
40085 wxPyEndAllowThreads(__tstate);
40086 if (PyErr_Occurred()) SWIG_fail;
40087 }
40088 resultobj = SWIG_From_int(static_cast< int >(result));
40089 return resultobj;
40090 fail:
40091 return NULL;
40092 }
40093
40094
40095 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40096 PyObject *resultobj = 0;
40097 wxWindow *arg1 = (wxWindow *) 0 ;
40098 int arg2 ;
40099 int arg3 ;
40100 wxRect *arg4 = (wxRect *) NULL ;
40101 void *argp1 = 0 ;
40102 int res1 = 0 ;
40103 int val2 ;
40104 int ecode2 = 0 ;
40105 int val3 ;
40106 int ecode3 = 0 ;
40107 void *argp4 = 0 ;
40108 int res4 = 0 ;
40109 PyObject * obj0 = 0 ;
40110 PyObject * obj1 = 0 ;
40111 PyObject * obj2 = 0 ;
40112 PyObject * obj3 = 0 ;
40113 char * kwnames[] = {
40114 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
40115 };
40116
40117 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
40118 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40119 if (!SWIG_IsOK(res1)) {
40120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
40121 }
40122 arg1 = reinterpret_cast< wxWindow * >(argp1);
40123 ecode2 = SWIG_AsVal_int(obj1, &val2);
40124 if (!SWIG_IsOK(ecode2)) {
40125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
40126 }
40127 arg2 = static_cast< int >(val2);
40128 ecode3 = SWIG_AsVal_int(obj2, &val3);
40129 if (!SWIG_IsOK(ecode3)) {
40130 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
40131 }
40132 arg3 = static_cast< int >(val3);
40133 if (obj3) {
40134 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
40135 if (!SWIG_IsOK(res4)) {
40136 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
40137 }
40138 arg4 = reinterpret_cast< wxRect * >(argp4);
40139 }
40140 {
40141 PyThreadState* __tstate = wxPyBeginAllowThreads();
40142 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
40143 wxPyEndAllowThreads(__tstate);
40144 if (PyErr_Occurred()) SWIG_fail;
40145 }
40146 resultobj = SWIG_Py_Void();
40147 return resultobj;
40148 fail:
40149 return NULL;
40150 }
40151
40152
40153 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40154 PyObject *resultobj = 0;
40155 wxWindow *arg1 = (wxWindow *) 0 ;
40156 int arg2 ;
40157 bool result;
40158 void *argp1 = 0 ;
40159 int res1 = 0 ;
40160 int val2 ;
40161 int ecode2 = 0 ;
40162 PyObject * obj0 = 0 ;
40163 PyObject * obj1 = 0 ;
40164 char * kwnames[] = {
40165 (char *) "self",(char *) "lines", NULL
40166 };
40167
40168 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
40169 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40170 if (!SWIG_IsOK(res1)) {
40171 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
40172 }
40173 arg1 = reinterpret_cast< wxWindow * >(argp1);
40174 ecode2 = SWIG_AsVal_int(obj1, &val2);
40175 if (!SWIG_IsOK(ecode2)) {
40176 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
40177 }
40178 arg2 = static_cast< int >(val2);
40179 {
40180 PyThreadState* __tstate = wxPyBeginAllowThreads();
40181 result = (bool)(arg1)->ScrollLines(arg2);
40182 wxPyEndAllowThreads(__tstate);
40183 if (PyErr_Occurred()) SWIG_fail;
40184 }
40185 {
40186 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40187 }
40188 return resultobj;
40189 fail:
40190 return NULL;
40191 }
40192
40193
40194 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40195 PyObject *resultobj = 0;
40196 wxWindow *arg1 = (wxWindow *) 0 ;
40197 int arg2 ;
40198 bool result;
40199 void *argp1 = 0 ;
40200 int res1 = 0 ;
40201 int val2 ;
40202 int ecode2 = 0 ;
40203 PyObject * obj0 = 0 ;
40204 PyObject * obj1 = 0 ;
40205 char * kwnames[] = {
40206 (char *) "self",(char *) "pages", NULL
40207 };
40208
40209 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
40210 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40211 if (!SWIG_IsOK(res1)) {
40212 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
40213 }
40214 arg1 = reinterpret_cast< wxWindow * >(argp1);
40215 ecode2 = SWIG_AsVal_int(obj1, &val2);
40216 if (!SWIG_IsOK(ecode2)) {
40217 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
40218 }
40219 arg2 = static_cast< int >(val2);
40220 {
40221 PyThreadState* __tstate = wxPyBeginAllowThreads();
40222 result = (bool)(arg1)->ScrollPages(arg2);
40223 wxPyEndAllowThreads(__tstate);
40224 if (PyErr_Occurred()) SWIG_fail;
40225 }
40226 {
40227 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40228 }
40229 return resultobj;
40230 fail:
40231 return NULL;
40232 }
40233
40234
40235 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40236 PyObject *resultobj = 0;
40237 wxWindow *arg1 = (wxWindow *) 0 ;
40238 bool result;
40239 void *argp1 = 0 ;
40240 int res1 = 0 ;
40241 PyObject *swig_obj[1] ;
40242
40243 if (!args) SWIG_fail;
40244 swig_obj[0] = args;
40245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40246 if (!SWIG_IsOK(res1)) {
40247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40248 }
40249 arg1 = reinterpret_cast< wxWindow * >(argp1);
40250 {
40251 PyThreadState* __tstate = wxPyBeginAllowThreads();
40252 result = (bool)(arg1)->LineUp();
40253 wxPyEndAllowThreads(__tstate);
40254 if (PyErr_Occurred()) SWIG_fail;
40255 }
40256 {
40257 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40258 }
40259 return resultobj;
40260 fail:
40261 return NULL;
40262 }
40263
40264
40265 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40266 PyObject *resultobj = 0;
40267 wxWindow *arg1 = (wxWindow *) 0 ;
40268 bool result;
40269 void *argp1 = 0 ;
40270 int res1 = 0 ;
40271 PyObject *swig_obj[1] ;
40272
40273 if (!args) SWIG_fail;
40274 swig_obj[0] = args;
40275 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40276 if (!SWIG_IsOK(res1)) {
40277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40278 }
40279 arg1 = reinterpret_cast< wxWindow * >(argp1);
40280 {
40281 PyThreadState* __tstate = wxPyBeginAllowThreads();
40282 result = (bool)(arg1)->LineDown();
40283 wxPyEndAllowThreads(__tstate);
40284 if (PyErr_Occurred()) SWIG_fail;
40285 }
40286 {
40287 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40288 }
40289 return resultobj;
40290 fail:
40291 return NULL;
40292 }
40293
40294
40295 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40296 PyObject *resultobj = 0;
40297 wxWindow *arg1 = (wxWindow *) 0 ;
40298 bool result;
40299 void *argp1 = 0 ;
40300 int res1 = 0 ;
40301 PyObject *swig_obj[1] ;
40302
40303 if (!args) SWIG_fail;
40304 swig_obj[0] = args;
40305 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40306 if (!SWIG_IsOK(res1)) {
40307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
40308 }
40309 arg1 = reinterpret_cast< wxWindow * >(argp1);
40310 {
40311 PyThreadState* __tstate = wxPyBeginAllowThreads();
40312 result = (bool)(arg1)->PageUp();
40313 wxPyEndAllowThreads(__tstate);
40314 if (PyErr_Occurred()) SWIG_fail;
40315 }
40316 {
40317 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40318 }
40319 return resultobj;
40320 fail:
40321 return NULL;
40322 }
40323
40324
40325 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40326 PyObject *resultobj = 0;
40327 wxWindow *arg1 = (wxWindow *) 0 ;
40328 bool result;
40329 void *argp1 = 0 ;
40330 int res1 = 0 ;
40331 PyObject *swig_obj[1] ;
40332
40333 if (!args) SWIG_fail;
40334 swig_obj[0] = args;
40335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40336 if (!SWIG_IsOK(res1)) {
40337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
40338 }
40339 arg1 = reinterpret_cast< wxWindow * >(argp1);
40340 {
40341 PyThreadState* __tstate = wxPyBeginAllowThreads();
40342 result = (bool)(arg1)->PageDown();
40343 wxPyEndAllowThreads(__tstate);
40344 if (PyErr_Occurred()) SWIG_fail;
40345 }
40346 {
40347 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40348 }
40349 return resultobj;
40350 fail:
40351 return NULL;
40352 }
40353
40354
40355 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40356 PyObject *resultobj = 0;
40357 wxWindow *arg1 = (wxWindow *) 0 ;
40358 wxString *arg2 = 0 ;
40359 void *argp1 = 0 ;
40360 int res1 = 0 ;
40361 bool temp2 = false ;
40362 PyObject * obj0 = 0 ;
40363 PyObject * obj1 = 0 ;
40364 char * kwnames[] = {
40365 (char *) "self",(char *) "text", NULL
40366 };
40367
40368 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
40369 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40370 if (!SWIG_IsOK(res1)) {
40371 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
40372 }
40373 arg1 = reinterpret_cast< wxWindow * >(argp1);
40374 {
40375 arg2 = wxString_in_helper(obj1);
40376 if (arg2 == NULL) SWIG_fail;
40377 temp2 = true;
40378 }
40379 {
40380 PyThreadState* __tstate = wxPyBeginAllowThreads();
40381 (arg1)->SetHelpText((wxString const &)*arg2);
40382 wxPyEndAllowThreads(__tstate);
40383 if (PyErr_Occurred()) SWIG_fail;
40384 }
40385 resultobj = SWIG_Py_Void();
40386 {
40387 if (temp2)
40388 delete arg2;
40389 }
40390 return resultobj;
40391 fail:
40392 {
40393 if (temp2)
40394 delete arg2;
40395 }
40396 return NULL;
40397 }
40398
40399
40400 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40401 PyObject *resultobj = 0;
40402 wxWindow *arg1 = (wxWindow *) 0 ;
40403 wxString *arg2 = 0 ;
40404 void *argp1 = 0 ;
40405 int res1 = 0 ;
40406 bool temp2 = false ;
40407 PyObject * obj0 = 0 ;
40408 PyObject * obj1 = 0 ;
40409 char * kwnames[] = {
40410 (char *) "self",(char *) "text", NULL
40411 };
40412
40413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
40414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40415 if (!SWIG_IsOK(res1)) {
40416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
40417 }
40418 arg1 = reinterpret_cast< wxWindow * >(argp1);
40419 {
40420 arg2 = wxString_in_helper(obj1);
40421 if (arg2 == NULL) SWIG_fail;
40422 temp2 = true;
40423 }
40424 {
40425 PyThreadState* __tstate = wxPyBeginAllowThreads();
40426 (arg1)->SetHelpTextForId((wxString const &)*arg2);
40427 wxPyEndAllowThreads(__tstate);
40428 if (PyErr_Occurred()) SWIG_fail;
40429 }
40430 resultobj = SWIG_Py_Void();
40431 {
40432 if (temp2)
40433 delete arg2;
40434 }
40435 return resultobj;
40436 fail:
40437 {
40438 if (temp2)
40439 delete arg2;
40440 }
40441 return NULL;
40442 }
40443
40444
40445 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40446 PyObject *resultobj = 0;
40447 wxWindow *arg1 = (wxWindow *) 0 ;
40448 wxPoint *arg2 = 0 ;
40449 wxHelpEvent::Origin arg3 ;
40450 wxString result;
40451 void *argp1 = 0 ;
40452 int res1 = 0 ;
40453 wxPoint temp2 ;
40454 void *argp3 ;
40455 int res3 = 0 ;
40456 PyObject * obj0 = 0 ;
40457 PyObject * obj1 = 0 ;
40458 PyObject * obj2 = 0 ;
40459 char * kwnames[] = {
40460 (char *) "self",(char *) "pt",(char *) "origin", NULL
40461 };
40462
40463 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40464 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40465 if (!SWIG_IsOK(res1)) {
40466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
40467 }
40468 arg1 = reinterpret_cast< wxWindow * >(argp1);
40469 {
40470 arg2 = &temp2;
40471 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
40472 }
40473 {
40474 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
40475 if (!SWIG_IsOK(res3)) {
40476 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40477 }
40478 if (!argp3) {
40479 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
40480 } else {
40481 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
40482 arg3 = *temp;
40483 if (SWIG_IsNewObj(res3)) delete temp;
40484 }
40485 }
40486 {
40487 PyThreadState* __tstate = wxPyBeginAllowThreads();
40488 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
40489 wxPyEndAllowThreads(__tstate);
40490 if (PyErr_Occurred()) SWIG_fail;
40491 }
40492 {
40493 #if wxUSE_UNICODE
40494 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40495 #else
40496 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40497 #endif
40498 }
40499 return resultobj;
40500 fail:
40501 return NULL;
40502 }
40503
40504
40505 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40506 PyObject *resultobj = 0;
40507 wxWindow *arg1 = (wxWindow *) 0 ;
40508 wxString result;
40509 void *argp1 = 0 ;
40510 int res1 = 0 ;
40511 PyObject *swig_obj[1] ;
40512
40513 if (!args) SWIG_fail;
40514 swig_obj[0] = args;
40515 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40516 if (!SWIG_IsOK(res1)) {
40517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
40518 }
40519 arg1 = reinterpret_cast< wxWindow * >(argp1);
40520 {
40521 PyThreadState* __tstate = wxPyBeginAllowThreads();
40522 result = ((wxWindow const *)arg1)->GetHelpText();
40523 wxPyEndAllowThreads(__tstate);
40524 if (PyErr_Occurred()) SWIG_fail;
40525 }
40526 {
40527 #if wxUSE_UNICODE
40528 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40529 #else
40530 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40531 #endif
40532 }
40533 return resultobj;
40534 fail:
40535 return NULL;
40536 }
40537
40538
40539 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40540 PyObject *resultobj = 0;
40541 wxWindow *arg1 = (wxWindow *) 0 ;
40542 wxString *arg2 = 0 ;
40543 void *argp1 = 0 ;
40544 int res1 = 0 ;
40545 bool temp2 = false ;
40546 PyObject * obj0 = 0 ;
40547 PyObject * obj1 = 0 ;
40548 char * kwnames[] = {
40549 (char *) "self",(char *) "tip", NULL
40550 };
40551
40552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
40553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40554 if (!SWIG_IsOK(res1)) {
40555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
40556 }
40557 arg1 = reinterpret_cast< wxWindow * >(argp1);
40558 {
40559 arg2 = wxString_in_helper(obj1);
40560 if (arg2 == NULL) SWIG_fail;
40561 temp2 = true;
40562 }
40563 {
40564 PyThreadState* __tstate = wxPyBeginAllowThreads();
40565 (arg1)->SetToolTip((wxString const &)*arg2);
40566 wxPyEndAllowThreads(__tstate);
40567 if (PyErr_Occurred()) SWIG_fail;
40568 }
40569 resultobj = SWIG_Py_Void();
40570 {
40571 if (temp2)
40572 delete arg2;
40573 }
40574 return resultobj;
40575 fail:
40576 {
40577 if (temp2)
40578 delete arg2;
40579 }
40580 return NULL;
40581 }
40582
40583
40584 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40585 PyObject *resultobj = 0;
40586 wxWindow *arg1 = (wxWindow *) 0 ;
40587 wxToolTip *arg2 = (wxToolTip *) 0 ;
40588 void *argp1 = 0 ;
40589 int res1 = 0 ;
40590 int res2 = 0 ;
40591 PyObject * obj0 = 0 ;
40592 PyObject * obj1 = 0 ;
40593 char * kwnames[] = {
40594 (char *) "self",(char *) "tip", NULL
40595 };
40596
40597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
40598 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40599 if (!SWIG_IsOK(res1)) {
40600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
40601 }
40602 arg1 = reinterpret_cast< wxWindow * >(argp1);
40603 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
40604 if (!SWIG_IsOK(res2)) {
40605 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
40606 }
40607 {
40608 PyThreadState* __tstate = wxPyBeginAllowThreads();
40609 (arg1)->SetToolTip(arg2);
40610 wxPyEndAllowThreads(__tstate);
40611 if (PyErr_Occurred()) SWIG_fail;
40612 }
40613 resultobj = SWIG_Py_Void();
40614 return resultobj;
40615 fail:
40616 return NULL;
40617 }
40618
40619
40620 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40621 PyObject *resultobj = 0;
40622 wxWindow *arg1 = (wxWindow *) 0 ;
40623 wxToolTip *result = 0 ;
40624 void *argp1 = 0 ;
40625 int res1 = 0 ;
40626 PyObject *swig_obj[1] ;
40627
40628 if (!args) SWIG_fail;
40629 swig_obj[0] = args;
40630 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40631 if (!SWIG_IsOK(res1)) {
40632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
40633 }
40634 arg1 = reinterpret_cast< wxWindow * >(argp1);
40635 {
40636 PyThreadState* __tstate = wxPyBeginAllowThreads();
40637 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
40638 wxPyEndAllowThreads(__tstate);
40639 if (PyErr_Occurred()) SWIG_fail;
40640 }
40641 {
40642 resultobj = wxPyMake_wxObject(result, (bool)0);
40643 }
40644 return resultobj;
40645 fail:
40646 return NULL;
40647 }
40648
40649
40650 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40651 PyObject *resultobj = 0;
40652 wxWindow *arg1 = (wxWindow *) 0 ;
40653 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
40654 void *argp1 = 0 ;
40655 int res1 = 0 ;
40656 int res2 = 0 ;
40657 PyObject * obj0 = 0 ;
40658 PyObject * obj1 = 0 ;
40659 char * kwnames[] = {
40660 (char *) "self",(char *) "dropTarget", NULL
40661 };
40662
40663 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
40664 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40665 if (!SWIG_IsOK(res1)) {
40666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
40667 }
40668 arg1 = reinterpret_cast< wxWindow * >(argp1);
40669 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
40670 if (!SWIG_IsOK(res2)) {
40671 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
40672 }
40673 {
40674 PyThreadState* __tstate = wxPyBeginAllowThreads();
40675 (arg1)->SetDropTarget(arg2);
40676 wxPyEndAllowThreads(__tstate);
40677 if (PyErr_Occurred()) SWIG_fail;
40678 }
40679 resultobj = SWIG_Py_Void();
40680 return resultobj;
40681 fail:
40682 return NULL;
40683 }
40684
40685
40686 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40687 PyObject *resultobj = 0;
40688 wxWindow *arg1 = (wxWindow *) 0 ;
40689 wxPyDropTarget *result = 0 ;
40690 void *argp1 = 0 ;
40691 int res1 = 0 ;
40692 PyObject *swig_obj[1] ;
40693
40694 if (!args) SWIG_fail;
40695 swig_obj[0] = args;
40696 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40697 if (!SWIG_IsOK(res1)) {
40698 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
40699 }
40700 arg1 = reinterpret_cast< wxWindow * >(argp1);
40701 {
40702 PyThreadState* __tstate = wxPyBeginAllowThreads();
40703 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
40704 wxPyEndAllowThreads(__tstate);
40705 if (PyErr_Occurred()) SWIG_fail;
40706 }
40707 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
40708 return resultobj;
40709 fail:
40710 return NULL;
40711 }
40712
40713
40714 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40715 PyObject *resultobj = 0;
40716 wxWindow *arg1 = (wxWindow *) 0 ;
40717 bool arg2 ;
40718 void *argp1 = 0 ;
40719 int res1 = 0 ;
40720 bool val2 ;
40721 int ecode2 = 0 ;
40722 PyObject * obj0 = 0 ;
40723 PyObject * obj1 = 0 ;
40724 char * kwnames[] = {
40725 (char *) "self",(char *) "accept", NULL
40726 };
40727
40728 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
40729 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40730 if (!SWIG_IsOK(res1)) {
40731 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
40732 }
40733 arg1 = reinterpret_cast< wxWindow * >(argp1);
40734 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40735 if (!SWIG_IsOK(ecode2)) {
40736 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
40737 }
40738 arg2 = static_cast< bool >(val2);
40739 {
40740 PyThreadState* __tstate = wxPyBeginAllowThreads();
40741 wxWindow_DragAcceptFiles(arg1,arg2);
40742 wxPyEndAllowThreads(__tstate);
40743 if (PyErr_Occurred()) SWIG_fail;
40744 }
40745 resultobj = SWIG_Py_Void();
40746 return resultobj;
40747 fail:
40748 return NULL;
40749 }
40750
40751
40752 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40753 PyObject *resultobj = 0;
40754 wxWindow *arg1 = (wxWindow *) 0 ;
40755 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
40756 void *argp1 = 0 ;
40757 int res1 = 0 ;
40758 int res2 = 0 ;
40759 PyObject * obj0 = 0 ;
40760 PyObject * obj1 = 0 ;
40761 char * kwnames[] = {
40762 (char *) "self",(char *) "constraints", NULL
40763 };
40764
40765 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
40766 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40767 if (!SWIG_IsOK(res1)) {
40768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
40769 }
40770 arg1 = reinterpret_cast< wxWindow * >(argp1);
40771 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
40772 if (!SWIG_IsOK(res2)) {
40773 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
40774 }
40775 {
40776 PyThreadState* __tstate = wxPyBeginAllowThreads();
40777 (arg1)->SetConstraints(arg2);
40778 wxPyEndAllowThreads(__tstate);
40779 if (PyErr_Occurred()) SWIG_fail;
40780 }
40781 resultobj = SWIG_Py_Void();
40782 return resultobj;
40783 fail:
40784 return NULL;
40785 }
40786
40787
40788 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40789 PyObject *resultobj = 0;
40790 wxWindow *arg1 = (wxWindow *) 0 ;
40791 wxLayoutConstraints *result = 0 ;
40792 void *argp1 = 0 ;
40793 int res1 = 0 ;
40794 PyObject *swig_obj[1] ;
40795
40796 if (!args) SWIG_fail;
40797 swig_obj[0] = args;
40798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40799 if (!SWIG_IsOK(res1)) {
40800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
40801 }
40802 arg1 = reinterpret_cast< wxWindow * >(argp1);
40803 {
40804 PyThreadState* __tstate = wxPyBeginAllowThreads();
40805 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
40806 wxPyEndAllowThreads(__tstate);
40807 if (PyErr_Occurred()) SWIG_fail;
40808 }
40809 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
40810 return resultobj;
40811 fail:
40812 return NULL;
40813 }
40814
40815
40816 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40817 PyObject *resultobj = 0;
40818 wxWindow *arg1 = (wxWindow *) 0 ;
40819 bool arg2 ;
40820 void *argp1 = 0 ;
40821 int res1 = 0 ;
40822 bool val2 ;
40823 int ecode2 = 0 ;
40824 PyObject * obj0 = 0 ;
40825 PyObject * obj1 = 0 ;
40826 char * kwnames[] = {
40827 (char *) "self",(char *) "autoLayout", NULL
40828 };
40829
40830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
40831 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40832 if (!SWIG_IsOK(res1)) {
40833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
40834 }
40835 arg1 = reinterpret_cast< wxWindow * >(argp1);
40836 ecode2 = SWIG_AsVal_bool(obj1, &val2);
40837 if (!SWIG_IsOK(ecode2)) {
40838 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
40839 }
40840 arg2 = static_cast< bool >(val2);
40841 {
40842 PyThreadState* __tstate = wxPyBeginAllowThreads();
40843 (arg1)->SetAutoLayout(arg2);
40844 wxPyEndAllowThreads(__tstate);
40845 if (PyErr_Occurred()) SWIG_fail;
40846 }
40847 resultobj = SWIG_Py_Void();
40848 return resultobj;
40849 fail:
40850 return NULL;
40851 }
40852
40853
40854 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40855 PyObject *resultobj = 0;
40856 wxWindow *arg1 = (wxWindow *) 0 ;
40857 bool result;
40858 void *argp1 = 0 ;
40859 int res1 = 0 ;
40860 PyObject *swig_obj[1] ;
40861
40862 if (!args) SWIG_fail;
40863 swig_obj[0] = args;
40864 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40865 if (!SWIG_IsOK(res1)) {
40866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
40867 }
40868 arg1 = reinterpret_cast< wxWindow * >(argp1);
40869 {
40870 PyThreadState* __tstate = wxPyBeginAllowThreads();
40871 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
40872 wxPyEndAllowThreads(__tstate);
40873 if (PyErr_Occurred()) SWIG_fail;
40874 }
40875 {
40876 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40877 }
40878 return resultobj;
40879 fail:
40880 return NULL;
40881 }
40882
40883
40884 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40885 PyObject *resultobj = 0;
40886 wxWindow *arg1 = (wxWindow *) 0 ;
40887 bool result;
40888 void *argp1 = 0 ;
40889 int res1 = 0 ;
40890 PyObject *swig_obj[1] ;
40891
40892 if (!args) SWIG_fail;
40893 swig_obj[0] = args;
40894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40895 if (!SWIG_IsOK(res1)) {
40896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
40897 }
40898 arg1 = reinterpret_cast< wxWindow * >(argp1);
40899 {
40900 PyThreadState* __tstate = wxPyBeginAllowThreads();
40901 result = (bool)(arg1)->Layout();
40902 wxPyEndAllowThreads(__tstate);
40903 if (PyErr_Occurred()) SWIG_fail;
40904 }
40905 {
40906 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40907 }
40908 return resultobj;
40909 fail:
40910 return NULL;
40911 }
40912
40913
40914 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40915 PyObject *resultobj = 0;
40916 wxWindow *arg1 = (wxWindow *) 0 ;
40917 wxSizer *arg2 = (wxSizer *) 0 ;
40918 bool arg3 = (bool) true ;
40919 void *argp1 = 0 ;
40920 int res1 = 0 ;
40921 int res2 = 0 ;
40922 bool val3 ;
40923 int ecode3 = 0 ;
40924 PyObject * obj0 = 0 ;
40925 PyObject * obj1 = 0 ;
40926 PyObject * obj2 = 0 ;
40927 char * kwnames[] = {
40928 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40929 };
40930
40931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40933 if (!SWIG_IsOK(res1)) {
40934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
40935 }
40936 arg1 = reinterpret_cast< wxWindow * >(argp1);
40937 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40938 if (!SWIG_IsOK(res2)) {
40939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
40940 }
40941 if (obj2) {
40942 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40943 if (!SWIG_IsOK(ecode3)) {
40944 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
40945 }
40946 arg3 = static_cast< bool >(val3);
40947 }
40948 {
40949 PyThreadState* __tstate = wxPyBeginAllowThreads();
40950 (arg1)->SetSizer(arg2,arg3);
40951 wxPyEndAllowThreads(__tstate);
40952 if (PyErr_Occurred()) SWIG_fail;
40953 }
40954 resultobj = SWIG_Py_Void();
40955 return resultobj;
40956 fail:
40957 return NULL;
40958 }
40959
40960
40961 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40962 PyObject *resultobj = 0;
40963 wxWindow *arg1 = (wxWindow *) 0 ;
40964 wxSizer *arg2 = (wxSizer *) 0 ;
40965 bool arg3 = (bool) true ;
40966 void *argp1 = 0 ;
40967 int res1 = 0 ;
40968 int res2 = 0 ;
40969 bool val3 ;
40970 int ecode3 = 0 ;
40971 PyObject * obj0 = 0 ;
40972 PyObject * obj1 = 0 ;
40973 PyObject * obj2 = 0 ;
40974 char * kwnames[] = {
40975 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
40976 };
40977
40978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40979 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
40980 if (!SWIG_IsOK(res1)) {
40981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
40982 }
40983 arg1 = reinterpret_cast< wxWindow * >(argp1);
40984 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
40985 if (!SWIG_IsOK(res2)) {
40986 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
40987 }
40988 if (obj2) {
40989 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40990 if (!SWIG_IsOK(ecode3)) {
40991 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
40992 }
40993 arg3 = static_cast< bool >(val3);
40994 }
40995 {
40996 PyThreadState* __tstate = wxPyBeginAllowThreads();
40997 (arg1)->SetSizerAndFit(arg2,arg3);
40998 wxPyEndAllowThreads(__tstate);
40999 if (PyErr_Occurred()) SWIG_fail;
41000 }
41001 resultobj = SWIG_Py_Void();
41002 return resultobj;
41003 fail:
41004 return NULL;
41005 }
41006
41007
41008 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41009 PyObject *resultobj = 0;
41010 wxWindow *arg1 = (wxWindow *) 0 ;
41011 wxSizer *result = 0 ;
41012 void *argp1 = 0 ;
41013 int res1 = 0 ;
41014 PyObject *swig_obj[1] ;
41015
41016 if (!args) SWIG_fail;
41017 swig_obj[0] = args;
41018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41019 if (!SWIG_IsOK(res1)) {
41020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41021 }
41022 arg1 = reinterpret_cast< wxWindow * >(argp1);
41023 {
41024 PyThreadState* __tstate = wxPyBeginAllowThreads();
41025 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
41026 wxPyEndAllowThreads(__tstate);
41027 if (PyErr_Occurred()) SWIG_fail;
41028 }
41029 {
41030 resultobj = wxPyMake_wxObject(result, (bool)0);
41031 }
41032 return resultobj;
41033 fail:
41034 return NULL;
41035 }
41036
41037
41038 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41039 PyObject *resultobj = 0;
41040 wxWindow *arg1 = (wxWindow *) 0 ;
41041 wxSizer *arg2 = (wxSizer *) 0 ;
41042 void *argp1 = 0 ;
41043 int res1 = 0 ;
41044 void *argp2 = 0 ;
41045 int res2 = 0 ;
41046 PyObject * obj0 = 0 ;
41047 PyObject * obj1 = 0 ;
41048 char * kwnames[] = {
41049 (char *) "self",(char *) "sizer", NULL
41050 };
41051
41052 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
41053 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41054 if (!SWIG_IsOK(res1)) {
41055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
41056 }
41057 arg1 = reinterpret_cast< wxWindow * >(argp1);
41058 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
41059 if (!SWIG_IsOK(res2)) {
41060 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
41061 }
41062 arg2 = reinterpret_cast< wxSizer * >(argp2);
41063 {
41064 PyThreadState* __tstate = wxPyBeginAllowThreads();
41065 (arg1)->SetContainingSizer(arg2);
41066 wxPyEndAllowThreads(__tstate);
41067 if (PyErr_Occurred()) SWIG_fail;
41068 }
41069 resultobj = SWIG_Py_Void();
41070 return resultobj;
41071 fail:
41072 return NULL;
41073 }
41074
41075
41076 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41077 PyObject *resultobj = 0;
41078 wxWindow *arg1 = (wxWindow *) 0 ;
41079 wxSizer *result = 0 ;
41080 void *argp1 = 0 ;
41081 int res1 = 0 ;
41082 PyObject *swig_obj[1] ;
41083
41084 if (!args) SWIG_fail;
41085 swig_obj[0] = args;
41086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41087 if (!SWIG_IsOK(res1)) {
41088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
41089 }
41090 arg1 = reinterpret_cast< wxWindow * >(argp1);
41091 {
41092 PyThreadState* __tstate = wxPyBeginAllowThreads();
41093 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
41094 wxPyEndAllowThreads(__tstate);
41095 if (PyErr_Occurred()) SWIG_fail;
41096 }
41097 {
41098 resultobj = wxPyMake_wxObject(result, (bool)0);
41099 }
41100 return resultobj;
41101 fail:
41102 return NULL;
41103 }
41104
41105
41106 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41107 PyObject *resultobj = 0;
41108 wxWindow *arg1 = (wxWindow *) 0 ;
41109 void *argp1 = 0 ;
41110 int res1 = 0 ;
41111 PyObject *swig_obj[1] ;
41112
41113 if (!args) SWIG_fail;
41114 swig_obj[0] = args;
41115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41116 if (!SWIG_IsOK(res1)) {
41117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
41118 }
41119 arg1 = reinterpret_cast< wxWindow * >(argp1);
41120 {
41121 PyThreadState* __tstate = wxPyBeginAllowThreads();
41122 (arg1)->InheritAttributes();
41123 wxPyEndAllowThreads(__tstate);
41124 if (PyErr_Occurred()) SWIG_fail;
41125 }
41126 resultobj = SWIG_Py_Void();
41127 return resultobj;
41128 fail:
41129 return NULL;
41130 }
41131
41132
41133 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41134 PyObject *resultobj = 0;
41135 wxWindow *arg1 = (wxWindow *) 0 ;
41136 bool result;
41137 void *argp1 = 0 ;
41138 int res1 = 0 ;
41139 PyObject *swig_obj[1] ;
41140
41141 if (!args) SWIG_fail;
41142 swig_obj[0] = args;
41143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41144 if (!SWIG_IsOK(res1)) {
41145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
41146 }
41147 arg1 = reinterpret_cast< wxWindow * >(argp1);
41148 {
41149 PyThreadState* __tstate = wxPyBeginAllowThreads();
41150 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
41151 wxPyEndAllowThreads(__tstate);
41152 if (PyErr_Occurred()) SWIG_fail;
41153 }
41154 {
41155 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41156 }
41157 return resultobj;
41158 fail:
41159 return NULL;
41160 }
41161
41162
41163 SWIGINTERN PyObject *_wrap_Window_CanSetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41164 PyObject *resultobj = 0;
41165 wxWindow *arg1 = (wxWindow *) 0 ;
41166 bool result;
41167 void *argp1 = 0 ;
41168 int res1 = 0 ;
41169 PyObject *swig_obj[1] ;
41170
41171 if (!args) SWIG_fail;
41172 swig_obj[0] = args;
41173 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41174 if (!SWIG_IsOK(res1)) {
41175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CanSetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41176 }
41177 arg1 = reinterpret_cast< wxWindow * >(argp1);
41178 {
41179 PyThreadState* __tstate = wxPyBeginAllowThreads();
41180 result = (bool)(arg1)->CanSetTransparent();
41181 wxPyEndAllowThreads(__tstate);
41182 if (PyErr_Occurred()) SWIG_fail;
41183 }
41184 {
41185 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41186 }
41187 return resultobj;
41188 fail:
41189 return NULL;
41190 }
41191
41192
41193 SWIGINTERN PyObject *_wrap_Window_SetTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41194 PyObject *resultobj = 0;
41195 wxWindow *arg1 = (wxWindow *) 0 ;
41196 byte arg2 ;
41197 bool result;
41198 void *argp1 = 0 ;
41199 int res1 = 0 ;
41200 unsigned char val2 ;
41201 int ecode2 = 0 ;
41202 PyObject * obj0 = 0 ;
41203 PyObject * obj1 = 0 ;
41204 char * kwnames[] = {
41205 (char *) "self",(char *) "alpha", NULL
41206 };
41207
41208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetTransparent",kwnames,&obj0,&obj1)) SWIG_fail;
41209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41210 if (!SWIG_IsOK(res1)) {
41211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetTransparent" "', expected argument " "1"" of type '" "wxWindow *""'");
41212 }
41213 arg1 = reinterpret_cast< wxWindow * >(argp1);
41214 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
41215 if (!SWIG_IsOK(ecode2)) {
41216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetTransparent" "', expected argument " "2"" of type '" "byte""'");
41217 }
41218 arg2 = static_cast< byte >(val2);
41219 {
41220 PyThreadState* __tstate = wxPyBeginAllowThreads();
41221 result = (bool)(arg1)->SetTransparent(arg2);
41222 wxPyEndAllowThreads(__tstate);
41223 if (PyErr_Occurred()) SWIG_fail;
41224 }
41225 {
41226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41227 }
41228 return resultobj;
41229 fail:
41230 return NULL;
41231 }
41232
41233
41234 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41235 PyObject *obj;
41236 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41237 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
41238 return SWIG_Py_Void();
41239 }
41240
41241 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41242 return SWIG_Python_InitShadowInstance(args);
41243 }
41244
41245 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41246 PyObject *resultobj = 0;
41247 long arg1 ;
41248 wxWindow *arg2 = (wxWindow *) NULL ;
41249 wxWindow *result = 0 ;
41250 long val1 ;
41251 int ecode1 = 0 ;
41252 void *argp2 = 0 ;
41253 int res2 = 0 ;
41254 PyObject * obj0 = 0 ;
41255 PyObject * obj1 = 0 ;
41256 char * kwnames[] = {
41257 (char *) "id",(char *) "parent", NULL
41258 };
41259
41260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
41261 ecode1 = SWIG_AsVal_long(obj0, &val1);
41262 if (!SWIG_IsOK(ecode1)) {
41263 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
41264 }
41265 arg1 = static_cast< long >(val1);
41266 if (obj1) {
41267 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41268 if (!SWIG_IsOK(res2)) {
41269 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
41270 }
41271 arg2 = reinterpret_cast< wxWindow * >(argp2);
41272 }
41273 {
41274 if (!wxPyCheckForApp()) SWIG_fail;
41275 PyThreadState* __tstate = wxPyBeginAllowThreads();
41276 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
41277 wxPyEndAllowThreads(__tstate);
41278 if (PyErr_Occurred()) SWIG_fail;
41279 }
41280 {
41281 resultobj = wxPyMake_wxObject(result, 0);
41282 }
41283 return resultobj;
41284 fail:
41285 return NULL;
41286 }
41287
41288
41289 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41290 PyObject *resultobj = 0;
41291 wxString *arg1 = 0 ;
41292 wxWindow *arg2 = (wxWindow *) NULL ;
41293 wxWindow *result = 0 ;
41294 bool temp1 = false ;
41295 void *argp2 = 0 ;
41296 int res2 = 0 ;
41297 PyObject * obj0 = 0 ;
41298 PyObject * obj1 = 0 ;
41299 char * kwnames[] = {
41300 (char *) "name",(char *) "parent", NULL
41301 };
41302
41303 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
41304 {
41305 arg1 = wxString_in_helper(obj0);
41306 if (arg1 == NULL) SWIG_fail;
41307 temp1 = true;
41308 }
41309 if (obj1) {
41310 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41311 if (!SWIG_IsOK(res2)) {
41312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
41313 }
41314 arg2 = reinterpret_cast< wxWindow * >(argp2);
41315 }
41316 {
41317 if (!wxPyCheckForApp()) SWIG_fail;
41318 PyThreadState* __tstate = wxPyBeginAllowThreads();
41319 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
41320 wxPyEndAllowThreads(__tstate);
41321 if (PyErr_Occurred()) SWIG_fail;
41322 }
41323 {
41324 resultobj = wxPyMake_wxObject(result, 0);
41325 }
41326 {
41327 if (temp1)
41328 delete arg1;
41329 }
41330 return resultobj;
41331 fail:
41332 {
41333 if (temp1)
41334 delete arg1;
41335 }
41336 return NULL;
41337 }
41338
41339
41340 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41341 PyObject *resultobj = 0;
41342 wxString *arg1 = 0 ;
41343 wxWindow *arg2 = (wxWindow *) NULL ;
41344 wxWindow *result = 0 ;
41345 bool temp1 = false ;
41346 void *argp2 = 0 ;
41347 int res2 = 0 ;
41348 PyObject * obj0 = 0 ;
41349 PyObject * obj1 = 0 ;
41350 char * kwnames[] = {
41351 (char *) "label",(char *) "parent", NULL
41352 };
41353
41354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41355 {
41356 arg1 = wxString_in_helper(obj0);
41357 if (arg1 == NULL) SWIG_fail;
41358 temp1 = true;
41359 }
41360 if (obj1) {
41361 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41362 if (!SWIG_IsOK(res2)) {
41363 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
41364 }
41365 arg2 = reinterpret_cast< wxWindow * >(argp2);
41366 }
41367 {
41368 if (!wxPyCheckForApp()) SWIG_fail;
41369 PyThreadState* __tstate = wxPyBeginAllowThreads();
41370 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
41371 wxPyEndAllowThreads(__tstate);
41372 if (PyErr_Occurred()) SWIG_fail;
41373 }
41374 {
41375 resultobj = wxPyMake_wxObject(result, 0);
41376 }
41377 {
41378 if (temp1)
41379 delete arg1;
41380 }
41381 return resultobj;
41382 fail:
41383 {
41384 if (temp1)
41385 delete arg1;
41386 }
41387 return NULL;
41388 }
41389
41390
41391 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41392 PyObject *resultobj = 0;
41393 wxWindow *arg1 = (wxWindow *) 0 ;
41394 unsigned long arg2 ;
41395 wxWindow *result = 0 ;
41396 void *argp1 = 0 ;
41397 int res1 = 0 ;
41398 unsigned long val2 ;
41399 int ecode2 = 0 ;
41400 PyObject * obj0 = 0 ;
41401 PyObject * obj1 = 0 ;
41402 char * kwnames[] = {
41403 (char *) "parent",(char *) "_hWnd", NULL
41404 };
41405
41406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
41407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
41408 if (!SWIG_IsOK(res1)) {
41409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
41410 }
41411 arg1 = reinterpret_cast< wxWindow * >(argp1);
41412 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
41413 if (!SWIG_IsOK(ecode2)) {
41414 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
41415 }
41416 arg2 = static_cast< unsigned long >(val2);
41417 {
41418 if (!wxPyCheckForApp()) SWIG_fail;
41419 PyThreadState* __tstate = wxPyBeginAllowThreads();
41420 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
41421 wxPyEndAllowThreads(__tstate);
41422 if (PyErr_Occurred()) SWIG_fail;
41423 }
41424 {
41425 resultobj = wxPyMake_wxObject(result, 0);
41426 }
41427 return resultobj;
41428 fail:
41429 return NULL;
41430 }
41431
41432
41433 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41434 PyObject *resultobj = 0;
41435 PyObject *result = 0 ;
41436
41437 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
41438 {
41439 PyThreadState* __tstate = wxPyBeginAllowThreads();
41440 result = (PyObject *)GetTopLevelWindows();
41441 wxPyEndAllowThreads(__tstate);
41442 if (PyErr_Occurred()) SWIG_fail;
41443 }
41444 resultobj = result;
41445 return resultobj;
41446 fail:
41447 return NULL;
41448 }
41449
41450
41451 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41452 PyObject *resultobj = 0;
41453 wxValidator *result = 0 ;
41454
41455 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
41456 {
41457 PyThreadState* __tstate = wxPyBeginAllowThreads();
41458 result = (wxValidator *)new wxValidator();
41459 wxPyEndAllowThreads(__tstate);
41460 if (PyErr_Occurred()) SWIG_fail;
41461 }
41462 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
41463 return resultobj;
41464 fail:
41465 return NULL;
41466 }
41467
41468
41469 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41470 PyObject *resultobj = 0;
41471 wxValidator *arg1 = (wxValidator *) 0 ;
41472 wxValidator *result = 0 ;
41473 void *argp1 = 0 ;
41474 int res1 = 0 ;
41475 PyObject *swig_obj[1] ;
41476
41477 if (!args) SWIG_fail;
41478 swig_obj[0] = args;
41479 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41480 if (!SWIG_IsOK(res1)) {
41481 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
41482 }
41483 arg1 = reinterpret_cast< wxValidator * >(argp1);
41484 {
41485 PyThreadState* __tstate = wxPyBeginAllowThreads();
41486 result = (wxValidator *)(arg1)->Clone();
41487 wxPyEndAllowThreads(__tstate);
41488 if (PyErr_Occurred()) SWIG_fail;
41489 }
41490 {
41491 resultobj = wxPyMake_wxObject(result, 0);
41492 }
41493 return resultobj;
41494 fail:
41495 return NULL;
41496 }
41497
41498
41499 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41500 PyObject *resultobj = 0;
41501 wxValidator *arg1 = (wxValidator *) 0 ;
41502 wxWindow *arg2 = (wxWindow *) 0 ;
41503 bool result;
41504 void *argp1 = 0 ;
41505 int res1 = 0 ;
41506 void *argp2 = 0 ;
41507 int res2 = 0 ;
41508 PyObject * obj0 = 0 ;
41509 PyObject * obj1 = 0 ;
41510 char * kwnames[] = {
41511 (char *) "self",(char *) "parent", NULL
41512 };
41513
41514 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
41515 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41516 if (!SWIG_IsOK(res1)) {
41517 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
41518 }
41519 arg1 = reinterpret_cast< wxValidator * >(argp1);
41520 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41521 if (!SWIG_IsOK(res2)) {
41522 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
41523 }
41524 arg2 = reinterpret_cast< wxWindow * >(argp2);
41525 {
41526 PyThreadState* __tstate = wxPyBeginAllowThreads();
41527 result = (bool)(arg1)->Validate(arg2);
41528 wxPyEndAllowThreads(__tstate);
41529 if (PyErr_Occurred()) SWIG_fail;
41530 }
41531 {
41532 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41533 }
41534 return resultobj;
41535 fail:
41536 return NULL;
41537 }
41538
41539
41540 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41541 PyObject *resultobj = 0;
41542 wxValidator *arg1 = (wxValidator *) 0 ;
41543 bool result;
41544 void *argp1 = 0 ;
41545 int res1 = 0 ;
41546 PyObject *swig_obj[1] ;
41547
41548 if (!args) SWIG_fail;
41549 swig_obj[0] = args;
41550 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41551 if (!SWIG_IsOK(res1)) {
41552 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41553 }
41554 arg1 = reinterpret_cast< wxValidator * >(argp1);
41555 {
41556 PyThreadState* __tstate = wxPyBeginAllowThreads();
41557 result = (bool)(arg1)->TransferToWindow();
41558 wxPyEndAllowThreads(__tstate);
41559 if (PyErr_Occurred()) SWIG_fail;
41560 }
41561 {
41562 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41563 }
41564 return resultobj;
41565 fail:
41566 return NULL;
41567 }
41568
41569
41570 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41571 PyObject *resultobj = 0;
41572 wxValidator *arg1 = (wxValidator *) 0 ;
41573 bool result;
41574 void *argp1 = 0 ;
41575 int res1 = 0 ;
41576 PyObject *swig_obj[1] ;
41577
41578 if (!args) SWIG_fail;
41579 swig_obj[0] = args;
41580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41581 if (!SWIG_IsOK(res1)) {
41582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41583 }
41584 arg1 = reinterpret_cast< wxValidator * >(argp1);
41585 {
41586 PyThreadState* __tstate = wxPyBeginAllowThreads();
41587 result = (bool)(arg1)->TransferFromWindow();
41588 wxPyEndAllowThreads(__tstate);
41589 if (PyErr_Occurred()) SWIG_fail;
41590 }
41591 {
41592 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41593 }
41594 return resultobj;
41595 fail:
41596 return NULL;
41597 }
41598
41599
41600 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41601 PyObject *resultobj = 0;
41602 wxValidator *arg1 = (wxValidator *) 0 ;
41603 wxWindow *result = 0 ;
41604 void *argp1 = 0 ;
41605 int res1 = 0 ;
41606 PyObject *swig_obj[1] ;
41607
41608 if (!args) SWIG_fail;
41609 swig_obj[0] = args;
41610 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41611 if (!SWIG_IsOK(res1)) {
41612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41613 }
41614 arg1 = reinterpret_cast< wxValidator * >(argp1);
41615 {
41616 PyThreadState* __tstate = wxPyBeginAllowThreads();
41617 result = (wxWindow *)(arg1)->GetWindow();
41618 wxPyEndAllowThreads(__tstate);
41619 if (PyErr_Occurred()) SWIG_fail;
41620 }
41621 {
41622 resultobj = wxPyMake_wxObject(result, 0);
41623 }
41624 return resultobj;
41625 fail:
41626 return NULL;
41627 }
41628
41629
41630 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41631 PyObject *resultobj = 0;
41632 wxValidator *arg1 = (wxValidator *) 0 ;
41633 wxWindow *arg2 = (wxWindow *) 0 ;
41634 void *argp1 = 0 ;
41635 int res1 = 0 ;
41636 void *argp2 = 0 ;
41637 int res2 = 0 ;
41638 PyObject * obj0 = 0 ;
41639 PyObject * obj1 = 0 ;
41640 char * kwnames[] = {
41641 (char *) "self",(char *) "window", NULL
41642 };
41643
41644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
41645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
41646 if (!SWIG_IsOK(res1)) {
41647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
41648 }
41649 arg1 = reinterpret_cast< wxValidator * >(argp1);
41650 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
41651 if (!SWIG_IsOK(res2)) {
41652 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
41653 }
41654 arg2 = reinterpret_cast< wxWindow * >(argp2);
41655 {
41656 PyThreadState* __tstate = wxPyBeginAllowThreads();
41657 (arg1)->SetWindow(arg2);
41658 wxPyEndAllowThreads(__tstate);
41659 if (PyErr_Occurred()) SWIG_fail;
41660 }
41661 resultobj = SWIG_Py_Void();
41662 return resultobj;
41663 fail:
41664 return NULL;
41665 }
41666
41667
41668 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41669 PyObject *resultobj = 0;
41670 bool result;
41671
41672 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
41673 {
41674 PyThreadState* __tstate = wxPyBeginAllowThreads();
41675 result = (bool)wxValidator::IsSilent();
41676 wxPyEndAllowThreads(__tstate);
41677 if (PyErr_Occurred()) SWIG_fail;
41678 }
41679 {
41680 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41681 }
41682 return resultobj;
41683 fail:
41684 return NULL;
41685 }
41686
41687
41688 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41689 PyObject *resultobj = 0;
41690 int arg1 = (int) true ;
41691 int val1 ;
41692 int ecode1 = 0 ;
41693 PyObject * obj0 = 0 ;
41694 char * kwnames[] = {
41695 (char *) "doIt", NULL
41696 };
41697
41698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
41699 if (obj0) {
41700 ecode1 = SWIG_AsVal_int(obj0, &val1);
41701 if (!SWIG_IsOK(ecode1)) {
41702 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
41703 }
41704 arg1 = static_cast< int >(val1);
41705 }
41706 {
41707 PyThreadState* __tstate = wxPyBeginAllowThreads();
41708 wxValidator::SetBellOnError(arg1);
41709 wxPyEndAllowThreads(__tstate);
41710 if (PyErr_Occurred()) SWIG_fail;
41711 }
41712 resultobj = SWIG_Py_Void();
41713 return resultobj;
41714 fail:
41715 return NULL;
41716 }
41717
41718
41719 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41720 PyObject *obj;
41721 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41722 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
41723 return SWIG_Py_Void();
41724 }
41725
41726 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41727 return SWIG_Python_InitShadowInstance(args);
41728 }
41729
41730 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41731 PyObject *resultobj = 0;
41732 wxPyValidator *result = 0 ;
41733
41734 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
41735 {
41736 PyThreadState* __tstate = wxPyBeginAllowThreads();
41737 result = (wxPyValidator *)new wxPyValidator();
41738 wxPyEndAllowThreads(__tstate);
41739 if (PyErr_Occurred()) SWIG_fail;
41740 }
41741 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
41742 return resultobj;
41743 fail:
41744 return NULL;
41745 }
41746
41747
41748 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41749 PyObject *resultobj = 0;
41750 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
41751 PyObject *arg2 = (PyObject *) 0 ;
41752 PyObject *arg3 = (PyObject *) 0 ;
41753 int arg4 = (int) 1 ;
41754 void *argp1 = 0 ;
41755 int res1 = 0 ;
41756 int val4 ;
41757 int ecode4 = 0 ;
41758 PyObject * obj0 = 0 ;
41759 PyObject * obj1 = 0 ;
41760 PyObject * obj2 = 0 ;
41761 PyObject * obj3 = 0 ;
41762 char * kwnames[] = {
41763 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
41764 };
41765
41766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
41768 if (!SWIG_IsOK(res1)) {
41769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
41770 }
41771 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
41772 arg2 = obj1;
41773 arg3 = obj2;
41774 if (obj3) {
41775 ecode4 = SWIG_AsVal_int(obj3, &val4);
41776 if (!SWIG_IsOK(ecode4)) {
41777 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
41778 }
41779 arg4 = static_cast< int >(val4);
41780 }
41781 {
41782 PyThreadState* __tstate = wxPyBeginAllowThreads();
41783 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
41784 wxPyEndAllowThreads(__tstate);
41785 if (PyErr_Occurred()) SWIG_fail;
41786 }
41787 resultobj = SWIG_Py_Void();
41788 return resultobj;
41789 fail:
41790 return NULL;
41791 }
41792
41793
41794 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41795 PyObject *obj;
41796 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
41797 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
41798 return SWIG_Py_Void();
41799 }
41800
41801 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41802 return SWIG_Python_InitShadowInstance(args);
41803 }
41804
41805 SWIGINTERN int DefaultValidator_set(PyObject *) {
41806 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
41807 return 1;
41808 }
41809
41810
41811 SWIGINTERN PyObject *DefaultValidator_get(void) {
41812 PyObject *pyobj = 0;
41813
41814 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
41815 return pyobj;
41816 }
41817
41818
41819 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41820 PyObject *resultobj = 0;
41821 wxString const &arg1_defvalue = wxPyEmptyString ;
41822 wxString *arg1 = (wxString *) &arg1_defvalue ;
41823 long arg2 = (long) 0 ;
41824 wxMenu *result = 0 ;
41825 bool temp1 = false ;
41826 long val2 ;
41827 int ecode2 = 0 ;
41828 PyObject * obj0 = 0 ;
41829 PyObject * obj1 = 0 ;
41830 char * kwnames[] = {
41831 (char *) "title",(char *) "style", NULL
41832 };
41833
41834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
41835 if (obj0) {
41836 {
41837 arg1 = wxString_in_helper(obj0);
41838 if (arg1 == NULL) SWIG_fail;
41839 temp1 = true;
41840 }
41841 }
41842 if (obj1) {
41843 ecode2 = SWIG_AsVal_long(obj1, &val2);
41844 if (!SWIG_IsOK(ecode2)) {
41845 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
41846 }
41847 arg2 = static_cast< long >(val2);
41848 }
41849 {
41850 if (!wxPyCheckForApp()) SWIG_fail;
41851 PyThreadState* __tstate = wxPyBeginAllowThreads();
41852 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
41853 wxPyEndAllowThreads(__tstate);
41854 if (PyErr_Occurred()) SWIG_fail;
41855 }
41856 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
41857 {
41858 if (temp1)
41859 delete arg1;
41860 }
41861 return resultobj;
41862 fail:
41863 {
41864 if (temp1)
41865 delete arg1;
41866 }
41867 return NULL;
41868 }
41869
41870
41871 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41872 PyObject *resultobj = 0;
41873 wxMenu *arg1 = (wxMenu *) 0 ;
41874 int arg2 ;
41875 wxString const &arg3_defvalue = wxPyEmptyString ;
41876 wxString *arg3 = (wxString *) &arg3_defvalue ;
41877 wxString const &arg4_defvalue = wxPyEmptyString ;
41878 wxString *arg4 = (wxString *) &arg4_defvalue ;
41879 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
41880 wxMenuItem *result = 0 ;
41881 void *argp1 = 0 ;
41882 int res1 = 0 ;
41883 int val2 ;
41884 int ecode2 = 0 ;
41885 bool temp3 = false ;
41886 bool temp4 = false ;
41887 int val5 ;
41888 int ecode5 = 0 ;
41889 PyObject * obj0 = 0 ;
41890 PyObject * obj1 = 0 ;
41891 PyObject * obj2 = 0 ;
41892 PyObject * obj3 = 0 ;
41893 PyObject * obj4 = 0 ;
41894 char * kwnames[] = {
41895 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
41896 };
41897
41898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
41899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41900 if (!SWIG_IsOK(res1)) {
41901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
41902 }
41903 arg1 = reinterpret_cast< wxMenu * >(argp1);
41904 ecode2 = SWIG_AsVal_int(obj1, &val2);
41905 if (!SWIG_IsOK(ecode2)) {
41906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
41907 }
41908 arg2 = static_cast< int >(val2);
41909 if (obj2) {
41910 {
41911 arg3 = wxString_in_helper(obj2);
41912 if (arg3 == NULL) SWIG_fail;
41913 temp3 = true;
41914 }
41915 }
41916 if (obj3) {
41917 {
41918 arg4 = wxString_in_helper(obj3);
41919 if (arg4 == NULL) SWIG_fail;
41920 temp4 = true;
41921 }
41922 }
41923 if (obj4) {
41924 ecode5 = SWIG_AsVal_int(obj4, &val5);
41925 if (!SWIG_IsOK(ecode5)) {
41926 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
41927 }
41928 arg5 = static_cast< wxItemKind >(val5);
41929 }
41930 {
41931 PyThreadState* __tstate = wxPyBeginAllowThreads();
41932 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
41933 wxPyEndAllowThreads(__tstate);
41934 if (PyErr_Occurred()) SWIG_fail;
41935 }
41936 {
41937 resultobj = wxPyMake_wxObject(result, (bool)0);
41938 }
41939 {
41940 if (temp3)
41941 delete arg3;
41942 }
41943 {
41944 if (temp4)
41945 delete arg4;
41946 }
41947 return resultobj;
41948 fail:
41949 {
41950 if (temp3)
41951 delete arg3;
41952 }
41953 {
41954 if (temp4)
41955 delete arg4;
41956 }
41957 return NULL;
41958 }
41959
41960
41961 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41962 PyObject *resultobj = 0;
41963 wxMenu *arg1 = (wxMenu *) 0 ;
41964 wxMenuItem *result = 0 ;
41965 void *argp1 = 0 ;
41966 int res1 = 0 ;
41967 PyObject *swig_obj[1] ;
41968
41969 if (!args) SWIG_fail;
41970 swig_obj[0] = args;
41971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
41972 if (!SWIG_IsOK(res1)) {
41973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
41974 }
41975 arg1 = reinterpret_cast< wxMenu * >(argp1);
41976 {
41977 PyThreadState* __tstate = wxPyBeginAllowThreads();
41978 result = (wxMenuItem *)(arg1)->AppendSeparator();
41979 wxPyEndAllowThreads(__tstate);
41980 if (PyErr_Occurred()) SWIG_fail;
41981 }
41982 {
41983 resultobj = wxPyMake_wxObject(result, (bool)0);
41984 }
41985 return resultobj;
41986 fail:
41987 return NULL;
41988 }
41989
41990
41991 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41992 PyObject *resultobj = 0;
41993 wxMenu *arg1 = (wxMenu *) 0 ;
41994 int arg2 ;
41995 wxString *arg3 = 0 ;
41996 wxString const &arg4_defvalue = wxPyEmptyString ;
41997 wxString *arg4 = (wxString *) &arg4_defvalue ;
41998 wxMenuItem *result = 0 ;
41999 void *argp1 = 0 ;
42000 int res1 = 0 ;
42001 int val2 ;
42002 int ecode2 = 0 ;
42003 bool temp3 = false ;
42004 bool temp4 = false ;
42005 PyObject * obj0 = 0 ;
42006 PyObject * obj1 = 0 ;
42007 PyObject * obj2 = 0 ;
42008 PyObject * obj3 = 0 ;
42009 char * kwnames[] = {
42010 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42011 };
42012
42013 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42014 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42015 if (!SWIG_IsOK(res1)) {
42016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42017 }
42018 arg1 = reinterpret_cast< wxMenu * >(argp1);
42019 ecode2 = SWIG_AsVal_int(obj1, &val2);
42020 if (!SWIG_IsOK(ecode2)) {
42021 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
42022 }
42023 arg2 = static_cast< int >(val2);
42024 {
42025 arg3 = wxString_in_helper(obj2);
42026 if (arg3 == NULL) SWIG_fail;
42027 temp3 = true;
42028 }
42029 if (obj3) {
42030 {
42031 arg4 = wxString_in_helper(obj3);
42032 if (arg4 == NULL) SWIG_fail;
42033 temp4 = true;
42034 }
42035 }
42036 {
42037 PyThreadState* __tstate = wxPyBeginAllowThreads();
42038 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42039 wxPyEndAllowThreads(__tstate);
42040 if (PyErr_Occurred()) SWIG_fail;
42041 }
42042 {
42043 resultobj = wxPyMake_wxObject(result, (bool)0);
42044 }
42045 {
42046 if (temp3)
42047 delete arg3;
42048 }
42049 {
42050 if (temp4)
42051 delete arg4;
42052 }
42053 return resultobj;
42054 fail:
42055 {
42056 if (temp3)
42057 delete arg3;
42058 }
42059 {
42060 if (temp4)
42061 delete arg4;
42062 }
42063 return NULL;
42064 }
42065
42066
42067 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42068 PyObject *resultobj = 0;
42069 wxMenu *arg1 = (wxMenu *) 0 ;
42070 int arg2 ;
42071 wxString *arg3 = 0 ;
42072 wxString const &arg4_defvalue = wxPyEmptyString ;
42073 wxString *arg4 = (wxString *) &arg4_defvalue ;
42074 wxMenuItem *result = 0 ;
42075 void *argp1 = 0 ;
42076 int res1 = 0 ;
42077 int val2 ;
42078 int ecode2 = 0 ;
42079 bool temp3 = false ;
42080 bool temp4 = false ;
42081 PyObject * obj0 = 0 ;
42082 PyObject * obj1 = 0 ;
42083 PyObject * obj2 = 0 ;
42084 PyObject * obj3 = 0 ;
42085 char * kwnames[] = {
42086 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
42087 };
42088
42089 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42090 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42091 if (!SWIG_IsOK(res1)) {
42092 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42093 }
42094 arg1 = reinterpret_cast< wxMenu * >(argp1);
42095 ecode2 = SWIG_AsVal_int(obj1, &val2);
42096 if (!SWIG_IsOK(ecode2)) {
42097 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
42098 }
42099 arg2 = static_cast< int >(val2);
42100 {
42101 arg3 = wxString_in_helper(obj2);
42102 if (arg3 == NULL) SWIG_fail;
42103 temp3 = true;
42104 }
42105 if (obj3) {
42106 {
42107 arg4 = wxString_in_helper(obj3);
42108 if (arg4 == NULL) SWIG_fail;
42109 temp4 = true;
42110 }
42111 }
42112 {
42113 PyThreadState* __tstate = wxPyBeginAllowThreads();
42114 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42115 wxPyEndAllowThreads(__tstate);
42116 if (PyErr_Occurred()) SWIG_fail;
42117 }
42118 {
42119 resultobj = wxPyMake_wxObject(result, (bool)0);
42120 }
42121 {
42122 if (temp3)
42123 delete arg3;
42124 }
42125 {
42126 if (temp4)
42127 delete arg4;
42128 }
42129 return resultobj;
42130 fail:
42131 {
42132 if (temp3)
42133 delete arg3;
42134 }
42135 {
42136 if (temp4)
42137 delete arg4;
42138 }
42139 return NULL;
42140 }
42141
42142
42143 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42144 PyObject *resultobj = 0;
42145 wxMenu *arg1 = (wxMenu *) 0 ;
42146 int arg2 ;
42147 wxString *arg3 = 0 ;
42148 wxMenu *arg4 = (wxMenu *) 0 ;
42149 wxString const &arg5_defvalue = wxPyEmptyString ;
42150 wxString *arg5 = (wxString *) &arg5_defvalue ;
42151 wxMenuItem *result = 0 ;
42152 void *argp1 = 0 ;
42153 int res1 = 0 ;
42154 int val2 ;
42155 int ecode2 = 0 ;
42156 bool temp3 = false ;
42157 void *argp4 = 0 ;
42158 int res4 = 0 ;
42159 bool temp5 = false ;
42160 PyObject * obj0 = 0 ;
42161 PyObject * obj1 = 0 ;
42162 PyObject * obj2 = 0 ;
42163 PyObject * obj3 = 0 ;
42164 PyObject * obj4 = 0 ;
42165 char * kwnames[] = {
42166 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42167 };
42168
42169 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42170 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42171 if (!SWIG_IsOK(res1)) {
42172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42173 }
42174 arg1 = reinterpret_cast< wxMenu * >(argp1);
42175 ecode2 = SWIG_AsVal_int(obj1, &val2);
42176 if (!SWIG_IsOK(ecode2)) {
42177 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
42178 }
42179 arg2 = static_cast< int >(val2);
42180 {
42181 arg3 = wxString_in_helper(obj2);
42182 if (arg3 == NULL) SWIG_fail;
42183 temp3 = true;
42184 }
42185 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
42186 if (!SWIG_IsOK(res4)) {
42187 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
42188 }
42189 arg4 = reinterpret_cast< wxMenu * >(argp4);
42190 if (obj4) {
42191 {
42192 arg5 = wxString_in_helper(obj4);
42193 if (arg5 == NULL) SWIG_fail;
42194 temp5 = true;
42195 }
42196 }
42197 {
42198 PyThreadState* __tstate = wxPyBeginAllowThreads();
42199 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
42200 wxPyEndAllowThreads(__tstate);
42201 if (PyErr_Occurred()) SWIG_fail;
42202 }
42203 {
42204 resultobj = wxPyMake_wxObject(result, (bool)0);
42205 }
42206 {
42207 if (temp3)
42208 delete arg3;
42209 }
42210 {
42211 if (temp5)
42212 delete arg5;
42213 }
42214 return resultobj;
42215 fail:
42216 {
42217 if (temp3)
42218 delete arg3;
42219 }
42220 {
42221 if (temp5)
42222 delete arg5;
42223 }
42224 return NULL;
42225 }
42226
42227
42228 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42229 PyObject *resultobj = 0;
42230 wxMenu *arg1 = (wxMenu *) 0 ;
42231 wxMenu *arg2 = (wxMenu *) 0 ;
42232 wxString *arg3 = 0 ;
42233 wxString const &arg4_defvalue = wxPyEmptyString ;
42234 wxString *arg4 = (wxString *) &arg4_defvalue ;
42235 wxMenuItem *result = 0 ;
42236 void *argp1 = 0 ;
42237 int res1 = 0 ;
42238 void *argp2 = 0 ;
42239 int res2 = 0 ;
42240 bool temp3 = false ;
42241 bool temp4 = false ;
42242 PyObject * obj0 = 0 ;
42243 PyObject * obj1 = 0 ;
42244 PyObject * obj2 = 0 ;
42245 PyObject * obj3 = 0 ;
42246 char * kwnames[] = {
42247 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
42248 };
42249
42250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
42251 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42252 if (!SWIG_IsOK(res1)) {
42253 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42254 }
42255 arg1 = reinterpret_cast< wxMenu * >(argp1);
42256 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42257 if (!SWIG_IsOK(res2)) {
42258 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42259 }
42260 arg2 = reinterpret_cast< wxMenu * >(argp2);
42261 {
42262 arg3 = wxString_in_helper(obj2);
42263 if (arg3 == NULL) SWIG_fail;
42264 temp3 = true;
42265 }
42266 if (obj3) {
42267 {
42268 arg4 = wxString_in_helper(obj3);
42269 if (arg4 == NULL) SWIG_fail;
42270 temp4 = true;
42271 }
42272 }
42273 {
42274 PyThreadState* __tstate = wxPyBeginAllowThreads();
42275 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
42276 wxPyEndAllowThreads(__tstate);
42277 if (PyErr_Occurred()) SWIG_fail;
42278 }
42279 {
42280 resultobj = wxPyMake_wxObject(result, (bool)0);
42281 }
42282 {
42283 if (temp3)
42284 delete arg3;
42285 }
42286 {
42287 if (temp4)
42288 delete arg4;
42289 }
42290 return resultobj;
42291 fail:
42292 {
42293 if (temp3)
42294 delete arg3;
42295 }
42296 {
42297 if (temp4)
42298 delete arg4;
42299 }
42300 return NULL;
42301 }
42302
42303
42304 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42305 PyObject *resultobj = 0;
42306 wxMenu *arg1 = (wxMenu *) 0 ;
42307 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42308 wxMenuItem *result = 0 ;
42309 void *argp1 = 0 ;
42310 int res1 = 0 ;
42311 int res2 = 0 ;
42312 PyObject * obj0 = 0 ;
42313 PyObject * obj1 = 0 ;
42314 char * kwnames[] = {
42315 (char *) "self",(char *) "item", NULL
42316 };
42317
42318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
42319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42320 if (!SWIG_IsOK(res1)) {
42321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42322 }
42323 arg1 = reinterpret_cast< wxMenu * >(argp1);
42324 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42325 if (!SWIG_IsOK(res2)) {
42326 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42327 }
42328 {
42329 PyThreadState* __tstate = wxPyBeginAllowThreads();
42330 result = (wxMenuItem *)(arg1)->Append(arg2);
42331 wxPyEndAllowThreads(__tstate);
42332 if (PyErr_Occurred()) SWIG_fail;
42333 }
42334 {
42335 resultobj = wxPyMake_wxObject(result, (bool)0);
42336 }
42337 return resultobj;
42338 fail:
42339 return NULL;
42340 }
42341
42342
42343 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42344 PyObject *resultobj = 0;
42345 wxMenu *arg1 = (wxMenu *) 0 ;
42346 size_t arg2 ;
42347 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
42348 wxMenuItem *result = 0 ;
42349 void *argp1 = 0 ;
42350 int res1 = 0 ;
42351 size_t val2 ;
42352 int ecode2 = 0 ;
42353 int res3 = 0 ;
42354 PyObject * obj0 = 0 ;
42355 PyObject * obj1 = 0 ;
42356 PyObject * obj2 = 0 ;
42357 char * kwnames[] = {
42358 (char *) "self",(char *) "pos",(char *) "item", NULL
42359 };
42360
42361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
42362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42363 if (!SWIG_IsOK(res1)) {
42364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42365 }
42366 arg1 = reinterpret_cast< wxMenu * >(argp1);
42367 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42368 if (!SWIG_IsOK(ecode2)) {
42369 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
42370 }
42371 arg2 = static_cast< size_t >(val2);
42372 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42373 if (!SWIG_IsOK(res3)) {
42374 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
42375 }
42376 {
42377 PyThreadState* __tstate = wxPyBeginAllowThreads();
42378 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
42379 wxPyEndAllowThreads(__tstate);
42380 if (PyErr_Occurred()) SWIG_fail;
42381 }
42382 {
42383 resultobj = wxPyMake_wxObject(result, (bool)0);
42384 }
42385 return resultobj;
42386 fail:
42387 return NULL;
42388 }
42389
42390
42391 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42392 PyObject *resultobj = 0;
42393 wxMenu *arg1 = (wxMenu *) 0 ;
42394 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
42395 wxMenuItem *result = 0 ;
42396 void *argp1 = 0 ;
42397 int res1 = 0 ;
42398 int res2 = 0 ;
42399 PyObject * obj0 = 0 ;
42400 PyObject * obj1 = 0 ;
42401 char * kwnames[] = {
42402 (char *) "self",(char *) "item", NULL
42403 };
42404
42405 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
42406 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42407 if (!SWIG_IsOK(res1)) {
42408 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42409 }
42410 arg1 = reinterpret_cast< wxMenu * >(argp1);
42411 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42412 if (!SWIG_IsOK(res2)) {
42413 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
42414 }
42415 {
42416 PyThreadState* __tstate = wxPyBeginAllowThreads();
42417 result = (wxMenuItem *)(arg1)->Prepend(arg2);
42418 wxPyEndAllowThreads(__tstate);
42419 if (PyErr_Occurred()) SWIG_fail;
42420 }
42421 {
42422 resultobj = wxPyMake_wxObject(result, (bool)0);
42423 }
42424 return resultobj;
42425 fail:
42426 return NULL;
42427 }
42428
42429
42430 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42431 PyObject *resultobj = 0;
42432 wxMenu *arg1 = (wxMenu *) 0 ;
42433 void *argp1 = 0 ;
42434 int res1 = 0 ;
42435 PyObject *swig_obj[1] ;
42436
42437 if (!args) SWIG_fail;
42438 swig_obj[0] = args;
42439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42440 if (!SWIG_IsOK(res1)) {
42441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
42442 }
42443 arg1 = reinterpret_cast< wxMenu * >(argp1);
42444 {
42445 PyThreadState* __tstate = wxPyBeginAllowThreads();
42446 (arg1)->Break();
42447 wxPyEndAllowThreads(__tstate);
42448 if (PyErr_Occurred()) SWIG_fail;
42449 }
42450 resultobj = SWIG_Py_Void();
42451 return resultobj;
42452 fail:
42453 return NULL;
42454 }
42455
42456
42457 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42458 PyObject *resultobj = 0;
42459 wxMenu *arg1 = (wxMenu *) 0 ;
42460 size_t arg2 ;
42461 int arg3 ;
42462 wxString const &arg4_defvalue = wxPyEmptyString ;
42463 wxString *arg4 = (wxString *) &arg4_defvalue ;
42464 wxString const &arg5_defvalue = wxPyEmptyString ;
42465 wxString *arg5 = (wxString *) &arg5_defvalue ;
42466 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
42467 wxMenuItem *result = 0 ;
42468 void *argp1 = 0 ;
42469 int res1 = 0 ;
42470 size_t val2 ;
42471 int ecode2 = 0 ;
42472 int val3 ;
42473 int ecode3 = 0 ;
42474 bool temp4 = false ;
42475 bool temp5 = false ;
42476 int val6 ;
42477 int ecode6 = 0 ;
42478 PyObject * obj0 = 0 ;
42479 PyObject * obj1 = 0 ;
42480 PyObject * obj2 = 0 ;
42481 PyObject * obj3 = 0 ;
42482 PyObject * obj4 = 0 ;
42483 PyObject * obj5 = 0 ;
42484 char * kwnames[] = {
42485 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42486 };
42487
42488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42490 if (!SWIG_IsOK(res1)) {
42491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
42492 }
42493 arg1 = reinterpret_cast< wxMenu * >(argp1);
42494 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42495 if (!SWIG_IsOK(ecode2)) {
42496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
42497 }
42498 arg2 = static_cast< size_t >(val2);
42499 ecode3 = SWIG_AsVal_int(obj2, &val3);
42500 if (!SWIG_IsOK(ecode3)) {
42501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
42502 }
42503 arg3 = static_cast< int >(val3);
42504 if (obj3) {
42505 {
42506 arg4 = wxString_in_helper(obj3);
42507 if (arg4 == NULL) SWIG_fail;
42508 temp4 = true;
42509 }
42510 }
42511 if (obj4) {
42512 {
42513 arg5 = wxString_in_helper(obj4);
42514 if (arg5 == NULL) SWIG_fail;
42515 temp5 = true;
42516 }
42517 }
42518 if (obj5) {
42519 ecode6 = SWIG_AsVal_int(obj5, &val6);
42520 if (!SWIG_IsOK(ecode6)) {
42521 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
42522 }
42523 arg6 = static_cast< wxItemKind >(val6);
42524 }
42525 {
42526 PyThreadState* __tstate = wxPyBeginAllowThreads();
42527 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
42528 wxPyEndAllowThreads(__tstate);
42529 if (PyErr_Occurred()) SWIG_fail;
42530 }
42531 {
42532 resultobj = wxPyMake_wxObject(result, (bool)0);
42533 }
42534 {
42535 if (temp4)
42536 delete arg4;
42537 }
42538 {
42539 if (temp5)
42540 delete arg5;
42541 }
42542 return resultobj;
42543 fail:
42544 {
42545 if (temp4)
42546 delete arg4;
42547 }
42548 {
42549 if (temp5)
42550 delete arg5;
42551 }
42552 return NULL;
42553 }
42554
42555
42556 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42557 PyObject *resultobj = 0;
42558 wxMenu *arg1 = (wxMenu *) 0 ;
42559 size_t arg2 ;
42560 wxMenuItem *result = 0 ;
42561 void *argp1 = 0 ;
42562 int res1 = 0 ;
42563 size_t val2 ;
42564 int ecode2 = 0 ;
42565 PyObject * obj0 = 0 ;
42566 PyObject * obj1 = 0 ;
42567 char * kwnames[] = {
42568 (char *) "self",(char *) "pos", NULL
42569 };
42570
42571 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
42572 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42573 if (!SWIG_IsOK(res1)) {
42574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42575 }
42576 arg1 = reinterpret_cast< wxMenu * >(argp1);
42577 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42578 if (!SWIG_IsOK(ecode2)) {
42579 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
42580 }
42581 arg2 = static_cast< size_t >(val2);
42582 {
42583 PyThreadState* __tstate = wxPyBeginAllowThreads();
42584 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
42585 wxPyEndAllowThreads(__tstate);
42586 if (PyErr_Occurred()) SWIG_fail;
42587 }
42588 {
42589 resultobj = wxPyMake_wxObject(result, (bool)0);
42590 }
42591 return resultobj;
42592 fail:
42593 return NULL;
42594 }
42595
42596
42597 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42598 PyObject *resultobj = 0;
42599 wxMenu *arg1 = (wxMenu *) 0 ;
42600 size_t arg2 ;
42601 int arg3 ;
42602 wxString *arg4 = 0 ;
42603 wxString const &arg5_defvalue = wxPyEmptyString ;
42604 wxString *arg5 = (wxString *) &arg5_defvalue ;
42605 wxMenuItem *result = 0 ;
42606 void *argp1 = 0 ;
42607 int res1 = 0 ;
42608 size_t val2 ;
42609 int ecode2 = 0 ;
42610 int val3 ;
42611 int ecode3 = 0 ;
42612 bool temp4 = false ;
42613 bool temp5 = false ;
42614 PyObject * obj0 = 0 ;
42615 PyObject * obj1 = 0 ;
42616 PyObject * obj2 = 0 ;
42617 PyObject * obj3 = 0 ;
42618 PyObject * obj4 = 0 ;
42619 char * kwnames[] = {
42620 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42621 };
42622
42623 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42624 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42625 if (!SWIG_IsOK(res1)) {
42626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42627 }
42628 arg1 = reinterpret_cast< wxMenu * >(argp1);
42629 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42630 if (!SWIG_IsOK(ecode2)) {
42631 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
42632 }
42633 arg2 = static_cast< size_t >(val2);
42634 ecode3 = SWIG_AsVal_int(obj2, &val3);
42635 if (!SWIG_IsOK(ecode3)) {
42636 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
42637 }
42638 arg3 = static_cast< int >(val3);
42639 {
42640 arg4 = wxString_in_helper(obj3);
42641 if (arg4 == NULL) SWIG_fail;
42642 temp4 = true;
42643 }
42644 if (obj4) {
42645 {
42646 arg5 = wxString_in_helper(obj4);
42647 if (arg5 == NULL) SWIG_fail;
42648 temp5 = true;
42649 }
42650 }
42651 {
42652 PyThreadState* __tstate = wxPyBeginAllowThreads();
42653 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42654 wxPyEndAllowThreads(__tstate);
42655 if (PyErr_Occurred()) SWIG_fail;
42656 }
42657 {
42658 resultobj = wxPyMake_wxObject(result, (bool)0);
42659 }
42660 {
42661 if (temp4)
42662 delete arg4;
42663 }
42664 {
42665 if (temp5)
42666 delete arg5;
42667 }
42668 return resultobj;
42669 fail:
42670 {
42671 if (temp4)
42672 delete arg4;
42673 }
42674 {
42675 if (temp5)
42676 delete arg5;
42677 }
42678 return NULL;
42679 }
42680
42681
42682 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42683 PyObject *resultobj = 0;
42684 wxMenu *arg1 = (wxMenu *) 0 ;
42685 size_t arg2 ;
42686 int arg3 ;
42687 wxString *arg4 = 0 ;
42688 wxString const &arg5_defvalue = wxPyEmptyString ;
42689 wxString *arg5 = (wxString *) &arg5_defvalue ;
42690 wxMenuItem *result = 0 ;
42691 void *argp1 = 0 ;
42692 int res1 = 0 ;
42693 size_t val2 ;
42694 int ecode2 = 0 ;
42695 int val3 ;
42696 int ecode3 = 0 ;
42697 bool temp4 = false ;
42698 bool temp5 = false ;
42699 PyObject * obj0 = 0 ;
42700 PyObject * obj1 = 0 ;
42701 PyObject * obj2 = 0 ;
42702 PyObject * obj3 = 0 ;
42703 PyObject * obj4 = 0 ;
42704 char * kwnames[] = {
42705 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
42706 };
42707
42708 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42709 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42710 if (!SWIG_IsOK(res1)) {
42711 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42712 }
42713 arg1 = reinterpret_cast< wxMenu * >(argp1);
42714 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42715 if (!SWIG_IsOK(ecode2)) {
42716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
42717 }
42718 arg2 = static_cast< size_t >(val2);
42719 ecode3 = SWIG_AsVal_int(obj2, &val3);
42720 if (!SWIG_IsOK(ecode3)) {
42721 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
42722 }
42723 arg3 = static_cast< int >(val3);
42724 {
42725 arg4 = wxString_in_helper(obj3);
42726 if (arg4 == NULL) SWIG_fail;
42727 temp4 = true;
42728 }
42729 if (obj4) {
42730 {
42731 arg5 = wxString_in_helper(obj4);
42732 if (arg5 == NULL) SWIG_fail;
42733 temp5 = true;
42734 }
42735 }
42736 {
42737 PyThreadState* __tstate = wxPyBeginAllowThreads();
42738 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
42739 wxPyEndAllowThreads(__tstate);
42740 if (PyErr_Occurred()) SWIG_fail;
42741 }
42742 {
42743 resultobj = wxPyMake_wxObject(result, (bool)0);
42744 }
42745 {
42746 if (temp4)
42747 delete arg4;
42748 }
42749 {
42750 if (temp5)
42751 delete arg5;
42752 }
42753 return resultobj;
42754 fail:
42755 {
42756 if (temp4)
42757 delete arg4;
42758 }
42759 {
42760 if (temp5)
42761 delete arg5;
42762 }
42763 return NULL;
42764 }
42765
42766
42767 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42768 PyObject *resultobj = 0;
42769 wxMenu *arg1 = (wxMenu *) 0 ;
42770 size_t arg2 ;
42771 int arg3 ;
42772 wxString *arg4 = 0 ;
42773 wxMenu *arg5 = (wxMenu *) 0 ;
42774 wxString const &arg6_defvalue = wxPyEmptyString ;
42775 wxString *arg6 = (wxString *) &arg6_defvalue ;
42776 wxMenuItem *result = 0 ;
42777 void *argp1 = 0 ;
42778 int res1 = 0 ;
42779 size_t val2 ;
42780 int ecode2 = 0 ;
42781 int val3 ;
42782 int ecode3 = 0 ;
42783 bool temp4 = false ;
42784 void *argp5 = 0 ;
42785 int res5 = 0 ;
42786 bool temp6 = false ;
42787 PyObject * obj0 = 0 ;
42788 PyObject * obj1 = 0 ;
42789 PyObject * obj2 = 0 ;
42790 PyObject * obj3 = 0 ;
42791 PyObject * obj4 = 0 ;
42792 PyObject * obj5 = 0 ;
42793 char * kwnames[] = {
42794 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
42795 };
42796
42797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42799 if (!SWIG_IsOK(res1)) {
42800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
42801 }
42802 arg1 = reinterpret_cast< wxMenu * >(argp1);
42803 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
42804 if (!SWIG_IsOK(ecode2)) {
42805 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
42806 }
42807 arg2 = static_cast< size_t >(val2);
42808 ecode3 = SWIG_AsVal_int(obj2, &val3);
42809 if (!SWIG_IsOK(ecode3)) {
42810 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
42811 }
42812 arg3 = static_cast< int >(val3);
42813 {
42814 arg4 = wxString_in_helper(obj3);
42815 if (arg4 == NULL) SWIG_fail;
42816 temp4 = true;
42817 }
42818 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
42819 if (!SWIG_IsOK(res5)) {
42820 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
42821 }
42822 arg5 = reinterpret_cast< wxMenu * >(argp5);
42823 if (obj5) {
42824 {
42825 arg6 = wxString_in_helper(obj5);
42826 if (arg6 == NULL) SWIG_fail;
42827 temp6 = true;
42828 }
42829 }
42830 {
42831 PyThreadState* __tstate = wxPyBeginAllowThreads();
42832 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
42833 wxPyEndAllowThreads(__tstate);
42834 if (PyErr_Occurred()) SWIG_fail;
42835 }
42836 {
42837 resultobj = wxPyMake_wxObject(result, (bool)0);
42838 }
42839 {
42840 if (temp4)
42841 delete arg4;
42842 }
42843 {
42844 if (temp6)
42845 delete arg6;
42846 }
42847 return resultobj;
42848 fail:
42849 {
42850 if (temp4)
42851 delete arg4;
42852 }
42853 {
42854 if (temp6)
42855 delete arg6;
42856 }
42857 return NULL;
42858 }
42859
42860
42861 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42862 PyObject *resultobj = 0;
42863 wxMenu *arg1 = (wxMenu *) 0 ;
42864 int arg2 ;
42865 wxString const &arg3_defvalue = wxPyEmptyString ;
42866 wxString *arg3 = (wxString *) &arg3_defvalue ;
42867 wxString const &arg4_defvalue = wxPyEmptyString ;
42868 wxString *arg4 = (wxString *) &arg4_defvalue ;
42869 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42870 wxMenuItem *result = 0 ;
42871 void *argp1 = 0 ;
42872 int res1 = 0 ;
42873 int val2 ;
42874 int ecode2 = 0 ;
42875 bool temp3 = false ;
42876 bool temp4 = false ;
42877 int val5 ;
42878 int ecode5 = 0 ;
42879 PyObject * obj0 = 0 ;
42880 PyObject * obj1 = 0 ;
42881 PyObject * obj2 = 0 ;
42882 PyObject * obj3 = 0 ;
42883 PyObject * obj4 = 0 ;
42884 char * kwnames[] = {
42885 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
42886 };
42887
42888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
42889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42890 if (!SWIG_IsOK(res1)) {
42891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
42892 }
42893 arg1 = reinterpret_cast< wxMenu * >(argp1);
42894 ecode2 = SWIG_AsVal_int(obj1, &val2);
42895 if (!SWIG_IsOK(ecode2)) {
42896 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
42897 }
42898 arg2 = static_cast< int >(val2);
42899 if (obj2) {
42900 {
42901 arg3 = wxString_in_helper(obj2);
42902 if (arg3 == NULL) SWIG_fail;
42903 temp3 = true;
42904 }
42905 }
42906 if (obj3) {
42907 {
42908 arg4 = wxString_in_helper(obj3);
42909 if (arg4 == NULL) SWIG_fail;
42910 temp4 = true;
42911 }
42912 }
42913 if (obj4) {
42914 ecode5 = SWIG_AsVal_int(obj4, &val5);
42915 if (!SWIG_IsOK(ecode5)) {
42916 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
42917 }
42918 arg5 = static_cast< wxItemKind >(val5);
42919 }
42920 {
42921 PyThreadState* __tstate = wxPyBeginAllowThreads();
42922 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
42923 wxPyEndAllowThreads(__tstate);
42924 if (PyErr_Occurred()) SWIG_fail;
42925 }
42926 {
42927 resultobj = wxPyMake_wxObject(result, (bool)0);
42928 }
42929 {
42930 if (temp3)
42931 delete arg3;
42932 }
42933 {
42934 if (temp4)
42935 delete arg4;
42936 }
42937 return resultobj;
42938 fail:
42939 {
42940 if (temp3)
42941 delete arg3;
42942 }
42943 {
42944 if (temp4)
42945 delete arg4;
42946 }
42947 return NULL;
42948 }
42949
42950
42951 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42952 PyObject *resultobj = 0;
42953 wxMenu *arg1 = (wxMenu *) 0 ;
42954 wxMenuItem *result = 0 ;
42955 void *argp1 = 0 ;
42956 int res1 = 0 ;
42957 PyObject *swig_obj[1] ;
42958
42959 if (!args) SWIG_fail;
42960 swig_obj[0] = args;
42961 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42962 if (!SWIG_IsOK(res1)) {
42963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
42964 }
42965 arg1 = reinterpret_cast< wxMenu * >(argp1);
42966 {
42967 PyThreadState* __tstate = wxPyBeginAllowThreads();
42968 result = (wxMenuItem *)(arg1)->PrependSeparator();
42969 wxPyEndAllowThreads(__tstate);
42970 if (PyErr_Occurred()) SWIG_fail;
42971 }
42972 {
42973 resultobj = wxPyMake_wxObject(result, (bool)0);
42974 }
42975 return resultobj;
42976 fail:
42977 return NULL;
42978 }
42979
42980
42981 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42982 PyObject *resultobj = 0;
42983 wxMenu *arg1 = (wxMenu *) 0 ;
42984 int arg2 ;
42985 wxString *arg3 = 0 ;
42986 wxString const &arg4_defvalue = wxPyEmptyString ;
42987 wxString *arg4 = (wxString *) &arg4_defvalue ;
42988 wxMenuItem *result = 0 ;
42989 void *argp1 = 0 ;
42990 int res1 = 0 ;
42991 int val2 ;
42992 int ecode2 = 0 ;
42993 bool temp3 = false ;
42994 bool temp4 = false ;
42995 PyObject * obj0 = 0 ;
42996 PyObject * obj1 = 0 ;
42997 PyObject * obj2 = 0 ;
42998 PyObject * obj3 = 0 ;
42999 char * kwnames[] = {
43000 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43001 };
43002
43003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43005 if (!SWIG_IsOK(res1)) {
43006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43007 }
43008 arg1 = reinterpret_cast< wxMenu * >(argp1);
43009 ecode2 = SWIG_AsVal_int(obj1, &val2);
43010 if (!SWIG_IsOK(ecode2)) {
43011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
43012 }
43013 arg2 = static_cast< int >(val2);
43014 {
43015 arg3 = wxString_in_helper(obj2);
43016 if (arg3 == NULL) SWIG_fail;
43017 temp3 = true;
43018 }
43019 if (obj3) {
43020 {
43021 arg4 = wxString_in_helper(obj3);
43022 if (arg4 == NULL) SWIG_fail;
43023 temp4 = true;
43024 }
43025 }
43026 {
43027 PyThreadState* __tstate = wxPyBeginAllowThreads();
43028 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43029 wxPyEndAllowThreads(__tstate);
43030 if (PyErr_Occurred()) SWIG_fail;
43031 }
43032 {
43033 resultobj = wxPyMake_wxObject(result, (bool)0);
43034 }
43035 {
43036 if (temp3)
43037 delete arg3;
43038 }
43039 {
43040 if (temp4)
43041 delete arg4;
43042 }
43043 return resultobj;
43044 fail:
43045 {
43046 if (temp3)
43047 delete arg3;
43048 }
43049 {
43050 if (temp4)
43051 delete arg4;
43052 }
43053 return NULL;
43054 }
43055
43056
43057 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43058 PyObject *resultobj = 0;
43059 wxMenu *arg1 = (wxMenu *) 0 ;
43060 int arg2 ;
43061 wxString *arg3 = 0 ;
43062 wxString const &arg4_defvalue = wxPyEmptyString ;
43063 wxString *arg4 = (wxString *) &arg4_defvalue ;
43064 wxMenuItem *result = 0 ;
43065 void *argp1 = 0 ;
43066 int res1 = 0 ;
43067 int val2 ;
43068 int ecode2 = 0 ;
43069 bool temp3 = false ;
43070 bool temp4 = false ;
43071 PyObject * obj0 = 0 ;
43072 PyObject * obj1 = 0 ;
43073 PyObject * obj2 = 0 ;
43074 PyObject * obj3 = 0 ;
43075 char * kwnames[] = {
43076 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
43077 };
43078
43079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
43080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43081 if (!SWIG_IsOK(res1)) {
43082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43083 }
43084 arg1 = reinterpret_cast< wxMenu * >(argp1);
43085 ecode2 = SWIG_AsVal_int(obj1, &val2);
43086 if (!SWIG_IsOK(ecode2)) {
43087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
43088 }
43089 arg2 = static_cast< int >(val2);
43090 {
43091 arg3 = wxString_in_helper(obj2);
43092 if (arg3 == NULL) SWIG_fail;
43093 temp3 = true;
43094 }
43095 if (obj3) {
43096 {
43097 arg4 = wxString_in_helper(obj3);
43098 if (arg4 == NULL) SWIG_fail;
43099 temp4 = true;
43100 }
43101 }
43102 {
43103 PyThreadState* __tstate = wxPyBeginAllowThreads();
43104 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
43105 wxPyEndAllowThreads(__tstate);
43106 if (PyErr_Occurred()) SWIG_fail;
43107 }
43108 {
43109 resultobj = wxPyMake_wxObject(result, (bool)0);
43110 }
43111 {
43112 if (temp3)
43113 delete arg3;
43114 }
43115 {
43116 if (temp4)
43117 delete arg4;
43118 }
43119 return resultobj;
43120 fail:
43121 {
43122 if (temp3)
43123 delete arg3;
43124 }
43125 {
43126 if (temp4)
43127 delete arg4;
43128 }
43129 return NULL;
43130 }
43131
43132
43133 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43134 PyObject *resultobj = 0;
43135 wxMenu *arg1 = (wxMenu *) 0 ;
43136 int arg2 ;
43137 wxString *arg3 = 0 ;
43138 wxMenu *arg4 = (wxMenu *) 0 ;
43139 wxString const &arg5_defvalue = wxPyEmptyString ;
43140 wxString *arg5 = (wxString *) &arg5_defvalue ;
43141 wxMenuItem *result = 0 ;
43142 void *argp1 = 0 ;
43143 int res1 = 0 ;
43144 int val2 ;
43145 int ecode2 = 0 ;
43146 bool temp3 = false ;
43147 void *argp4 = 0 ;
43148 int res4 = 0 ;
43149 bool temp5 = false ;
43150 PyObject * obj0 = 0 ;
43151 PyObject * obj1 = 0 ;
43152 PyObject * obj2 = 0 ;
43153 PyObject * obj3 = 0 ;
43154 PyObject * obj4 = 0 ;
43155 char * kwnames[] = {
43156 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
43157 };
43158
43159 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
43160 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43161 if (!SWIG_IsOK(res1)) {
43162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
43163 }
43164 arg1 = reinterpret_cast< wxMenu * >(argp1);
43165 ecode2 = SWIG_AsVal_int(obj1, &val2);
43166 if (!SWIG_IsOK(ecode2)) {
43167 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
43168 }
43169 arg2 = static_cast< int >(val2);
43170 {
43171 arg3 = wxString_in_helper(obj2);
43172 if (arg3 == NULL) SWIG_fail;
43173 temp3 = true;
43174 }
43175 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
43176 if (!SWIG_IsOK(res4)) {
43177 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
43178 }
43179 arg4 = reinterpret_cast< wxMenu * >(argp4);
43180 if (obj4) {
43181 {
43182 arg5 = wxString_in_helper(obj4);
43183 if (arg5 == NULL) SWIG_fail;
43184 temp5 = true;
43185 }
43186 }
43187 {
43188 PyThreadState* __tstate = wxPyBeginAllowThreads();
43189 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
43190 wxPyEndAllowThreads(__tstate);
43191 if (PyErr_Occurred()) SWIG_fail;
43192 }
43193 {
43194 resultobj = wxPyMake_wxObject(result, (bool)0);
43195 }
43196 {
43197 if (temp3)
43198 delete arg3;
43199 }
43200 {
43201 if (temp5)
43202 delete arg5;
43203 }
43204 return resultobj;
43205 fail:
43206 {
43207 if (temp3)
43208 delete arg3;
43209 }
43210 {
43211 if (temp5)
43212 delete arg5;
43213 }
43214 return NULL;
43215 }
43216
43217
43218 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43219 PyObject *resultobj = 0;
43220 wxMenu *arg1 = (wxMenu *) 0 ;
43221 int arg2 ;
43222 wxMenuItem *result = 0 ;
43223 void *argp1 = 0 ;
43224 int res1 = 0 ;
43225 int val2 ;
43226 int ecode2 = 0 ;
43227 PyObject * obj0 = 0 ;
43228 PyObject * obj1 = 0 ;
43229 char * kwnames[] = {
43230 (char *) "self",(char *) "id", NULL
43231 };
43232
43233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
43234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43235 if (!SWIG_IsOK(res1)) {
43236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
43237 }
43238 arg1 = reinterpret_cast< wxMenu * >(argp1);
43239 ecode2 = SWIG_AsVal_int(obj1, &val2);
43240 if (!SWIG_IsOK(ecode2)) {
43241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
43242 }
43243 arg2 = static_cast< int >(val2);
43244 {
43245 PyThreadState* __tstate = wxPyBeginAllowThreads();
43246 result = (wxMenuItem *)(arg1)->Remove(arg2);
43247 wxPyEndAllowThreads(__tstate);
43248 if (PyErr_Occurred()) SWIG_fail;
43249 }
43250 {
43251 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43252 }
43253 return resultobj;
43254 fail:
43255 return NULL;
43256 }
43257
43258
43259 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43260 PyObject *resultobj = 0;
43261 wxMenu *arg1 = (wxMenu *) 0 ;
43262 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43263 wxMenuItem *result = 0 ;
43264 void *argp1 = 0 ;
43265 int res1 = 0 ;
43266 void *argp2 = 0 ;
43267 int res2 = 0 ;
43268 PyObject * obj0 = 0 ;
43269 PyObject * obj1 = 0 ;
43270 char * kwnames[] = {
43271 (char *) "self",(char *) "item", NULL
43272 };
43273
43274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
43275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43276 if (!SWIG_IsOK(res1)) {
43277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43278 }
43279 arg1 = reinterpret_cast< wxMenu * >(argp1);
43280 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43281 if (!SWIG_IsOK(res2)) {
43282 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43283 }
43284 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43285 {
43286 PyThreadState* __tstate = wxPyBeginAllowThreads();
43287 result = (wxMenuItem *)(arg1)->Remove(arg2);
43288 wxPyEndAllowThreads(__tstate);
43289 if (PyErr_Occurred()) SWIG_fail;
43290 }
43291 {
43292 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
43293 }
43294 return resultobj;
43295 fail:
43296 return NULL;
43297 }
43298
43299
43300 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43301 PyObject *resultobj = 0;
43302 wxMenu *arg1 = (wxMenu *) 0 ;
43303 int arg2 ;
43304 bool result;
43305 void *argp1 = 0 ;
43306 int res1 = 0 ;
43307 int val2 ;
43308 int ecode2 = 0 ;
43309 PyObject * obj0 = 0 ;
43310 PyObject * obj1 = 0 ;
43311 char * kwnames[] = {
43312 (char *) "self",(char *) "id", NULL
43313 };
43314
43315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
43316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43317 if (!SWIG_IsOK(res1)) {
43318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
43319 }
43320 arg1 = reinterpret_cast< wxMenu * >(argp1);
43321 ecode2 = SWIG_AsVal_int(obj1, &val2);
43322 if (!SWIG_IsOK(ecode2)) {
43323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
43324 }
43325 arg2 = static_cast< int >(val2);
43326 {
43327 PyThreadState* __tstate = wxPyBeginAllowThreads();
43328 result = (bool)(arg1)->Delete(arg2);
43329 wxPyEndAllowThreads(__tstate);
43330 if (PyErr_Occurred()) SWIG_fail;
43331 }
43332 {
43333 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43334 }
43335 return resultobj;
43336 fail:
43337 return NULL;
43338 }
43339
43340
43341 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43342 PyObject *resultobj = 0;
43343 wxMenu *arg1 = (wxMenu *) 0 ;
43344 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43345 bool result;
43346 void *argp1 = 0 ;
43347 int res1 = 0 ;
43348 void *argp2 = 0 ;
43349 int res2 = 0 ;
43350 PyObject * obj0 = 0 ;
43351 PyObject * obj1 = 0 ;
43352 char * kwnames[] = {
43353 (char *) "self",(char *) "item", NULL
43354 };
43355
43356 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
43357 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43358 if (!SWIG_IsOK(res1)) {
43359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43360 }
43361 arg1 = reinterpret_cast< wxMenu * >(argp1);
43362 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43363 if (!SWIG_IsOK(res2)) {
43364 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43365 }
43366 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43367 {
43368 PyThreadState* __tstate = wxPyBeginAllowThreads();
43369 result = (bool)(arg1)->Delete(arg2);
43370 wxPyEndAllowThreads(__tstate);
43371 if (PyErr_Occurred()) SWIG_fail;
43372 }
43373 {
43374 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43375 }
43376 return resultobj;
43377 fail:
43378 return NULL;
43379 }
43380
43381
43382 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43383 PyObject *resultobj = 0;
43384 wxMenu *arg1 = (wxMenu *) 0 ;
43385 void *argp1 = 0 ;
43386 int res1 = 0 ;
43387 PyObject *swig_obj[1] ;
43388
43389 if (!args) SWIG_fail;
43390 swig_obj[0] = args;
43391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43392 if (!SWIG_IsOK(res1)) {
43393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
43394 }
43395 arg1 = reinterpret_cast< wxMenu * >(argp1);
43396 {
43397 PyThreadState* __tstate = wxPyBeginAllowThreads();
43398 wxMenu_Destroy(arg1);
43399 wxPyEndAllowThreads(__tstate);
43400 if (PyErr_Occurred()) SWIG_fail;
43401 }
43402 resultobj = SWIG_Py_Void();
43403 return resultobj;
43404 fail:
43405 return NULL;
43406 }
43407
43408
43409 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43410 PyObject *resultobj = 0;
43411 wxMenu *arg1 = (wxMenu *) 0 ;
43412 int arg2 ;
43413 bool result;
43414 void *argp1 = 0 ;
43415 int res1 = 0 ;
43416 int val2 ;
43417 int ecode2 = 0 ;
43418 PyObject * obj0 = 0 ;
43419 PyObject * obj1 = 0 ;
43420 char * kwnames[] = {
43421 (char *) "self",(char *) "id", NULL
43422 };
43423
43424 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
43425 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43426 if (!SWIG_IsOK(res1)) {
43427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
43428 }
43429 arg1 = reinterpret_cast< wxMenu * >(argp1);
43430 ecode2 = SWIG_AsVal_int(obj1, &val2);
43431 if (!SWIG_IsOK(ecode2)) {
43432 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
43433 }
43434 arg2 = static_cast< int >(val2);
43435 {
43436 PyThreadState* __tstate = wxPyBeginAllowThreads();
43437 result = (bool)(arg1)->Destroy(arg2);
43438 wxPyEndAllowThreads(__tstate);
43439 if (PyErr_Occurred()) SWIG_fail;
43440 }
43441 {
43442 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43443 }
43444 return resultobj;
43445 fail:
43446 return NULL;
43447 }
43448
43449
43450 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43451 PyObject *resultobj = 0;
43452 wxMenu *arg1 = (wxMenu *) 0 ;
43453 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
43454 bool result;
43455 void *argp1 = 0 ;
43456 int res1 = 0 ;
43457 void *argp2 = 0 ;
43458 int res2 = 0 ;
43459 PyObject * obj0 = 0 ;
43460 PyObject * obj1 = 0 ;
43461 char * kwnames[] = {
43462 (char *) "self",(char *) "item", NULL
43463 };
43464
43465 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
43466 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43467 if (!SWIG_IsOK(res1)) {
43468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
43469 }
43470 arg1 = reinterpret_cast< wxMenu * >(argp1);
43471 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43472 if (!SWIG_IsOK(res2)) {
43473 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
43474 }
43475 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
43476 {
43477 PyThreadState* __tstate = wxPyBeginAllowThreads();
43478 result = (bool)(arg1)->Destroy(arg2);
43479 wxPyEndAllowThreads(__tstate);
43480 if (PyErr_Occurred()) SWIG_fail;
43481 }
43482 {
43483 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43484 }
43485 return resultobj;
43486 fail:
43487 return NULL;
43488 }
43489
43490
43491 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43492 PyObject *resultobj = 0;
43493 wxMenu *arg1 = (wxMenu *) 0 ;
43494 size_t result;
43495 void *argp1 = 0 ;
43496 int res1 = 0 ;
43497 PyObject *swig_obj[1] ;
43498
43499 if (!args) SWIG_fail;
43500 swig_obj[0] = args;
43501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43502 if (!SWIG_IsOK(res1)) {
43503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
43504 }
43505 arg1 = reinterpret_cast< wxMenu * >(argp1);
43506 {
43507 PyThreadState* __tstate = wxPyBeginAllowThreads();
43508 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
43509 wxPyEndAllowThreads(__tstate);
43510 if (PyErr_Occurred()) SWIG_fail;
43511 }
43512 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
43513 return resultobj;
43514 fail:
43515 return NULL;
43516 }
43517
43518
43519 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43520 PyObject *resultobj = 0;
43521 wxMenu *arg1 = (wxMenu *) 0 ;
43522 PyObject *result = 0 ;
43523 void *argp1 = 0 ;
43524 int res1 = 0 ;
43525 PyObject *swig_obj[1] ;
43526
43527 if (!args) SWIG_fail;
43528 swig_obj[0] = args;
43529 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43530 if (!SWIG_IsOK(res1)) {
43531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
43532 }
43533 arg1 = reinterpret_cast< wxMenu * >(argp1);
43534 {
43535 PyThreadState* __tstate = wxPyBeginAllowThreads();
43536 result = (PyObject *)wxMenu_GetMenuItems(arg1);
43537 wxPyEndAllowThreads(__tstate);
43538 if (PyErr_Occurred()) SWIG_fail;
43539 }
43540 resultobj = result;
43541 return resultobj;
43542 fail:
43543 return NULL;
43544 }
43545
43546
43547 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43548 PyObject *resultobj = 0;
43549 wxMenu *arg1 = (wxMenu *) 0 ;
43550 wxString *arg2 = 0 ;
43551 int result;
43552 void *argp1 = 0 ;
43553 int res1 = 0 ;
43554 bool temp2 = false ;
43555 PyObject * obj0 = 0 ;
43556 PyObject * obj1 = 0 ;
43557 char * kwnames[] = {
43558 (char *) "self",(char *) "item", NULL
43559 };
43560
43561 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
43562 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43563 if (!SWIG_IsOK(res1)) {
43564 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
43565 }
43566 arg1 = reinterpret_cast< wxMenu * >(argp1);
43567 {
43568 arg2 = wxString_in_helper(obj1);
43569 if (arg2 == NULL) SWIG_fail;
43570 temp2 = true;
43571 }
43572 {
43573 PyThreadState* __tstate = wxPyBeginAllowThreads();
43574 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
43575 wxPyEndAllowThreads(__tstate);
43576 if (PyErr_Occurred()) SWIG_fail;
43577 }
43578 resultobj = SWIG_From_int(static_cast< int >(result));
43579 {
43580 if (temp2)
43581 delete arg2;
43582 }
43583 return resultobj;
43584 fail:
43585 {
43586 if (temp2)
43587 delete arg2;
43588 }
43589 return NULL;
43590 }
43591
43592
43593 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43594 PyObject *resultobj = 0;
43595 wxMenu *arg1 = (wxMenu *) 0 ;
43596 int arg2 ;
43597 wxMenuItem *result = 0 ;
43598 void *argp1 = 0 ;
43599 int res1 = 0 ;
43600 int val2 ;
43601 int ecode2 = 0 ;
43602 PyObject * obj0 = 0 ;
43603 PyObject * obj1 = 0 ;
43604 char * kwnames[] = {
43605 (char *) "self",(char *) "id", NULL
43606 };
43607
43608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
43609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43610 if (!SWIG_IsOK(res1)) {
43611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
43612 }
43613 arg1 = reinterpret_cast< wxMenu * >(argp1);
43614 ecode2 = SWIG_AsVal_int(obj1, &val2);
43615 if (!SWIG_IsOK(ecode2)) {
43616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
43617 }
43618 arg2 = static_cast< int >(val2);
43619 {
43620 PyThreadState* __tstate = wxPyBeginAllowThreads();
43621 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
43622 wxPyEndAllowThreads(__tstate);
43623 if (PyErr_Occurred()) SWIG_fail;
43624 }
43625 {
43626 resultobj = wxPyMake_wxObject(result, (bool)0);
43627 }
43628 return resultobj;
43629 fail:
43630 return NULL;
43631 }
43632
43633
43634 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43635 PyObject *resultobj = 0;
43636 wxMenu *arg1 = (wxMenu *) 0 ;
43637 size_t arg2 ;
43638 wxMenuItem *result = 0 ;
43639 void *argp1 = 0 ;
43640 int res1 = 0 ;
43641 size_t val2 ;
43642 int ecode2 = 0 ;
43643 PyObject * obj0 = 0 ;
43644 PyObject * obj1 = 0 ;
43645 char * kwnames[] = {
43646 (char *) "self",(char *) "position", NULL
43647 };
43648
43649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
43650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43651 if (!SWIG_IsOK(res1)) {
43652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
43653 }
43654 arg1 = reinterpret_cast< wxMenu * >(argp1);
43655 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
43656 if (!SWIG_IsOK(ecode2)) {
43657 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
43658 }
43659 arg2 = static_cast< size_t >(val2);
43660 {
43661 PyThreadState* __tstate = wxPyBeginAllowThreads();
43662 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
43663 wxPyEndAllowThreads(__tstate);
43664 if (PyErr_Occurred()) SWIG_fail;
43665 }
43666 {
43667 resultobj = wxPyMake_wxObject(result, (bool)0);
43668 }
43669 return resultobj;
43670 fail:
43671 return NULL;
43672 }
43673
43674
43675 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43676 PyObject *resultobj = 0;
43677 wxMenu *arg1 = (wxMenu *) 0 ;
43678 int arg2 ;
43679 bool arg3 ;
43680 void *argp1 = 0 ;
43681 int res1 = 0 ;
43682 int val2 ;
43683 int ecode2 = 0 ;
43684 bool val3 ;
43685 int ecode3 = 0 ;
43686 PyObject * obj0 = 0 ;
43687 PyObject * obj1 = 0 ;
43688 PyObject * obj2 = 0 ;
43689 char * kwnames[] = {
43690 (char *) "self",(char *) "id",(char *) "enable", NULL
43691 };
43692
43693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43694 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43695 if (!SWIG_IsOK(res1)) {
43696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
43697 }
43698 arg1 = reinterpret_cast< wxMenu * >(argp1);
43699 ecode2 = SWIG_AsVal_int(obj1, &val2);
43700 if (!SWIG_IsOK(ecode2)) {
43701 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
43702 }
43703 arg2 = static_cast< int >(val2);
43704 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43705 if (!SWIG_IsOK(ecode3)) {
43706 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
43707 }
43708 arg3 = static_cast< bool >(val3);
43709 {
43710 PyThreadState* __tstate = wxPyBeginAllowThreads();
43711 (arg1)->Enable(arg2,arg3);
43712 wxPyEndAllowThreads(__tstate);
43713 if (PyErr_Occurred()) SWIG_fail;
43714 }
43715 resultobj = SWIG_Py_Void();
43716 return resultobj;
43717 fail:
43718 return NULL;
43719 }
43720
43721
43722 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43723 PyObject *resultobj = 0;
43724 wxMenu *arg1 = (wxMenu *) 0 ;
43725 int arg2 ;
43726 bool result;
43727 void *argp1 = 0 ;
43728 int res1 = 0 ;
43729 int val2 ;
43730 int ecode2 = 0 ;
43731 PyObject * obj0 = 0 ;
43732 PyObject * obj1 = 0 ;
43733 char * kwnames[] = {
43734 (char *) "self",(char *) "id", NULL
43735 };
43736
43737 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
43738 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43739 if (!SWIG_IsOK(res1)) {
43740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
43741 }
43742 arg1 = reinterpret_cast< wxMenu * >(argp1);
43743 ecode2 = SWIG_AsVal_int(obj1, &val2);
43744 if (!SWIG_IsOK(ecode2)) {
43745 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
43746 }
43747 arg2 = static_cast< int >(val2);
43748 {
43749 PyThreadState* __tstate = wxPyBeginAllowThreads();
43750 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
43751 wxPyEndAllowThreads(__tstate);
43752 if (PyErr_Occurred()) SWIG_fail;
43753 }
43754 {
43755 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43756 }
43757 return resultobj;
43758 fail:
43759 return NULL;
43760 }
43761
43762
43763 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43764 PyObject *resultobj = 0;
43765 wxMenu *arg1 = (wxMenu *) 0 ;
43766 int arg2 ;
43767 bool arg3 ;
43768 void *argp1 = 0 ;
43769 int res1 = 0 ;
43770 int val2 ;
43771 int ecode2 = 0 ;
43772 bool val3 ;
43773 int ecode3 = 0 ;
43774 PyObject * obj0 = 0 ;
43775 PyObject * obj1 = 0 ;
43776 PyObject * obj2 = 0 ;
43777 char * kwnames[] = {
43778 (char *) "self",(char *) "id",(char *) "check", NULL
43779 };
43780
43781 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43782 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43783 if (!SWIG_IsOK(res1)) {
43784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
43785 }
43786 arg1 = reinterpret_cast< wxMenu * >(argp1);
43787 ecode2 = SWIG_AsVal_int(obj1, &val2);
43788 if (!SWIG_IsOK(ecode2)) {
43789 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
43790 }
43791 arg2 = static_cast< int >(val2);
43792 ecode3 = SWIG_AsVal_bool(obj2, &val3);
43793 if (!SWIG_IsOK(ecode3)) {
43794 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
43795 }
43796 arg3 = static_cast< bool >(val3);
43797 {
43798 PyThreadState* __tstate = wxPyBeginAllowThreads();
43799 (arg1)->Check(arg2,arg3);
43800 wxPyEndAllowThreads(__tstate);
43801 if (PyErr_Occurred()) SWIG_fail;
43802 }
43803 resultobj = SWIG_Py_Void();
43804 return resultobj;
43805 fail:
43806 return NULL;
43807 }
43808
43809
43810 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43811 PyObject *resultobj = 0;
43812 wxMenu *arg1 = (wxMenu *) 0 ;
43813 int arg2 ;
43814 bool result;
43815 void *argp1 = 0 ;
43816 int res1 = 0 ;
43817 int val2 ;
43818 int ecode2 = 0 ;
43819 PyObject * obj0 = 0 ;
43820 PyObject * obj1 = 0 ;
43821 char * kwnames[] = {
43822 (char *) "self",(char *) "id", NULL
43823 };
43824
43825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
43826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43827 if (!SWIG_IsOK(res1)) {
43828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
43829 }
43830 arg1 = reinterpret_cast< wxMenu * >(argp1);
43831 ecode2 = SWIG_AsVal_int(obj1, &val2);
43832 if (!SWIG_IsOK(ecode2)) {
43833 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
43834 }
43835 arg2 = static_cast< int >(val2);
43836 {
43837 PyThreadState* __tstate = wxPyBeginAllowThreads();
43838 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
43839 wxPyEndAllowThreads(__tstate);
43840 if (PyErr_Occurred()) SWIG_fail;
43841 }
43842 {
43843 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43844 }
43845 return resultobj;
43846 fail:
43847 return NULL;
43848 }
43849
43850
43851 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43852 PyObject *resultobj = 0;
43853 wxMenu *arg1 = (wxMenu *) 0 ;
43854 int arg2 ;
43855 wxString *arg3 = 0 ;
43856 void *argp1 = 0 ;
43857 int res1 = 0 ;
43858 int val2 ;
43859 int ecode2 = 0 ;
43860 bool temp3 = false ;
43861 PyObject * obj0 = 0 ;
43862 PyObject * obj1 = 0 ;
43863 PyObject * obj2 = 0 ;
43864 char * kwnames[] = {
43865 (char *) "self",(char *) "id",(char *) "label", NULL
43866 };
43867
43868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43870 if (!SWIG_IsOK(res1)) {
43871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
43872 }
43873 arg1 = reinterpret_cast< wxMenu * >(argp1);
43874 ecode2 = SWIG_AsVal_int(obj1, &val2);
43875 if (!SWIG_IsOK(ecode2)) {
43876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
43877 }
43878 arg2 = static_cast< int >(val2);
43879 {
43880 arg3 = wxString_in_helper(obj2);
43881 if (arg3 == NULL) SWIG_fail;
43882 temp3 = true;
43883 }
43884 {
43885 PyThreadState* __tstate = wxPyBeginAllowThreads();
43886 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
43887 wxPyEndAllowThreads(__tstate);
43888 if (PyErr_Occurred()) SWIG_fail;
43889 }
43890 resultobj = SWIG_Py_Void();
43891 {
43892 if (temp3)
43893 delete arg3;
43894 }
43895 return resultobj;
43896 fail:
43897 {
43898 if (temp3)
43899 delete arg3;
43900 }
43901 return NULL;
43902 }
43903
43904
43905 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43906 PyObject *resultobj = 0;
43907 wxMenu *arg1 = (wxMenu *) 0 ;
43908 int arg2 ;
43909 wxString result;
43910 void *argp1 = 0 ;
43911 int res1 = 0 ;
43912 int val2 ;
43913 int ecode2 = 0 ;
43914 PyObject * obj0 = 0 ;
43915 PyObject * obj1 = 0 ;
43916 char * kwnames[] = {
43917 (char *) "self",(char *) "id", NULL
43918 };
43919
43920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
43921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43922 if (!SWIG_IsOK(res1)) {
43923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
43924 }
43925 arg1 = reinterpret_cast< wxMenu * >(argp1);
43926 ecode2 = SWIG_AsVal_int(obj1, &val2);
43927 if (!SWIG_IsOK(ecode2)) {
43928 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
43929 }
43930 arg2 = static_cast< int >(val2);
43931 {
43932 PyThreadState* __tstate = wxPyBeginAllowThreads();
43933 result = ((wxMenu const *)arg1)->GetLabel(arg2);
43934 wxPyEndAllowThreads(__tstate);
43935 if (PyErr_Occurred()) SWIG_fail;
43936 }
43937 {
43938 #if wxUSE_UNICODE
43939 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
43940 #else
43941 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
43942 #endif
43943 }
43944 return resultobj;
43945 fail:
43946 return NULL;
43947 }
43948
43949
43950 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43951 PyObject *resultobj = 0;
43952 wxMenu *arg1 = (wxMenu *) 0 ;
43953 int arg2 ;
43954 wxString *arg3 = 0 ;
43955 void *argp1 = 0 ;
43956 int res1 = 0 ;
43957 int val2 ;
43958 int ecode2 = 0 ;
43959 bool temp3 = false ;
43960 PyObject * obj0 = 0 ;
43961 PyObject * obj1 = 0 ;
43962 PyObject * obj2 = 0 ;
43963 char * kwnames[] = {
43964 (char *) "self",(char *) "id",(char *) "helpString", NULL
43965 };
43966
43967 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43968 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
43969 if (!SWIG_IsOK(res1)) {
43970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
43971 }
43972 arg1 = reinterpret_cast< wxMenu * >(argp1);
43973 ecode2 = SWIG_AsVal_int(obj1, &val2);
43974 if (!SWIG_IsOK(ecode2)) {
43975 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
43976 }
43977 arg2 = static_cast< int >(val2);
43978 {
43979 arg3 = wxString_in_helper(obj2);
43980 if (arg3 == NULL) SWIG_fail;
43981 temp3 = true;
43982 }
43983 {
43984 PyThreadState* __tstate = wxPyBeginAllowThreads();
43985 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
43986 wxPyEndAllowThreads(__tstate);
43987 if (PyErr_Occurred()) SWIG_fail;
43988 }
43989 resultobj = SWIG_Py_Void();
43990 {
43991 if (temp3)
43992 delete arg3;
43993 }
43994 return resultobj;
43995 fail:
43996 {
43997 if (temp3)
43998 delete arg3;
43999 }
44000 return NULL;
44001 }
44002
44003
44004 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44005 PyObject *resultobj = 0;
44006 wxMenu *arg1 = (wxMenu *) 0 ;
44007 int arg2 ;
44008 wxString result;
44009 void *argp1 = 0 ;
44010 int res1 = 0 ;
44011 int val2 ;
44012 int ecode2 = 0 ;
44013 PyObject * obj0 = 0 ;
44014 PyObject * obj1 = 0 ;
44015 char * kwnames[] = {
44016 (char *) "self",(char *) "id", NULL
44017 };
44018
44019 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
44020 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44021 if (!SWIG_IsOK(res1)) {
44022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
44023 }
44024 arg1 = reinterpret_cast< wxMenu * >(argp1);
44025 ecode2 = SWIG_AsVal_int(obj1, &val2);
44026 if (!SWIG_IsOK(ecode2)) {
44027 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
44028 }
44029 arg2 = static_cast< int >(val2);
44030 {
44031 PyThreadState* __tstate = wxPyBeginAllowThreads();
44032 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
44033 wxPyEndAllowThreads(__tstate);
44034 if (PyErr_Occurred()) SWIG_fail;
44035 }
44036 {
44037 #if wxUSE_UNICODE
44038 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44039 #else
44040 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44041 #endif
44042 }
44043 return resultobj;
44044 fail:
44045 return NULL;
44046 }
44047
44048
44049 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44050 PyObject *resultobj = 0;
44051 wxMenu *arg1 = (wxMenu *) 0 ;
44052 wxString *arg2 = 0 ;
44053 void *argp1 = 0 ;
44054 int res1 = 0 ;
44055 bool temp2 = false ;
44056 PyObject * obj0 = 0 ;
44057 PyObject * obj1 = 0 ;
44058 char * kwnames[] = {
44059 (char *) "self",(char *) "title", NULL
44060 };
44061
44062 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
44063 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44064 if (!SWIG_IsOK(res1)) {
44065 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
44066 }
44067 arg1 = reinterpret_cast< wxMenu * >(argp1);
44068 {
44069 arg2 = wxString_in_helper(obj1);
44070 if (arg2 == NULL) SWIG_fail;
44071 temp2 = true;
44072 }
44073 {
44074 PyThreadState* __tstate = wxPyBeginAllowThreads();
44075 (arg1)->SetTitle((wxString const &)*arg2);
44076 wxPyEndAllowThreads(__tstate);
44077 if (PyErr_Occurred()) SWIG_fail;
44078 }
44079 resultobj = SWIG_Py_Void();
44080 {
44081 if (temp2)
44082 delete arg2;
44083 }
44084 return resultobj;
44085 fail:
44086 {
44087 if (temp2)
44088 delete arg2;
44089 }
44090 return NULL;
44091 }
44092
44093
44094 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44095 PyObject *resultobj = 0;
44096 wxMenu *arg1 = (wxMenu *) 0 ;
44097 wxString result;
44098 void *argp1 = 0 ;
44099 int res1 = 0 ;
44100 PyObject *swig_obj[1] ;
44101
44102 if (!args) SWIG_fail;
44103 swig_obj[0] = args;
44104 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44105 if (!SWIG_IsOK(res1)) {
44106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44107 }
44108 arg1 = reinterpret_cast< wxMenu * >(argp1);
44109 {
44110 PyThreadState* __tstate = wxPyBeginAllowThreads();
44111 result = ((wxMenu const *)arg1)->GetTitle();
44112 wxPyEndAllowThreads(__tstate);
44113 if (PyErr_Occurred()) SWIG_fail;
44114 }
44115 {
44116 #if wxUSE_UNICODE
44117 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44118 #else
44119 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44120 #endif
44121 }
44122 return resultobj;
44123 fail:
44124 return NULL;
44125 }
44126
44127
44128 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44129 PyObject *resultobj = 0;
44130 wxMenu *arg1 = (wxMenu *) 0 ;
44131 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
44132 void *argp1 = 0 ;
44133 int res1 = 0 ;
44134 void *argp2 = 0 ;
44135 int res2 = 0 ;
44136 PyObject * obj0 = 0 ;
44137 PyObject * obj1 = 0 ;
44138 char * kwnames[] = {
44139 (char *) "self",(char *) "handler", NULL
44140 };
44141
44142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
44143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44144 if (!SWIG_IsOK(res1)) {
44145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
44146 }
44147 arg1 = reinterpret_cast< wxMenu * >(argp1);
44148 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44149 if (!SWIG_IsOK(res2)) {
44150 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44151 }
44152 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44153 {
44154 PyThreadState* __tstate = wxPyBeginAllowThreads();
44155 (arg1)->SetEventHandler(arg2);
44156 wxPyEndAllowThreads(__tstate);
44157 if (PyErr_Occurred()) SWIG_fail;
44158 }
44159 resultobj = SWIG_Py_Void();
44160 return resultobj;
44161 fail:
44162 return NULL;
44163 }
44164
44165
44166 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44167 PyObject *resultobj = 0;
44168 wxMenu *arg1 = (wxMenu *) 0 ;
44169 wxEvtHandler *result = 0 ;
44170 void *argp1 = 0 ;
44171 int res1 = 0 ;
44172 PyObject *swig_obj[1] ;
44173
44174 if (!args) SWIG_fail;
44175 swig_obj[0] = args;
44176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44177 if (!SWIG_IsOK(res1)) {
44178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
44179 }
44180 arg1 = reinterpret_cast< wxMenu * >(argp1);
44181 {
44182 PyThreadState* __tstate = wxPyBeginAllowThreads();
44183 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
44184 wxPyEndAllowThreads(__tstate);
44185 if (PyErr_Occurred()) SWIG_fail;
44186 }
44187 {
44188 resultobj = wxPyMake_wxObject(result, 0);
44189 }
44190 return resultobj;
44191 fail:
44192 return NULL;
44193 }
44194
44195
44196 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44197 PyObject *resultobj = 0;
44198 wxMenu *arg1 = (wxMenu *) 0 ;
44199 wxWindow *arg2 = (wxWindow *) 0 ;
44200 void *argp1 = 0 ;
44201 int res1 = 0 ;
44202 void *argp2 = 0 ;
44203 int res2 = 0 ;
44204 PyObject * obj0 = 0 ;
44205 PyObject * obj1 = 0 ;
44206 char * kwnames[] = {
44207 (char *) "self",(char *) "win", NULL
44208 };
44209
44210 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
44211 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44212 if (!SWIG_IsOK(res1)) {
44213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
44214 }
44215 arg1 = reinterpret_cast< wxMenu * >(argp1);
44216 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44217 if (!SWIG_IsOK(res2)) {
44218 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
44219 }
44220 arg2 = reinterpret_cast< wxWindow * >(argp2);
44221 {
44222 PyThreadState* __tstate = wxPyBeginAllowThreads();
44223 (arg1)->SetInvokingWindow(arg2);
44224 wxPyEndAllowThreads(__tstate);
44225 if (PyErr_Occurred()) SWIG_fail;
44226 }
44227 resultobj = SWIG_Py_Void();
44228 return resultobj;
44229 fail:
44230 return NULL;
44231 }
44232
44233
44234 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44235 PyObject *resultobj = 0;
44236 wxMenu *arg1 = (wxMenu *) 0 ;
44237 wxWindow *result = 0 ;
44238 void *argp1 = 0 ;
44239 int res1 = 0 ;
44240 PyObject *swig_obj[1] ;
44241
44242 if (!args) SWIG_fail;
44243 swig_obj[0] = args;
44244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44245 if (!SWIG_IsOK(res1)) {
44246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
44247 }
44248 arg1 = reinterpret_cast< wxMenu * >(argp1);
44249 {
44250 PyThreadState* __tstate = wxPyBeginAllowThreads();
44251 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
44252 wxPyEndAllowThreads(__tstate);
44253 if (PyErr_Occurred()) SWIG_fail;
44254 }
44255 {
44256 resultobj = wxPyMake_wxObject(result, 0);
44257 }
44258 return resultobj;
44259 fail:
44260 return NULL;
44261 }
44262
44263
44264 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44265 PyObject *resultobj = 0;
44266 wxMenu *arg1 = (wxMenu *) 0 ;
44267 long result;
44268 void *argp1 = 0 ;
44269 int res1 = 0 ;
44270 PyObject *swig_obj[1] ;
44271
44272 if (!args) SWIG_fail;
44273 swig_obj[0] = args;
44274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44275 if (!SWIG_IsOK(res1)) {
44276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
44277 }
44278 arg1 = reinterpret_cast< wxMenu * >(argp1);
44279 {
44280 PyThreadState* __tstate = wxPyBeginAllowThreads();
44281 result = (long)((wxMenu const *)arg1)->GetStyle();
44282 wxPyEndAllowThreads(__tstate);
44283 if (PyErr_Occurred()) SWIG_fail;
44284 }
44285 resultobj = SWIG_From_long(static_cast< long >(result));
44286 return resultobj;
44287 fail:
44288 return NULL;
44289 }
44290
44291
44292 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44293 PyObject *resultobj = 0;
44294 wxMenu *arg1 = (wxMenu *) 0 ;
44295 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
44296 void *argp1 = 0 ;
44297 int res1 = 0 ;
44298 void *argp2 = 0 ;
44299 int res2 = 0 ;
44300 PyObject * obj0 = 0 ;
44301 PyObject * obj1 = 0 ;
44302 char * kwnames[] = {
44303 (char *) "self",(char *) "source", NULL
44304 };
44305
44306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
44307 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44308 if (!SWIG_IsOK(res1)) {
44309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
44310 }
44311 arg1 = reinterpret_cast< wxMenu * >(argp1);
44312 if (obj1) {
44313 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
44314 if (!SWIG_IsOK(res2)) {
44315 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
44316 }
44317 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
44318 }
44319 {
44320 PyThreadState* __tstate = wxPyBeginAllowThreads();
44321 (arg1)->UpdateUI(arg2);
44322 wxPyEndAllowThreads(__tstate);
44323 if (PyErr_Occurred()) SWIG_fail;
44324 }
44325 resultobj = SWIG_Py_Void();
44326 return resultobj;
44327 fail:
44328 return NULL;
44329 }
44330
44331
44332 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44333 PyObject *resultobj = 0;
44334 wxMenu *arg1 = (wxMenu *) 0 ;
44335 wxMenuBar *result = 0 ;
44336 void *argp1 = 0 ;
44337 int res1 = 0 ;
44338 PyObject *swig_obj[1] ;
44339
44340 if (!args) SWIG_fail;
44341 swig_obj[0] = args;
44342 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44343 if (!SWIG_IsOK(res1)) {
44344 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
44345 }
44346 arg1 = reinterpret_cast< wxMenu * >(argp1);
44347 {
44348 PyThreadState* __tstate = wxPyBeginAllowThreads();
44349 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
44350 wxPyEndAllowThreads(__tstate);
44351 if (PyErr_Occurred()) SWIG_fail;
44352 }
44353 {
44354 resultobj = wxPyMake_wxObject(result, (bool)0);
44355 }
44356 return resultobj;
44357 fail:
44358 return NULL;
44359 }
44360
44361
44362 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44363 PyObject *resultobj = 0;
44364 wxMenu *arg1 = (wxMenu *) 0 ;
44365 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
44366 void *argp1 = 0 ;
44367 int res1 = 0 ;
44368 void *argp2 = 0 ;
44369 int res2 = 0 ;
44370 PyObject * obj0 = 0 ;
44371 PyObject * obj1 = 0 ;
44372 char * kwnames[] = {
44373 (char *) "self",(char *) "menubar", NULL
44374 };
44375
44376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
44377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44378 if (!SWIG_IsOK(res1)) {
44379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
44380 }
44381 arg1 = reinterpret_cast< wxMenu * >(argp1);
44382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
44383 if (!SWIG_IsOK(res2)) {
44384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
44385 }
44386 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
44387 {
44388 PyThreadState* __tstate = wxPyBeginAllowThreads();
44389 (arg1)->Attach(arg2);
44390 wxPyEndAllowThreads(__tstate);
44391 if (PyErr_Occurred()) SWIG_fail;
44392 }
44393 resultobj = SWIG_Py_Void();
44394 return resultobj;
44395 fail:
44396 return NULL;
44397 }
44398
44399
44400 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44401 PyObject *resultobj = 0;
44402 wxMenu *arg1 = (wxMenu *) 0 ;
44403 void *argp1 = 0 ;
44404 int res1 = 0 ;
44405 PyObject *swig_obj[1] ;
44406
44407 if (!args) SWIG_fail;
44408 swig_obj[0] = args;
44409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44410 if (!SWIG_IsOK(res1)) {
44411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
44412 }
44413 arg1 = reinterpret_cast< wxMenu * >(argp1);
44414 {
44415 PyThreadState* __tstate = wxPyBeginAllowThreads();
44416 (arg1)->Detach();
44417 wxPyEndAllowThreads(__tstate);
44418 if (PyErr_Occurred()) SWIG_fail;
44419 }
44420 resultobj = SWIG_Py_Void();
44421 return resultobj;
44422 fail:
44423 return NULL;
44424 }
44425
44426
44427 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44428 PyObject *resultobj = 0;
44429 wxMenu *arg1 = (wxMenu *) 0 ;
44430 bool result;
44431 void *argp1 = 0 ;
44432 int res1 = 0 ;
44433 PyObject *swig_obj[1] ;
44434
44435 if (!args) SWIG_fail;
44436 swig_obj[0] = args;
44437 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44438 if (!SWIG_IsOK(res1)) {
44439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
44440 }
44441 arg1 = reinterpret_cast< wxMenu * >(argp1);
44442 {
44443 PyThreadState* __tstate = wxPyBeginAllowThreads();
44444 result = (bool)((wxMenu const *)arg1)->IsAttached();
44445 wxPyEndAllowThreads(__tstate);
44446 if (PyErr_Occurred()) SWIG_fail;
44447 }
44448 {
44449 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44450 }
44451 return resultobj;
44452 fail:
44453 return NULL;
44454 }
44455
44456
44457 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44458 PyObject *resultobj = 0;
44459 wxMenu *arg1 = (wxMenu *) 0 ;
44460 wxMenu *arg2 = (wxMenu *) 0 ;
44461 void *argp1 = 0 ;
44462 int res1 = 0 ;
44463 void *argp2 = 0 ;
44464 int res2 = 0 ;
44465 PyObject * obj0 = 0 ;
44466 PyObject * obj1 = 0 ;
44467 char * kwnames[] = {
44468 (char *) "self",(char *) "parent", NULL
44469 };
44470
44471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
44472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44473 if (!SWIG_IsOK(res1)) {
44474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
44475 }
44476 arg1 = reinterpret_cast< wxMenu * >(argp1);
44477 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44478 if (!SWIG_IsOK(res2)) {
44479 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
44480 }
44481 arg2 = reinterpret_cast< wxMenu * >(argp2);
44482 {
44483 PyThreadState* __tstate = wxPyBeginAllowThreads();
44484 (arg1)->SetParent(arg2);
44485 wxPyEndAllowThreads(__tstate);
44486 if (PyErr_Occurred()) SWIG_fail;
44487 }
44488 resultobj = SWIG_Py_Void();
44489 return resultobj;
44490 fail:
44491 return NULL;
44492 }
44493
44494
44495 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44496 PyObject *resultobj = 0;
44497 wxMenu *arg1 = (wxMenu *) 0 ;
44498 wxMenu *result = 0 ;
44499 void *argp1 = 0 ;
44500 int res1 = 0 ;
44501 PyObject *swig_obj[1] ;
44502
44503 if (!args) SWIG_fail;
44504 swig_obj[0] = args;
44505 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
44506 if (!SWIG_IsOK(res1)) {
44507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
44508 }
44509 arg1 = reinterpret_cast< wxMenu * >(argp1);
44510 {
44511 PyThreadState* __tstate = wxPyBeginAllowThreads();
44512 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
44513 wxPyEndAllowThreads(__tstate);
44514 if (PyErr_Occurred()) SWIG_fail;
44515 }
44516 {
44517 resultobj = wxPyMake_wxObject(result, 0);
44518 }
44519 return resultobj;
44520 fail:
44521 return NULL;
44522 }
44523
44524
44525 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44526 PyObject *obj;
44527 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44528 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
44529 return SWIG_Py_Void();
44530 }
44531
44532 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44533 return SWIG_Python_InitShadowInstance(args);
44534 }
44535
44536 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44537 PyObject *resultobj = 0;
44538 long arg1 = (long) 0 ;
44539 wxMenuBar *result = 0 ;
44540 long val1 ;
44541 int ecode1 = 0 ;
44542 PyObject * obj0 = 0 ;
44543 char * kwnames[] = {
44544 (char *) "style", NULL
44545 };
44546
44547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
44548 if (obj0) {
44549 ecode1 = SWIG_AsVal_long(obj0, &val1);
44550 if (!SWIG_IsOK(ecode1)) {
44551 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
44552 }
44553 arg1 = static_cast< long >(val1);
44554 }
44555 {
44556 if (!wxPyCheckForApp()) SWIG_fail;
44557 PyThreadState* __tstate = wxPyBeginAllowThreads();
44558 result = (wxMenuBar *)new wxMenuBar(arg1);
44559 wxPyEndAllowThreads(__tstate);
44560 if (PyErr_Occurred()) SWIG_fail;
44561 }
44562 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
44563 return resultobj;
44564 fail:
44565 return NULL;
44566 }
44567
44568
44569 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44570 PyObject *resultobj = 0;
44571 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44572 wxMenu *arg2 = (wxMenu *) 0 ;
44573 wxString *arg3 = 0 ;
44574 bool result;
44575 void *argp1 = 0 ;
44576 int res1 = 0 ;
44577 void *argp2 = 0 ;
44578 int res2 = 0 ;
44579 bool temp3 = false ;
44580 PyObject * obj0 = 0 ;
44581 PyObject * obj1 = 0 ;
44582 PyObject * obj2 = 0 ;
44583 char * kwnames[] = {
44584 (char *) "self",(char *) "menu",(char *) "title", NULL
44585 };
44586
44587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44589 if (!SWIG_IsOK(res1)) {
44590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44591 }
44592 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44593 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
44594 if (!SWIG_IsOK(res2)) {
44595 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
44596 }
44597 arg2 = reinterpret_cast< wxMenu * >(argp2);
44598 {
44599 arg3 = wxString_in_helper(obj2);
44600 if (arg3 == NULL) SWIG_fail;
44601 temp3 = true;
44602 }
44603 {
44604 PyThreadState* __tstate = wxPyBeginAllowThreads();
44605 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
44606 wxPyEndAllowThreads(__tstate);
44607 if (PyErr_Occurred()) SWIG_fail;
44608 }
44609 {
44610 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44611 }
44612 {
44613 if (temp3)
44614 delete arg3;
44615 }
44616 return resultobj;
44617 fail:
44618 {
44619 if (temp3)
44620 delete arg3;
44621 }
44622 return NULL;
44623 }
44624
44625
44626 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44627 PyObject *resultobj = 0;
44628 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44629 size_t arg2 ;
44630 wxMenu *arg3 = (wxMenu *) 0 ;
44631 wxString *arg4 = 0 ;
44632 bool result;
44633 void *argp1 = 0 ;
44634 int res1 = 0 ;
44635 size_t val2 ;
44636 int ecode2 = 0 ;
44637 void *argp3 = 0 ;
44638 int res3 = 0 ;
44639 bool temp4 = false ;
44640 PyObject * obj0 = 0 ;
44641 PyObject * obj1 = 0 ;
44642 PyObject * obj2 = 0 ;
44643 PyObject * obj3 = 0 ;
44644 char * kwnames[] = {
44645 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44646 };
44647
44648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44650 if (!SWIG_IsOK(res1)) {
44651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44652 }
44653 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44654 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44655 if (!SWIG_IsOK(ecode2)) {
44656 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
44657 }
44658 arg2 = static_cast< size_t >(val2);
44659 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44660 if (!SWIG_IsOK(res3)) {
44661 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
44662 }
44663 arg3 = reinterpret_cast< wxMenu * >(argp3);
44664 {
44665 arg4 = wxString_in_helper(obj3);
44666 if (arg4 == NULL) SWIG_fail;
44667 temp4 = true;
44668 }
44669 {
44670 PyThreadState* __tstate = wxPyBeginAllowThreads();
44671 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
44672 wxPyEndAllowThreads(__tstate);
44673 if (PyErr_Occurred()) SWIG_fail;
44674 }
44675 {
44676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44677 }
44678 {
44679 if (temp4)
44680 delete arg4;
44681 }
44682 return resultobj;
44683 fail:
44684 {
44685 if (temp4)
44686 delete arg4;
44687 }
44688 return NULL;
44689 }
44690
44691
44692 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44693 PyObject *resultobj = 0;
44694 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44695 size_t result;
44696 void *argp1 = 0 ;
44697 int res1 = 0 ;
44698 PyObject *swig_obj[1] ;
44699
44700 if (!args) SWIG_fail;
44701 swig_obj[0] = args;
44702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44703 if (!SWIG_IsOK(res1)) {
44704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44705 }
44706 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44707 {
44708 PyThreadState* __tstate = wxPyBeginAllowThreads();
44709 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
44710 wxPyEndAllowThreads(__tstate);
44711 if (PyErr_Occurred()) SWIG_fail;
44712 }
44713 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
44714 return resultobj;
44715 fail:
44716 return NULL;
44717 }
44718
44719
44720 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44721 PyObject *resultobj = 0;
44722 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44723 size_t arg2 ;
44724 wxMenu *result = 0 ;
44725 void *argp1 = 0 ;
44726 int res1 = 0 ;
44727 size_t val2 ;
44728 int ecode2 = 0 ;
44729 PyObject * obj0 = 0 ;
44730 PyObject * obj1 = 0 ;
44731 char * kwnames[] = {
44732 (char *) "self",(char *) "pos", NULL
44733 };
44734
44735 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
44736 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44737 if (!SWIG_IsOK(res1)) {
44738 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44739 }
44740 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44741 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44742 if (!SWIG_IsOK(ecode2)) {
44743 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
44744 }
44745 arg2 = static_cast< size_t >(val2);
44746 {
44747 PyThreadState* __tstate = wxPyBeginAllowThreads();
44748 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
44749 wxPyEndAllowThreads(__tstate);
44750 if (PyErr_Occurred()) SWIG_fail;
44751 }
44752 {
44753 resultobj = wxPyMake_wxObject(result, 0);
44754 }
44755 return resultobj;
44756 fail:
44757 return NULL;
44758 }
44759
44760
44761 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44762 PyObject *resultobj = 0;
44763 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44764 size_t arg2 ;
44765 wxMenu *arg3 = (wxMenu *) 0 ;
44766 wxString *arg4 = 0 ;
44767 wxMenu *result = 0 ;
44768 void *argp1 = 0 ;
44769 int res1 = 0 ;
44770 size_t val2 ;
44771 int ecode2 = 0 ;
44772 void *argp3 = 0 ;
44773 int res3 = 0 ;
44774 bool temp4 = false ;
44775 PyObject * obj0 = 0 ;
44776 PyObject * obj1 = 0 ;
44777 PyObject * obj2 = 0 ;
44778 PyObject * obj3 = 0 ;
44779 char * kwnames[] = {
44780 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
44781 };
44782
44783 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44784 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44785 if (!SWIG_IsOK(res1)) {
44786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44787 }
44788 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44789 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44790 if (!SWIG_IsOK(ecode2)) {
44791 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
44792 }
44793 arg2 = static_cast< size_t >(val2);
44794 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
44795 if (!SWIG_IsOK(res3)) {
44796 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
44797 }
44798 arg3 = reinterpret_cast< wxMenu * >(argp3);
44799 {
44800 arg4 = wxString_in_helper(obj3);
44801 if (arg4 == NULL) SWIG_fail;
44802 temp4 = true;
44803 }
44804 {
44805 PyThreadState* __tstate = wxPyBeginAllowThreads();
44806 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
44807 wxPyEndAllowThreads(__tstate);
44808 if (PyErr_Occurred()) SWIG_fail;
44809 }
44810 {
44811 resultobj = wxPyMake_wxObject(result, 0);
44812 }
44813 {
44814 if (temp4)
44815 delete arg4;
44816 }
44817 return resultobj;
44818 fail:
44819 {
44820 if (temp4)
44821 delete arg4;
44822 }
44823 return NULL;
44824 }
44825
44826
44827 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44828 PyObject *resultobj = 0;
44829 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44830 size_t arg2 ;
44831 wxMenu *result = 0 ;
44832 void *argp1 = 0 ;
44833 int res1 = 0 ;
44834 size_t val2 ;
44835 int ecode2 = 0 ;
44836 PyObject * obj0 = 0 ;
44837 PyObject * obj1 = 0 ;
44838 char * kwnames[] = {
44839 (char *) "self",(char *) "pos", NULL
44840 };
44841
44842 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
44843 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44844 if (!SWIG_IsOK(res1)) {
44845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44846 }
44847 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44848 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44849 if (!SWIG_IsOK(ecode2)) {
44850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
44851 }
44852 arg2 = static_cast< size_t >(val2);
44853 {
44854 PyThreadState* __tstate = wxPyBeginAllowThreads();
44855 result = (wxMenu *)(arg1)->Remove(arg2);
44856 wxPyEndAllowThreads(__tstate);
44857 if (PyErr_Occurred()) SWIG_fail;
44858 }
44859 {
44860 resultobj = wxPyMake_wxObject(result, 0);
44861 }
44862 return resultobj;
44863 fail:
44864 return NULL;
44865 }
44866
44867
44868 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44869 PyObject *resultobj = 0;
44870 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44871 size_t arg2 ;
44872 bool arg3 ;
44873 void *argp1 = 0 ;
44874 int res1 = 0 ;
44875 size_t val2 ;
44876 int ecode2 = 0 ;
44877 bool val3 ;
44878 int ecode3 = 0 ;
44879 PyObject * obj0 = 0 ;
44880 PyObject * obj1 = 0 ;
44881 PyObject * obj2 = 0 ;
44882 char * kwnames[] = {
44883 (char *) "self",(char *) "pos",(char *) "enable", NULL
44884 };
44885
44886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44888 if (!SWIG_IsOK(res1)) {
44889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44890 }
44891 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44892 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44893 if (!SWIG_IsOK(ecode2)) {
44894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
44895 }
44896 arg2 = static_cast< size_t >(val2);
44897 ecode3 = SWIG_AsVal_bool(obj2, &val3);
44898 if (!SWIG_IsOK(ecode3)) {
44899 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
44900 }
44901 arg3 = static_cast< bool >(val3);
44902 {
44903 PyThreadState* __tstate = wxPyBeginAllowThreads();
44904 (arg1)->EnableTop(arg2,arg3);
44905 wxPyEndAllowThreads(__tstate);
44906 if (PyErr_Occurred()) SWIG_fail;
44907 }
44908 resultobj = SWIG_Py_Void();
44909 return resultobj;
44910 fail:
44911 return NULL;
44912 }
44913
44914
44915 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44916 PyObject *resultobj = 0;
44917 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44918 size_t arg2 ;
44919 bool result;
44920 void *argp1 = 0 ;
44921 int res1 = 0 ;
44922 size_t val2 ;
44923 int ecode2 = 0 ;
44924 PyObject * obj0 = 0 ;
44925 PyObject * obj1 = 0 ;
44926 char * kwnames[] = {
44927 (char *) "self",(char *) "pos", NULL
44928 };
44929
44930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
44931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44932 if (!SWIG_IsOK(res1)) {
44933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
44934 }
44935 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44936 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44937 if (!SWIG_IsOK(ecode2)) {
44938 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
44939 }
44940 arg2 = static_cast< size_t >(val2);
44941 {
44942 PyThreadState* __tstate = wxPyBeginAllowThreads();
44943 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
44944 wxPyEndAllowThreads(__tstate);
44945 if (PyErr_Occurred()) SWIG_fail;
44946 }
44947 {
44948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44949 }
44950 return resultobj;
44951 fail:
44952 return NULL;
44953 }
44954
44955
44956 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44957 PyObject *resultobj = 0;
44958 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
44959 size_t arg2 ;
44960 wxString *arg3 = 0 ;
44961 void *argp1 = 0 ;
44962 int res1 = 0 ;
44963 size_t val2 ;
44964 int ecode2 = 0 ;
44965 bool temp3 = false ;
44966 PyObject * obj0 = 0 ;
44967 PyObject * obj1 = 0 ;
44968 PyObject * obj2 = 0 ;
44969 char * kwnames[] = {
44970 (char *) "self",(char *) "pos",(char *) "label", NULL
44971 };
44972
44973 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44974 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
44975 if (!SWIG_IsOK(res1)) {
44976 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
44977 }
44978 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
44979 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
44980 if (!SWIG_IsOK(ecode2)) {
44981 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
44982 }
44983 arg2 = static_cast< size_t >(val2);
44984 {
44985 arg3 = wxString_in_helper(obj2);
44986 if (arg3 == NULL) SWIG_fail;
44987 temp3 = true;
44988 }
44989 {
44990 PyThreadState* __tstate = wxPyBeginAllowThreads();
44991 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
44992 wxPyEndAllowThreads(__tstate);
44993 if (PyErr_Occurred()) SWIG_fail;
44994 }
44995 resultobj = SWIG_Py_Void();
44996 {
44997 if (temp3)
44998 delete arg3;
44999 }
45000 return resultobj;
45001 fail:
45002 {
45003 if (temp3)
45004 delete arg3;
45005 }
45006 return NULL;
45007 }
45008
45009
45010 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45011 PyObject *resultobj = 0;
45012 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45013 size_t arg2 ;
45014 wxString result;
45015 void *argp1 = 0 ;
45016 int res1 = 0 ;
45017 size_t val2 ;
45018 int ecode2 = 0 ;
45019 PyObject * obj0 = 0 ;
45020 PyObject * obj1 = 0 ;
45021 char * kwnames[] = {
45022 (char *) "self",(char *) "pos", NULL
45023 };
45024
45025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
45026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45027 if (!SWIG_IsOK(res1)) {
45028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45029 }
45030 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45031 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
45032 if (!SWIG_IsOK(ecode2)) {
45033 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
45034 }
45035 arg2 = static_cast< size_t >(val2);
45036 {
45037 PyThreadState* __tstate = wxPyBeginAllowThreads();
45038 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
45039 wxPyEndAllowThreads(__tstate);
45040 if (PyErr_Occurred()) SWIG_fail;
45041 }
45042 {
45043 #if wxUSE_UNICODE
45044 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45045 #else
45046 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45047 #endif
45048 }
45049 return resultobj;
45050 fail:
45051 return NULL;
45052 }
45053
45054
45055 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45056 PyObject *resultobj = 0;
45057 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45058 wxString *arg2 = 0 ;
45059 wxString *arg3 = 0 ;
45060 int result;
45061 void *argp1 = 0 ;
45062 int res1 = 0 ;
45063 bool temp2 = false ;
45064 bool temp3 = false ;
45065 PyObject * obj0 = 0 ;
45066 PyObject * obj1 = 0 ;
45067 PyObject * obj2 = 0 ;
45068 char * kwnames[] = {
45069 (char *) "self",(char *) "menu",(char *) "item", NULL
45070 };
45071
45072 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45073 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45074 if (!SWIG_IsOK(res1)) {
45075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45076 }
45077 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45078 {
45079 arg2 = wxString_in_helper(obj1);
45080 if (arg2 == NULL) SWIG_fail;
45081 temp2 = true;
45082 }
45083 {
45084 arg3 = wxString_in_helper(obj2);
45085 if (arg3 == NULL) SWIG_fail;
45086 temp3 = true;
45087 }
45088 {
45089 PyThreadState* __tstate = wxPyBeginAllowThreads();
45090 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
45091 wxPyEndAllowThreads(__tstate);
45092 if (PyErr_Occurred()) SWIG_fail;
45093 }
45094 resultobj = SWIG_From_int(static_cast< int >(result));
45095 {
45096 if (temp2)
45097 delete arg2;
45098 }
45099 {
45100 if (temp3)
45101 delete arg3;
45102 }
45103 return resultobj;
45104 fail:
45105 {
45106 if (temp2)
45107 delete arg2;
45108 }
45109 {
45110 if (temp3)
45111 delete arg3;
45112 }
45113 return NULL;
45114 }
45115
45116
45117 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45118 PyObject *resultobj = 0;
45119 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45120 int arg2 ;
45121 wxMenuItem *result = 0 ;
45122 void *argp1 = 0 ;
45123 int res1 = 0 ;
45124 int val2 ;
45125 int ecode2 = 0 ;
45126 PyObject * obj0 = 0 ;
45127 PyObject * obj1 = 0 ;
45128 char * kwnames[] = {
45129 (char *) "self",(char *) "id", NULL
45130 };
45131
45132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
45133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45134 if (!SWIG_IsOK(res1)) {
45135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45136 }
45137 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45138 ecode2 = SWIG_AsVal_int(obj1, &val2);
45139 if (!SWIG_IsOK(ecode2)) {
45140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
45141 }
45142 arg2 = static_cast< int >(val2);
45143 {
45144 PyThreadState* __tstate = wxPyBeginAllowThreads();
45145 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
45146 wxPyEndAllowThreads(__tstate);
45147 if (PyErr_Occurred()) SWIG_fail;
45148 }
45149 {
45150 resultobj = wxPyMake_wxObject(result, (bool)0);
45151 }
45152 return resultobj;
45153 fail:
45154 return NULL;
45155 }
45156
45157
45158 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45159 PyObject *resultobj = 0;
45160 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45161 wxString *arg2 = 0 ;
45162 int result;
45163 void *argp1 = 0 ;
45164 int res1 = 0 ;
45165 bool temp2 = false ;
45166 PyObject * obj0 = 0 ;
45167 PyObject * obj1 = 0 ;
45168 char * kwnames[] = {
45169 (char *) "self",(char *) "title", NULL
45170 };
45171
45172 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45173 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45174 if (!SWIG_IsOK(res1)) {
45175 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45176 }
45177 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45178 {
45179 arg2 = wxString_in_helper(obj1);
45180 if (arg2 == NULL) SWIG_fail;
45181 temp2 = true;
45182 }
45183 {
45184 PyThreadState* __tstate = wxPyBeginAllowThreads();
45185 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
45186 wxPyEndAllowThreads(__tstate);
45187 if (PyErr_Occurred()) SWIG_fail;
45188 }
45189 resultobj = SWIG_From_int(static_cast< int >(result));
45190 {
45191 if (temp2)
45192 delete arg2;
45193 }
45194 return resultobj;
45195 fail:
45196 {
45197 if (temp2)
45198 delete arg2;
45199 }
45200 return NULL;
45201 }
45202
45203
45204 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45205 PyObject *resultobj = 0;
45206 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45207 int arg2 ;
45208 bool arg3 ;
45209 void *argp1 = 0 ;
45210 int res1 = 0 ;
45211 int val2 ;
45212 int ecode2 = 0 ;
45213 bool val3 ;
45214 int ecode3 = 0 ;
45215 PyObject * obj0 = 0 ;
45216 PyObject * obj1 = 0 ;
45217 PyObject * obj2 = 0 ;
45218 char * kwnames[] = {
45219 (char *) "self",(char *) "id",(char *) "enable", NULL
45220 };
45221
45222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45224 if (!SWIG_IsOK(res1)) {
45225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45226 }
45227 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45228 ecode2 = SWIG_AsVal_int(obj1, &val2);
45229 if (!SWIG_IsOK(ecode2)) {
45230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
45231 }
45232 arg2 = static_cast< int >(val2);
45233 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45234 if (!SWIG_IsOK(ecode3)) {
45235 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
45236 }
45237 arg3 = static_cast< bool >(val3);
45238 {
45239 PyThreadState* __tstate = wxPyBeginAllowThreads();
45240 (arg1)->Enable(arg2,arg3);
45241 wxPyEndAllowThreads(__tstate);
45242 if (PyErr_Occurred()) SWIG_fail;
45243 }
45244 resultobj = SWIG_Py_Void();
45245 return resultobj;
45246 fail:
45247 return NULL;
45248 }
45249
45250
45251 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45252 PyObject *resultobj = 0;
45253 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45254 int arg2 ;
45255 bool arg3 ;
45256 void *argp1 = 0 ;
45257 int res1 = 0 ;
45258 int val2 ;
45259 int ecode2 = 0 ;
45260 bool val3 ;
45261 int ecode3 = 0 ;
45262 PyObject * obj0 = 0 ;
45263 PyObject * obj1 = 0 ;
45264 PyObject * obj2 = 0 ;
45265 char * kwnames[] = {
45266 (char *) "self",(char *) "id",(char *) "check", NULL
45267 };
45268
45269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45271 if (!SWIG_IsOK(res1)) {
45272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45273 }
45274 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45275 ecode2 = SWIG_AsVal_int(obj1, &val2);
45276 if (!SWIG_IsOK(ecode2)) {
45277 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
45278 }
45279 arg2 = static_cast< int >(val2);
45280 ecode3 = SWIG_AsVal_bool(obj2, &val3);
45281 if (!SWIG_IsOK(ecode3)) {
45282 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
45283 }
45284 arg3 = static_cast< bool >(val3);
45285 {
45286 PyThreadState* __tstate = wxPyBeginAllowThreads();
45287 (arg1)->Check(arg2,arg3);
45288 wxPyEndAllowThreads(__tstate);
45289 if (PyErr_Occurred()) SWIG_fail;
45290 }
45291 resultobj = SWIG_Py_Void();
45292 return resultobj;
45293 fail:
45294 return NULL;
45295 }
45296
45297
45298 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45299 PyObject *resultobj = 0;
45300 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45301 int arg2 ;
45302 bool result;
45303 void *argp1 = 0 ;
45304 int res1 = 0 ;
45305 int val2 ;
45306 int ecode2 = 0 ;
45307 PyObject * obj0 = 0 ;
45308 PyObject * obj1 = 0 ;
45309 char * kwnames[] = {
45310 (char *) "self",(char *) "id", NULL
45311 };
45312
45313 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
45314 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45315 if (!SWIG_IsOK(res1)) {
45316 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45317 }
45318 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45319 ecode2 = SWIG_AsVal_int(obj1, &val2);
45320 if (!SWIG_IsOK(ecode2)) {
45321 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
45322 }
45323 arg2 = static_cast< int >(val2);
45324 {
45325 PyThreadState* __tstate = wxPyBeginAllowThreads();
45326 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
45327 wxPyEndAllowThreads(__tstate);
45328 if (PyErr_Occurred()) SWIG_fail;
45329 }
45330 {
45331 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45332 }
45333 return resultobj;
45334 fail:
45335 return NULL;
45336 }
45337
45338
45339 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45340 PyObject *resultobj = 0;
45341 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45342 int arg2 ;
45343 bool result;
45344 void *argp1 = 0 ;
45345 int res1 = 0 ;
45346 int val2 ;
45347 int ecode2 = 0 ;
45348 PyObject * obj0 = 0 ;
45349 PyObject * obj1 = 0 ;
45350 char * kwnames[] = {
45351 (char *) "self",(char *) "id", NULL
45352 };
45353
45354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
45355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45356 if (!SWIG_IsOK(res1)) {
45357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45358 }
45359 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45360 ecode2 = SWIG_AsVal_int(obj1, &val2);
45361 if (!SWIG_IsOK(ecode2)) {
45362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
45363 }
45364 arg2 = static_cast< int >(val2);
45365 {
45366 PyThreadState* __tstate = wxPyBeginAllowThreads();
45367 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
45368 wxPyEndAllowThreads(__tstate);
45369 if (PyErr_Occurred()) SWIG_fail;
45370 }
45371 {
45372 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45373 }
45374 return resultobj;
45375 fail:
45376 return NULL;
45377 }
45378
45379
45380 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45381 PyObject *resultobj = 0;
45382 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45383 int arg2 ;
45384 wxString *arg3 = 0 ;
45385 void *argp1 = 0 ;
45386 int res1 = 0 ;
45387 int val2 ;
45388 int ecode2 = 0 ;
45389 bool temp3 = false ;
45390 PyObject * obj0 = 0 ;
45391 PyObject * obj1 = 0 ;
45392 PyObject * obj2 = 0 ;
45393 char * kwnames[] = {
45394 (char *) "self",(char *) "id",(char *) "label", NULL
45395 };
45396
45397 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45398 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45399 if (!SWIG_IsOK(res1)) {
45400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45401 }
45402 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45403 ecode2 = SWIG_AsVal_int(obj1, &val2);
45404 if (!SWIG_IsOK(ecode2)) {
45405 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
45406 }
45407 arg2 = static_cast< int >(val2);
45408 {
45409 arg3 = wxString_in_helper(obj2);
45410 if (arg3 == NULL) SWIG_fail;
45411 temp3 = true;
45412 }
45413 {
45414 PyThreadState* __tstate = wxPyBeginAllowThreads();
45415 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
45416 wxPyEndAllowThreads(__tstate);
45417 if (PyErr_Occurred()) SWIG_fail;
45418 }
45419 resultobj = SWIG_Py_Void();
45420 {
45421 if (temp3)
45422 delete arg3;
45423 }
45424 return resultobj;
45425 fail:
45426 {
45427 if (temp3)
45428 delete arg3;
45429 }
45430 return NULL;
45431 }
45432
45433
45434 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45435 PyObject *resultobj = 0;
45436 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45437 int arg2 ;
45438 wxString result;
45439 void *argp1 = 0 ;
45440 int res1 = 0 ;
45441 int val2 ;
45442 int ecode2 = 0 ;
45443 PyObject * obj0 = 0 ;
45444 PyObject * obj1 = 0 ;
45445 char * kwnames[] = {
45446 (char *) "self",(char *) "id", NULL
45447 };
45448
45449 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
45450 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45451 if (!SWIG_IsOK(res1)) {
45452 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45453 }
45454 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45455 ecode2 = SWIG_AsVal_int(obj1, &val2);
45456 if (!SWIG_IsOK(ecode2)) {
45457 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
45458 }
45459 arg2 = static_cast< int >(val2);
45460 {
45461 PyThreadState* __tstate = wxPyBeginAllowThreads();
45462 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
45463 wxPyEndAllowThreads(__tstate);
45464 if (PyErr_Occurred()) SWIG_fail;
45465 }
45466 {
45467 #if wxUSE_UNICODE
45468 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45469 #else
45470 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45471 #endif
45472 }
45473 return resultobj;
45474 fail:
45475 return NULL;
45476 }
45477
45478
45479 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45480 PyObject *resultobj = 0;
45481 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45482 int arg2 ;
45483 wxString *arg3 = 0 ;
45484 void *argp1 = 0 ;
45485 int res1 = 0 ;
45486 int val2 ;
45487 int ecode2 = 0 ;
45488 bool temp3 = false ;
45489 PyObject * obj0 = 0 ;
45490 PyObject * obj1 = 0 ;
45491 PyObject * obj2 = 0 ;
45492 char * kwnames[] = {
45493 (char *) "self",(char *) "id",(char *) "helpString", NULL
45494 };
45495
45496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45498 if (!SWIG_IsOK(res1)) {
45499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45500 }
45501 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45502 ecode2 = SWIG_AsVal_int(obj1, &val2);
45503 if (!SWIG_IsOK(ecode2)) {
45504 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
45505 }
45506 arg2 = static_cast< int >(val2);
45507 {
45508 arg3 = wxString_in_helper(obj2);
45509 if (arg3 == NULL) SWIG_fail;
45510 temp3 = true;
45511 }
45512 {
45513 PyThreadState* __tstate = wxPyBeginAllowThreads();
45514 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
45515 wxPyEndAllowThreads(__tstate);
45516 if (PyErr_Occurred()) SWIG_fail;
45517 }
45518 resultobj = SWIG_Py_Void();
45519 {
45520 if (temp3)
45521 delete arg3;
45522 }
45523 return resultobj;
45524 fail:
45525 {
45526 if (temp3)
45527 delete arg3;
45528 }
45529 return NULL;
45530 }
45531
45532
45533 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45534 PyObject *resultobj = 0;
45535 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45536 int arg2 ;
45537 wxString result;
45538 void *argp1 = 0 ;
45539 int res1 = 0 ;
45540 int val2 ;
45541 int ecode2 = 0 ;
45542 PyObject * obj0 = 0 ;
45543 PyObject * obj1 = 0 ;
45544 char * kwnames[] = {
45545 (char *) "self",(char *) "id", NULL
45546 };
45547
45548 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
45549 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45550 if (!SWIG_IsOK(res1)) {
45551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45552 }
45553 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45554 ecode2 = SWIG_AsVal_int(obj1, &val2);
45555 if (!SWIG_IsOK(ecode2)) {
45556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
45557 }
45558 arg2 = static_cast< int >(val2);
45559 {
45560 PyThreadState* __tstate = wxPyBeginAllowThreads();
45561 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
45562 wxPyEndAllowThreads(__tstate);
45563 if (PyErr_Occurred()) SWIG_fail;
45564 }
45565 {
45566 #if wxUSE_UNICODE
45567 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
45568 #else
45569 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
45570 #endif
45571 }
45572 return resultobj;
45573 fail:
45574 return NULL;
45575 }
45576
45577
45578 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45579 PyObject *resultobj = 0;
45580 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45581 wxFrame *result = 0 ;
45582 void *argp1 = 0 ;
45583 int res1 = 0 ;
45584 PyObject *swig_obj[1] ;
45585
45586 if (!args) SWIG_fail;
45587 swig_obj[0] = args;
45588 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45589 if (!SWIG_IsOK(res1)) {
45590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45591 }
45592 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45593 {
45594 PyThreadState* __tstate = wxPyBeginAllowThreads();
45595 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
45596 wxPyEndAllowThreads(__tstate);
45597 if (PyErr_Occurred()) SWIG_fail;
45598 }
45599 {
45600 resultobj = wxPyMake_wxObject(result, (bool)0);
45601 }
45602 return resultobj;
45603 fail:
45604 return NULL;
45605 }
45606
45607
45608 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45609 PyObject *resultobj = 0;
45610 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45611 bool result;
45612 void *argp1 = 0 ;
45613 int res1 = 0 ;
45614 PyObject *swig_obj[1] ;
45615
45616 if (!args) SWIG_fail;
45617 swig_obj[0] = args;
45618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45619 if (!SWIG_IsOK(res1)) {
45620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
45621 }
45622 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45623 {
45624 PyThreadState* __tstate = wxPyBeginAllowThreads();
45625 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
45626 wxPyEndAllowThreads(__tstate);
45627 if (PyErr_Occurred()) SWIG_fail;
45628 }
45629 {
45630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45631 }
45632 return resultobj;
45633 fail:
45634 return NULL;
45635 }
45636
45637
45638 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45639 PyObject *resultobj = 0;
45640 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45641 wxFrame *arg2 = (wxFrame *) 0 ;
45642 void *argp1 = 0 ;
45643 int res1 = 0 ;
45644 void *argp2 = 0 ;
45645 int res2 = 0 ;
45646 PyObject * obj0 = 0 ;
45647 PyObject * obj1 = 0 ;
45648 char * kwnames[] = {
45649 (char *) "self",(char *) "frame", NULL
45650 };
45651
45652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
45653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45654 if (!SWIG_IsOK(res1)) {
45655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45656 }
45657 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45658 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
45659 if (!SWIG_IsOK(res2)) {
45660 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
45661 }
45662 arg2 = reinterpret_cast< wxFrame * >(argp2);
45663 {
45664 PyThreadState* __tstate = wxPyBeginAllowThreads();
45665 (arg1)->Attach(arg2);
45666 wxPyEndAllowThreads(__tstate);
45667 if (PyErr_Occurred()) SWIG_fail;
45668 }
45669 resultobj = SWIG_Py_Void();
45670 return resultobj;
45671 fail:
45672 return NULL;
45673 }
45674
45675
45676 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45677 PyObject *resultobj = 0;
45678 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45679 void *argp1 = 0 ;
45680 int res1 = 0 ;
45681 PyObject *swig_obj[1] ;
45682
45683 if (!args) SWIG_fail;
45684 swig_obj[0] = args;
45685 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45686 if (!SWIG_IsOK(res1)) {
45687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45688 }
45689 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45690 {
45691 PyThreadState* __tstate = wxPyBeginAllowThreads();
45692 (arg1)->Detach();
45693 wxPyEndAllowThreads(__tstate);
45694 if (PyErr_Occurred()) SWIG_fail;
45695 }
45696 resultobj = SWIG_Py_Void();
45697 return resultobj;
45698 fail:
45699 return NULL;
45700 }
45701
45702
45703 SWIGINTERN PyObject *_wrap_MenuBar_UpdateMenus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45704 PyObject *resultobj = 0;
45705 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
45706 void *argp1 = 0 ;
45707 int res1 = 0 ;
45708 PyObject *swig_obj[1] ;
45709
45710 if (!args) SWIG_fail;
45711 swig_obj[0] = args;
45712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
45713 if (!SWIG_IsOK(res1)) {
45714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_UpdateMenus" "', expected argument " "1"" of type '" "wxMenuBar *""'");
45715 }
45716 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
45717 {
45718 PyThreadState* __tstate = wxPyBeginAllowThreads();
45719 (arg1)->UpdateMenus();
45720 wxPyEndAllowThreads(__tstate);
45721 if (PyErr_Occurred()) SWIG_fail;
45722 }
45723 resultobj = SWIG_Py_Void();
45724 return resultobj;
45725 fail:
45726 return NULL;
45727 }
45728
45729
45730 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45731 PyObject *resultobj = 0;
45732 bool arg1 ;
45733 bool val1 ;
45734 int ecode1 = 0 ;
45735 PyObject * obj0 = 0 ;
45736 char * kwnames[] = {
45737 (char *) "enable", NULL
45738 };
45739
45740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
45741 ecode1 = SWIG_AsVal_bool(obj0, &val1);
45742 if (!SWIG_IsOK(ecode1)) {
45743 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
45744 }
45745 arg1 = static_cast< bool >(val1);
45746 {
45747 PyThreadState* __tstate = wxPyBeginAllowThreads();
45748 wxMenuBar::SetAutoWindowMenu(arg1);
45749 wxPyEndAllowThreads(__tstate);
45750 if (PyErr_Occurred()) SWIG_fail;
45751 }
45752 resultobj = SWIG_Py_Void();
45753 return resultobj;
45754 fail:
45755 return NULL;
45756 }
45757
45758
45759 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45760 PyObject *resultobj = 0;
45761 bool result;
45762
45763 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
45764 {
45765 PyThreadState* __tstate = wxPyBeginAllowThreads();
45766 result = (bool)wxMenuBar::GetAutoWindowMenu();
45767 wxPyEndAllowThreads(__tstate);
45768 if (PyErr_Occurred()) SWIG_fail;
45769 }
45770 {
45771 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45772 }
45773 return resultobj;
45774 fail:
45775 return NULL;
45776 }
45777
45778
45779 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45780 PyObject *obj;
45781 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
45782 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
45783 return SWIG_Py_Void();
45784 }
45785
45786 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45787 return SWIG_Python_InitShadowInstance(args);
45788 }
45789
45790 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45791 PyObject *resultobj = 0;
45792 wxMenu *arg1 = (wxMenu *) NULL ;
45793 int arg2 = (int) wxID_SEPARATOR ;
45794 wxString const &arg3_defvalue = wxPyEmptyString ;
45795 wxString *arg3 = (wxString *) &arg3_defvalue ;
45796 wxString const &arg4_defvalue = wxPyEmptyString ;
45797 wxString *arg4 = (wxString *) &arg4_defvalue ;
45798 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
45799 wxMenu *arg6 = (wxMenu *) NULL ;
45800 wxMenuItem *result = 0 ;
45801 void *argp1 = 0 ;
45802 int res1 = 0 ;
45803 int val2 ;
45804 int ecode2 = 0 ;
45805 bool temp3 = false ;
45806 bool temp4 = false ;
45807 int val5 ;
45808 int ecode5 = 0 ;
45809 void *argp6 = 0 ;
45810 int res6 = 0 ;
45811 PyObject * obj0 = 0 ;
45812 PyObject * obj1 = 0 ;
45813 PyObject * obj2 = 0 ;
45814 PyObject * obj3 = 0 ;
45815 PyObject * obj4 = 0 ;
45816 PyObject * obj5 = 0 ;
45817 char * kwnames[] = {
45818 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
45819 };
45820
45821 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45822 if (obj0) {
45823 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
45824 if (!SWIG_IsOK(res1)) {
45825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
45826 }
45827 arg1 = reinterpret_cast< wxMenu * >(argp1);
45828 }
45829 if (obj1) {
45830 ecode2 = SWIG_AsVal_int(obj1, &val2);
45831 if (!SWIG_IsOK(ecode2)) {
45832 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
45833 }
45834 arg2 = static_cast< int >(val2);
45835 }
45836 if (obj2) {
45837 {
45838 arg3 = wxString_in_helper(obj2);
45839 if (arg3 == NULL) SWIG_fail;
45840 temp3 = true;
45841 }
45842 }
45843 if (obj3) {
45844 {
45845 arg4 = wxString_in_helper(obj3);
45846 if (arg4 == NULL) SWIG_fail;
45847 temp4 = true;
45848 }
45849 }
45850 if (obj4) {
45851 ecode5 = SWIG_AsVal_int(obj4, &val5);
45852 if (!SWIG_IsOK(ecode5)) {
45853 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
45854 }
45855 arg5 = static_cast< wxItemKind >(val5);
45856 }
45857 if (obj5) {
45858 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
45859 if (!SWIG_IsOK(res6)) {
45860 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
45861 }
45862 arg6 = reinterpret_cast< wxMenu * >(argp6);
45863 }
45864 {
45865 PyThreadState* __tstate = wxPyBeginAllowThreads();
45866 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
45867 wxPyEndAllowThreads(__tstate);
45868 if (PyErr_Occurred()) SWIG_fail;
45869 }
45870 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_NEW | 0 );
45871 {
45872 if (temp3)
45873 delete arg3;
45874 }
45875 {
45876 if (temp4)
45877 delete arg4;
45878 }
45879 return resultobj;
45880 fail:
45881 {
45882 if (temp3)
45883 delete arg3;
45884 }
45885 {
45886 if (temp4)
45887 delete arg4;
45888 }
45889 return NULL;
45890 }
45891
45892
45893 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45894 PyObject *resultobj = 0;
45895 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45896 void *argp1 = 0 ;
45897 int res1 = 0 ;
45898 PyObject *swig_obj[1] ;
45899
45900 if (!args) SWIG_fail;
45901 swig_obj[0] = args;
45902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
45903 if (!SWIG_IsOK(res1)) {
45904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45905 }
45906 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45907 {
45908 PyThreadState* __tstate = wxPyBeginAllowThreads();
45909 delete arg1;
45910
45911 wxPyEndAllowThreads(__tstate);
45912 if (PyErr_Occurred()) SWIG_fail;
45913 }
45914 resultobj = SWIG_Py_Void();
45915 return resultobj;
45916 fail:
45917 return NULL;
45918 }
45919
45920
45921 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45922 PyObject *resultobj = 0;
45923 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45924 wxMenu *result = 0 ;
45925 void *argp1 = 0 ;
45926 int res1 = 0 ;
45927 PyObject *swig_obj[1] ;
45928
45929 if (!args) SWIG_fail;
45930 swig_obj[0] = args;
45931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45932 if (!SWIG_IsOK(res1)) {
45933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
45934 }
45935 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45936 {
45937 PyThreadState* __tstate = wxPyBeginAllowThreads();
45938 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
45939 wxPyEndAllowThreads(__tstate);
45940 if (PyErr_Occurred()) SWIG_fail;
45941 }
45942 {
45943 resultobj = wxPyMake_wxObject(result, 0);
45944 }
45945 return resultobj;
45946 fail:
45947 return NULL;
45948 }
45949
45950
45951 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45952 PyObject *resultobj = 0;
45953 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45954 wxMenu *arg2 = (wxMenu *) 0 ;
45955 void *argp1 = 0 ;
45956 int res1 = 0 ;
45957 void *argp2 = 0 ;
45958 int res2 = 0 ;
45959 PyObject * obj0 = 0 ;
45960 PyObject * obj1 = 0 ;
45961 char * kwnames[] = {
45962 (char *) "self",(char *) "menu", NULL
45963 };
45964
45965 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
45966 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
45967 if (!SWIG_IsOK(res1)) {
45968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
45969 }
45970 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
45971 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
45972 if (!SWIG_IsOK(res2)) {
45973 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
45974 }
45975 arg2 = reinterpret_cast< wxMenu * >(argp2);
45976 {
45977 PyThreadState* __tstate = wxPyBeginAllowThreads();
45978 (arg1)->SetMenu(arg2);
45979 wxPyEndAllowThreads(__tstate);
45980 if (PyErr_Occurred()) SWIG_fail;
45981 }
45982 resultobj = SWIG_Py_Void();
45983 return resultobj;
45984 fail:
45985 return NULL;
45986 }
45987
45988
45989 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45990 PyObject *resultobj = 0;
45991 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
45992 int arg2 ;
45993 void *argp1 = 0 ;
45994 int res1 = 0 ;
45995 int val2 ;
45996 int ecode2 = 0 ;
45997 PyObject * obj0 = 0 ;
45998 PyObject * obj1 = 0 ;
45999 char * kwnames[] = {
46000 (char *) "self",(char *) "id", NULL
46001 };
46002
46003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
46004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46005 if (!SWIG_IsOK(res1)) {
46006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46007 }
46008 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46009 ecode2 = SWIG_AsVal_int(obj1, &val2);
46010 if (!SWIG_IsOK(ecode2)) {
46011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
46012 }
46013 arg2 = static_cast< int >(val2);
46014 {
46015 PyThreadState* __tstate = wxPyBeginAllowThreads();
46016 (arg1)->SetId(arg2);
46017 wxPyEndAllowThreads(__tstate);
46018 if (PyErr_Occurred()) SWIG_fail;
46019 }
46020 resultobj = SWIG_Py_Void();
46021 return resultobj;
46022 fail:
46023 return NULL;
46024 }
46025
46026
46027 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46028 PyObject *resultobj = 0;
46029 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46030 int result;
46031 void *argp1 = 0 ;
46032 int res1 = 0 ;
46033 PyObject *swig_obj[1] ;
46034
46035 if (!args) SWIG_fail;
46036 swig_obj[0] = args;
46037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46038 if (!SWIG_IsOK(res1)) {
46039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46040 }
46041 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46042 {
46043 PyThreadState* __tstate = wxPyBeginAllowThreads();
46044 result = (int)((wxMenuItem const *)arg1)->GetId();
46045 wxPyEndAllowThreads(__tstate);
46046 if (PyErr_Occurred()) SWIG_fail;
46047 }
46048 resultobj = SWIG_From_int(static_cast< int >(result));
46049 return resultobj;
46050 fail:
46051 return NULL;
46052 }
46053
46054
46055 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46056 PyObject *resultobj = 0;
46057 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46058 bool result;
46059 void *argp1 = 0 ;
46060 int res1 = 0 ;
46061 PyObject *swig_obj[1] ;
46062
46063 if (!args) SWIG_fail;
46064 swig_obj[0] = args;
46065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46066 if (!SWIG_IsOK(res1)) {
46067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46068 }
46069 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46070 {
46071 PyThreadState* __tstate = wxPyBeginAllowThreads();
46072 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
46073 wxPyEndAllowThreads(__tstate);
46074 if (PyErr_Occurred()) SWIG_fail;
46075 }
46076 {
46077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46078 }
46079 return resultobj;
46080 fail:
46081 return NULL;
46082 }
46083
46084
46085 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46086 PyObject *resultobj = 0;
46087 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46088 wxString *arg2 = 0 ;
46089 void *argp1 = 0 ;
46090 int res1 = 0 ;
46091 bool temp2 = false ;
46092 PyObject * obj0 = 0 ;
46093 PyObject * obj1 = 0 ;
46094 char * kwnames[] = {
46095 (char *) "self",(char *) "str", NULL
46096 };
46097
46098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
46099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46100 if (!SWIG_IsOK(res1)) {
46101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46102 }
46103 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46104 {
46105 arg2 = wxString_in_helper(obj1);
46106 if (arg2 == NULL) SWIG_fail;
46107 temp2 = true;
46108 }
46109 {
46110 PyThreadState* __tstate = wxPyBeginAllowThreads();
46111 (arg1)->SetText((wxString const &)*arg2);
46112 wxPyEndAllowThreads(__tstate);
46113 if (PyErr_Occurred()) SWIG_fail;
46114 }
46115 resultobj = SWIG_Py_Void();
46116 {
46117 if (temp2)
46118 delete arg2;
46119 }
46120 return resultobj;
46121 fail:
46122 {
46123 if (temp2)
46124 delete arg2;
46125 }
46126 return NULL;
46127 }
46128
46129
46130 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46131 PyObject *resultobj = 0;
46132 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46133 wxString result;
46134 void *argp1 = 0 ;
46135 int res1 = 0 ;
46136 PyObject *swig_obj[1] ;
46137
46138 if (!args) SWIG_fail;
46139 swig_obj[0] = args;
46140 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46141 if (!SWIG_IsOK(res1)) {
46142 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46143 }
46144 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46145 {
46146 PyThreadState* __tstate = wxPyBeginAllowThreads();
46147 result = ((wxMenuItem const *)arg1)->GetLabel();
46148 wxPyEndAllowThreads(__tstate);
46149 if (PyErr_Occurred()) SWIG_fail;
46150 }
46151 {
46152 #if wxUSE_UNICODE
46153 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46154 #else
46155 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46156 #endif
46157 }
46158 return resultobj;
46159 fail:
46160 return NULL;
46161 }
46162
46163
46164 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46165 PyObject *resultobj = 0;
46166 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46167 wxString *result = 0 ;
46168 void *argp1 = 0 ;
46169 int res1 = 0 ;
46170 PyObject *swig_obj[1] ;
46171
46172 if (!args) SWIG_fail;
46173 swig_obj[0] = args;
46174 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46175 if (!SWIG_IsOK(res1)) {
46176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46177 }
46178 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46179 {
46180 PyThreadState* __tstate = wxPyBeginAllowThreads();
46181 {
46182 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
46183 result = (wxString *) &_result_ref;
46184 }
46185 wxPyEndAllowThreads(__tstate);
46186 if (PyErr_Occurred()) SWIG_fail;
46187 }
46188 {
46189 #if wxUSE_UNICODE
46190 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46191 #else
46192 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46193 #endif
46194 }
46195 return resultobj;
46196 fail:
46197 return NULL;
46198 }
46199
46200
46201 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46202 PyObject *resultobj = 0;
46203 wxString *arg1 = 0 ;
46204 wxString result;
46205 bool temp1 = false ;
46206 PyObject * obj0 = 0 ;
46207 char * kwnames[] = {
46208 (char *) "text", NULL
46209 };
46210
46211 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
46212 {
46213 arg1 = wxString_in_helper(obj0);
46214 if (arg1 == NULL) SWIG_fail;
46215 temp1 = true;
46216 }
46217 {
46218 PyThreadState* __tstate = wxPyBeginAllowThreads();
46219 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
46220 wxPyEndAllowThreads(__tstate);
46221 if (PyErr_Occurred()) SWIG_fail;
46222 }
46223 {
46224 #if wxUSE_UNICODE
46225 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
46226 #else
46227 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
46228 #endif
46229 }
46230 {
46231 if (temp1)
46232 delete arg1;
46233 }
46234 return resultobj;
46235 fail:
46236 {
46237 if (temp1)
46238 delete arg1;
46239 }
46240 return NULL;
46241 }
46242
46243
46244 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46245 PyObject *resultobj = 0;
46246 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46247 wxItemKind result;
46248 void *argp1 = 0 ;
46249 int res1 = 0 ;
46250 PyObject *swig_obj[1] ;
46251
46252 if (!args) SWIG_fail;
46253 swig_obj[0] = args;
46254 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46255 if (!SWIG_IsOK(res1)) {
46256 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46257 }
46258 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46259 {
46260 PyThreadState* __tstate = wxPyBeginAllowThreads();
46261 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
46262 wxPyEndAllowThreads(__tstate);
46263 if (PyErr_Occurred()) SWIG_fail;
46264 }
46265 resultobj = SWIG_From_int(static_cast< int >(result));
46266 return resultobj;
46267 fail:
46268 return NULL;
46269 }
46270
46271
46272 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46273 PyObject *resultobj = 0;
46274 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46275 wxItemKind arg2 ;
46276 void *argp1 = 0 ;
46277 int res1 = 0 ;
46278 int val2 ;
46279 int ecode2 = 0 ;
46280 PyObject * obj0 = 0 ;
46281 PyObject * obj1 = 0 ;
46282 char * kwnames[] = {
46283 (char *) "self",(char *) "kind", NULL
46284 };
46285
46286 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
46287 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46288 if (!SWIG_IsOK(res1)) {
46289 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46290 }
46291 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46292 ecode2 = SWIG_AsVal_int(obj1, &val2);
46293 if (!SWIG_IsOK(ecode2)) {
46294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
46295 }
46296 arg2 = static_cast< wxItemKind >(val2);
46297 {
46298 PyThreadState* __tstate = wxPyBeginAllowThreads();
46299 (arg1)->SetKind(arg2);
46300 wxPyEndAllowThreads(__tstate);
46301 if (PyErr_Occurred()) SWIG_fail;
46302 }
46303 resultobj = SWIG_Py_Void();
46304 return resultobj;
46305 fail:
46306 return NULL;
46307 }
46308
46309
46310 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46311 PyObject *resultobj = 0;
46312 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46313 bool arg2 ;
46314 void *argp1 = 0 ;
46315 int res1 = 0 ;
46316 bool val2 ;
46317 int ecode2 = 0 ;
46318 PyObject * obj0 = 0 ;
46319 PyObject * obj1 = 0 ;
46320 char * kwnames[] = {
46321 (char *) "self",(char *) "checkable", NULL
46322 };
46323
46324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
46325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46326 if (!SWIG_IsOK(res1)) {
46327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46328 }
46329 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46330 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46331 if (!SWIG_IsOK(ecode2)) {
46332 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
46333 }
46334 arg2 = static_cast< bool >(val2);
46335 {
46336 PyThreadState* __tstate = wxPyBeginAllowThreads();
46337 (arg1)->SetCheckable(arg2);
46338 wxPyEndAllowThreads(__tstate);
46339 if (PyErr_Occurred()) SWIG_fail;
46340 }
46341 resultobj = SWIG_Py_Void();
46342 return resultobj;
46343 fail:
46344 return NULL;
46345 }
46346
46347
46348 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46349 PyObject *resultobj = 0;
46350 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46351 bool result;
46352 void *argp1 = 0 ;
46353 int res1 = 0 ;
46354 PyObject *swig_obj[1] ;
46355
46356 if (!args) SWIG_fail;
46357 swig_obj[0] = args;
46358 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46359 if (!SWIG_IsOK(res1)) {
46360 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46361 }
46362 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46363 {
46364 PyThreadState* __tstate = wxPyBeginAllowThreads();
46365 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
46366 wxPyEndAllowThreads(__tstate);
46367 if (PyErr_Occurred()) SWIG_fail;
46368 }
46369 {
46370 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46371 }
46372 return resultobj;
46373 fail:
46374 return NULL;
46375 }
46376
46377
46378 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46379 PyObject *resultobj = 0;
46380 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46381 bool result;
46382 void *argp1 = 0 ;
46383 int res1 = 0 ;
46384 PyObject *swig_obj[1] ;
46385
46386 if (!args) SWIG_fail;
46387 swig_obj[0] = args;
46388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46389 if (!SWIG_IsOK(res1)) {
46390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46391 }
46392 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46393 {
46394 PyThreadState* __tstate = wxPyBeginAllowThreads();
46395 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
46396 wxPyEndAllowThreads(__tstate);
46397 if (PyErr_Occurred()) SWIG_fail;
46398 }
46399 {
46400 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46401 }
46402 return resultobj;
46403 fail:
46404 return NULL;
46405 }
46406
46407
46408 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46409 PyObject *resultobj = 0;
46410 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46411 wxMenu *arg2 = (wxMenu *) 0 ;
46412 void *argp1 = 0 ;
46413 int res1 = 0 ;
46414 void *argp2 = 0 ;
46415 int res2 = 0 ;
46416 PyObject * obj0 = 0 ;
46417 PyObject * obj1 = 0 ;
46418 char * kwnames[] = {
46419 (char *) "self",(char *) "menu", NULL
46420 };
46421
46422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
46423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46424 if (!SWIG_IsOK(res1)) {
46425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46426 }
46427 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46428 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
46429 if (!SWIG_IsOK(res2)) {
46430 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
46431 }
46432 arg2 = reinterpret_cast< wxMenu * >(argp2);
46433 {
46434 PyThreadState* __tstate = wxPyBeginAllowThreads();
46435 (arg1)->SetSubMenu(arg2);
46436 wxPyEndAllowThreads(__tstate);
46437 if (PyErr_Occurred()) SWIG_fail;
46438 }
46439 resultobj = SWIG_Py_Void();
46440 return resultobj;
46441 fail:
46442 return NULL;
46443 }
46444
46445
46446 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46447 PyObject *resultobj = 0;
46448 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46449 wxMenu *result = 0 ;
46450 void *argp1 = 0 ;
46451 int res1 = 0 ;
46452 PyObject *swig_obj[1] ;
46453
46454 if (!args) SWIG_fail;
46455 swig_obj[0] = args;
46456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46457 if (!SWIG_IsOK(res1)) {
46458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46459 }
46460 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46461 {
46462 PyThreadState* __tstate = wxPyBeginAllowThreads();
46463 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
46464 wxPyEndAllowThreads(__tstate);
46465 if (PyErr_Occurred()) SWIG_fail;
46466 }
46467 {
46468 resultobj = wxPyMake_wxObject(result, 0);
46469 }
46470 return resultobj;
46471 fail:
46472 return NULL;
46473 }
46474
46475
46476 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46477 PyObject *resultobj = 0;
46478 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46479 bool arg2 = (bool) true ;
46480 void *argp1 = 0 ;
46481 int res1 = 0 ;
46482 bool val2 ;
46483 int ecode2 = 0 ;
46484 PyObject * obj0 = 0 ;
46485 PyObject * obj1 = 0 ;
46486 char * kwnames[] = {
46487 (char *) "self",(char *) "enable", NULL
46488 };
46489
46490 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
46491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46492 if (!SWIG_IsOK(res1)) {
46493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46494 }
46495 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46496 if (obj1) {
46497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46498 if (!SWIG_IsOK(ecode2)) {
46499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
46500 }
46501 arg2 = static_cast< bool >(val2);
46502 }
46503 {
46504 PyThreadState* __tstate = wxPyBeginAllowThreads();
46505 (arg1)->Enable(arg2);
46506 wxPyEndAllowThreads(__tstate);
46507 if (PyErr_Occurred()) SWIG_fail;
46508 }
46509 resultobj = SWIG_Py_Void();
46510 return resultobj;
46511 fail:
46512 return NULL;
46513 }
46514
46515
46516 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46517 PyObject *resultobj = 0;
46518 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46519 bool result;
46520 void *argp1 = 0 ;
46521 int res1 = 0 ;
46522 PyObject *swig_obj[1] ;
46523
46524 if (!args) SWIG_fail;
46525 swig_obj[0] = args;
46526 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46527 if (!SWIG_IsOK(res1)) {
46528 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46529 }
46530 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46531 {
46532 PyThreadState* __tstate = wxPyBeginAllowThreads();
46533 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
46534 wxPyEndAllowThreads(__tstate);
46535 if (PyErr_Occurred()) SWIG_fail;
46536 }
46537 {
46538 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46539 }
46540 return resultobj;
46541 fail:
46542 return NULL;
46543 }
46544
46545
46546 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46547 PyObject *resultobj = 0;
46548 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46549 bool arg2 = (bool) true ;
46550 void *argp1 = 0 ;
46551 int res1 = 0 ;
46552 bool val2 ;
46553 int ecode2 = 0 ;
46554 PyObject * obj0 = 0 ;
46555 PyObject * obj1 = 0 ;
46556 char * kwnames[] = {
46557 (char *) "self",(char *) "check", NULL
46558 };
46559
46560 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
46561 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46562 if (!SWIG_IsOK(res1)) {
46563 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46564 }
46565 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46566 if (obj1) {
46567 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46568 if (!SWIG_IsOK(ecode2)) {
46569 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
46570 }
46571 arg2 = static_cast< bool >(val2);
46572 }
46573 {
46574 PyThreadState* __tstate = wxPyBeginAllowThreads();
46575 (arg1)->Check(arg2);
46576 wxPyEndAllowThreads(__tstate);
46577 if (PyErr_Occurred()) SWIG_fail;
46578 }
46579 resultobj = SWIG_Py_Void();
46580 return resultobj;
46581 fail:
46582 return NULL;
46583 }
46584
46585
46586 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46587 PyObject *resultobj = 0;
46588 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46589 bool result;
46590 void *argp1 = 0 ;
46591 int res1 = 0 ;
46592 PyObject *swig_obj[1] ;
46593
46594 if (!args) SWIG_fail;
46595 swig_obj[0] = args;
46596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46597 if (!SWIG_IsOK(res1)) {
46598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46599 }
46600 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46601 {
46602 PyThreadState* __tstate = wxPyBeginAllowThreads();
46603 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
46604 wxPyEndAllowThreads(__tstate);
46605 if (PyErr_Occurred()) SWIG_fail;
46606 }
46607 {
46608 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46609 }
46610 return resultobj;
46611 fail:
46612 return NULL;
46613 }
46614
46615
46616 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46617 PyObject *resultobj = 0;
46618 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46619 void *argp1 = 0 ;
46620 int res1 = 0 ;
46621 PyObject *swig_obj[1] ;
46622
46623 if (!args) SWIG_fail;
46624 swig_obj[0] = args;
46625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46626 if (!SWIG_IsOK(res1)) {
46627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46628 }
46629 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46630 {
46631 PyThreadState* __tstate = wxPyBeginAllowThreads();
46632 (arg1)->Toggle();
46633 wxPyEndAllowThreads(__tstate);
46634 if (PyErr_Occurred()) SWIG_fail;
46635 }
46636 resultobj = SWIG_Py_Void();
46637 return resultobj;
46638 fail:
46639 return NULL;
46640 }
46641
46642
46643 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46644 PyObject *resultobj = 0;
46645 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46646 wxString *arg2 = 0 ;
46647 void *argp1 = 0 ;
46648 int res1 = 0 ;
46649 bool temp2 = false ;
46650 PyObject * obj0 = 0 ;
46651 PyObject * obj1 = 0 ;
46652 char * kwnames[] = {
46653 (char *) "self",(char *) "str", NULL
46654 };
46655
46656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
46657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46658 if (!SWIG_IsOK(res1)) {
46659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46660 }
46661 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46662 {
46663 arg2 = wxString_in_helper(obj1);
46664 if (arg2 == NULL) SWIG_fail;
46665 temp2 = true;
46666 }
46667 {
46668 PyThreadState* __tstate = wxPyBeginAllowThreads();
46669 (arg1)->SetHelp((wxString const &)*arg2);
46670 wxPyEndAllowThreads(__tstate);
46671 if (PyErr_Occurred()) SWIG_fail;
46672 }
46673 resultobj = SWIG_Py_Void();
46674 {
46675 if (temp2)
46676 delete arg2;
46677 }
46678 return resultobj;
46679 fail:
46680 {
46681 if (temp2)
46682 delete arg2;
46683 }
46684 return NULL;
46685 }
46686
46687
46688 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46689 PyObject *resultobj = 0;
46690 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46691 wxString *result = 0 ;
46692 void *argp1 = 0 ;
46693 int res1 = 0 ;
46694 PyObject *swig_obj[1] ;
46695
46696 if (!args) SWIG_fail;
46697 swig_obj[0] = args;
46698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46699 if (!SWIG_IsOK(res1)) {
46700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46701 }
46702 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46703 {
46704 PyThreadState* __tstate = wxPyBeginAllowThreads();
46705 {
46706 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
46707 result = (wxString *) &_result_ref;
46708 }
46709 wxPyEndAllowThreads(__tstate);
46710 if (PyErr_Occurred()) SWIG_fail;
46711 }
46712 {
46713 #if wxUSE_UNICODE
46714 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
46715 #else
46716 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
46717 #endif
46718 }
46719 return resultobj;
46720 fail:
46721 return NULL;
46722 }
46723
46724
46725 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46726 PyObject *resultobj = 0;
46727 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46728 wxAcceleratorEntry *result = 0 ;
46729 void *argp1 = 0 ;
46730 int res1 = 0 ;
46731 PyObject *swig_obj[1] ;
46732
46733 if (!args) SWIG_fail;
46734 swig_obj[0] = args;
46735 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46736 if (!SWIG_IsOK(res1)) {
46737 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
46738 }
46739 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46740 {
46741 PyThreadState* __tstate = wxPyBeginAllowThreads();
46742 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
46743 wxPyEndAllowThreads(__tstate);
46744 if (PyErr_Occurred()) SWIG_fail;
46745 }
46746 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46747 return resultobj;
46748 fail:
46749 return NULL;
46750 }
46751
46752
46753 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46754 PyObject *resultobj = 0;
46755 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46756 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
46757 void *argp1 = 0 ;
46758 int res1 = 0 ;
46759 void *argp2 = 0 ;
46760 int res2 = 0 ;
46761 PyObject * obj0 = 0 ;
46762 PyObject * obj1 = 0 ;
46763 char * kwnames[] = {
46764 (char *) "self",(char *) "accel", NULL
46765 };
46766
46767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
46768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46769 if (!SWIG_IsOK(res1)) {
46770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46771 }
46772 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46773 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
46774 if (!SWIG_IsOK(res2)) {
46775 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
46776 }
46777 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
46778 {
46779 PyThreadState* __tstate = wxPyBeginAllowThreads();
46780 (arg1)->SetAccel(arg2);
46781 wxPyEndAllowThreads(__tstate);
46782 if (PyErr_Occurred()) SWIG_fail;
46783 }
46784 resultobj = SWIG_Py_Void();
46785 return resultobj;
46786 fail:
46787 return NULL;
46788 }
46789
46790
46791 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46792 PyObject *resultobj = 0;
46793 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46794 wxBitmap *arg2 = 0 ;
46795 void *argp1 = 0 ;
46796 int res1 = 0 ;
46797 void *argp2 = 0 ;
46798 int res2 = 0 ;
46799 PyObject * obj0 = 0 ;
46800 PyObject * obj1 = 0 ;
46801 char * kwnames[] = {
46802 (char *) "self",(char *) "bitmap", NULL
46803 };
46804
46805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
46806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46807 if (!SWIG_IsOK(res1)) {
46808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46809 }
46810 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46811 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
46812 if (!SWIG_IsOK(res2)) {
46813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46814 }
46815 if (!argp2) {
46816 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
46817 }
46818 arg2 = reinterpret_cast< wxBitmap * >(argp2);
46819 {
46820 PyThreadState* __tstate = wxPyBeginAllowThreads();
46821 (arg1)->SetBitmap((wxBitmap const &)*arg2);
46822 wxPyEndAllowThreads(__tstate);
46823 if (PyErr_Occurred()) SWIG_fail;
46824 }
46825 resultobj = SWIG_Py_Void();
46826 return resultobj;
46827 fail:
46828 return NULL;
46829 }
46830
46831
46832 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46833 PyObject *resultobj = 0;
46834 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46835 wxBitmap *result = 0 ;
46836 void *argp1 = 0 ;
46837 int res1 = 0 ;
46838 PyObject *swig_obj[1] ;
46839
46840 if (!args) SWIG_fail;
46841 swig_obj[0] = args;
46842 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46843 if (!SWIG_IsOK(res1)) {
46844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46845 }
46846 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46847 {
46848 PyThreadState* __tstate = wxPyBeginAllowThreads();
46849 {
46850 wxBitmap const &_result_ref = (arg1)->GetBitmap();
46851 result = (wxBitmap *) &_result_ref;
46852 }
46853 wxPyEndAllowThreads(__tstate);
46854 if (PyErr_Occurred()) SWIG_fail;
46855 }
46856 {
46857 wxBitmap* resultptr = new wxBitmap(*result);
46858 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
46859 }
46860 return resultobj;
46861 fail:
46862 return NULL;
46863 }
46864
46865
46866 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46867 PyObject *resultobj = 0;
46868 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46869 wxFont *arg2 = 0 ;
46870 void *argp1 = 0 ;
46871 int res1 = 0 ;
46872 void *argp2 = 0 ;
46873 int res2 = 0 ;
46874 PyObject * obj0 = 0 ;
46875 PyObject * obj1 = 0 ;
46876 char * kwnames[] = {
46877 (char *) "self",(char *) "font", NULL
46878 };
46879
46880 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
46881 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46882 if (!SWIG_IsOK(res1)) {
46883 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46884 }
46885 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46886 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
46887 if (!SWIG_IsOK(res2)) {
46888 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46889 }
46890 if (!argp2) {
46891 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
46892 }
46893 arg2 = reinterpret_cast< wxFont * >(argp2);
46894 {
46895 PyThreadState* __tstate = wxPyBeginAllowThreads();
46896 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
46897 wxPyEndAllowThreads(__tstate);
46898 if (PyErr_Occurred()) SWIG_fail;
46899 }
46900 resultobj = SWIG_Py_Void();
46901 return resultobj;
46902 fail:
46903 return NULL;
46904 }
46905
46906
46907 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46908 PyObject *resultobj = 0;
46909 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46910 wxFont result;
46911 void *argp1 = 0 ;
46912 int res1 = 0 ;
46913 PyObject *swig_obj[1] ;
46914
46915 if (!args) SWIG_fail;
46916 swig_obj[0] = args;
46917 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46918 if (!SWIG_IsOK(res1)) {
46919 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46920 }
46921 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46922 {
46923 PyThreadState* __tstate = wxPyBeginAllowThreads();
46924 result = wxMenuItem_GetFont(arg1);
46925 wxPyEndAllowThreads(__tstate);
46926 if (PyErr_Occurred()) SWIG_fail;
46927 }
46928 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
46929 return resultobj;
46930 fail:
46931 return NULL;
46932 }
46933
46934
46935 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46936 PyObject *resultobj = 0;
46937 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46938 wxColour *arg2 = 0 ;
46939 void *argp1 = 0 ;
46940 int res1 = 0 ;
46941 wxColour temp2 ;
46942 PyObject * obj0 = 0 ;
46943 PyObject * obj1 = 0 ;
46944 char * kwnames[] = {
46945 (char *) "self",(char *) "colText", NULL
46946 };
46947
46948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
46949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46950 if (!SWIG_IsOK(res1)) {
46951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46952 }
46953 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46954 {
46955 arg2 = &temp2;
46956 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
46957 }
46958 {
46959 PyThreadState* __tstate = wxPyBeginAllowThreads();
46960 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
46961 wxPyEndAllowThreads(__tstate);
46962 if (PyErr_Occurred()) SWIG_fail;
46963 }
46964 resultobj = SWIG_Py_Void();
46965 return resultobj;
46966 fail:
46967 return NULL;
46968 }
46969
46970
46971 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46972 PyObject *resultobj = 0;
46973 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
46974 wxColour result;
46975 void *argp1 = 0 ;
46976 int res1 = 0 ;
46977 PyObject *swig_obj[1] ;
46978
46979 if (!args) SWIG_fail;
46980 swig_obj[0] = args;
46981 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
46982 if (!SWIG_IsOK(res1)) {
46983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
46984 }
46985 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
46986 {
46987 PyThreadState* __tstate = wxPyBeginAllowThreads();
46988 result = wxMenuItem_GetTextColour(arg1);
46989 wxPyEndAllowThreads(__tstate);
46990 if (PyErr_Occurred()) SWIG_fail;
46991 }
46992 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
46993 return resultobj;
46994 fail:
46995 return NULL;
46996 }
46997
46998
46999 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47000 PyObject *resultobj = 0;
47001 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47002 wxColour *arg2 = 0 ;
47003 void *argp1 = 0 ;
47004 int res1 = 0 ;
47005 wxColour temp2 ;
47006 PyObject * obj0 = 0 ;
47007 PyObject * obj1 = 0 ;
47008 char * kwnames[] = {
47009 (char *) "self",(char *) "colBack", NULL
47010 };
47011
47012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
47013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47014 if (!SWIG_IsOK(res1)) {
47015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47016 }
47017 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47018 {
47019 arg2 = &temp2;
47020 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
47021 }
47022 {
47023 PyThreadState* __tstate = wxPyBeginAllowThreads();
47024 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
47025 wxPyEndAllowThreads(__tstate);
47026 if (PyErr_Occurred()) SWIG_fail;
47027 }
47028 resultobj = SWIG_Py_Void();
47029 return resultobj;
47030 fail:
47031 return NULL;
47032 }
47033
47034
47035 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47036 PyObject *resultobj = 0;
47037 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47038 wxColour result;
47039 void *argp1 = 0 ;
47040 int res1 = 0 ;
47041 PyObject *swig_obj[1] ;
47042
47043 if (!args) SWIG_fail;
47044 swig_obj[0] = args;
47045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47046 if (!SWIG_IsOK(res1)) {
47047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47048 }
47049 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47050 {
47051 PyThreadState* __tstate = wxPyBeginAllowThreads();
47052 result = wxMenuItem_GetBackgroundColour(arg1);
47053 wxPyEndAllowThreads(__tstate);
47054 if (PyErr_Occurred()) SWIG_fail;
47055 }
47056 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
47057 return resultobj;
47058 fail:
47059 return NULL;
47060 }
47061
47062
47063 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47064 PyObject *resultobj = 0;
47065 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47066 wxBitmap *arg2 = 0 ;
47067 wxBitmap const &arg3_defvalue = wxNullBitmap ;
47068 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
47069 void *argp1 = 0 ;
47070 int res1 = 0 ;
47071 void *argp2 = 0 ;
47072 int res2 = 0 ;
47073 void *argp3 = 0 ;
47074 int res3 = 0 ;
47075 PyObject * obj0 = 0 ;
47076 PyObject * obj1 = 0 ;
47077 PyObject * obj2 = 0 ;
47078 char * kwnames[] = {
47079 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
47080 };
47081
47082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47084 if (!SWIG_IsOK(res1)) {
47085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47086 }
47087 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47088 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47089 if (!SWIG_IsOK(res2)) {
47090 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47091 }
47092 if (!argp2) {
47093 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47094 }
47095 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47096 if (obj2) {
47097 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
47098 if (!SWIG_IsOK(res3)) {
47099 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47100 }
47101 if (!argp3) {
47102 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
47103 }
47104 arg3 = reinterpret_cast< wxBitmap * >(argp3);
47105 }
47106 {
47107 PyThreadState* __tstate = wxPyBeginAllowThreads();
47108 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
47109 wxPyEndAllowThreads(__tstate);
47110 if (PyErr_Occurred()) SWIG_fail;
47111 }
47112 resultobj = SWIG_Py_Void();
47113 return resultobj;
47114 fail:
47115 return NULL;
47116 }
47117
47118
47119 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47120 PyObject *resultobj = 0;
47121 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47122 wxBitmap *arg2 = 0 ;
47123 void *argp1 = 0 ;
47124 int res1 = 0 ;
47125 void *argp2 = 0 ;
47126 int res2 = 0 ;
47127 PyObject * obj0 = 0 ;
47128 PyObject * obj1 = 0 ;
47129 char * kwnames[] = {
47130 (char *) "self",(char *) "bmpDisabled", NULL
47131 };
47132
47133 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
47134 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47135 if (!SWIG_IsOK(res1)) {
47136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47137 }
47138 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47139 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
47140 if (!SWIG_IsOK(res2)) {
47141 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47142 }
47143 if (!argp2) {
47144 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
47145 }
47146 arg2 = reinterpret_cast< wxBitmap * >(argp2);
47147 {
47148 PyThreadState* __tstate = wxPyBeginAllowThreads();
47149 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
47150 wxPyEndAllowThreads(__tstate);
47151 if (PyErr_Occurred()) SWIG_fail;
47152 }
47153 resultobj = SWIG_Py_Void();
47154 return resultobj;
47155 fail:
47156 return NULL;
47157 }
47158
47159
47160 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47161 PyObject *resultobj = 0;
47162 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47163 wxBitmap *result = 0 ;
47164 void *argp1 = 0 ;
47165 int res1 = 0 ;
47166 PyObject *swig_obj[1] ;
47167
47168 if (!args) SWIG_fail;
47169 swig_obj[0] = args;
47170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47171 if (!SWIG_IsOK(res1)) {
47172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
47173 }
47174 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47175 {
47176 PyThreadState* __tstate = wxPyBeginAllowThreads();
47177 {
47178 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
47179 result = (wxBitmap *) &_result_ref;
47180 }
47181 wxPyEndAllowThreads(__tstate);
47182 if (PyErr_Occurred()) SWIG_fail;
47183 }
47184 {
47185 wxBitmap* resultptr = new wxBitmap(*result);
47186 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
47187 }
47188 return resultobj;
47189 fail:
47190 return NULL;
47191 }
47192
47193
47194 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47195 PyObject *resultobj = 0;
47196 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47197 int arg2 ;
47198 void *argp1 = 0 ;
47199 int res1 = 0 ;
47200 int val2 ;
47201 int ecode2 = 0 ;
47202 PyObject * obj0 = 0 ;
47203 PyObject * obj1 = 0 ;
47204 char * kwnames[] = {
47205 (char *) "self",(char *) "nWidth", NULL
47206 };
47207
47208 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
47209 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47210 if (!SWIG_IsOK(res1)) {
47211 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47212 }
47213 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47214 ecode2 = SWIG_AsVal_int(obj1, &val2);
47215 if (!SWIG_IsOK(ecode2)) {
47216 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
47217 }
47218 arg2 = static_cast< int >(val2);
47219 {
47220 PyThreadState* __tstate = wxPyBeginAllowThreads();
47221 wxMenuItem_SetMarginWidth(arg1,arg2);
47222 wxPyEndAllowThreads(__tstate);
47223 if (PyErr_Occurred()) SWIG_fail;
47224 }
47225 resultobj = SWIG_Py_Void();
47226 return resultobj;
47227 fail:
47228 return NULL;
47229 }
47230
47231
47232 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47233 PyObject *resultobj = 0;
47234 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47235 int result;
47236 void *argp1 = 0 ;
47237 int res1 = 0 ;
47238 PyObject *swig_obj[1] ;
47239
47240 if (!args) SWIG_fail;
47241 swig_obj[0] = args;
47242 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47243 if (!SWIG_IsOK(res1)) {
47244 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47245 }
47246 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47247 {
47248 PyThreadState* __tstate = wxPyBeginAllowThreads();
47249 result = (int)wxMenuItem_GetMarginWidth(arg1);
47250 wxPyEndAllowThreads(__tstate);
47251 if (PyErr_Occurred()) SWIG_fail;
47252 }
47253 resultobj = SWIG_From_int(static_cast< int >(result));
47254 return resultobj;
47255 fail:
47256 return NULL;
47257 }
47258
47259
47260 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47261 PyObject *resultobj = 0;
47262 int result;
47263
47264 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
47265 {
47266 PyThreadState* __tstate = wxPyBeginAllowThreads();
47267 result = (int)wxMenuItem_GetDefaultMarginWidth();
47268 wxPyEndAllowThreads(__tstate);
47269 if (PyErr_Occurred()) SWIG_fail;
47270 }
47271 resultobj = SWIG_From_int(static_cast< int >(result));
47272 return resultobj;
47273 fail:
47274 return NULL;
47275 }
47276
47277
47278 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47279 PyObject *resultobj = 0;
47280 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47281 bool result;
47282 void *argp1 = 0 ;
47283 int res1 = 0 ;
47284 PyObject *swig_obj[1] ;
47285
47286 if (!args) SWIG_fail;
47287 swig_obj[0] = args;
47288 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47289 if (!SWIG_IsOK(res1)) {
47290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47291 }
47292 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47293 {
47294 PyThreadState* __tstate = wxPyBeginAllowThreads();
47295 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
47296 wxPyEndAllowThreads(__tstate);
47297 if (PyErr_Occurred()) SWIG_fail;
47298 }
47299 {
47300 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47301 }
47302 return resultobj;
47303 fail:
47304 return NULL;
47305 }
47306
47307
47308 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47309 PyObject *resultobj = 0;
47310 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47311 bool arg2 = (bool) true ;
47312 void *argp1 = 0 ;
47313 int res1 = 0 ;
47314 bool val2 ;
47315 int ecode2 = 0 ;
47316 PyObject * obj0 = 0 ;
47317 PyObject * obj1 = 0 ;
47318 char * kwnames[] = {
47319 (char *) "self",(char *) "ownerDrawn", NULL
47320 };
47321
47322 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
47323 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47324 if (!SWIG_IsOK(res1)) {
47325 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47326 }
47327 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47328 if (obj1) {
47329 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47330 if (!SWIG_IsOK(ecode2)) {
47331 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
47332 }
47333 arg2 = static_cast< bool >(val2);
47334 }
47335 {
47336 PyThreadState* __tstate = wxPyBeginAllowThreads();
47337 wxMenuItem_SetOwnerDrawn(arg1,arg2);
47338 wxPyEndAllowThreads(__tstate);
47339 if (PyErr_Occurred()) SWIG_fail;
47340 }
47341 resultobj = SWIG_Py_Void();
47342 return resultobj;
47343 fail:
47344 return NULL;
47345 }
47346
47347
47348 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47349 PyObject *resultobj = 0;
47350 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
47351 void *argp1 = 0 ;
47352 int res1 = 0 ;
47353 PyObject *swig_obj[1] ;
47354
47355 if (!args) SWIG_fail;
47356 swig_obj[0] = args;
47357 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
47358 if (!SWIG_IsOK(res1)) {
47359 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
47360 }
47361 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
47362 {
47363 PyThreadState* __tstate = wxPyBeginAllowThreads();
47364 wxMenuItem_ResetOwnerDrawn(arg1);
47365 wxPyEndAllowThreads(__tstate);
47366 if (PyErr_Occurred()) SWIG_fail;
47367 }
47368 resultobj = SWIG_Py_Void();
47369 return resultobj;
47370 fail:
47371 return NULL;
47372 }
47373
47374
47375 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47376 PyObject *obj;
47377 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47378 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
47379 return SWIG_Py_Void();
47380 }
47381
47382 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47383 return SWIG_Python_InitShadowInstance(args);
47384 }
47385
47386 SWIGINTERN int ControlNameStr_set(PyObject *) {
47387 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
47388 return 1;
47389 }
47390
47391
47392 SWIGINTERN PyObject *ControlNameStr_get(void) {
47393 PyObject *pyobj = 0;
47394
47395 {
47396 #if wxUSE_UNICODE
47397 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47398 #else
47399 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
47400 #endif
47401 }
47402 return pyobj;
47403 }
47404
47405
47406 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47407 PyObject *resultobj = 0;
47408 wxWindow *arg1 = (wxWindow *) 0 ;
47409 int arg2 = (int) -1 ;
47410 wxPoint const &arg3_defvalue = wxDefaultPosition ;
47411 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
47412 wxSize const &arg4_defvalue = wxDefaultSize ;
47413 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
47414 long arg5 = (long) 0 ;
47415 wxValidator const &arg6_defvalue = wxDefaultValidator ;
47416 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
47417 wxString const &arg7_defvalue = wxPyControlNameStr ;
47418 wxString *arg7 = (wxString *) &arg7_defvalue ;
47419 wxControl *result = 0 ;
47420 void *argp1 = 0 ;
47421 int res1 = 0 ;
47422 int val2 ;
47423 int ecode2 = 0 ;
47424 wxPoint temp3 ;
47425 wxSize temp4 ;
47426 long val5 ;
47427 int ecode5 = 0 ;
47428 void *argp6 = 0 ;
47429 int res6 = 0 ;
47430 bool temp7 = false ;
47431 PyObject * obj0 = 0 ;
47432 PyObject * obj1 = 0 ;
47433 PyObject * obj2 = 0 ;
47434 PyObject * obj3 = 0 ;
47435 PyObject * obj4 = 0 ;
47436 PyObject * obj5 = 0 ;
47437 PyObject * obj6 = 0 ;
47438 char * kwnames[] = {
47439 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47440 };
47441
47442 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
47443 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
47444 if (!SWIG_IsOK(res1)) {
47445 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
47446 }
47447 arg1 = reinterpret_cast< wxWindow * >(argp1);
47448 if (obj1) {
47449 ecode2 = SWIG_AsVal_int(obj1, &val2);
47450 if (!SWIG_IsOK(ecode2)) {
47451 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
47452 }
47453 arg2 = static_cast< int >(val2);
47454 }
47455 if (obj2) {
47456 {
47457 arg3 = &temp3;
47458 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
47459 }
47460 }
47461 if (obj3) {
47462 {
47463 arg4 = &temp4;
47464 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
47465 }
47466 }
47467 if (obj4) {
47468 ecode5 = SWIG_AsVal_long(obj4, &val5);
47469 if (!SWIG_IsOK(ecode5)) {
47470 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
47471 }
47472 arg5 = static_cast< long >(val5);
47473 }
47474 if (obj5) {
47475 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
47476 if (!SWIG_IsOK(res6)) {
47477 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47478 }
47479 if (!argp6) {
47480 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
47481 }
47482 arg6 = reinterpret_cast< wxValidator * >(argp6);
47483 }
47484 if (obj6) {
47485 {
47486 arg7 = wxString_in_helper(obj6);
47487 if (arg7 == NULL) SWIG_fail;
47488 temp7 = true;
47489 }
47490 }
47491 {
47492 if (!wxPyCheckForApp()) SWIG_fail;
47493 PyThreadState* __tstate = wxPyBeginAllowThreads();
47494 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
47495 wxPyEndAllowThreads(__tstate);
47496 if (PyErr_Occurred()) SWIG_fail;
47497 }
47498 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
47499 {
47500 if (temp7)
47501 delete arg7;
47502 }
47503 return resultobj;
47504 fail:
47505 {
47506 if (temp7)
47507 delete arg7;
47508 }
47509 return NULL;
47510 }
47511
47512
47513 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47514 PyObject *resultobj = 0;
47515 wxControl *result = 0 ;
47516
47517 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
47518 {
47519 if (!wxPyCheckForApp()) SWIG_fail;
47520 PyThreadState* __tstate = wxPyBeginAllowThreads();
47521 result = (wxControl *)new wxControl();
47522 wxPyEndAllowThreads(__tstate);
47523 if (PyErr_Occurred()) SWIG_fail;
47524 }
47525 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
47526 return resultobj;
47527 fail:
47528 return NULL;
47529 }
47530
47531
47532 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47533 PyObject *resultobj = 0;
47534 wxControl *arg1 = (wxControl *) 0 ;
47535 wxWindow *arg2 = (wxWindow *) 0 ;
47536 int arg3 = (int) -1 ;
47537 wxPoint const &arg4_defvalue = wxDefaultPosition ;
47538 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
47539 wxSize const &arg5_defvalue = wxDefaultSize ;
47540 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
47541 long arg6 = (long) 0 ;
47542 wxValidator const &arg7_defvalue = wxDefaultValidator ;
47543 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
47544 wxString const &arg8_defvalue = wxPyControlNameStr ;
47545 wxString *arg8 = (wxString *) &arg8_defvalue ;
47546 bool result;
47547 void *argp1 = 0 ;
47548 int res1 = 0 ;
47549 void *argp2 = 0 ;
47550 int res2 = 0 ;
47551 int val3 ;
47552 int ecode3 = 0 ;
47553 wxPoint temp4 ;
47554 wxSize temp5 ;
47555 long val6 ;
47556 int ecode6 = 0 ;
47557 void *argp7 = 0 ;
47558 int res7 = 0 ;
47559 bool temp8 = false ;
47560 PyObject * obj0 = 0 ;
47561 PyObject * obj1 = 0 ;
47562 PyObject * obj2 = 0 ;
47563 PyObject * obj3 = 0 ;
47564 PyObject * obj4 = 0 ;
47565 PyObject * obj5 = 0 ;
47566 PyObject * obj6 = 0 ;
47567 PyObject * obj7 = 0 ;
47568 char * kwnames[] = {
47569 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
47570 };
47571
47572 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
47573 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47574 if (!SWIG_IsOK(res1)) {
47575 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
47576 }
47577 arg1 = reinterpret_cast< wxControl * >(argp1);
47578 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47579 if (!SWIG_IsOK(res2)) {
47580 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
47581 }
47582 arg2 = reinterpret_cast< wxWindow * >(argp2);
47583 if (obj2) {
47584 ecode3 = SWIG_AsVal_int(obj2, &val3);
47585 if (!SWIG_IsOK(ecode3)) {
47586 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
47587 }
47588 arg3 = static_cast< int >(val3);
47589 }
47590 if (obj3) {
47591 {
47592 arg4 = &temp4;
47593 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
47594 }
47595 }
47596 if (obj4) {
47597 {
47598 arg5 = &temp5;
47599 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
47600 }
47601 }
47602 if (obj5) {
47603 ecode6 = SWIG_AsVal_long(obj5, &val6);
47604 if (!SWIG_IsOK(ecode6)) {
47605 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
47606 }
47607 arg6 = static_cast< long >(val6);
47608 }
47609 if (obj6) {
47610 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
47611 if (!SWIG_IsOK(res7)) {
47612 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47613 }
47614 if (!argp7) {
47615 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
47616 }
47617 arg7 = reinterpret_cast< wxValidator * >(argp7);
47618 }
47619 if (obj7) {
47620 {
47621 arg8 = wxString_in_helper(obj7);
47622 if (arg8 == NULL) SWIG_fail;
47623 temp8 = true;
47624 }
47625 }
47626 {
47627 PyThreadState* __tstate = wxPyBeginAllowThreads();
47628 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
47629 wxPyEndAllowThreads(__tstate);
47630 if (PyErr_Occurred()) SWIG_fail;
47631 }
47632 {
47633 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47634 }
47635 {
47636 if (temp8)
47637 delete arg8;
47638 }
47639 return resultobj;
47640 fail:
47641 {
47642 if (temp8)
47643 delete arg8;
47644 }
47645 return NULL;
47646 }
47647
47648
47649 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47650 PyObject *resultobj = 0;
47651 wxControl *arg1 = (wxControl *) 0 ;
47652 int result;
47653 void *argp1 = 0 ;
47654 int res1 = 0 ;
47655 PyObject *swig_obj[1] ;
47656
47657 if (!args) SWIG_fail;
47658 swig_obj[0] = args;
47659 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47660 if (!SWIG_IsOK(res1)) {
47661 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
47662 }
47663 arg1 = reinterpret_cast< wxControl * >(argp1);
47664 {
47665 PyThreadState* __tstate = wxPyBeginAllowThreads();
47666 result = (int)((wxControl const *)arg1)->GetAlignment();
47667 wxPyEndAllowThreads(__tstate);
47668 if (PyErr_Occurred()) SWIG_fail;
47669 }
47670 resultobj = SWIG_From_int(static_cast< int >(result));
47671 return resultobj;
47672 fail:
47673 return NULL;
47674 }
47675
47676
47677 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47678 PyObject *resultobj = 0;
47679 wxControl *arg1 = (wxControl *) 0 ;
47680 wxString result;
47681 void *argp1 = 0 ;
47682 int res1 = 0 ;
47683 PyObject *swig_obj[1] ;
47684
47685 if (!args) SWIG_fail;
47686 swig_obj[0] = args;
47687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47688 if (!SWIG_IsOK(res1)) {
47689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
47690 }
47691 arg1 = reinterpret_cast< wxControl * >(argp1);
47692 {
47693 PyThreadState* __tstate = wxPyBeginAllowThreads();
47694 result = ((wxControl const *)arg1)->GetLabelText();
47695 wxPyEndAllowThreads(__tstate);
47696 if (PyErr_Occurred()) SWIG_fail;
47697 }
47698 {
47699 #if wxUSE_UNICODE
47700 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
47701 #else
47702 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
47703 #endif
47704 }
47705 return resultobj;
47706 fail:
47707 return NULL;
47708 }
47709
47710
47711 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47712 PyObject *resultobj = 0;
47713 wxControl *arg1 = (wxControl *) 0 ;
47714 wxCommandEvent *arg2 = 0 ;
47715 void *argp1 = 0 ;
47716 int res1 = 0 ;
47717 void *argp2 = 0 ;
47718 int res2 = 0 ;
47719 PyObject * obj0 = 0 ;
47720 PyObject * obj1 = 0 ;
47721 char * kwnames[] = {
47722 (char *) "self",(char *) "event", NULL
47723 };
47724
47725 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
47726 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
47727 if (!SWIG_IsOK(res1)) {
47728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
47729 }
47730 arg1 = reinterpret_cast< wxControl * >(argp1);
47731 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
47732 if (!SWIG_IsOK(res2)) {
47733 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47734 }
47735 if (!argp2) {
47736 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
47737 }
47738 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
47739 {
47740 PyThreadState* __tstate = wxPyBeginAllowThreads();
47741 (arg1)->Command(*arg2);
47742 wxPyEndAllowThreads(__tstate);
47743 if (PyErr_Occurred()) SWIG_fail;
47744 }
47745 resultobj = SWIG_Py_Void();
47746 return resultobj;
47747 fail:
47748 return NULL;
47749 }
47750
47751
47752 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47753 PyObject *resultobj = 0;
47754 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
47755 SwigValueWrapper<wxVisualAttributes > result;
47756 int val1 ;
47757 int ecode1 = 0 ;
47758 PyObject * obj0 = 0 ;
47759 char * kwnames[] = {
47760 (char *) "variant", NULL
47761 };
47762
47763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
47764 if (obj0) {
47765 ecode1 = SWIG_AsVal_int(obj0, &val1);
47766 if (!SWIG_IsOK(ecode1)) {
47767 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
47768 }
47769 arg1 = static_cast< wxWindowVariant >(val1);
47770 }
47771 {
47772 if (!wxPyCheckForApp()) SWIG_fail;
47773 PyThreadState* __tstate = wxPyBeginAllowThreads();
47774 result = wxControl::GetClassDefaultAttributes(arg1);
47775 wxPyEndAllowThreads(__tstate);
47776 if (PyErr_Occurred()) SWIG_fail;
47777 }
47778 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
47779 return resultobj;
47780 fail:
47781 return NULL;
47782 }
47783
47784
47785 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47786 PyObject *obj;
47787 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47788 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
47789 return SWIG_Py_Void();
47790 }
47791
47792 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47793 return SWIG_Python_InitShadowInstance(args);
47794 }
47795
47796 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47797 PyObject *resultobj = 0;
47798 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47799 wxString *arg2 = 0 ;
47800 PyObject *arg3 = (PyObject *) NULL ;
47801 int result;
47802 void *argp1 = 0 ;
47803 int res1 = 0 ;
47804 bool temp2 = false ;
47805 PyObject * obj0 = 0 ;
47806 PyObject * obj1 = 0 ;
47807 PyObject * obj2 = 0 ;
47808 char * kwnames[] = {
47809 (char *) "self",(char *) "item",(char *) "clientData", NULL
47810 };
47811
47812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47814 if (!SWIG_IsOK(res1)) {
47815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47816 }
47817 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47818 {
47819 arg2 = wxString_in_helper(obj1);
47820 if (arg2 == NULL) SWIG_fail;
47821 temp2 = true;
47822 }
47823 if (obj2) {
47824 arg3 = obj2;
47825 }
47826 {
47827 PyThreadState* __tstate = wxPyBeginAllowThreads();
47828 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
47829 wxPyEndAllowThreads(__tstate);
47830 if (PyErr_Occurred()) SWIG_fail;
47831 }
47832 resultobj = SWIG_From_int(static_cast< int >(result));
47833 {
47834 if (temp2)
47835 delete arg2;
47836 }
47837 return resultobj;
47838 fail:
47839 {
47840 if (temp2)
47841 delete arg2;
47842 }
47843 return NULL;
47844 }
47845
47846
47847 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47848 PyObject *resultobj = 0;
47849 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47850 wxArrayString *arg2 = 0 ;
47851 void *argp1 = 0 ;
47852 int res1 = 0 ;
47853 bool temp2 = false ;
47854 PyObject * obj0 = 0 ;
47855 PyObject * obj1 = 0 ;
47856 char * kwnames[] = {
47857 (char *) "self",(char *) "strings", NULL
47858 };
47859
47860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
47861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47862 if (!SWIG_IsOK(res1)) {
47863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47864 }
47865 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47866 {
47867 if (! PySequence_Check(obj1)) {
47868 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
47869 SWIG_fail;
47870 }
47871 arg2 = new wxArrayString;
47872 temp2 = true;
47873 int i, len=PySequence_Length(obj1);
47874 for (i=0; i<len; i++) {
47875 PyObject* item = PySequence_GetItem(obj1, i);
47876 wxString* s = wxString_in_helper(item);
47877 if (PyErr_Occurred()) SWIG_fail;
47878 arg2->Add(*s);
47879 delete s;
47880 Py_DECREF(item);
47881 }
47882 }
47883 {
47884 PyThreadState* __tstate = wxPyBeginAllowThreads();
47885 (arg1)->Append((wxArrayString const &)*arg2);
47886 wxPyEndAllowThreads(__tstate);
47887 if (PyErr_Occurred()) SWIG_fail;
47888 }
47889 resultobj = SWIG_Py_Void();
47890 {
47891 if (temp2) delete arg2;
47892 }
47893 return resultobj;
47894 fail:
47895 {
47896 if (temp2) delete arg2;
47897 }
47898 return NULL;
47899 }
47900
47901
47902 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47903 PyObject *resultobj = 0;
47904 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47905 wxString *arg2 = 0 ;
47906 int arg3 ;
47907 PyObject *arg4 = (PyObject *) NULL ;
47908 int result;
47909 void *argp1 = 0 ;
47910 int res1 = 0 ;
47911 bool temp2 = false ;
47912 int val3 ;
47913 int ecode3 = 0 ;
47914 PyObject * obj0 = 0 ;
47915 PyObject * obj1 = 0 ;
47916 PyObject * obj2 = 0 ;
47917 PyObject * obj3 = 0 ;
47918 char * kwnames[] = {
47919 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
47920 };
47921
47922 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47923 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47924 if (!SWIG_IsOK(res1)) {
47925 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47926 }
47927 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47928 {
47929 arg2 = wxString_in_helper(obj1);
47930 if (arg2 == NULL) SWIG_fail;
47931 temp2 = true;
47932 }
47933 ecode3 = SWIG_AsVal_int(obj2, &val3);
47934 if (!SWIG_IsOK(ecode3)) {
47935 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "int""'");
47936 }
47937 arg3 = static_cast< int >(val3);
47938 if (obj3) {
47939 arg4 = obj3;
47940 }
47941 {
47942 PyThreadState* __tstate = wxPyBeginAllowThreads();
47943 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
47944 wxPyEndAllowThreads(__tstate);
47945 if (PyErr_Occurred()) SWIG_fail;
47946 }
47947 resultobj = SWIG_From_int(static_cast< int >(result));
47948 {
47949 if (temp2)
47950 delete arg2;
47951 }
47952 return resultobj;
47953 fail:
47954 {
47955 if (temp2)
47956 delete arg2;
47957 }
47958 return NULL;
47959 }
47960
47961
47962 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47963 PyObject *resultobj = 0;
47964 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47965 void *argp1 = 0 ;
47966 int res1 = 0 ;
47967 PyObject *swig_obj[1] ;
47968
47969 if (!args) SWIG_fail;
47970 swig_obj[0] = args;
47971 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
47972 if (!SWIG_IsOK(res1)) {
47973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
47974 }
47975 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
47976 {
47977 PyThreadState* __tstate = wxPyBeginAllowThreads();
47978 (arg1)->Clear();
47979 wxPyEndAllowThreads(__tstate);
47980 if (PyErr_Occurred()) SWIG_fail;
47981 }
47982 resultobj = SWIG_Py_Void();
47983 return resultobj;
47984 fail:
47985 return NULL;
47986 }
47987
47988
47989 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47990 PyObject *resultobj = 0;
47991 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
47992 int arg2 ;
47993 void *argp1 = 0 ;
47994 int res1 = 0 ;
47995 int val2 ;
47996 int ecode2 = 0 ;
47997 PyObject * obj0 = 0 ;
47998 PyObject * obj1 = 0 ;
47999 char * kwnames[] = {
48000 (char *) "self",(char *) "n", NULL
48001 };
48002
48003 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
48004 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48005 if (!SWIG_IsOK(res1)) {
48006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48007 }
48008 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48009 ecode2 = SWIG_AsVal_int(obj1, &val2);
48010 if (!SWIG_IsOK(ecode2)) {
48011 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "int""'");
48012 }
48013 arg2 = static_cast< int >(val2);
48014 {
48015 PyThreadState* __tstate = wxPyBeginAllowThreads();
48016 (arg1)->Delete(arg2);
48017 wxPyEndAllowThreads(__tstate);
48018 if (PyErr_Occurred()) SWIG_fail;
48019 }
48020 resultobj = SWIG_Py_Void();
48021 return resultobj;
48022 fail:
48023 return NULL;
48024 }
48025
48026
48027 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48028 PyObject *resultobj = 0;
48029 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48030 int arg2 ;
48031 PyObject *result = 0 ;
48032 void *argp1 = 0 ;
48033 int res1 = 0 ;
48034 int val2 ;
48035 int ecode2 = 0 ;
48036 PyObject * obj0 = 0 ;
48037 PyObject * obj1 = 0 ;
48038 char * kwnames[] = {
48039 (char *) "self",(char *) "n", NULL
48040 };
48041
48042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
48043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48044 if (!SWIG_IsOK(res1)) {
48045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48046 }
48047 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48048 ecode2 = SWIG_AsVal_int(obj1, &val2);
48049 if (!SWIG_IsOK(ecode2)) {
48050 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "int""'");
48051 }
48052 arg2 = static_cast< int >(val2);
48053 {
48054 PyThreadState* __tstate = wxPyBeginAllowThreads();
48055 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
48056 wxPyEndAllowThreads(__tstate);
48057 if (PyErr_Occurred()) SWIG_fail;
48058 }
48059 resultobj = result;
48060 return resultobj;
48061 fail:
48062 return NULL;
48063 }
48064
48065
48066 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48067 PyObject *resultobj = 0;
48068 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48069 int arg2 ;
48070 PyObject *arg3 = (PyObject *) 0 ;
48071 void *argp1 = 0 ;
48072 int res1 = 0 ;
48073 int val2 ;
48074 int ecode2 = 0 ;
48075 PyObject * obj0 = 0 ;
48076 PyObject * obj1 = 0 ;
48077 PyObject * obj2 = 0 ;
48078 char * kwnames[] = {
48079 (char *) "self",(char *) "n",(char *) "clientData", NULL
48080 };
48081
48082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48084 if (!SWIG_IsOK(res1)) {
48085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48086 }
48087 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48088 ecode2 = SWIG_AsVal_int(obj1, &val2);
48089 if (!SWIG_IsOK(ecode2)) {
48090 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "int""'");
48091 }
48092 arg2 = static_cast< int >(val2);
48093 arg3 = obj2;
48094 {
48095 PyThreadState* __tstate = wxPyBeginAllowThreads();
48096 wxItemContainer_SetClientData(arg1,arg2,arg3);
48097 wxPyEndAllowThreads(__tstate);
48098 if (PyErr_Occurred()) SWIG_fail;
48099 }
48100 resultobj = SWIG_Py_Void();
48101 return resultobj;
48102 fail:
48103 return NULL;
48104 }
48105
48106
48107 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48108 PyObject *resultobj = 0;
48109 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48110 int result;
48111 void *argp1 = 0 ;
48112 int res1 = 0 ;
48113 PyObject *swig_obj[1] ;
48114
48115 if (!args) SWIG_fail;
48116 swig_obj[0] = args;
48117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48118 if (!SWIG_IsOK(res1)) {
48119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48120 }
48121 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48122 {
48123 PyThreadState* __tstate = wxPyBeginAllowThreads();
48124 result = (int)((wxItemContainer const *)arg1)->GetCount();
48125 wxPyEndAllowThreads(__tstate);
48126 if (PyErr_Occurred()) SWIG_fail;
48127 }
48128 resultobj = SWIG_From_int(static_cast< int >(result));
48129 return resultobj;
48130 fail:
48131 return NULL;
48132 }
48133
48134
48135 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48136 PyObject *resultobj = 0;
48137 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48138 bool result;
48139 void *argp1 = 0 ;
48140 int res1 = 0 ;
48141 PyObject *swig_obj[1] ;
48142
48143 if (!args) SWIG_fail;
48144 swig_obj[0] = args;
48145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48146 if (!SWIG_IsOK(res1)) {
48147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48148 }
48149 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48150 {
48151 PyThreadState* __tstate = wxPyBeginAllowThreads();
48152 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
48153 wxPyEndAllowThreads(__tstate);
48154 if (PyErr_Occurred()) SWIG_fail;
48155 }
48156 {
48157 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48158 }
48159 return resultobj;
48160 fail:
48161 return NULL;
48162 }
48163
48164
48165 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48166 PyObject *resultobj = 0;
48167 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48168 int arg2 ;
48169 wxString result;
48170 void *argp1 = 0 ;
48171 int res1 = 0 ;
48172 int val2 ;
48173 int ecode2 = 0 ;
48174 PyObject * obj0 = 0 ;
48175 PyObject * obj1 = 0 ;
48176 char * kwnames[] = {
48177 (char *) "self",(char *) "n", NULL
48178 };
48179
48180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
48181 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48182 if (!SWIG_IsOK(res1)) {
48183 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48184 }
48185 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48186 ecode2 = SWIG_AsVal_int(obj1, &val2);
48187 if (!SWIG_IsOK(ecode2)) {
48188 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "int""'");
48189 }
48190 arg2 = static_cast< int >(val2);
48191 {
48192 PyThreadState* __tstate = wxPyBeginAllowThreads();
48193 result = ((wxItemContainer const *)arg1)->GetString(arg2);
48194 wxPyEndAllowThreads(__tstate);
48195 if (PyErr_Occurred()) SWIG_fail;
48196 }
48197 {
48198 #if wxUSE_UNICODE
48199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48200 #else
48201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48202 #endif
48203 }
48204 return resultobj;
48205 fail:
48206 return NULL;
48207 }
48208
48209
48210 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48211 PyObject *resultobj = 0;
48212 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48213 wxArrayString result;
48214 void *argp1 = 0 ;
48215 int res1 = 0 ;
48216 PyObject *swig_obj[1] ;
48217
48218 if (!args) SWIG_fail;
48219 swig_obj[0] = args;
48220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48221 if (!SWIG_IsOK(res1)) {
48222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48223 }
48224 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48225 {
48226 PyThreadState* __tstate = wxPyBeginAllowThreads();
48227 result = ((wxItemContainer const *)arg1)->GetStrings();
48228 wxPyEndAllowThreads(__tstate);
48229 if (PyErr_Occurred()) SWIG_fail;
48230 }
48231 {
48232 resultobj = wxArrayString2PyList_helper(result);
48233 }
48234 return resultobj;
48235 fail:
48236 return NULL;
48237 }
48238
48239
48240 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48241 PyObject *resultobj = 0;
48242 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48243 int arg2 ;
48244 wxString *arg3 = 0 ;
48245 void *argp1 = 0 ;
48246 int res1 = 0 ;
48247 int val2 ;
48248 int ecode2 = 0 ;
48249 bool temp3 = false ;
48250 PyObject * obj0 = 0 ;
48251 PyObject * obj1 = 0 ;
48252 PyObject * obj2 = 0 ;
48253 char * kwnames[] = {
48254 (char *) "self",(char *) "n",(char *) "s", NULL
48255 };
48256
48257 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48258 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48259 if (!SWIG_IsOK(res1)) {
48260 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48261 }
48262 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48263 ecode2 = SWIG_AsVal_int(obj1, &val2);
48264 if (!SWIG_IsOK(ecode2)) {
48265 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "int""'");
48266 }
48267 arg2 = static_cast< int >(val2);
48268 {
48269 arg3 = wxString_in_helper(obj2);
48270 if (arg3 == NULL) SWIG_fail;
48271 temp3 = true;
48272 }
48273 {
48274 PyThreadState* __tstate = wxPyBeginAllowThreads();
48275 (arg1)->SetString(arg2,(wxString const &)*arg3);
48276 wxPyEndAllowThreads(__tstate);
48277 if (PyErr_Occurred()) SWIG_fail;
48278 }
48279 resultobj = SWIG_Py_Void();
48280 {
48281 if (temp3)
48282 delete arg3;
48283 }
48284 return resultobj;
48285 fail:
48286 {
48287 if (temp3)
48288 delete arg3;
48289 }
48290 return NULL;
48291 }
48292
48293
48294 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48295 PyObject *resultobj = 0;
48296 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48297 wxString *arg2 = 0 ;
48298 int result;
48299 void *argp1 = 0 ;
48300 int res1 = 0 ;
48301 bool temp2 = false ;
48302 PyObject * obj0 = 0 ;
48303 PyObject * obj1 = 0 ;
48304 char * kwnames[] = {
48305 (char *) "self",(char *) "s", NULL
48306 };
48307
48308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
48309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48310 if (!SWIG_IsOK(res1)) {
48311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48312 }
48313 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48314 {
48315 arg2 = wxString_in_helper(obj1);
48316 if (arg2 == NULL) SWIG_fail;
48317 temp2 = true;
48318 }
48319 {
48320 PyThreadState* __tstate = wxPyBeginAllowThreads();
48321 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
48322 wxPyEndAllowThreads(__tstate);
48323 if (PyErr_Occurred()) SWIG_fail;
48324 }
48325 resultobj = SWIG_From_int(static_cast< int >(result));
48326 {
48327 if (temp2)
48328 delete arg2;
48329 }
48330 return resultobj;
48331 fail:
48332 {
48333 if (temp2)
48334 delete arg2;
48335 }
48336 return NULL;
48337 }
48338
48339
48340 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48341 PyObject *resultobj = 0;
48342 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48343 int arg2 ;
48344 void *argp1 = 0 ;
48345 int res1 = 0 ;
48346 int val2 ;
48347 int ecode2 = 0 ;
48348 PyObject * obj0 = 0 ;
48349 PyObject * obj1 = 0 ;
48350 char * kwnames[] = {
48351 (char *) "self",(char *) "n", NULL
48352 };
48353
48354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48356 if (!SWIG_IsOK(res1)) {
48357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48358 }
48359 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48360 ecode2 = SWIG_AsVal_int(obj1, &val2);
48361 if (!SWIG_IsOK(ecode2)) {
48362 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
48363 }
48364 arg2 = static_cast< int >(val2);
48365 {
48366 PyThreadState* __tstate = wxPyBeginAllowThreads();
48367 (arg1)->SetSelection(arg2);
48368 wxPyEndAllowThreads(__tstate);
48369 if (PyErr_Occurred()) SWIG_fail;
48370 }
48371 resultobj = SWIG_Py_Void();
48372 return resultobj;
48373 fail:
48374 return NULL;
48375 }
48376
48377
48378 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48379 PyObject *resultobj = 0;
48380 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48381 int result;
48382 void *argp1 = 0 ;
48383 int res1 = 0 ;
48384 PyObject *swig_obj[1] ;
48385
48386 if (!args) SWIG_fail;
48387 swig_obj[0] = args;
48388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48389 if (!SWIG_IsOK(res1)) {
48390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48391 }
48392 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48393 {
48394 PyThreadState* __tstate = wxPyBeginAllowThreads();
48395 result = (int)((wxItemContainer const *)arg1)->GetSelection();
48396 wxPyEndAllowThreads(__tstate);
48397 if (PyErr_Occurred()) SWIG_fail;
48398 }
48399 resultobj = SWIG_From_int(static_cast< int >(result));
48400 return resultobj;
48401 fail:
48402 return NULL;
48403 }
48404
48405
48406 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48407 PyObject *resultobj = 0;
48408 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48409 wxString *arg2 = 0 ;
48410 bool result;
48411 void *argp1 = 0 ;
48412 int res1 = 0 ;
48413 bool temp2 = false ;
48414 PyObject * obj0 = 0 ;
48415 PyObject * obj1 = 0 ;
48416 char * kwnames[] = {
48417 (char *) "self",(char *) "s", NULL
48418 };
48419
48420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
48421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48422 if (!SWIG_IsOK(res1)) {
48423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48424 }
48425 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48426 {
48427 arg2 = wxString_in_helper(obj1);
48428 if (arg2 == NULL) SWIG_fail;
48429 temp2 = true;
48430 }
48431 {
48432 PyThreadState* __tstate = wxPyBeginAllowThreads();
48433 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
48434 wxPyEndAllowThreads(__tstate);
48435 if (PyErr_Occurred()) SWIG_fail;
48436 }
48437 {
48438 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
48439 }
48440 {
48441 if (temp2)
48442 delete arg2;
48443 }
48444 return resultobj;
48445 fail:
48446 {
48447 if (temp2)
48448 delete arg2;
48449 }
48450 return NULL;
48451 }
48452
48453
48454 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48455 PyObject *resultobj = 0;
48456 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48457 wxString result;
48458 void *argp1 = 0 ;
48459 int res1 = 0 ;
48460 PyObject *swig_obj[1] ;
48461
48462 if (!args) SWIG_fail;
48463 swig_obj[0] = args;
48464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48465 if (!SWIG_IsOK(res1)) {
48466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
48467 }
48468 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48469 {
48470 PyThreadState* __tstate = wxPyBeginAllowThreads();
48471 result = ((wxItemContainer const *)arg1)->GetStringSelection();
48472 wxPyEndAllowThreads(__tstate);
48473 if (PyErr_Occurred()) SWIG_fail;
48474 }
48475 {
48476 #if wxUSE_UNICODE
48477 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
48478 #else
48479 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
48480 #endif
48481 }
48482 return resultobj;
48483 fail:
48484 return NULL;
48485 }
48486
48487
48488 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48489 PyObject *resultobj = 0;
48490 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
48491 int arg2 ;
48492 void *argp1 = 0 ;
48493 int res1 = 0 ;
48494 int val2 ;
48495 int ecode2 = 0 ;
48496 PyObject * obj0 = 0 ;
48497 PyObject * obj1 = 0 ;
48498 char * kwnames[] = {
48499 (char *) "self",(char *) "n", NULL
48500 };
48501
48502 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
48503 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
48504 if (!SWIG_IsOK(res1)) {
48505 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
48506 }
48507 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
48508 ecode2 = SWIG_AsVal_int(obj1, &val2);
48509 if (!SWIG_IsOK(ecode2)) {
48510 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
48511 }
48512 arg2 = static_cast< int >(val2);
48513 {
48514 PyThreadState* __tstate = wxPyBeginAllowThreads();
48515 (arg1)->Select(arg2);
48516 wxPyEndAllowThreads(__tstate);
48517 if (PyErr_Occurred()) SWIG_fail;
48518 }
48519 resultobj = SWIG_Py_Void();
48520 return resultobj;
48521 fail:
48522 return NULL;
48523 }
48524
48525
48526 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48527 PyObject *obj;
48528 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48529 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
48530 return SWIG_Py_Void();
48531 }
48532
48533 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48534 PyObject *obj;
48535 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48536 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
48537 return SWIG_Py_Void();
48538 }
48539
48540 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48541 PyObject *resultobj = 0;
48542 wxSizerItem *result = 0 ;
48543
48544 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
48545 {
48546 PyThreadState* __tstate = wxPyBeginAllowThreads();
48547 result = (wxSizerItem *)new wxSizerItem();
48548 wxPyEndAllowThreads(__tstate);
48549 if (PyErr_Occurred()) SWIG_fail;
48550 }
48551 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
48552 return resultobj;
48553 fail:
48554 return NULL;
48555 }
48556
48557
48558 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48559 PyObject *resultobj = 0;
48560 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48561 void *argp1 = 0 ;
48562 int res1 = 0 ;
48563 PyObject *swig_obj[1] ;
48564
48565 if (!args) SWIG_fail;
48566 swig_obj[0] = args;
48567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
48568 if (!SWIG_IsOK(res1)) {
48569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48570 }
48571 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48572 {
48573 PyThreadState* __tstate = wxPyBeginAllowThreads();
48574 delete arg1;
48575
48576 wxPyEndAllowThreads(__tstate);
48577 if (PyErr_Occurred()) SWIG_fail;
48578 }
48579 resultobj = SWIG_Py_Void();
48580 return resultobj;
48581 fail:
48582 return NULL;
48583 }
48584
48585
48586 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48587 PyObject *resultobj = 0;
48588 wxWindow *arg1 = (wxWindow *) 0 ;
48589 int arg2 ;
48590 int arg3 ;
48591 int arg4 ;
48592 PyObject *arg5 = (PyObject *) NULL ;
48593 wxSizerItem *result = 0 ;
48594 void *argp1 = 0 ;
48595 int res1 = 0 ;
48596 int val2 ;
48597 int ecode2 = 0 ;
48598 int val3 ;
48599 int ecode3 = 0 ;
48600 int val4 ;
48601 int ecode4 = 0 ;
48602 PyObject * obj0 = 0 ;
48603 PyObject * obj1 = 0 ;
48604 PyObject * obj2 = 0 ;
48605 PyObject * obj3 = 0 ;
48606 PyObject * obj4 = 0 ;
48607 char * kwnames[] = {
48608 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48609 };
48610
48611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
48613 if (!SWIG_IsOK(res1)) {
48614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
48615 }
48616 arg1 = reinterpret_cast< wxWindow * >(argp1);
48617 ecode2 = SWIG_AsVal_int(obj1, &val2);
48618 if (!SWIG_IsOK(ecode2)) {
48619 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
48620 }
48621 arg2 = static_cast< int >(val2);
48622 ecode3 = SWIG_AsVal_int(obj2, &val3);
48623 if (!SWIG_IsOK(ecode3)) {
48624 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
48625 }
48626 arg3 = static_cast< int >(val3);
48627 ecode4 = SWIG_AsVal_int(obj3, &val4);
48628 if (!SWIG_IsOK(ecode4)) {
48629 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
48630 }
48631 arg4 = static_cast< int >(val4);
48632 if (obj4) {
48633 arg5 = obj4;
48634 }
48635 {
48636 PyThreadState* __tstate = wxPyBeginAllowThreads();
48637 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48638 wxPyEndAllowThreads(__tstate);
48639 if (PyErr_Occurred()) SWIG_fail;
48640 }
48641 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48642 return resultobj;
48643 fail:
48644 return NULL;
48645 }
48646
48647
48648 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48649 PyObject *resultobj = 0;
48650 int arg1 ;
48651 int arg2 ;
48652 int arg3 ;
48653 int arg4 ;
48654 int arg5 ;
48655 PyObject *arg6 = (PyObject *) NULL ;
48656 wxSizerItem *result = 0 ;
48657 int val1 ;
48658 int ecode1 = 0 ;
48659 int val2 ;
48660 int ecode2 = 0 ;
48661 int val3 ;
48662 int ecode3 = 0 ;
48663 int val4 ;
48664 int ecode4 = 0 ;
48665 int val5 ;
48666 int ecode5 = 0 ;
48667 PyObject * obj0 = 0 ;
48668 PyObject * obj1 = 0 ;
48669 PyObject * obj2 = 0 ;
48670 PyObject * obj3 = 0 ;
48671 PyObject * obj4 = 0 ;
48672 PyObject * obj5 = 0 ;
48673 char * kwnames[] = {
48674 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48675 };
48676
48677 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
48678 ecode1 = SWIG_AsVal_int(obj0, &val1);
48679 if (!SWIG_IsOK(ecode1)) {
48680 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
48681 }
48682 arg1 = static_cast< int >(val1);
48683 ecode2 = SWIG_AsVal_int(obj1, &val2);
48684 if (!SWIG_IsOK(ecode2)) {
48685 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
48686 }
48687 arg2 = static_cast< int >(val2);
48688 ecode3 = SWIG_AsVal_int(obj2, &val3);
48689 if (!SWIG_IsOK(ecode3)) {
48690 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
48691 }
48692 arg3 = static_cast< int >(val3);
48693 ecode4 = SWIG_AsVal_int(obj3, &val4);
48694 if (!SWIG_IsOK(ecode4)) {
48695 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
48696 }
48697 arg4 = static_cast< int >(val4);
48698 ecode5 = SWIG_AsVal_int(obj4, &val5);
48699 if (!SWIG_IsOK(ecode5)) {
48700 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
48701 }
48702 arg5 = static_cast< int >(val5);
48703 if (obj5) {
48704 arg6 = obj5;
48705 }
48706 {
48707 PyThreadState* __tstate = wxPyBeginAllowThreads();
48708 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
48709 wxPyEndAllowThreads(__tstate);
48710 if (PyErr_Occurred()) SWIG_fail;
48711 }
48712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48713 return resultobj;
48714 fail:
48715 return NULL;
48716 }
48717
48718
48719 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48720 PyObject *resultobj = 0;
48721 wxSizer *arg1 = (wxSizer *) 0 ;
48722 int arg2 ;
48723 int arg3 ;
48724 int arg4 ;
48725 PyObject *arg5 = (PyObject *) NULL ;
48726 wxSizerItem *result = 0 ;
48727 int res1 = 0 ;
48728 int val2 ;
48729 int ecode2 = 0 ;
48730 int val3 ;
48731 int ecode3 = 0 ;
48732 int val4 ;
48733 int ecode4 = 0 ;
48734 PyObject * obj0 = 0 ;
48735 PyObject * obj1 = 0 ;
48736 PyObject * obj2 = 0 ;
48737 PyObject * obj3 = 0 ;
48738 PyObject * obj4 = 0 ;
48739 char * kwnames[] = {
48740 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
48741 };
48742
48743 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
48744 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
48745 if (!SWIG_IsOK(res1)) {
48746 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
48747 }
48748 ecode2 = SWIG_AsVal_int(obj1, &val2);
48749 if (!SWIG_IsOK(ecode2)) {
48750 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
48751 }
48752 arg2 = static_cast< int >(val2);
48753 ecode3 = SWIG_AsVal_int(obj2, &val3);
48754 if (!SWIG_IsOK(ecode3)) {
48755 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
48756 }
48757 arg3 = static_cast< int >(val3);
48758 ecode4 = SWIG_AsVal_int(obj3, &val4);
48759 if (!SWIG_IsOK(ecode4)) {
48760 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
48761 }
48762 arg4 = static_cast< int >(val4);
48763 if (obj4) {
48764 arg5 = obj4;
48765 }
48766 {
48767 PyThreadState* __tstate = wxPyBeginAllowThreads();
48768 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
48769 wxPyEndAllowThreads(__tstate);
48770 if (PyErr_Occurred()) SWIG_fail;
48771 }
48772 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
48773 return resultobj;
48774 fail:
48775 return NULL;
48776 }
48777
48778
48779 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48780 PyObject *resultobj = 0;
48781 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48782 void *argp1 = 0 ;
48783 int res1 = 0 ;
48784 PyObject *swig_obj[1] ;
48785
48786 if (!args) SWIG_fail;
48787 swig_obj[0] = args;
48788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48789 if (!SWIG_IsOK(res1)) {
48790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48791 }
48792 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48793 {
48794 PyThreadState* __tstate = wxPyBeginAllowThreads();
48795 (arg1)->DeleteWindows();
48796 wxPyEndAllowThreads(__tstate);
48797 if (PyErr_Occurred()) SWIG_fail;
48798 }
48799 resultobj = SWIG_Py_Void();
48800 return resultobj;
48801 fail:
48802 return NULL;
48803 }
48804
48805
48806 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48807 PyObject *resultobj = 0;
48808 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48809 void *argp1 = 0 ;
48810 int res1 = 0 ;
48811 PyObject *swig_obj[1] ;
48812
48813 if (!args) SWIG_fail;
48814 swig_obj[0] = args;
48815 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48816 if (!SWIG_IsOK(res1)) {
48817 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48818 }
48819 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48820 {
48821 PyThreadState* __tstate = wxPyBeginAllowThreads();
48822 (arg1)->DetachSizer();
48823 wxPyEndAllowThreads(__tstate);
48824 if (PyErr_Occurred()) SWIG_fail;
48825 }
48826 resultobj = SWIG_Py_Void();
48827 return resultobj;
48828 fail:
48829 return NULL;
48830 }
48831
48832
48833 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48834 PyObject *resultobj = 0;
48835 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48836 wxSize result;
48837 void *argp1 = 0 ;
48838 int res1 = 0 ;
48839 PyObject *swig_obj[1] ;
48840
48841 if (!args) SWIG_fail;
48842 swig_obj[0] = args;
48843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48844 if (!SWIG_IsOK(res1)) {
48845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48846 }
48847 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48848 {
48849 PyThreadState* __tstate = wxPyBeginAllowThreads();
48850 result = (arg1)->GetSize();
48851 wxPyEndAllowThreads(__tstate);
48852 if (PyErr_Occurred()) SWIG_fail;
48853 }
48854 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48855 return resultobj;
48856 fail:
48857 return NULL;
48858 }
48859
48860
48861 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48862 PyObject *resultobj = 0;
48863 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48864 wxSize result;
48865 void *argp1 = 0 ;
48866 int res1 = 0 ;
48867 PyObject *swig_obj[1] ;
48868
48869 if (!args) SWIG_fail;
48870 swig_obj[0] = args;
48871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48872 if (!SWIG_IsOK(res1)) {
48873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48874 }
48875 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48876 {
48877 PyThreadState* __tstate = wxPyBeginAllowThreads();
48878 result = (arg1)->CalcMin();
48879 wxPyEndAllowThreads(__tstate);
48880 if (PyErr_Occurred()) SWIG_fail;
48881 }
48882 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48883 return resultobj;
48884 fail:
48885 return NULL;
48886 }
48887
48888
48889 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48890 PyObject *resultobj = 0;
48891 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48892 wxPoint *arg2 = 0 ;
48893 wxSize *arg3 = 0 ;
48894 void *argp1 = 0 ;
48895 int res1 = 0 ;
48896 wxPoint temp2 ;
48897 wxSize temp3 ;
48898 PyObject * obj0 = 0 ;
48899 PyObject * obj1 = 0 ;
48900 PyObject * obj2 = 0 ;
48901 char * kwnames[] = {
48902 (char *) "self",(char *) "pos",(char *) "size", NULL
48903 };
48904
48905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48907 if (!SWIG_IsOK(res1)) {
48908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48909 }
48910 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48911 {
48912 arg2 = &temp2;
48913 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
48914 }
48915 {
48916 arg3 = &temp3;
48917 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
48918 }
48919 {
48920 PyThreadState* __tstate = wxPyBeginAllowThreads();
48921 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
48922 wxPyEndAllowThreads(__tstate);
48923 if (PyErr_Occurred()) SWIG_fail;
48924 }
48925 resultobj = SWIG_Py_Void();
48926 return resultobj;
48927 fail:
48928 return NULL;
48929 }
48930
48931
48932 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48933 PyObject *resultobj = 0;
48934 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48935 wxSize result;
48936 void *argp1 = 0 ;
48937 int res1 = 0 ;
48938 PyObject *swig_obj[1] ;
48939
48940 if (!args) SWIG_fail;
48941 swig_obj[0] = args;
48942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48943 if (!SWIG_IsOK(res1)) {
48944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
48945 }
48946 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48947 {
48948 PyThreadState* __tstate = wxPyBeginAllowThreads();
48949 result = (arg1)->GetMinSize();
48950 wxPyEndAllowThreads(__tstate);
48951 if (PyErr_Occurred()) SWIG_fail;
48952 }
48953 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48954 return resultobj;
48955 fail:
48956 return NULL;
48957 }
48958
48959
48960 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48961 PyObject *resultobj = 0;
48962 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48963 wxSize result;
48964 void *argp1 = 0 ;
48965 int res1 = 0 ;
48966 PyObject *swig_obj[1] ;
48967
48968 if (!args) SWIG_fail;
48969 swig_obj[0] = args;
48970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
48971 if (!SWIG_IsOK(res1)) {
48972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
48973 }
48974 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
48975 {
48976 PyThreadState* __tstate = wxPyBeginAllowThreads();
48977 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
48978 wxPyEndAllowThreads(__tstate);
48979 if (PyErr_Occurred()) SWIG_fail;
48980 }
48981 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
48982 return resultobj;
48983 fail:
48984 return NULL;
48985 }
48986
48987
48988 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48989 PyObject *resultobj = 0;
48990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
48991 int arg2 ;
48992 int arg3 ;
48993 void *argp1 = 0 ;
48994 int res1 = 0 ;
48995 int val2 ;
48996 int ecode2 = 0 ;
48997 int val3 ;
48998 int ecode3 = 0 ;
48999 PyObject * obj0 = 0 ;
49000 PyObject * obj1 = 0 ;
49001 PyObject * obj2 = 0 ;
49002 char * kwnames[] = {
49003 (char *) "self",(char *) "x",(char *) "y", NULL
49004 };
49005
49006 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49007 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49008 if (!SWIG_IsOK(res1)) {
49009 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49010 }
49011 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49012 ecode2 = SWIG_AsVal_int(obj1, &val2);
49013 if (!SWIG_IsOK(ecode2)) {
49014 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
49015 }
49016 arg2 = static_cast< int >(val2);
49017 ecode3 = SWIG_AsVal_int(obj2, &val3);
49018 if (!SWIG_IsOK(ecode3)) {
49019 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
49020 }
49021 arg3 = static_cast< int >(val3);
49022 {
49023 PyThreadState* __tstate = wxPyBeginAllowThreads();
49024 (arg1)->SetInitSize(arg2,arg3);
49025 wxPyEndAllowThreads(__tstate);
49026 if (PyErr_Occurred()) SWIG_fail;
49027 }
49028 resultobj = SWIG_Py_Void();
49029 return resultobj;
49030 fail:
49031 return NULL;
49032 }
49033
49034
49035 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49036 PyObject *resultobj = 0;
49037 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49038 int arg2 ;
49039 int arg3 ;
49040 void *argp1 = 0 ;
49041 int res1 = 0 ;
49042 int val2 ;
49043 int ecode2 = 0 ;
49044 int val3 ;
49045 int ecode3 = 0 ;
49046 PyObject * obj0 = 0 ;
49047 PyObject * obj1 = 0 ;
49048 PyObject * obj2 = 0 ;
49049 char * kwnames[] = {
49050 (char *) "self",(char *) "width",(char *) "height", NULL
49051 };
49052
49053 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49054 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49055 if (!SWIG_IsOK(res1)) {
49056 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49057 }
49058 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49059 ecode2 = SWIG_AsVal_int(obj1, &val2);
49060 if (!SWIG_IsOK(ecode2)) {
49061 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
49062 }
49063 arg2 = static_cast< int >(val2);
49064 ecode3 = SWIG_AsVal_int(obj2, &val3);
49065 if (!SWIG_IsOK(ecode3)) {
49066 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
49067 }
49068 arg3 = static_cast< int >(val3);
49069 {
49070 PyThreadState* __tstate = wxPyBeginAllowThreads();
49071 (arg1)->SetRatio(arg2,arg3);
49072 wxPyEndAllowThreads(__tstate);
49073 if (PyErr_Occurred()) SWIG_fail;
49074 }
49075 resultobj = SWIG_Py_Void();
49076 return resultobj;
49077 fail:
49078 return NULL;
49079 }
49080
49081
49082 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49083 PyObject *resultobj = 0;
49084 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49085 wxSize *arg2 = 0 ;
49086 void *argp1 = 0 ;
49087 int res1 = 0 ;
49088 wxSize temp2 ;
49089 PyObject * obj0 = 0 ;
49090 PyObject * obj1 = 0 ;
49091 char * kwnames[] = {
49092 (char *) "self",(char *) "size", NULL
49093 };
49094
49095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
49096 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49097 if (!SWIG_IsOK(res1)) {
49098 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49099 }
49100 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49101 {
49102 arg2 = &temp2;
49103 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49104 }
49105 {
49106 PyThreadState* __tstate = wxPyBeginAllowThreads();
49107 (arg1)->SetRatio((wxSize const &)*arg2);
49108 wxPyEndAllowThreads(__tstate);
49109 if (PyErr_Occurred()) SWIG_fail;
49110 }
49111 resultobj = SWIG_Py_Void();
49112 return resultobj;
49113 fail:
49114 return NULL;
49115 }
49116
49117
49118 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49119 PyObject *resultobj = 0;
49120 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49121 float arg2 ;
49122 void *argp1 = 0 ;
49123 int res1 = 0 ;
49124 float val2 ;
49125 int ecode2 = 0 ;
49126 PyObject * obj0 = 0 ;
49127 PyObject * obj1 = 0 ;
49128 char * kwnames[] = {
49129 (char *) "self",(char *) "ratio", NULL
49130 };
49131
49132 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
49133 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49134 if (!SWIG_IsOK(res1)) {
49135 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49136 }
49137 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49138 ecode2 = SWIG_AsVal_float(obj1, &val2);
49139 if (!SWIG_IsOK(ecode2)) {
49140 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
49141 }
49142 arg2 = static_cast< float >(val2);
49143 {
49144 PyThreadState* __tstate = wxPyBeginAllowThreads();
49145 (arg1)->SetRatio(arg2);
49146 wxPyEndAllowThreads(__tstate);
49147 if (PyErr_Occurred()) SWIG_fail;
49148 }
49149 resultobj = SWIG_Py_Void();
49150 return resultobj;
49151 fail:
49152 return NULL;
49153 }
49154
49155
49156 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49157 PyObject *resultobj = 0;
49158 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49159 float result;
49160 void *argp1 = 0 ;
49161 int res1 = 0 ;
49162 PyObject *swig_obj[1] ;
49163
49164 if (!args) SWIG_fail;
49165 swig_obj[0] = args;
49166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49167 if (!SWIG_IsOK(res1)) {
49168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49169 }
49170 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49171 {
49172 PyThreadState* __tstate = wxPyBeginAllowThreads();
49173 result = (float)(arg1)->GetRatio();
49174 wxPyEndAllowThreads(__tstate);
49175 if (PyErr_Occurred()) SWIG_fail;
49176 }
49177 resultobj = SWIG_From_float(static_cast< float >(result));
49178 return resultobj;
49179 fail:
49180 return NULL;
49181 }
49182
49183
49184 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49185 PyObject *resultobj = 0;
49186 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49187 wxRect result;
49188 void *argp1 = 0 ;
49189 int res1 = 0 ;
49190 PyObject *swig_obj[1] ;
49191
49192 if (!args) SWIG_fail;
49193 swig_obj[0] = args;
49194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49195 if (!SWIG_IsOK(res1)) {
49196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49197 }
49198 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49199 {
49200 PyThreadState* __tstate = wxPyBeginAllowThreads();
49201 result = (arg1)->GetRect();
49202 wxPyEndAllowThreads(__tstate);
49203 if (PyErr_Occurred()) SWIG_fail;
49204 }
49205 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
49206 return resultobj;
49207 fail:
49208 return NULL;
49209 }
49210
49211
49212 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49213 PyObject *resultobj = 0;
49214 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49215 bool result;
49216 void *argp1 = 0 ;
49217 int res1 = 0 ;
49218 PyObject *swig_obj[1] ;
49219
49220 if (!args) SWIG_fail;
49221 swig_obj[0] = args;
49222 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49223 if (!SWIG_IsOK(res1)) {
49224 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49225 }
49226 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49227 {
49228 PyThreadState* __tstate = wxPyBeginAllowThreads();
49229 result = (bool)(arg1)->IsWindow();
49230 wxPyEndAllowThreads(__tstate);
49231 if (PyErr_Occurred()) SWIG_fail;
49232 }
49233 {
49234 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49235 }
49236 return resultobj;
49237 fail:
49238 return NULL;
49239 }
49240
49241
49242 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49243 PyObject *resultobj = 0;
49244 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49245 bool result;
49246 void *argp1 = 0 ;
49247 int res1 = 0 ;
49248 PyObject *swig_obj[1] ;
49249
49250 if (!args) SWIG_fail;
49251 swig_obj[0] = args;
49252 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49253 if (!SWIG_IsOK(res1)) {
49254 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49255 }
49256 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49257 {
49258 PyThreadState* __tstate = wxPyBeginAllowThreads();
49259 result = (bool)(arg1)->IsSizer();
49260 wxPyEndAllowThreads(__tstate);
49261 if (PyErr_Occurred()) SWIG_fail;
49262 }
49263 {
49264 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49265 }
49266 return resultobj;
49267 fail:
49268 return NULL;
49269 }
49270
49271
49272 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49273 PyObject *resultobj = 0;
49274 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49275 bool result;
49276 void *argp1 = 0 ;
49277 int res1 = 0 ;
49278 PyObject *swig_obj[1] ;
49279
49280 if (!args) SWIG_fail;
49281 swig_obj[0] = args;
49282 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49283 if (!SWIG_IsOK(res1)) {
49284 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49285 }
49286 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49287 {
49288 PyThreadState* __tstate = wxPyBeginAllowThreads();
49289 result = (bool)(arg1)->IsSpacer();
49290 wxPyEndAllowThreads(__tstate);
49291 if (PyErr_Occurred()) SWIG_fail;
49292 }
49293 {
49294 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49295 }
49296 return resultobj;
49297 fail:
49298 return NULL;
49299 }
49300
49301
49302 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49303 PyObject *resultobj = 0;
49304 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49305 int arg2 ;
49306 void *argp1 = 0 ;
49307 int res1 = 0 ;
49308 int val2 ;
49309 int ecode2 = 0 ;
49310 PyObject * obj0 = 0 ;
49311 PyObject * obj1 = 0 ;
49312 char * kwnames[] = {
49313 (char *) "self",(char *) "proportion", NULL
49314 };
49315
49316 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
49317 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49318 if (!SWIG_IsOK(res1)) {
49319 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49320 }
49321 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49322 ecode2 = SWIG_AsVal_int(obj1, &val2);
49323 if (!SWIG_IsOK(ecode2)) {
49324 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
49325 }
49326 arg2 = static_cast< int >(val2);
49327 {
49328 PyThreadState* __tstate = wxPyBeginAllowThreads();
49329 (arg1)->SetProportion(arg2);
49330 wxPyEndAllowThreads(__tstate);
49331 if (PyErr_Occurred()) SWIG_fail;
49332 }
49333 resultobj = SWIG_Py_Void();
49334 return resultobj;
49335 fail:
49336 return NULL;
49337 }
49338
49339
49340 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49341 PyObject *resultobj = 0;
49342 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49343 int result;
49344 void *argp1 = 0 ;
49345 int res1 = 0 ;
49346 PyObject *swig_obj[1] ;
49347
49348 if (!args) SWIG_fail;
49349 swig_obj[0] = args;
49350 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49351 if (!SWIG_IsOK(res1)) {
49352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49353 }
49354 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49355 {
49356 PyThreadState* __tstate = wxPyBeginAllowThreads();
49357 result = (int)(arg1)->GetProportion();
49358 wxPyEndAllowThreads(__tstate);
49359 if (PyErr_Occurred()) SWIG_fail;
49360 }
49361 resultobj = SWIG_From_int(static_cast< int >(result));
49362 return resultobj;
49363 fail:
49364 return NULL;
49365 }
49366
49367
49368 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49369 PyObject *resultobj = 0;
49370 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49371 int arg2 ;
49372 void *argp1 = 0 ;
49373 int res1 = 0 ;
49374 int val2 ;
49375 int ecode2 = 0 ;
49376 PyObject * obj0 = 0 ;
49377 PyObject * obj1 = 0 ;
49378 char * kwnames[] = {
49379 (char *) "self",(char *) "flag", NULL
49380 };
49381
49382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
49383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49384 if (!SWIG_IsOK(res1)) {
49385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49386 }
49387 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49388 ecode2 = SWIG_AsVal_int(obj1, &val2);
49389 if (!SWIG_IsOK(ecode2)) {
49390 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
49391 }
49392 arg2 = static_cast< int >(val2);
49393 {
49394 PyThreadState* __tstate = wxPyBeginAllowThreads();
49395 (arg1)->SetFlag(arg2);
49396 wxPyEndAllowThreads(__tstate);
49397 if (PyErr_Occurred()) SWIG_fail;
49398 }
49399 resultobj = SWIG_Py_Void();
49400 return resultobj;
49401 fail:
49402 return NULL;
49403 }
49404
49405
49406 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49407 PyObject *resultobj = 0;
49408 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49409 int result;
49410 void *argp1 = 0 ;
49411 int res1 = 0 ;
49412 PyObject *swig_obj[1] ;
49413
49414 if (!args) SWIG_fail;
49415 swig_obj[0] = args;
49416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49417 if (!SWIG_IsOK(res1)) {
49418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49419 }
49420 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49421 {
49422 PyThreadState* __tstate = wxPyBeginAllowThreads();
49423 result = (int)(arg1)->GetFlag();
49424 wxPyEndAllowThreads(__tstate);
49425 if (PyErr_Occurred()) SWIG_fail;
49426 }
49427 resultobj = SWIG_From_int(static_cast< int >(result));
49428 return resultobj;
49429 fail:
49430 return NULL;
49431 }
49432
49433
49434 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49435 PyObject *resultobj = 0;
49436 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49437 int arg2 ;
49438 void *argp1 = 0 ;
49439 int res1 = 0 ;
49440 int val2 ;
49441 int ecode2 = 0 ;
49442 PyObject * obj0 = 0 ;
49443 PyObject * obj1 = 0 ;
49444 char * kwnames[] = {
49445 (char *) "self",(char *) "border", NULL
49446 };
49447
49448 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
49449 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49450 if (!SWIG_IsOK(res1)) {
49451 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49452 }
49453 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49454 ecode2 = SWIG_AsVal_int(obj1, &val2);
49455 if (!SWIG_IsOK(ecode2)) {
49456 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
49457 }
49458 arg2 = static_cast< int >(val2);
49459 {
49460 PyThreadState* __tstate = wxPyBeginAllowThreads();
49461 (arg1)->SetBorder(arg2);
49462 wxPyEndAllowThreads(__tstate);
49463 if (PyErr_Occurred()) SWIG_fail;
49464 }
49465 resultobj = SWIG_Py_Void();
49466 return resultobj;
49467 fail:
49468 return NULL;
49469 }
49470
49471
49472 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49473 PyObject *resultobj = 0;
49474 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49475 int result;
49476 void *argp1 = 0 ;
49477 int res1 = 0 ;
49478 PyObject *swig_obj[1] ;
49479
49480 if (!args) SWIG_fail;
49481 swig_obj[0] = args;
49482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49483 if (!SWIG_IsOK(res1)) {
49484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49485 }
49486 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49487 {
49488 PyThreadState* __tstate = wxPyBeginAllowThreads();
49489 result = (int)(arg1)->GetBorder();
49490 wxPyEndAllowThreads(__tstate);
49491 if (PyErr_Occurred()) SWIG_fail;
49492 }
49493 resultobj = SWIG_From_int(static_cast< int >(result));
49494 return resultobj;
49495 fail:
49496 return NULL;
49497 }
49498
49499
49500 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49501 PyObject *resultobj = 0;
49502 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49503 wxWindow *result = 0 ;
49504 void *argp1 = 0 ;
49505 int res1 = 0 ;
49506 PyObject *swig_obj[1] ;
49507
49508 if (!args) SWIG_fail;
49509 swig_obj[0] = args;
49510 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49511 if (!SWIG_IsOK(res1)) {
49512 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49513 }
49514 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49515 {
49516 PyThreadState* __tstate = wxPyBeginAllowThreads();
49517 result = (wxWindow *)(arg1)->GetWindow();
49518 wxPyEndAllowThreads(__tstate);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 {
49522 resultobj = wxPyMake_wxObject(result, 0);
49523 }
49524 return resultobj;
49525 fail:
49526 return NULL;
49527 }
49528
49529
49530 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49531 PyObject *resultobj = 0;
49532 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49533 wxWindow *arg2 = (wxWindow *) 0 ;
49534 void *argp1 = 0 ;
49535 int res1 = 0 ;
49536 void *argp2 = 0 ;
49537 int res2 = 0 ;
49538 PyObject * obj0 = 0 ;
49539 PyObject * obj1 = 0 ;
49540 char * kwnames[] = {
49541 (char *) "self",(char *) "window", NULL
49542 };
49543
49544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
49545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49546 if (!SWIG_IsOK(res1)) {
49547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49548 }
49549 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49550 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
49551 if (!SWIG_IsOK(res2)) {
49552 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
49553 }
49554 arg2 = reinterpret_cast< wxWindow * >(argp2);
49555 {
49556 PyThreadState* __tstate = wxPyBeginAllowThreads();
49557 (arg1)->SetWindow(arg2);
49558 wxPyEndAllowThreads(__tstate);
49559 if (PyErr_Occurred()) SWIG_fail;
49560 }
49561 resultobj = SWIG_Py_Void();
49562 return resultobj;
49563 fail:
49564 return NULL;
49565 }
49566
49567
49568 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49569 PyObject *resultobj = 0;
49570 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49571 wxSizer *result = 0 ;
49572 void *argp1 = 0 ;
49573 int res1 = 0 ;
49574 PyObject *swig_obj[1] ;
49575
49576 if (!args) SWIG_fail;
49577 swig_obj[0] = args;
49578 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49579 if (!SWIG_IsOK(res1)) {
49580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49581 }
49582 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49583 {
49584 PyThreadState* __tstate = wxPyBeginAllowThreads();
49585 result = (wxSizer *)(arg1)->GetSizer();
49586 wxPyEndAllowThreads(__tstate);
49587 if (PyErr_Occurred()) SWIG_fail;
49588 }
49589 {
49590 resultobj = wxPyMake_wxObject(result, (bool)0);
49591 }
49592 return resultobj;
49593 fail:
49594 return NULL;
49595 }
49596
49597
49598 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49599 PyObject *resultobj = 0;
49600 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49601 wxSizer *arg2 = (wxSizer *) 0 ;
49602 void *argp1 = 0 ;
49603 int res1 = 0 ;
49604 int res2 = 0 ;
49605 PyObject * obj0 = 0 ;
49606 PyObject * obj1 = 0 ;
49607 char * kwnames[] = {
49608 (char *) "self",(char *) "sizer", NULL
49609 };
49610
49611 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
49612 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49613 if (!SWIG_IsOK(res1)) {
49614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49615 }
49616 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49617 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49618 if (!SWIG_IsOK(res2)) {
49619 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
49620 }
49621 {
49622 PyThreadState* __tstate = wxPyBeginAllowThreads();
49623 (arg1)->SetSizer(arg2);
49624 wxPyEndAllowThreads(__tstate);
49625 if (PyErr_Occurred()) SWIG_fail;
49626 }
49627 resultobj = SWIG_Py_Void();
49628 return resultobj;
49629 fail:
49630 return NULL;
49631 }
49632
49633
49634 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49635 PyObject *resultobj = 0;
49636 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49637 wxSize result;
49638 void *argp1 = 0 ;
49639 int res1 = 0 ;
49640 PyObject *swig_obj[1] ;
49641
49642 if (!args) SWIG_fail;
49643 swig_obj[0] = args;
49644 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49645 if (!SWIG_IsOK(res1)) {
49646 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49647 }
49648 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49649 {
49650 PyThreadState* __tstate = wxPyBeginAllowThreads();
49651 result = (arg1)->GetSpacer();
49652 wxPyEndAllowThreads(__tstate);
49653 if (PyErr_Occurred()) SWIG_fail;
49654 }
49655 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
49656 return resultobj;
49657 fail:
49658 return NULL;
49659 }
49660
49661
49662 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49663 PyObject *resultobj = 0;
49664 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49665 wxSize *arg2 = 0 ;
49666 void *argp1 = 0 ;
49667 int res1 = 0 ;
49668 wxSize temp2 ;
49669 PyObject * obj0 = 0 ;
49670 PyObject * obj1 = 0 ;
49671 char * kwnames[] = {
49672 (char *) "self",(char *) "size", NULL
49673 };
49674
49675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
49676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49677 if (!SWIG_IsOK(res1)) {
49678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49679 }
49680 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49681 {
49682 arg2 = &temp2;
49683 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
49684 }
49685 {
49686 PyThreadState* __tstate = wxPyBeginAllowThreads();
49687 (arg1)->SetSpacer((wxSize const &)*arg2);
49688 wxPyEndAllowThreads(__tstate);
49689 if (PyErr_Occurred()) SWIG_fail;
49690 }
49691 resultobj = SWIG_Py_Void();
49692 return resultobj;
49693 fail:
49694 return NULL;
49695 }
49696
49697
49698 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49699 PyObject *resultobj = 0;
49700 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49701 bool arg2 ;
49702 void *argp1 = 0 ;
49703 int res1 = 0 ;
49704 bool val2 ;
49705 int ecode2 = 0 ;
49706 PyObject * obj0 = 0 ;
49707 PyObject * obj1 = 0 ;
49708 char * kwnames[] = {
49709 (char *) "self",(char *) "show", NULL
49710 };
49711
49712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
49713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49714 if (!SWIG_IsOK(res1)) {
49715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49716 }
49717 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49718 ecode2 = SWIG_AsVal_bool(obj1, &val2);
49719 if (!SWIG_IsOK(ecode2)) {
49720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
49721 }
49722 arg2 = static_cast< bool >(val2);
49723 {
49724 PyThreadState* __tstate = wxPyBeginAllowThreads();
49725 (arg1)->Show(arg2);
49726 wxPyEndAllowThreads(__tstate);
49727 if (PyErr_Occurred()) SWIG_fail;
49728 }
49729 resultobj = SWIG_Py_Void();
49730 return resultobj;
49731 fail:
49732 return NULL;
49733 }
49734
49735
49736 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49737 PyObject *resultobj = 0;
49738 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49739 bool result;
49740 void *argp1 = 0 ;
49741 int res1 = 0 ;
49742 PyObject *swig_obj[1] ;
49743
49744 if (!args) SWIG_fail;
49745 swig_obj[0] = args;
49746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49747 if (!SWIG_IsOK(res1)) {
49748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49749 }
49750 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49751 {
49752 PyThreadState* __tstate = wxPyBeginAllowThreads();
49753 result = (bool)(arg1)->IsShown();
49754 wxPyEndAllowThreads(__tstate);
49755 if (PyErr_Occurred()) SWIG_fail;
49756 }
49757 {
49758 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49759 }
49760 return resultobj;
49761 fail:
49762 return NULL;
49763 }
49764
49765
49766 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49767 PyObject *resultobj = 0;
49768 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49769 wxPoint result;
49770 void *argp1 = 0 ;
49771 int res1 = 0 ;
49772 PyObject *swig_obj[1] ;
49773
49774 if (!args) SWIG_fail;
49775 swig_obj[0] = args;
49776 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49777 if (!SWIG_IsOK(res1)) {
49778 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49779 }
49780 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49781 {
49782 PyThreadState* __tstate = wxPyBeginAllowThreads();
49783 result = (arg1)->GetPosition();
49784 wxPyEndAllowThreads(__tstate);
49785 if (PyErr_Occurred()) SWIG_fail;
49786 }
49787 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
49788 return resultobj;
49789 fail:
49790 return NULL;
49791 }
49792
49793
49794 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49795 PyObject *resultobj = 0;
49796 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49797 PyObject *result = 0 ;
49798 void *argp1 = 0 ;
49799 int res1 = 0 ;
49800 PyObject *swig_obj[1] ;
49801
49802 if (!args) SWIG_fail;
49803 swig_obj[0] = args;
49804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49805 if (!SWIG_IsOK(res1)) {
49806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49807 }
49808 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49809 {
49810 PyThreadState* __tstate = wxPyBeginAllowThreads();
49811 result = (PyObject *)wxSizerItem_GetUserData(arg1);
49812 wxPyEndAllowThreads(__tstate);
49813 if (PyErr_Occurred()) SWIG_fail;
49814 }
49815 resultobj = result;
49816 return resultobj;
49817 fail:
49818 return NULL;
49819 }
49820
49821
49822 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49823 PyObject *resultobj = 0;
49824 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
49825 PyObject *arg2 = (PyObject *) 0 ;
49826 void *argp1 = 0 ;
49827 int res1 = 0 ;
49828 PyObject * obj0 = 0 ;
49829 PyObject * obj1 = 0 ;
49830 char * kwnames[] = {
49831 (char *) "self",(char *) "userData", NULL
49832 };
49833
49834 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
49835 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
49836 if (!SWIG_IsOK(res1)) {
49837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
49838 }
49839 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
49840 arg2 = obj1;
49841 {
49842 PyThreadState* __tstate = wxPyBeginAllowThreads();
49843 wxSizerItem_SetUserData(arg1,arg2);
49844 wxPyEndAllowThreads(__tstate);
49845 if (PyErr_Occurred()) SWIG_fail;
49846 }
49847 resultobj = SWIG_Py_Void();
49848 return resultobj;
49849 fail:
49850 return NULL;
49851 }
49852
49853
49854 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49855 PyObject *obj;
49856 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49857 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
49858 return SWIG_Py_Void();
49859 }
49860
49861 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49862 return SWIG_Python_InitShadowInstance(args);
49863 }
49864
49865 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49866 PyObject *resultobj = 0;
49867 wxSizer *arg1 = (wxSizer *) 0 ;
49868 void *argp1 = 0 ;
49869 int res1 = 0 ;
49870 PyObject *swig_obj[1] ;
49871
49872 if (!args) SWIG_fail;
49873 swig_obj[0] = args;
49874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49875 if (!SWIG_IsOK(res1)) {
49876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49877 }
49878 arg1 = reinterpret_cast< wxSizer * >(argp1);
49879 {
49880 PyThreadState* __tstate = wxPyBeginAllowThreads();
49881 delete arg1;
49882
49883 wxPyEndAllowThreads(__tstate);
49884 if (PyErr_Occurred()) SWIG_fail;
49885 }
49886 resultobj = SWIG_Py_Void();
49887 return resultobj;
49888 fail:
49889 return NULL;
49890 }
49891
49892
49893 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49894 PyObject *resultobj = 0;
49895 wxSizer *arg1 = (wxSizer *) 0 ;
49896 PyObject *arg2 = (PyObject *) 0 ;
49897 void *argp1 = 0 ;
49898 int res1 = 0 ;
49899 PyObject * obj0 = 0 ;
49900 PyObject * obj1 = 0 ;
49901 char * kwnames[] = {
49902 (char *) "self",(char *) "_self", NULL
49903 };
49904
49905 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
49906 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49907 if (!SWIG_IsOK(res1)) {
49908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
49909 }
49910 arg1 = reinterpret_cast< wxSizer * >(argp1);
49911 arg2 = obj1;
49912 {
49913 PyThreadState* __tstate = wxPyBeginAllowThreads();
49914 wxSizer__setOORInfo(arg1,arg2);
49915 wxPyEndAllowThreads(__tstate);
49916 if (PyErr_Occurred()) SWIG_fail;
49917 }
49918 resultobj = SWIG_Py_Void();
49919 return resultobj;
49920 fail:
49921 return NULL;
49922 }
49923
49924
49925 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49926 PyObject *resultobj = 0;
49927 wxSizer *arg1 = (wxSizer *) 0 ;
49928 PyObject *arg2 = (PyObject *) 0 ;
49929 int arg3 = (int) 0 ;
49930 int arg4 = (int) 0 ;
49931 int arg5 = (int) 0 ;
49932 PyObject *arg6 = (PyObject *) NULL ;
49933 wxSizerItem *result = 0 ;
49934 void *argp1 = 0 ;
49935 int res1 = 0 ;
49936 int val3 ;
49937 int ecode3 = 0 ;
49938 int val4 ;
49939 int ecode4 = 0 ;
49940 int val5 ;
49941 int ecode5 = 0 ;
49942 PyObject * obj0 = 0 ;
49943 PyObject * obj1 = 0 ;
49944 PyObject * obj2 = 0 ;
49945 PyObject * obj3 = 0 ;
49946 PyObject * obj4 = 0 ;
49947 PyObject * obj5 = 0 ;
49948 char * kwnames[] = {
49949 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
49950 };
49951
49952 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49953 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
49954 if (!SWIG_IsOK(res1)) {
49955 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
49956 }
49957 arg1 = reinterpret_cast< wxSizer * >(argp1);
49958 arg2 = obj1;
49959 if (obj2) {
49960 ecode3 = SWIG_AsVal_int(obj2, &val3);
49961 if (!SWIG_IsOK(ecode3)) {
49962 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
49963 }
49964 arg3 = static_cast< int >(val3);
49965 }
49966 if (obj3) {
49967 ecode4 = SWIG_AsVal_int(obj3, &val4);
49968 if (!SWIG_IsOK(ecode4)) {
49969 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
49970 }
49971 arg4 = static_cast< int >(val4);
49972 }
49973 if (obj4) {
49974 ecode5 = SWIG_AsVal_int(obj4, &val5);
49975 if (!SWIG_IsOK(ecode5)) {
49976 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
49977 }
49978 arg5 = static_cast< int >(val5);
49979 }
49980 if (obj5) {
49981 arg6 = obj5;
49982 }
49983 {
49984 PyThreadState* __tstate = wxPyBeginAllowThreads();
49985 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
49986 wxPyEndAllowThreads(__tstate);
49987 if (PyErr_Occurred()) SWIG_fail;
49988 }
49989 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
49990 return resultobj;
49991 fail:
49992 return NULL;
49993 }
49994
49995
49996 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49997 PyObject *resultobj = 0;
49998 wxSizer *arg1 = (wxSizer *) 0 ;
49999 int arg2 ;
50000 PyObject *arg3 = (PyObject *) 0 ;
50001 int arg4 = (int) 0 ;
50002 int arg5 = (int) 0 ;
50003 int arg6 = (int) 0 ;
50004 PyObject *arg7 = (PyObject *) NULL ;
50005 wxSizerItem *result = 0 ;
50006 void *argp1 = 0 ;
50007 int res1 = 0 ;
50008 int val2 ;
50009 int ecode2 = 0 ;
50010 int val4 ;
50011 int ecode4 = 0 ;
50012 int val5 ;
50013 int ecode5 = 0 ;
50014 int val6 ;
50015 int ecode6 = 0 ;
50016 PyObject * obj0 = 0 ;
50017 PyObject * obj1 = 0 ;
50018 PyObject * obj2 = 0 ;
50019 PyObject * obj3 = 0 ;
50020 PyObject * obj4 = 0 ;
50021 PyObject * obj5 = 0 ;
50022 PyObject * obj6 = 0 ;
50023 char * kwnames[] = {
50024 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50025 };
50026
50027 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50028 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50029 if (!SWIG_IsOK(res1)) {
50030 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
50031 }
50032 arg1 = reinterpret_cast< wxSizer * >(argp1);
50033 ecode2 = SWIG_AsVal_int(obj1, &val2);
50034 if (!SWIG_IsOK(ecode2)) {
50035 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
50036 }
50037 arg2 = static_cast< int >(val2);
50038 arg3 = obj2;
50039 if (obj3) {
50040 ecode4 = SWIG_AsVal_int(obj3, &val4);
50041 if (!SWIG_IsOK(ecode4)) {
50042 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
50043 }
50044 arg4 = static_cast< int >(val4);
50045 }
50046 if (obj4) {
50047 ecode5 = SWIG_AsVal_int(obj4, &val5);
50048 if (!SWIG_IsOK(ecode5)) {
50049 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
50050 }
50051 arg5 = static_cast< int >(val5);
50052 }
50053 if (obj5) {
50054 ecode6 = SWIG_AsVal_int(obj5, &val6);
50055 if (!SWIG_IsOK(ecode6)) {
50056 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
50057 }
50058 arg6 = static_cast< int >(val6);
50059 }
50060 if (obj6) {
50061 arg7 = obj6;
50062 }
50063 {
50064 PyThreadState* __tstate = wxPyBeginAllowThreads();
50065 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
50066 wxPyEndAllowThreads(__tstate);
50067 if (PyErr_Occurred()) SWIG_fail;
50068 }
50069 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50070 return resultobj;
50071 fail:
50072 return NULL;
50073 }
50074
50075
50076 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50077 PyObject *resultobj = 0;
50078 wxSizer *arg1 = (wxSizer *) 0 ;
50079 PyObject *arg2 = (PyObject *) 0 ;
50080 int arg3 = (int) 0 ;
50081 int arg4 = (int) 0 ;
50082 int arg5 = (int) 0 ;
50083 PyObject *arg6 = (PyObject *) NULL ;
50084 wxSizerItem *result = 0 ;
50085 void *argp1 = 0 ;
50086 int res1 = 0 ;
50087 int val3 ;
50088 int ecode3 = 0 ;
50089 int val4 ;
50090 int ecode4 = 0 ;
50091 int val5 ;
50092 int ecode5 = 0 ;
50093 PyObject * obj0 = 0 ;
50094 PyObject * obj1 = 0 ;
50095 PyObject * obj2 = 0 ;
50096 PyObject * obj3 = 0 ;
50097 PyObject * obj4 = 0 ;
50098 PyObject * obj5 = 0 ;
50099 char * kwnames[] = {
50100 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
50101 };
50102
50103 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
50104 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50105 if (!SWIG_IsOK(res1)) {
50106 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
50107 }
50108 arg1 = reinterpret_cast< wxSizer * >(argp1);
50109 arg2 = obj1;
50110 if (obj2) {
50111 ecode3 = SWIG_AsVal_int(obj2, &val3);
50112 if (!SWIG_IsOK(ecode3)) {
50113 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
50114 }
50115 arg3 = static_cast< int >(val3);
50116 }
50117 if (obj3) {
50118 ecode4 = SWIG_AsVal_int(obj3, &val4);
50119 if (!SWIG_IsOK(ecode4)) {
50120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
50121 }
50122 arg4 = static_cast< int >(val4);
50123 }
50124 if (obj4) {
50125 ecode5 = SWIG_AsVal_int(obj4, &val5);
50126 if (!SWIG_IsOK(ecode5)) {
50127 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
50128 }
50129 arg5 = static_cast< int >(val5);
50130 }
50131 if (obj5) {
50132 arg6 = obj5;
50133 }
50134 {
50135 PyThreadState* __tstate = wxPyBeginAllowThreads();
50136 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
50137 wxPyEndAllowThreads(__tstate);
50138 if (PyErr_Occurred()) SWIG_fail;
50139 }
50140 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50141 return resultobj;
50142 fail:
50143 return NULL;
50144 }
50145
50146
50147 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50148 PyObject *resultobj = 0;
50149 wxSizer *arg1 = (wxSizer *) 0 ;
50150 PyObject *arg2 = (PyObject *) 0 ;
50151 bool result;
50152 void *argp1 = 0 ;
50153 int res1 = 0 ;
50154 PyObject * obj0 = 0 ;
50155 PyObject * obj1 = 0 ;
50156 char * kwnames[] = {
50157 (char *) "self",(char *) "item", NULL
50158 };
50159
50160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
50161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50162 if (!SWIG_IsOK(res1)) {
50163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
50164 }
50165 arg1 = reinterpret_cast< wxSizer * >(argp1);
50166 arg2 = obj1;
50167 {
50168 PyThreadState* __tstate = wxPyBeginAllowThreads();
50169 result = (bool)wxSizer_Remove(arg1,arg2);
50170 wxPyEndAllowThreads(__tstate);
50171 if (PyErr_Occurred()) SWIG_fail;
50172 }
50173 {
50174 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50175 }
50176 return resultobj;
50177 fail:
50178 return NULL;
50179 }
50180
50181
50182 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50183 PyObject *resultobj = 0;
50184 wxSizer *arg1 = (wxSizer *) 0 ;
50185 PyObject *arg2 = (PyObject *) 0 ;
50186 bool result;
50187 void *argp1 = 0 ;
50188 int res1 = 0 ;
50189 PyObject * obj0 = 0 ;
50190 PyObject * obj1 = 0 ;
50191 char * kwnames[] = {
50192 (char *) "self",(char *) "item", NULL
50193 };
50194
50195 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
50196 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50197 if (!SWIG_IsOK(res1)) {
50198 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
50199 }
50200 arg1 = reinterpret_cast< wxSizer * >(argp1);
50201 arg2 = obj1;
50202 {
50203 PyThreadState* __tstate = wxPyBeginAllowThreads();
50204 result = (bool)wxSizer_Detach(arg1,arg2);
50205 wxPyEndAllowThreads(__tstate);
50206 if (PyErr_Occurred()) SWIG_fail;
50207 }
50208 {
50209 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50210 }
50211 return resultobj;
50212 fail:
50213 return NULL;
50214 }
50215
50216
50217 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50218 PyObject *resultobj = 0;
50219 wxSizer *arg1 = (wxSizer *) 0 ;
50220 PyObject *arg2 = (PyObject *) 0 ;
50221 wxSizerItem *result = 0 ;
50222 void *argp1 = 0 ;
50223 int res1 = 0 ;
50224 PyObject * obj0 = 0 ;
50225 PyObject * obj1 = 0 ;
50226 char * kwnames[] = {
50227 (char *) "self",(char *) "item", NULL
50228 };
50229
50230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
50231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50232 if (!SWIG_IsOK(res1)) {
50233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50234 }
50235 arg1 = reinterpret_cast< wxSizer * >(argp1);
50236 arg2 = obj1;
50237 {
50238 PyThreadState* __tstate = wxPyBeginAllowThreads();
50239 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
50240 wxPyEndAllowThreads(__tstate);
50241 if (PyErr_Occurred()) SWIG_fail;
50242 }
50243 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50244 return resultobj;
50245 fail:
50246 return NULL;
50247 }
50248
50249
50250 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50251 PyObject *resultobj = 0;
50252 wxSizer *arg1 = (wxSizer *) 0 ;
50253 PyObject *arg2 = (PyObject *) 0 ;
50254 wxSize *arg3 = 0 ;
50255 void *argp1 = 0 ;
50256 int res1 = 0 ;
50257 wxSize temp3 ;
50258 PyObject * obj0 = 0 ;
50259 PyObject * obj1 = 0 ;
50260 PyObject * obj2 = 0 ;
50261 char * kwnames[] = {
50262 (char *) "self",(char *) "item",(char *) "size", NULL
50263 };
50264
50265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50266 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50267 if (!SWIG_IsOK(res1)) {
50268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50269 }
50270 arg1 = reinterpret_cast< wxSizer * >(argp1);
50271 arg2 = obj1;
50272 {
50273 arg3 = &temp3;
50274 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
50275 }
50276 {
50277 PyThreadState* __tstate = wxPyBeginAllowThreads();
50278 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
50279 wxPyEndAllowThreads(__tstate);
50280 if (PyErr_Occurred()) SWIG_fail;
50281 }
50282 resultobj = SWIG_Py_Void();
50283 return resultobj;
50284 fail:
50285 return NULL;
50286 }
50287
50288
50289 SWIGINTERN PyObject *_wrap_Sizer__ReplaceWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50290 PyObject *resultobj = 0;
50291 wxSizer *arg1 = (wxSizer *) 0 ;
50292 wxWindow *arg2 = (wxWindow *) 0 ;
50293 wxWindow *arg3 = (wxWindow *) 0 ;
50294 bool arg4 = (bool) false ;
50295 bool result;
50296 void *argp1 = 0 ;
50297 int res1 = 0 ;
50298 void *argp2 = 0 ;
50299 int res2 = 0 ;
50300 void *argp3 = 0 ;
50301 int res3 = 0 ;
50302 bool val4 ;
50303 int ecode4 = 0 ;
50304 PyObject * obj0 = 0 ;
50305 PyObject * obj1 = 0 ;
50306 PyObject * obj2 = 0 ;
50307 PyObject * obj3 = 0 ;
50308 char * kwnames[] = {
50309 (char *) "self",(char *) "oldwin",(char *) "newwin",(char *) "recursive", NULL
50310 };
50311
50312 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceWin",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50313 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50314 if (!SWIG_IsOK(res1)) {
50315 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceWin" "', expected argument " "1"" of type '" "wxSizer *""'");
50316 }
50317 arg1 = reinterpret_cast< wxSizer * >(argp1);
50318 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50319 if (!SWIG_IsOK(res2)) {
50320 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceWin" "', expected argument " "2"" of type '" "wxWindow *""'");
50321 }
50322 arg2 = reinterpret_cast< wxWindow * >(argp2);
50323 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
50324 if (!SWIG_IsOK(res3)) {
50325 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceWin" "', expected argument " "3"" of type '" "wxWindow *""'");
50326 }
50327 arg3 = reinterpret_cast< wxWindow * >(argp3);
50328 if (obj3) {
50329 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50330 if (!SWIG_IsOK(ecode4)) {
50331 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceWin" "', expected argument " "4"" of type '" "bool""'");
50332 }
50333 arg4 = static_cast< bool >(val4);
50334 }
50335 {
50336 PyThreadState* __tstate = wxPyBeginAllowThreads();
50337 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50338 wxPyEndAllowThreads(__tstate);
50339 if (PyErr_Occurred()) SWIG_fail;
50340 }
50341 {
50342 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50343 }
50344 return resultobj;
50345 fail:
50346 return NULL;
50347 }
50348
50349
50350 SWIGINTERN PyObject *_wrap_Sizer__ReplaceSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50351 PyObject *resultobj = 0;
50352 wxSizer *arg1 = (wxSizer *) 0 ;
50353 wxSizer *arg2 = (wxSizer *) 0 ;
50354 wxSizer *arg3 = (wxSizer *) 0 ;
50355 bool arg4 = (bool) false ;
50356 bool result;
50357 void *argp1 = 0 ;
50358 int res1 = 0 ;
50359 void *argp2 = 0 ;
50360 int res2 = 0 ;
50361 void *argp3 = 0 ;
50362 int res3 = 0 ;
50363 bool val4 ;
50364 int ecode4 = 0 ;
50365 PyObject * obj0 = 0 ;
50366 PyObject * obj1 = 0 ;
50367 PyObject * obj2 = 0 ;
50368 PyObject * obj3 = 0 ;
50369 char * kwnames[] = {
50370 (char *) "self",(char *) "oldsz",(char *) "newsz",(char *) "recursive", NULL
50371 };
50372
50373 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Sizer__ReplaceSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
50374 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50375 if (!SWIG_IsOK(res1)) {
50376 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
50377 }
50378 arg1 = reinterpret_cast< wxSizer * >(argp1);
50379 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50380 if (!SWIG_IsOK(res2)) {
50381 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer__ReplaceSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
50382 }
50383 arg2 = reinterpret_cast< wxSizer * >(argp2);
50384 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizer, 0 | 0 );
50385 if (!SWIG_IsOK(res3)) {
50386 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceSizer" "', expected argument " "3"" of type '" "wxSizer *""'");
50387 }
50388 arg3 = reinterpret_cast< wxSizer * >(argp3);
50389 if (obj3) {
50390 ecode4 = SWIG_AsVal_bool(obj3, &val4);
50391 if (!SWIG_IsOK(ecode4)) {
50392 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer__ReplaceSizer" "', expected argument " "4"" of type '" "bool""'");
50393 }
50394 arg4 = static_cast< bool >(val4);
50395 }
50396 {
50397 PyThreadState* __tstate = wxPyBeginAllowThreads();
50398 result = (bool)(arg1)->Replace(arg2,arg3,arg4);
50399 wxPyEndAllowThreads(__tstate);
50400 if (PyErr_Occurred()) SWIG_fail;
50401 }
50402 {
50403 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50404 }
50405 return resultobj;
50406 fail:
50407 return NULL;
50408 }
50409
50410
50411 SWIGINTERN PyObject *_wrap_Sizer__ReplaceItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50412 PyObject *resultobj = 0;
50413 wxSizer *arg1 = (wxSizer *) 0 ;
50414 size_t arg2 ;
50415 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50416 bool result;
50417 void *argp1 = 0 ;
50418 int res1 = 0 ;
50419 size_t val2 ;
50420 int ecode2 = 0 ;
50421 void *argp3 = 0 ;
50422 int res3 = 0 ;
50423 PyObject * obj0 = 0 ;
50424 PyObject * obj1 = 0 ;
50425 PyObject * obj2 = 0 ;
50426 char * kwnames[] = {
50427 (char *) "self",(char *) "index",(char *) "newitem", NULL
50428 };
50429
50430 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__ReplaceItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50431 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50432 if (!SWIG_IsOK(res1)) {
50433 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__ReplaceItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50434 }
50435 arg1 = reinterpret_cast< wxSizer * >(argp1);
50436 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50437 if (!SWIG_IsOK(ecode2)) {
50438 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer__ReplaceItem" "', expected argument " "2"" of type '" "size_t""'");
50439 }
50440 arg2 = static_cast< size_t >(val2);
50441 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxSizerItem, 0 | 0 );
50442 if (!SWIG_IsOK(res3)) {
50443 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer__ReplaceItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50444 }
50445 arg3 = reinterpret_cast< wxSizerItem * >(argp3);
50446 {
50447 PyThreadState* __tstate = wxPyBeginAllowThreads();
50448 result = (bool)(arg1)->Replace(arg2,arg3);
50449 wxPyEndAllowThreads(__tstate);
50450 if (PyErr_Occurred()) SWIG_fail;
50451 }
50452 {
50453 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50454 }
50455 return resultobj;
50456 fail:
50457 return NULL;
50458 }
50459
50460
50461 SWIGINTERN PyObject *_wrap_Sizer_SetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50462 PyObject *resultobj = 0;
50463 wxSizer *arg1 = (wxSizer *) 0 ;
50464 wxWindow *arg2 = (wxWindow *) 0 ;
50465 void *argp1 = 0 ;
50466 int res1 = 0 ;
50467 void *argp2 = 0 ;
50468 int res2 = 0 ;
50469 PyObject * obj0 = 0 ;
50470 PyObject * obj1 = 0 ;
50471 char * kwnames[] = {
50472 (char *) "self",(char *) "window", NULL
50473 };
50474
50475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetContainingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
50476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50477 if (!SWIG_IsOK(res1)) {
50478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetContainingWindow" "', expected argument " "1"" of type '" "wxSizer *""'");
50479 }
50480 arg1 = reinterpret_cast< wxSizer * >(argp1);
50481 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50482 if (!SWIG_IsOK(res2)) {
50483 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetContainingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
50484 }
50485 arg2 = reinterpret_cast< wxWindow * >(argp2);
50486 {
50487 PyThreadState* __tstate = wxPyBeginAllowThreads();
50488 (arg1)->SetContainingWindow(arg2);
50489 wxPyEndAllowThreads(__tstate);
50490 if (PyErr_Occurred()) SWIG_fail;
50491 }
50492 resultobj = SWIG_Py_Void();
50493 return resultobj;
50494 fail:
50495 return NULL;
50496 }
50497
50498
50499 SWIGINTERN PyObject *_wrap_Sizer_GetContainingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50500 PyObject *resultobj = 0;
50501 wxSizer *arg1 = (wxSizer *) 0 ;
50502 wxWindow *result = 0 ;
50503 void *argp1 = 0 ;
50504 int res1 = 0 ;
50505 PyObject *swig_obj[1] ;
50506
50507 if (!args) SWIG_fail;
50508 swig_obj[0] = args;
50509 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50510 if (!SWIG_IsOK(res1)) {
50511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetContainingWindow" "', expected argument " "1"" of type '" "wxSizer const *""'");
50512 }
50513 arg1 = reinterpret_cast< wxSizer * >(argp1);
50514 {
50515 PyThreadState* __tstate = wxPyBeginAllowThreads();
50516 result = (wxWindow *)((wxSizer const *)arg1)->GetContainingWindow();
50517 wxPyEndAllowThreads(__tstate);
50518 if (PyErr_Occurred()) SWIG_fail;
50519 }
50520 {
50521 resultobj = wxPyMake_wxObject(result, 0);
50522 }
50523 return resultobj;
50524 fail:
50525 return NULL;
50526 }
50527
50528
50529 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50530 PyObject *resultobj = 0;
50531 wxSizer *arg1 = (wxSizer *) 0 ;
50532 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50533 wxSizerItem *result = 0 ;
50534 void *argp1 = 0 ;
50535 int res1 = 0 ;
50536 int res2 = 0 ;
50537 PyObject * obj0 = 0 ;
50538 PyObject * obj1 = 0 ;
50539 char * kwnames[] = {
50540 (char *) "self",(char *) "item", NULL
50541 };
50542
50543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50545 if (!SWIG_IsOK(res1)) {
50546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50547 }
50548 arg1 = reinterpret_cast< wxSizer * >(argp1);
50549 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50550 if (!SWIG_IsOK(res2)) {
50551 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50552 }
50553 {
50554 PyThreadState* __tstate = wxPyBeginAllowThreads();
50555 result = (wxSizerItem *)(arg1)->Add(arg2);
50556 wxPyEndAllowThreads(__tstate);
50557 if (PyErr_Occurred()) SWIG_fail;
50558 }
50559 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50560 return resultobj;
50561 fail:
50562 return NULL;
50563 }
50564
50565
50566 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50567 PyObject *resultobj = 0;
50568 wxSizer *arg1 = (wxSizer *) 0 ;
50569 size_t arg2 ;
50570 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
50571 wxSizerItem *result = 0 ;
50572 void *argp1 = 0 ;
50573 int res1 = 0 ;
50574 size_t val2 ;
50575 int ecode2 = 0 ;
50576 int res3 = 0 ;
50577 PyObject * obj0 = 0 ;
50578 PyObject * obj1 = 0 ;
50579 PyObject * obj2 = 0 ;
50580 char * kwnames[] = {
50581 (char *) "self",(char *) "index",(char *) "item", NULL
50582 };
50583
50584 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50585 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50586 if (!SWIG_IsOK(res1)) {
50587 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50588 }
50589 arg1 = reinterpret_cast< wxSizer * >(argp1);
50590 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
50591 if (!SWIG_IsOK(ecode2)) {
50592 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
50593 }
50594 arg2 = static_cast< size_t >(val2);
50595 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50596 if (!SWIG_IsOK(res3)) {
50597 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
50598 }
50599 {
50600 PyThreadState* __tstate = wxPyBeginAllowThreads();
50601 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
50602 wxPyEndAllowThreads(__tstate);
50603 if (PyErr_Occurred()) SWIG_fail;
50604 }
50605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50606 return resultobj;
50607 fail:
50608 return NULL;
50609 }
50610
50611
50612 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50613 PyObject *resultobj = 0;
50614 wxSizer *arg1 = (wxSizer *) 0 ;
50615 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
50616 wxSizerItem *result = 0 ;
50617 void *argp1 = 0 ;
50618 int res1 = 0 ;
50619 int res2 = 0 ;
50620 PyObject * obj0 = 0 ;
50621 PyObject * obj1 = 0 ;
50622 char * kwnames[] = {
50623 (char *) "self",(char *) "item", NULL
50624 };
50625
50626 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
50627 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50628 if (!SWIG_IsOK(res1)) {
50629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
50630 }
50631 arg1 = reinterpret_cast< wxSizer * >(argp1);
50632 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
50633 if (!SWIG_IsOK(res2)) {
50634 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
50635 }
50636 {
50637 PyThreadState* __tstate = wxPyBeginAllowThreads();
50638 result = (wxSizerItem *)(arg1)->Prepend(arg2);
50639 wxPyEndAllowThreads(__tstate);
50640 if (PyErr_Occurred()) SWIG_fail;
50641 }
50642 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
50643 return resultobj;
50644 fail:
50645 return NULL;
50646 }
50647
50648
50649 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50650 PyObject *resultobj = 0;
50651 wxSizer *arg1 = (wxSizer *) 0 ;
50652 int arg2 ;
50653 int arg3 ;
50654 int arg4 ;
50655 int arg5 ;
50656 void *argp1 = 0 ;
50657 int res1 = 0 ;
50658 int val2 ;
50659 int ecode2 = 0 ;
50660 int val3 ;
50661 int ecode3 = 0 ;
50662 int val4 ;
50663 int ecode4 = 0 ;
50664 int val5 ;
50665 int ecode5 = 0 ;
50666 PyObject * obj0 = 0 ;
50667 PyObject * obj1 = 0 ;
50668 PyObject * obj2 = 0 ;
50669 PyObject * obj3 = 0 ;
50670 PyObject * obj4 = 0 ;
50671 char * kwnames[] = {
50672 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
50673 };
50674
50675 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
50676 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50677 if (!SWIG_IsOK(res1)) {
50678 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
50679 }
50680 arg1 = reinterpret_cast< wxSizer * >(argp1);
50681 ecode2 = SWIG_AsVal_int(obj1, &val2);
50682 if (!SWIG_IsOK(ecode2)) {
50683 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
50684 }
50685 arg2 = static_cast< int >(val2);
50686 ecode3 = SWIG_AsVal_int(obj2, &val3);
50687 if (!SWIG_IsOK(ecode3)) {
50688 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
50689 }
50690 arg3 = static_cast< int >(val3);
50691 ecode4 = SWIG_AsVal_int(obj3, &val4);
50692 if (!SWIG_IsOK(ecode4)) {
50693 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
50694 }
50695 arg4 = static_cast< int >(val4);
50696 ecode5 = SWIG_AsVal_int(obj4, &val5);
50697 if (!SWIG_IsOK(ecode5)) {
50698 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
50699 }
50700 arg5 = static_cast< int >(val5);
50701 {
50702 PyThreadState* __tstate = wxPyBeginAllowThreads();
50703 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
50704 wxPyEndAllowThreads(__tstate);
50705 if (PyErr_Occurred()) SWIG_fail;
50706 }
50707 resultobj = SWIG_Py_Void();
50708 return resultobj;
50709 fail:
50710 return NULL;
50711 }
50712
50713
50714 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50715 PyObject *resultobj = 0;
50716 wxSizer *arg1 = (wxSizer *) 0 ;
50717 wxSize *arg2 = 0 ;
50718 void *argp1 = 0 ;
50719 int res1 = 0 ;
50720 wxSize temp2 ;
50721 PyObject * obj0 = 0 ;
50722 PyObject * obj1 = 0 ;
50723 char * kwnames[] = {
50724 (char *) "self",(char *) "size", NULL
50725 };
50726
50727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
50728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50729 if (!SWIG_IsOK(res1)) {
50730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50731 }
50732 arg1 = reinterpret_cast< wxSizer * >(argp1);
50733 {
50734 arg2 = &temp2;
50735 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50736 }
50737 {
50738 PyThreadState* __tstate = wxPyBeginAllowThreads();
50739 (arg1)->SetMinSize((wxSize const &)*arg2);
50740 wxPyEndAllowThreads(__tstate);
50741 if (PyErr_Occurred()) SWIG_fail;
50742 }
50743 resultobj = SWIG_Py_Void();
50744 return resultobj;
50745 fail:
50746 return NULL;
50747 }
50748
50749
50750 SWIGINTERN PyObject *_wrap_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50751 PyObject *resultobj = 0;
50752 wxSizer *arg1 = (wxSizer *) 0 ;
50753 wxSize result;
50754 void *argp1 = 0 ;
50755 int res1 = 0 ;
50756 PyObject *swig_obj[1] ;
50757
50758 if (!args) SWIG_fail;
50759 swig_obj[0] = args;
50760 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50761 if (!SWIG_IsOK(res1)) {
50762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50763 }
50764 arg1 = reinterpret_cast< wxSizer * >(argp1);
50765 {
50766 PyThreadState* __tstate = wxPyBeginAllowThreads();
50767 result = (arg1)->GetSize();
50768 wxPyEndAllowThreads(__tstate);
50769 if (PyErr_Occurred()) SWIG_fail;
50770 }
50771 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50772 return resultobj;
50773 fail:
50774 return NULL;
50775 }
50776
50777
50778 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50779 PyObject *resultobj = 0;
50780 wxSizer *arg1 = (wxSizer *) 0 ;
50781 wxPoint result;
50782 void *argp1 = 0 ;
50783 int res1 = 0 ;
50784 PyObject *swig_obj[1] ;
50785
50786 if (!args) SWIG_fail;
50787 swig_obj[0] = args;
50788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50789 if (!SWIG_IsOK(res1)) {
50790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
50791 }
50792 arg1 = reinterpret_cast< wxSizer * >(argp1);
50793 {
50794 PyThreadState* __tstate = wxPyBeginAllowThreads();
50795 result = (arg1)->GetPosition();
50796 wxPyEndAllowThreads(__tstate);
50797 if (PyErr_Occurred()) SWIG_fail;
50798 }
50799 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
50800 return resultobj;
50801 fail:
50802 return NULL;
50803 }
50804
50805
50806 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50807 PyObject *resultobj = 0;
50808 wxSizer *arg1 = (wxSizer *) 0 ;
50809 wxSize result;
50810 void *argp1 = 0 ;
50811 int res1 = 0 ;
50812 PyObject *swig_obj[1] ;
50813
50814 if (!args) SWIG_fail;
50815 swig_obj[0] = args;
50816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50817 if (!SWIG_IsOK(res1)) {
50818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
50819 }
50820 arg1 = reinterpret_cast< wxSizer * >(argp1);
50821 {
50822 PyThreadState* __tstate = wxPyBeginAllowThreads();
50823 result = (arg1)->GetMinSize();
50824 wxPyEndAllowThreads(__tstate);
50825 if (PyErr_Occurred()) SWIG_fail;
50826 }
50827 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50828 return resultobj;
50829 fail:
50830 return NULL;
50831 }
50832
50833
50834 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50835 PyObject *resultobj = 0;
50836 wxSizer *arg1 = (wxSizer *) 0 ;
50837 void *argp1 = 0 ;
50838 int res1 = 0 ;
50839 PyObject *swig_obj[1] ;
50840
50841 if (!args) SWIG_fail;
50842 swig_obj[0] = args;
50843 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50844 if (!SWIG_IsOK(res1)) {
50845 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
50846 }
50847 arg1 = reinterpret_cast< wxSizer * >(argp1);
50848 {
50849 PyThreadState* __tstate = wxPyBeginAllowThreads();
50850 (arg1)->RecalcSizes();
50851 wxPyEndAllowThreads(__tstate);
50852 if (PyErr_Occurred()) SWIG_fail;
50853 }
50854 resultobj = SWIG_Py_Void();
50855 return resultobj;
50856 fail:
50857 return NULL;
50858 }
50859
50860
50861 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50862 PyObject *resultobj = 0;
50863 wxSizer *arg1 = (wxSizer *) 0 ;
50864 wxSize result;
50865 void *argp1 = 0 ;
50866 int res1 = 0 ;
50867 PyObject *swig_obj[1] ;
50868
50869 if (!args) SWIG_fail;
50870 swig_obj[0] = args;
50871 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50872 if (!SWIG_IsOK(res1)) {
50873 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
50874 }
50875 arg1 = reinterpret_cast< wxSizer * >(argp1);
50876 {
50877 PyThreadState* __tstate = wxPyBeginAllowThreads();
50878 result = (arg1)->CalcMin();
50879 wxPyEndAllowThreads(__tstate);
50880 if (PyErr_Occurred()) SWIG_fail;
50881 }
50882 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50883 return resultobj;
50884 fail:
50885 return NULL;
50886 }
50887
50888
50889 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50890 PyObject *resultobj = 0;
50891 wxSizer *arg1 = (wxSizer *) 0 ;
50892 void *argp1 = 0 ;
50893 int res1 = 0 ;
50894 PyObject *swig_obj[1] ;
50895
50896 if (!args) SWIG_fail;
50897 swig_obj[0] = args;
50898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50899 if (!SWIG_IsOK(res1)) {
50900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
50901 }
50902 arg1 = reinterpret_cast< wxSizer * >(argp1);
50903 {
50904 PyThreadState* __tstate = wxPyBeginAllowThreads();
50905 (arg1)->Layout();
50906 wxPyEndAllowThreads(__tstate);
50907 if (PyErr_Occurred()) SWIG_fail;
50908 }
50909 resultobj = SWIG_Py_Void();
50910 return resultobj;
50911 fail:
50912 return NULL;
50913 }
50914
50915
50916 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50917 PyObject *resultobj = 0;
50918 wxSizer *arg1 = (wxSizer *) 0 ;
50919 wxWindow *arg2 = (wxWindow *) 0 ;
50920 wxSize result;
50921 void *argp1 = 0 ;
50922 int res1 = 0 ;
50923 void *argp2 = 0 ;
50924 int res2 = 0 ;
50925 PyObject * obj0 = 0 ;
50926 PyObject * obj1 = 0 ;
50927 char * kwnames[] = {
50928 (char *) "self",(char *) "window", NULL
50929 };
50930
50931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
50932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50933 if (!SWIG_IsOK(res1)) {
50934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
50935 }
50936 arg1 = reinterpret_cast< wxSizer * >(argp1);
50937 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50938 if (!SWIG_IsOK(res2)) {
50939 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
50940 }
50941 arg2 = reinterpret_cast< wxWindow * >(argp2);
50942 {
50943 PyThreadState* __tstate = wxPyBeginAllowThreads();
50944 result = (arg1)->Fit(arg2);
50945 wxPyEndAllowThreads(__tstate);
50946 if (PyErr_Occurred()) SWIG_fail;
50947 }
50948 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50949 return resultobj;
50950 fail:
50951 return NULL;
50952 }
50953
50954
50955 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50956 PyObject *resultobj = 0;
50957 wxSizer *arg1 = (wxSizer *) 0 ;
50958 wxWindow *arg2 = (wxWindow *) 0 ;
50959 void *argp1 = 0 ;
50960 int res1 = 0 ;
50961 void *argp2 = 0 ;
50962 int res2 = 0 ;
50963 PyObject * obj0 = 0 ;
50964 PyObject * obj1 = 0 ;
50965 char * kwnames[] = {
50966 (char *) "self",(char *) "window", NULL
50967 };
50968
50969 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
50970 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
50971 if (!SWIG_IsOK(res1)) {
50972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
50973 }
50974 arg1 = reinterpret_cast< wxSizer * >(argp1);
50975 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50976 if (!SWIG_IsOK(res2)) {
50977 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
50978 }
50979 arg2 = reinterpret_cast< wxWindow * >(argp2);
50980 {
50981 PyThreadState* __tstate = wxPyBeginAllowThreads();
50982 (arg1)->FitInside(arg2);
50983 wxPyEndAllowThreads(__tstate);
50984 if (PyErr_Occurred()) SWIG_fail;
50985 }
50986 resultobj = SWIG_Py_Void();
50987 return resultobj;
50988 fail:
50989 return NULL;
50990 }
50991
50992
50993 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50994 PyObject *resultobj = 0;
50995 wxSizer *arg1 = (wxSizer *) 0 ;
50996 wxWindow *arg2 = (wxWindow *) 0 ;
50997 void *argp1 = 0 ;
50998 int res1 = 0 ;
50999 void *argp2 = 0 ;
51000 int res2 = 0 ;
51001 PyObject * obj0 = 0 ;
51002 PyObject * obj1 = 0 ;
51003 char * kwnames[] = {
51004 (char *) "self",(char *) "window", NULL
51005 };
51006
51007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
51008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51009 if (!SWIG_IsOK(res1)) {
51010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
51011 }
51012 arg1 = reinterpret_cast< wxSizer * >(argp1);
51013 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51014 if (!SWIG_IsOK(res2)) {
51015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
51016 }
51017 arg2 = reinterpret_cast< wxWindow * >(argp2);
51018 {
51019 PyThreadState* __tstate = wxPyBeginAllowThreads();
51020 (arg1)->SetSizeHints(arg2);
51021 wxPyEndAllowThreads(__tstate);
51022 if (PyErr_Occurred()) SWIG_fail;
51023 }
51024 resultobj = SWIG_Py_Void();
51025 return resultobj;
51026 fail:
51027 return NULL;
51028 }
51029
51030
51031 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51032 PyObject *resultobj = 0;
51033 wxSizer *arg1 = (wxSizer *) 0 ;
51034 wxWindow *arg2 = (wxWindow *) 0 ;
51035 void *argp1 = 0 ;
51036 int res1 = 0 ;
51037 void *argp2 = 0 ;
51038 int res2 = 0 ;
51039 PyObject * obj0 = 0 ;
51040 PyObject * obj1 = 0 ;
51041 char * kwnames[] = {
51042 (char *) "self",(char *) "window", NULL
51043 };
51044
51045 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
51046 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51047 if (!SWIG_IsOK(res1)) {
51048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
51049 }
51050 arg1 = reinterpret_cast< wxSizer * >(argp1);
51051 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51052 if (!SWIG_IsOK(res2)) {
51053 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
51054 }
51055 arg2 = reinterpret_cast< wxWindow * >(argp2);
51056 {
51057 PyThreadState* __tstate = wxPyBeginAllowThreads();
51058 (arg1)->SetVirtualSizeHints(arg2);
51059 wxPyEndAllowThreads(__tstate);
51060 if (PyErr_Occurred()) SWIG_fail;
51061 }
51062 resultobj = SWIG_Py_Void();
51063 return resultobj;
51064 fail:
51065 return NULL;
51066 }
51067
51068
51069 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51070 PyObject *resultobj = 0;
51071 wxSizer *arg1 = (wxSizer *) 0 ;
51072 bool arg2 = (bool) false ;
51073 void *argp1 = 0 ;
51074 int res1 = 0 ;
51075 bool val2 ;
51076 int ecode2 = 0 ;
51077 PyObject * obj0 = 0 ;
51078 PyObject * obj1 = 0 ;
51079 char * kwnames[] = {
51080 (char *) "self",(char *) "deleteWindows", NULL
51081 };
51082
51083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
51084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51085 if (!SWIG_IsOK(res1)) {
51086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
51087 }
51088 arg1 = reinterpret_cast< wxSizer * >(argp1);
51089 if (obj1) {
51090 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51091 if (!SWIG_IsOK(ecode2)) {
51092 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
51093 }
51094 arg2 = static_cast< bool >(val2);
51095 }
51096 {
51097 PyThreadState* __tstate = wxPyBeginAllowThreads();
51098 (arg1)->Clear(arg2);
51099 wxPyEndAllowThreads(__tstate);
51100 if (PyErr_Occurred()) SWIG_fail;
51101 }
51102 resultobj = SWIG_Py_Void();
51103 return resultobj;
51104 fail:
51105 return NULL;
51106 }
51107
51108
51109 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51110 PyObject *resultobj = 0;
51111 wxSizer *arg1 = (wxSizer *) 0 ;
51112 void *argp1 = 0 ;
51113 int res1 = 0 ;
51114 PyObject *swig_obj[1] ;
51115
51116 if (!args) SWIG_fail;
51117 swig_obj[0] = args;
51118 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51119 if (!SWIG_IsOK(res1)) {
51120 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
51121 }
51122 arg1 = reinterpret_cast< wxSizer * >(argp1);
51123 {
51124 PyThreadState* __tstate = wxPyBeginAllowThreads();
51125 (arg1)->DeleteWindows();
51126 wxPyEndAllowThreads(__tstate);
51127 if (PyErr_Occurred()) SWIG_fail;
51128 }
51129 resultobj = SWIG_Py_Void();
51130 return resultobj;
51131 fail:
51132 return NULL;
51133 }
51134
51135
51136 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51137 PyObject *resultobj = 0;
51138 wxSizer *arg1 = (wxSizer *) 0 ;
51139 PyObject *result = 0 ;
51140 void *argp1 = 0 ;
51141 int res1 = 0 ;
51142 PyObject *swig_obj[1] ;
51143
51144 if (!args) SWIG_fail;
51145 swig_obj[0] = args;
51146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51147 if (!SWIG_IsOK(res1)) {
51148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
51149 }
51150 arg1 = reinterpret_cast< wxSizer * >(argp1);
51151 {
51152 PyThreadState* __tstate = wxPyBeginAllowThreads();
51153 result = (PyObject *)wxSizer_GetChildren(arg1);
51154 wxPyEndAllowThreads(__tstate);
51155 if (PyErr_Occurred()) SWIG_fail;
51156 }
51157 resultobj = result;
51158 return resultobj;
51159 fail:
51160 return NULL;
51161 }
51162
51163
51164 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51165 PyObject *resultobj = 0;
51166 wxSizer *arg1 = (wxSizer *) 0 ;
51167 PyObject *arg2 = (PyObject *) 0 ;
51168 bool arg3 = (bool) true ;
51169 bool arg4 = (bool) false ;
51170 bool result;
51171 void *argp1 = 0 ;
51172 int res1 = 0 ;
51173 bool val3 ;
51174 int ecode3 = 0 ;
51175 bool val4 ;
51176 int ecode4 = 0 ;
51177 PyObject * obj0 = 0 ;
51178 PyObject * obj1 = 0 ;
51179 PyObject * obj2 = 0 ;
51180 PyObject * obj3 = 0 ;
51181 char * kwnames[] = {
51182 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
51183 };
51184
51185 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51186 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51187 if (!SWIG_IsOK(res1)) {
51188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
51189 }
51190 arg1 = reinterpret_cast< wxSizer * >(argp1);
51191 arg2 = obj1;
51192 if (obj2) {
51193 ecode3 = SWIG_AsVal_bool(obj2, &val3);
51194 if (!SWIG_IsOK(ecode3)) {
51195 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
51196 }
51197 arg3 = static_cast< bool >(val3);
51198 }
51199 if (obj3) {
51200 ecode4 = SWIG_AsVal_bool(obj3, &val4);
51201 if (!SWIG_IsOK(ecode4)) {
51202 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
51203 }
51204 arg4 = static_cast< bool >(val4);
51205 }
51206 {
51207 PyThreadState* __tstate = wxPyBeginAllowThreads();
51208 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
51209 wxPyEndAllowThreads(__tstate);
51210 if (PyErr_Occurred()) SWIG_fail;
51211 }
51212 {
51213 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51214 }
51215 return resultobj;
51216 fail:
51217 return NULL;
51218 }
51219
51220
51221 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51222 PyObject *resultobj = 0;
51223 wxSizer *arg1 = (wxSizer *) 0 ;
51224 PyObject *arg2 = (PyObject *) 0 ;
51225 bool result;
51226 void *argp1 = 0 ;
51227 int res1 = 0 ;
51228 PyObject * obj0 = 0 ;
51229 PyObject * obj1 = 0 ;
51230 char * kwnames[] = {
51231 (char *) "self",(char *) "item", NULL
51232 };
51233
51234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
51235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51236 if (!SWIG_IsOK(res1)) {
51237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
51238 }
51239 arg1 = reinterpret_cast< wxSizer * >(argp1);
51240 arg2 = obj1;
51241 {
51242 PyThreadState* __tstate = wxPyBeginAllowThreads();
51243 result = (bool)wxSizer_IsShown(arg1,arg2);
51244 wxPyEndAllowThreads(__tstate);
51245 if (PyErr_Occurred()) SWIG_fail;
51246 }
51247 {
51248 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51249 }
51250 return resultobj;
51251 fail:
51252 return NULL;
51253 }
51254
51255
51256 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51257 PyObject *resultobj = 0;
51258 wxSizer *arg1 = (wxSizer *) 0 ;
51259 bool arg2 ;
51260 void *argp1 = 0 ;
51261 int res1 = 0 ;
51262 bool val2 ;
51263 int ecode2 = 0 ;
51264 PyObject * obj0 = 0 ;
51265 PyObject * obj1 = 0 ;
51266 char * kwnames[] = {
51267 (char *) "self",(char *) "show", NULL
51268 };
51269
51270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
51271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
51272 if (!SWIG_IsOK(res1)) {
51273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
51274 }
51275 arg1 = reinterpret_cast< wxSizer * >(argp1);
51276 ecode2 = SWIG_AsVal_bool(obj1, &val2);
51277 if (!SWIG_IsOK(ecode2)) {
51278 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
51279 }
51280 arg2 = static_cast< bool >(val2);
51281 {
51282 PyThreadState* __tstate = wxPyBeginAllowThreads();
51283 (arg1)->ShowItems(arg2);
51284 wxPyEndAllowThreads(__tstate);
51285 if (PyErr_Occurred()) SWIG_fail;
51286 }
51287 resultobj = SWIG_Py_Void();
51288 return resultobj;
51289 fail:
51290 return NULL;
51291 }
51292
51293
51294 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51295 PyObject *obj;
51296 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51297 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
51298 return SWIG_Py_Void();
51299 }
51300
51301 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51302 PyObject *resultobj = 0;
51303 wxPySizer *result = 0 ;
51304
51305 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
51306 {
51307 PyThreadState* __tstate = wxPyBeginAllowThreads();
51308 result = (wxPySizer *)new wxPySizer();
51309 wxPyEndAllowThreads(__tstate);
51310 if (PyErr_Occurred()) SWIG_fail;
51311 }
51312 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
51313 return resultobj;
51314 fail:
51315 return NULL;
51316 }
51317
51318
51319 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51320 PyObject *resultobj = 0;
51321 wxPySizer *arg1 = (wxPySizer *) 0 ;
51322 PyObject *arg2 = (PyObject *) 0 ;
51323 PyObject *arg3 = (PyObject *) 0 ;
51324 void *argp1 = 0 ;
51325 int res1 = 0 ;
51326 PyObject * obj0 = 0 ;
51327 PyObject * obj1 = 0 ;
51328 PyObject * obj2 = 0 ;
51329 char * kwnames[] = {
51330 (char *) "self",(char *) "self",(char *) "_class", NULL
51331 };
51332
51333 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51334 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
51335 if (!SWIG_IsOK(res1)) {
51336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
51337 }
51338 arg1 = reinterpret_cast< wxPySizer * >(argp1);
51339 arg2 = obj1;
51340 arg3 = obj2;
51341 {
51342 PyThreadState* __tstate = wxPyBeginAllowThreads();
51343 (arg1)->_setCallbackInfo(arg2,arg3);
51344 wxPyEndAllowThreads(__tstate);
51345 if (PyErr_Occurred()) SWIG_fail;
51346 }
51347 resultobj = SWIG_Py_Void();
51348 return resultobj;
51349 fail:
51350 return NULL;
51351 }
51352
51353
51354 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51355 PyObject *obj;
51356 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51357 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
51358 return SWIG_Py_Void();
51359 }
51360
51361 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51362 return SWIG_Python_InitShadowInstance(args);
51363 }
51364
51365 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51366 PyObject *resultobj = 0;
51367 int arg1 = (int) wxHORIZONTAL ;
51368 wxBoxSizer *result = 0 ;
51369 int val1 ;
51370 int ecode1 = 0 ;
51371 PyObject * obj0 = 0 ;
51372 char * kwnames[] = {
51373 (char *) "orient", NULL
51374 };
51375
51376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
51377 if (obj0) {
51378 ecode1 = SWIG_AsVal_int(obj0, &val1);
51379 if (!SWIG_IsOK(ecode1)) {
51380 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
51381 }
51382 arg1 = static_cast< int >(val1);
51383 }
51384 {
51385 PyThreadState* __tstate = wxPyBeginAllowThreads();
51386 result = (wxBoxSizer *)new wxBoxSizer(arg1);
51387 wxPyEndAllowThreads(__tstate);
51388 if (PyErr_Occurred()) SWIG_fail;
51389 }
51390 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
51391 return resultobj;
51392 fail:
51393 return NULL;
51394 }
51395
51396
51397 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51398 PyObject *resultobj = 0;
51399 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51400 int result;
51401 void *argp1 = 0 ;
51402 int res1 = 0 ;
51403 PyObject *swig_obj[1] ;
51404
51405 if (!args) SWIG_fail;
51406 swig_obj[0] = args;
51407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51408 if (!SWIG_IsOK(res1)) {
51409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51410 }
51411 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51412 {
51413 PyThreadState* __tstate = wxPyBeginAllowThreads();
51414 result = (int)(arg1)->GetOrientation();
51415 wxPyEndAllowThreads(__tstate);
51416 if (PyErr_Occurred()) SWIG_fail;
51417 }
51418 resultobj = SWIG_From_int(static_cast< int >(result));
51419 return resultobj;
51420 fail:
51421 return NULL;
51422 }
51423
51424
51425 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51426 PyObject *resultobj = 0;
51427 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
51428 int arg2 ;
51429 void *argp1 = 0 ;
51430 int res1 = 0 ;
51431 int val2 ;
51432 int ecode2 = 0 ;
51433 PyObject * obj0 = 0 ;
51434 PyObject * obj1 = 0 ;
51435 char * kwnames[] = {
51436 (char *) "self",(char *) "orient", NULL
51437 };
51438
51439 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
51440 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
51441 if (!SWIG_IsOK(res1)) {
51442 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
51443 }
51444 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
51445 ecode2 = SWIG_AsVal_int(obj1, &val2);
51446 if (!SWIG_IsOK(ecode2)) {
51447 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
51448 }
51449 arg2 = static_cast< int >(val2);
51450 {
51451 PyThreadState* __tstate = wxPyBeginAllowThreads();
51452 (arg1)->SetOrientation(arg2);
51453 wxPyEndAllowThreads(__tstate);
51454 if (PyErr_Occurred()) SWIG_fail;
51455 }
51456 resultobj = SWIG_Py_Void();
51457 return resultobj;
51458 fail:
51459 return NULL;
51460 }
51461
51462
51463 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51464 PyObject *obj;
51465 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51466 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
51467 return SWIG_Py_Void();
51468 }
51469
51470 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51471 return SWIG_Python_InitShadowInstance(args);
51472 }
51473
51474 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51475 PyObject *resultobj = 0;
51476 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
51477 int arg2 = (int) wxHORIZONTAL ;
51478 wxStaticBoxSizer *result = 0 ;
51479 void *argp1 = 0 ;
51480 int res1 = 0 ;
51481 int val2 ;
51482 int ecode2 = 0 ;
51483 PyObject * obj0 = 0 ;
51484 PyObject * obj1 = 0 ;
51485 char * kwnames[] = {
51486 (char *) "box",(char *) "orient", NULL
51487 };
51488
51489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
51490 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
51491 if (!SWIG_IsOK(res1)) {
51492 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
51493 }
51494 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
51495 if (obj1) {
51496 ecode2 = SWIG_AsVal_int(obj1, &val2);
51497 if (!SWIG_IsOK(ecode2)) {
51498 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
51499 }
51500 arg2 = static_cast< int >(val2);
51501 }
51502 {
51503 PyThreadState* __tstate = wxPyBeginAllowThreads();
51504 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
51505 wxPyEndAllowThreads(__tstate);
51506 if (PyErr_Occurred()) SWIG_fail;
51507 }
51508 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
51509 return resultobj;
51510 fail:
51511 return NULL;
51512 }
51513
51514
51515 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51516 PyObject *resultobj = 0;
51517 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
51518 wxStaticBox *result = 0 ;
51519 void *argp1 = 0 ;
51520 int res1 = 0 ;
51521 PyObject *swig_obj[1] ;
51522
51523 if (!args) SWIG_fail;
51524 swig_obj[0] = args;
51525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
51526 if (!SWIG_IsOK(res1)) {
51527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
51528 }
51529 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
51530 {
51531 PyThreadState* __tstate = wxPyBeginAllowThreads();
51532 result = (wxStaticBox *)(arg1)->GetStaticBox();
51533 wxPyEndAllowThreads(__tstate);
51534 if (PyErr_Occurred()) SWIG_fail;
51535 }
51536 {
51537 resultobj = wxPyMake_wxObject(result, (bool)0);
51538 }
51539 return resultobj;
51540 fail:
51541 return NULL;
51542 }
51543
51544
51545 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51546 PyObject *obj;
51547 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51548 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
51549 return SWIG_Py_Void();
51550 }
51551
51552 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51553 return SWIG_Python_InitShadowInstance(args);
51554 }
51555
51556 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51557 PyObject *resultobj = 0;
51558 int arg1 = (int) 1 ;
51559 int arg2 = (int) 0 ;
51560 int arg3 = (int) 0 ;
51561 int arg4 = (int) 0 ;
51562 wxGridSizer *result = 0 ;
51563 int val1 ;
51564 int ecode1 = 0 ;
51565 int val2 ;
51566 int ecode2 = 0 ;
51567 int val3 ;
51568 int ecode3 = 0 ;
51569 int val4 ;
51570 int ecode4 = 0 ;
51571 PyObject * obj0 = 0 ;
51572 PyObject * obj1 = 0 ;
51573 PyObject * obj2 = 0 ;
51574 PyObject * obj3 = 0 ;
51575 char * kwnames[] = {
51576 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51577 };
51578
51579 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51580 if (obj0) {
51581 ecode1 = SWIG_AsVal_int(obj0, &val1);
51582 if (!SWIG_IsOK(ecode1)) {
51583 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
51584 }
51585 arg1 = static_cast< int >(val1);
51586 }
51587 if (obj1) {
51588 ecode2 = SWIG_AsVal_int(obj1, &val2);
51589 if (!SWIG_IsOK(ecode2)) {
51590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
51591 }
51592 arg2 = static_cast< int >(val2);
51593 }
51594 if (obj2) {
51595 ecode3 = SWIG_AsVal_int(obj2, &val3);
51596 if (!SWIG_IsOK(ecode3)) {
51597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
51598 }
51599 arg3 = static_cast< int >(val3);
51600 }
51601 if (obj3) {
51602 ecode4 = SWIG_AsVal_int(obj3, &val4);
51603 if (!SWIG_IsOK(ecode4)) {
51604 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
51605 }
51606 arg4 = static_cast< int >(val4);
51607 }
51608 {
51609 PyThreadState* __tstate = wxPyBeginAllowThreads();
51610 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
51611 wxPyEndAllowThreads(__tstate);
51612 if (PyErr_Occurred()) SWIG_fail;
51613 }
51614 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
51615 return resultobj;
51616 fail:
51617 return NULL;
51618 }
51619
51620
51621 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51622 PyObject *resultobj = 0;
51623 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51624 int arg2 ;
51625 void *argp1 = 0 ;
51626 int res1 = 0 ;
51627 int val2 ;
51628 int ecode2 = 0 ;
51629 PyObject * obj0 = 0 ;
51630 PyObject * obj1 = 0 ;
51631 char * kwnames[] = {
51632 (char *) "self",(char *) "cols", NULL
51633 };
51634
51635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
51636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51637 if (!SWIG_IsOK(res1)) {
51638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51639 }
51640 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51641 ecode2 = SWIG_AsVal_int(obj1, &val2);
51642 if (!SWIG_IsOK(ecode2)) {
51643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
51644 }
51645 arg2 = static_cast< int >(val2);
51646 {
51647 PyThreadState* __tstate = wxPyBeginAllowThreads();
51648 (arg1)->SetCols(arg2);
51649 wxPyEndAllowThreads(__tstate);
51650 if (PyErr_Occurred()) SWIG_fail;
51651 }
51652 resultobj = SWIG_Py_Void();
51653 return resultobj;
51654 fail:
51655 return NULL;
51656 }
51657
51658
51659 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51660 PyObject *resultobj = 0;
51661 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51662 int arg2 ;
51663 void *argp1 = 0 ;
51664 int res1 = 0 ;
51665 int val2 ;
51666 int ecode2 = 0 ;
51667 PyObject * obj0 = 0 ;
51668 PyObject * obj1 = 0 ;
51669 char * kwnames[] = {
51670 (char *) "self",(char *) "rows", NULL
51671 };
51672
51673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
51674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51675 if (!SWIG_IsOK(res1)) {
51676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51677 }
51678 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51679 ecode2 = SWIG_AsVal_int(obj1, &val2);
51680 if (!SWIG_IsOK(ecode2)) {
51681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
51682 }
51683 arg2 = static_cast< int >(val2);
51684 {
51685 PyThreadState* __tstate = wxPyBeginAllowThreads();
51686 (arg1)->SetRows(arg2);
51687 wxPyEndAllowThreads(__tstate);
51688 if (PyErr_Occurred()) SWIG_fail;
51689 }
51690 resultobj = SWIG_Py_Void();
51691 return resultobj;
51692 fail:
51693 return NULL;
51694 }
51695
51696
51697 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51698 PyObject *resultobj = 0;
51699 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51700 int arg2 ;
51701 void *argp1 = 0 ;
51702 int res1 = 0 ;
51703 int val2 ;
51704 int ecode2 = 0 ;
51705 PyObject * obj0 = 0 ;
51706 PyObject * obj1 = 0 ;
51707 char * kwnames[] = {
51708 (char *) "self",(char *) "gap", NULL
51709 };
51710
51711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
51712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51713 if (!SWIG_IsOK(res1)) {
51714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51715 }
51716 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51717 ecode2 = SWIG_AsVal_int(obj1, &val2);
51718 if (!SWIG_IsOK(ecode2)) {
51719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
51720 }
51721 arg2 = static_cast< int >(val2);
51722 {
51723 PyThreadState* __tstate = wxPyBeginAllowThreads();
51724 (arg1)->SetVGap(arg2);
51725 wxPyEndAllowThreads(__tstate);
51726 if (PyErr_Occurred()) SWIG_fail;
51727 }
51728 resultobj = SWIG_Py_Void();
51729 return resultobj;
51730 fail:
51731 return NULL;
51732 }
51733
51734
51735 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51736 PyObject *resultobj = 0;
51737 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51738 int arg2 ;
51739 void *argp1 = 0 ;
51740 int res1 = 0 ;
51741 int val2 ;
51742 int ecode2 = 0 ;
51743 PyObject * obj0 = 0 ;
51744 PyObject * obj1 = 0 ;
51745 char * kwnames[] = {
51746 (char *) "self",(char *) "gap", NULL
51747 };
51748
51749 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
51750 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51751 if (!SWIG_IsOK(res1)) {
51752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51753 }
51754 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51755 ecode2 = SWIG_AsVal_int(obj1, &val2);
51756 if (!SWIG_IsOK(ecode2)) {
51757 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
51758 }
51759 arg2 = static_cast< int >(val2);
51760 {
51761 PyThreadState* __tstate = wxPyBeginAllowThreads();
51762 (arg1)->SetHGap(arg2);
51763 wxPyEndAllowThreads(__tstate);
51764 if (PyErr_Occurred()) SWIG_fail;
51765 }
51766 resultobj = SWIG_Py_Void();
51767 return resultobj;
51768 fail:
51769 return NULL;
51770 }
51771
51772
51773 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51774 PyObject *resultobj = 0;
51775 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51776 int result;
51777 void *argp1 = 0 ;
51778 int res1 = 0 ;
51779 PyObject *swig_obj[1] ;
51780
51781 if (!args) SWIG_fail;
51782 swig_obj[0] = args;
51783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51784 if (!SWIG_IsOK(res1)) {
51785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51786 }
51787 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51788 {
51789 PyThreadState* __tstate = wxPyBeginAllowThreads();
51790 result = (int)(arg1)->GetCols();
51791 wxPyEndAllowThreads(__tstate);
51792 if (PyErr_Occurred()) SWIG_fail;
51793 }
51794 resultobj = SWIG_From_int(static_cast< int >(result));
51795 return resultobj;
51796 fail:
51797 return NULL;
51798 }
51799
51800
51801 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51802 PyObject *resultobj = 0;
51803 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51804 int result;
51805 void *argp1 = 0 ;
51806 int res1 = 0 ;
51807 PyObject *swig_obj[1] ;
51808
51809 if (!args) SWIG_fail;
51810 swig_obj[0] = args;
51811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51812 if (!SWIG_IsOK(res1)) {
51813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51814 }
51815 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51816 {
51817 PyThreadState* __tstate = wxPyBeginAllowThreads();
51818 result = (int)(arg1)->GetRows();
51819 wxPyEndAllowThreads(__tstate);
51820 if (PyErr_Occurred()) SWIG_fail;
51821 }
51822 resultobj = SWIG_From_int(static_cast< int >(result));
51823 return resultobj;
51824 fail:
51825 return NULL;
51826 }
51827
51828
51829 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51830 PyObject *resultobj = 0;
51831 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51832 int result;
51833 void *argp1 = 0 ;
51834 int res1 = 0 ;
51835 PyObject *swig_obj[1] ;
51836
51837 if (!args) SWIG_fail;
51838 swig_obj[0] = args;
51839 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51840 if (!SWIG_IsOK(res1)) {
51841 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51842 }
51843 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51844 {
51845 PyThreadState* __tstate = wxPyBeginAllowThreads();
51846 result = (int)(arg1)->GetVGap();
51847 wxPyEndAllowThreads(__tstate);
51848 if (PyErr_Occurred()) SWIG_fail;
51849 }
51850 resultobj = SWIG_From_int(static_cast< int >(result));
51851 return resultobj;
51852 fail:
51853 return NULL;
51854 }
51855
51856
51857 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51858 PyObject *resultobj = 0;
51859 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
51860 int result;
51861 void *argp1 = 0 ;
51862 int res1 = 0 ;
51863 PyObject *swig_obj[1] ;
51864
51865 if (!args) SWIG_fail;
51866 swig_obj[0] = args;
51867 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
51868 if (!SWIG_IsOK(res1)) {
51869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
51870 }
51871 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
51872 {
51873 PyThreadState* __tstate = wxPyBeginAllowThreads();
51874 result = (int)(arg1)->GetHGap();
51875 wxPyEndAllowThreads(__tstate);
51876 if (PyErr_Occurred()) SWIG_fail;
51877 }
51878 resultobj = SWIG_From_int(static_cast< int >(result));
51879 return resultobj;
51880 fail:
51881 return NULL;
51882 }
51883
51884
51885 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51886 PyObject *obj;
51887 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51888 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
51889 return SWIG_Py_Void();
51890 }
51891
51892 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51893 return SWIG_Python_InitShadowInstance(args);
51894 }
51895
51896 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51897 PyObject *resultobj = 0;
51898 int arg1 = (int) 1 ;
51899 int arg2 = (int) 0 ;
51900 int arg3 = (int) 0 ;
51901 int arg4 = (int) 0 ;
51902 wxFlexGridSizer *result = 0 ;
51903 int val1 ;
51904 int ecode1 = 0 ;
51905 int val2 ;
51906 int ecode2 = 0 ;
51907 int val3 ;
51908 int ecode3 = 0 ;
51909 int val4 ;
51910 int ecode4 = 0 ;
51911 PyObject * obj0 = 0 ;
51912 PyObject * obj1 = 0 ;
51913 PyObject * obj2 = 0 ;
51914 PyObject * obj3 = 0 ;
51915 char * kwnames[] = {
51916 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
51917 };
51918
51919 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51920 if (obj0) {
51921 ecode1 = SWIG_AsVal_int(obj0, &val1);
51922 if (!SWIG_IsOK(ecode1)) {
51923 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
51924 }
51925 arg1 = static_cast< int >(val1);
51926 }
51927 if (obj1) {
51928 ecode2 = SWIG_AsVal_int(obj1, &val2);
51929 if (!SWIG_IsOK(ecode2)) {
51930 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
51931 }
51932 arg2 = static_cast< int >(val2);
51933 }
51934 if (obj2) {
51935 ecode3 = SWIG_AsVal_int(obj2, &val3);
51936 if (!SWIG_IsOK(ecode3)) {
51937 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
51938 }
51939 arg3 = static_cast< int >(val3);
51940 }
51941 if (obj3) {
51942 ecode4 = SWIG_AsVal_int(obj3, &val4);
51943 if (!SWIG_IsOK(ecode4)) {
51944 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
51945 }
51946 arg4 = static_cast< int >(val4);
51947 }
51948 {
51949 PyThreadState* __tstate = wxPyBeginAllowThreads();
51950 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
51951 wxPyEndAllowThreads(__tstate);
51952 if (PyErr_Occurred()) SWIG_fail;
51953 }
51954 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
51955 return resultobj;
51956 fail:
51957 return NULL;
51958 }
51959
51960
51961 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51962 PyObject *resultobj = 0;
51963 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
51964 size_t arg2 ;
51965 int arg3 = (int) 0 ;
51966 void *argp1 = 0 ;
51967 int res1 = 0 ;
51968 size_t val2 ;
51969 int ecode2 = 0 ;
51970 int val3 ;
51971 int ecode3 = 0 ;
51972 PyObject * obj0 = 0 ;
51973 PyObject * obj1 = 0 ;
51974 PyObject * obj2 = 0 ;
51975 char * kwnames[] = {
51976 (char *) "self",(char *) "idx",(char *) "proportion", NULL
51977 };
51978
51979 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51980 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
51981 if (!SWIG_IsOK(res1)) {
51982 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
51983 }
51984 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
51985 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
51986 if (!SWIG_IsOK(ecode2)) {
51987 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
51988 }
51989 arg2 = static_cast< size_t >(val2);
51990 if (obj2) {
51991 ecode3 = SWIG_AsVal_int(obj2, &val3);
51992 if (!SWIG_IsOK(ecode3)) {
51993 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
51994 }
51995 arg3 = static_cast< int >(val3);
51996 }
51997 {
51998 PyThreadState* __tstate = wxPyBeginAllowThreads();
51999 (arg1)->AddGrowableRow(arg2,arg3);
52000 wxPyEndAllowThreads(__tstate);
52001 if (PyErr_Occurred()) SWIG_fail;
52002 }
52003 resultobj = SWIG_Py_Void();
52004 return resultobj;
52005 fail:
52006 return NULL;
52007 }
52008
52009
52010 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52011 PyObject *resultobj = 0;
52012 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52013 size_t arg2 ;
52014 void *argp1 = 0 ;
52015 int res1 = 0 ;
52016 size_t val2 ;
52017 int ecode2 = 0 ;
52018 PyObject * obj0 = 0 ;
52019 PyObject * obj1 = 0 ;
52020 char * kwnames[] = {
52021 (char *) "self",(char *) "idx", NULL
52022 };
52023
52024 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
52025 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52026 if (!SWIG_IsOK(res1)) {
52027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52028 }
52029 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52030 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52031 if (!SWIG_IsOK(ecode2)) {
52032 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
52033 }
52034 arg2 = static_cast< size_t >(val2);
52035 {
52036 PyThreadState* __tstate = wxPyBeginAllowThreads();
52037 (arg1)->RemoveGrowableRow(arg2);
52038 wxPyEndAllowThreads(__tstate);
52039 if (PyErr_Occurred()) SWIG_fail;
52040 }
52041 resultobj = SWIG_Py_Void();
52042 return resultobj;
52043 fail:
52044 return NULL;
52045 }
52046
52047
52048 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52049 PyObject *resultobj = 0;
52050 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52051 size_t arg2 ;
52052 int arg3 = (int) 0 ;
52053 void *argp1 = 0 ;
52054 int res1 = 0 ;
52055 size_t val2 ;
52056 int ecode2 = 0 ;
52057 int val3 ;
52058 int ecode3 = 0 ;
52059 PyObject * obj0 = 0 ;
52060 PyObject * obj1 = 0 ;
52061 PyObject * obj2 = 0 ;
52062 char * kwnames[] = {
52063 (char *) "self",(char *) "idx",(char *) "proportion", NULL
52064 };
52065
52066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52068 if (!SWIG_IsOK(res1)) {
52069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52070 }
52071 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52072 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52073 if (!SWIG_IsOK(ecode2)) {
52074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52075 }
52076 arg2 = static_cast< size_t >(val2);
52077 if (obj2) {
52078 ecode3 = SWIG_AsVal_int(obj2, &val3);
52079 if (!SWIG_IsOK(ecode3)) {
52080 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
52081 }
52082 arg3 = static_cast< int >(val3);
52083 }
52084 {
52085 PyThreadState* __tstate = wxPyBeginAllowThreads();
52086 (arg1)->AddGrowableCol(arg2,arg3);
52087 wxPyEndAllowThreads(__tstate);
52088 if (PyErr_Occurred()) SWIG_fail;
52089 }
52090 resultobj = SWIG_Py_Void();
52091 return resultobj;
52092 fail:
52093 return NULL;
52094 }
52095
52096
52097 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52098 PyObject *resultobj = 0;
52099 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52100 size_t arg2 ;
52101 void *argp1 = 0 ;
52102 int res1 = 0 ;
52103 size_t val2 ;
52104 int ecode2 = 0 ;
52105 PyObject * obj0 = 0 ;
52106 PyObject * obj1 = 0 ;
52107 char * kwnames[] = {
52108 (char *) "self",(char *) "idx", NULL
52109 };
52110
52111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
52112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52113 if (!SWIG_IsOK(res1)) {
52114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52115 }
52116 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52117 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
52118 if (!SWIG_IsOK(ecode2)) {
52119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
52120 }
52121 arg2 = static_cast< size_t >(val2);
52122 {
52123 PyThreadState* __tstate = wxPyBeginAllowThreads();
52124 (arg1)->RemoveGrowableCol(arg2);
52125 wxPyEndAllowThreads(__tstate);
52126 if (PyErr_Occurred()) SWIG_fail;
52127 }
52128 resultobj = SWIG_Py_Void();
52129 return resultobj;
52130 fail:
52131 return NULL;
52132 }
52133
52134
52135 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52136 PyObject *resultobj = 0;
52137 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52138 int arg2 ;
52139 void *argp1 = 0 ;
52140 int res1 = 0 ;
52141 int val2 ;
52142 int ecode2 = 0 ;
52143 PyObject * obj0 = 0 ;
52144 PyObject * obj1 = 0 ;
52145 char * kwnames[] = {
52146 (char *) "self",(char *) "direction", NULL
52147 };
52148
52149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
52150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52151 if (!SWIG_IsOK(res1)) {
52152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52153 }
52154 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52155 ecode2 = SWIG_AsVal_int(obj1, &val2);
52156 if (!SWIG_IsOK(ecode2)) {
52157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
52158 }
52159 arg2 = static_cast< int >(val2);
52160 {
52161 PyThreadState* __tstate = wxPyBeginAllowThreads();
52162 (arg1)->SetFlexibleDirection(arg2);
52163 wxPyEndAllowThreads(__tstate);
52164 if (PyErr_Occurred()) SWIG_fail;
52165 }
52166 resultobj = SWIG_Py_Void();
52167 return resultobj;
52168 fail:
52169 return NULL;
52170 }
52171
52172
52173 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52174 PyObject *resultobj = 0;
52175 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52176 int result;
52177 void *argp1 = 0 ;
52178 int res1 = 0 ;
52179 PyObject *swig_obj[1] ;
52180
52181 if (!args) SWIG_fail;
52182 swig_obj[0] = args;
52183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52184 if (!SWIG_IsOK(res1)) {
52185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52186 }
52187 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52188 {
52189 PyThreadState* __tstate = wxPyBeginAllowThreads();
52190 result = (int)(arg1)->GetFlexibleDirection();
52191 wxPyEndAllowThreads(__tstate);
52192 if (PyErr_Occurred()) SWIG_fail;
52193 }
52194 resultobj = SWIG_From_int(static_cast< int >(result));
52195 return resultobj;
52196 fail:
52197 return NULL;
52198 }
52199
52200
52201 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52202 PyObject *resultobj = 0;
52203 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52204 wxFlexSizerGrowMode arg2 ;
52205 void *argp1 = 0 ;
52206 int res1 = 0 ;
52207 int val2 ;
52208 int ecode2 = 0 ;
52209 PyObject * obj0 = 0 ;
52210 PyObject * obj1 = 0 ;
52211 char * kwnames[] = {
52212 (char *) "self",(char *) "mode", NULL
52213 };
52214
52215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
52216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52217 if (!SWIG_IsOK(res1)) {
52218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52219 }
52220 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52221 ecode2 = SWIG_AsVal_int(obj1, &val2);
52222 if (!SWIG_IsOK(ecode2)) {
52223 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
52224 }
52225 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
52226 {
52227 PyThreadState* __tstate = wxPyBeginAllowThreads();
52228 (arg1)->SetNonFlexibleGrowMode(arg2);
52229 wxPyEndAllowThreads(__tstate);
52230 if (PyErr_Occurred()) SWIG_fail;
52231 }
52232 resultobj = SWIG_Py_Void();
52233 return resultobj;
52234 fail:
52235 return NULL;
52236 }
52237
52238
52239 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52240 PyObject *resultobj = 0;
52241 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52242 wxFlexSizerGrowMode result;
52243 void *argp1 = 0 ;
52244 int res1 = 0 ;
52245 PyObject *swig_obj[1] ;
52246
52247 if (!args) SWIG_fail;
52248 swig_obj[0] = args;
52249 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52250 if (!SWIG_IsOK(res1)) {
52251 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
52252 }
52253 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52254 {
52255 PyThreadState* __tstate = wxPyBeginAllowThreads();
52256 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
52257 wxPyEndAllowThreads(__tstate);
52258 if (PyErr_Occurred()) SWIG_fail;
52259 }
52260 resultobj = SWIG_From_int(static_cast< int >(result));
52261 return resultobj;
52262 fail:
52263 return NULL;
52264 }
52265
52266
52267 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52268 PyObject *resultobj = 0;
52269 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52270 wxArrayInt *result = 0 ;
52271 void *argp1 = 0 ;
52272 int res1 = 0 ;
52273 PyObject *swig_obj[1] ;
52274
52275 if (!args) SWIG_fail;
52276 swig_obj[0] = args;
52277 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52278 if (!SWIG_IsOK(res1)) {
52279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52280 }
52281 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52282 {
52283 PyThreadState* __tstate = wxPyBeginAllowThreads();
52284 {
52285 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
52286 result = (wxArrayInt *) &_result_ref;
52287 }
52288 wxPyEndAllowThreads(__tstate);
52289 if (PyErr_Occurred()) SWIG_fail;
52290 }
52291 {
52292 resultobj = wxArrayInt2PyList_helper(*result);
52293 }
52294 return resultobj;
52295 fail:
52296 return NULL;
52297 }
52298
52299
52300 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52301 PyObject *resultobj = 0;
52302 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
52303 wxArrayInt *result = 0 ;
52304 void *argp1 = 0 ;
52305 int res1 = 0 ;
52306 PyObject *swig_obj[1] ;
52307
52308 if (!args) SWIG_fail;
52309 swig_obj[0] = args;
52310 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
52311 if (!SWIG_IsOK(res1)) {
52312 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
52313 }
52314 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
52315 {
52316 PyThreadState* __tstate = wxPyBeginAllowThreads();
52317 {
52318 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
52319 result = (wxArrayInt *) &_result_ref;
52320 }
52321 wxPyEndAllowThreads(__tstate);
52322 if (PyErr_Occurred()) SWIG_fail;
52323 }
52324 {
52325 resultobj = wxArrayInt2PyList_helper(*result);
52326 }
52327 return resultobj;
52328 fail:
52329 return NULL;
52330 }
52331
52332
52333 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52334 PyObject *obj;
52335 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52336 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
52337 return SWIG_Py_Void();
52338 }
52339
52340 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52341 return SWIG_Python_InitShadowInstance(args);
52342 }
52343
52344 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52345 PyObject *resultobj = 0;
52346 wxStdDialogButtonSizer *result = 0 ;
52347
52348 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
52349 {
52350 PyThreadState* __tstate = wxPyBeginAllowThreads();
52351 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
52352 wxPyEndAllowThreads(__tstate);
52353 if (PyErr_Occurred()) SWIG_fail;
52354 }
52355 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
52356 return resultobj;
52357 fail:
52358 return NULL;
52359 }
52360
52361
52362 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52363 PyObject *resultobj = 0;
52364 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52365 wxButton *arg2 = (wxButton *) 0 ;
52366 void *argp1 = 0 ;
52367 int res1 = 0 ;
52368 void *argp2 = 0 ;
52369 int res2 = 0 ;
52370 PyObject * obj0 = 0 ;
52371 PyObject * obj1 = 0 ;
52372 char * kwnames[] = {
52373 (char *) "self",(char *) "button", NULL
52374 };
52375
52376 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
52377 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52378 if (!SWIG_IsOK(res1)) {
52379 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52380 }
52381 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52382 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52383 if (!SWIG_IsOK(res2)) {
52384 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
52385 }
52386 arg2 = reinterpret_cast< wxButton * >(argp2);
52387 {
52388 PyThreadState* __tstate = wxPyBeginAllowThreads();
52389 (arg1)->AddButton(arg2);
52390 wxPyEndAllowThreads(__tstate);
52391 if (PyErr_Occurred()) SWIG_fail;
52392 }
52393 resultobj = SWIG_Py_Void();
52394 return resultobj;
52395 fail:
52396 return NULL;
52397 }
52398
52399
52400 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52401 PyObject *resultobj = 0;
52402 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52403 void *argp1 = 0 ;
52404 int res1 = 0 ;
52405 PyObject *swig_obj[1] ;
52406
52407 if (!args) SWIG_fail;
52408 swig_obj[0] = args;
52409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52410 if (!SWIG_IsOK(res1)) {
52411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52412 }
52413 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52414 {
52415 PyThreadState* __tstate = wxPyBeginAllowThreads();
52416 (arg1)->Realize();
52417 wxPyEndAllowThreads(__tstate);
52418 if (PyErr_Occurred()) SWIG_fail;
52419 }
52420 resultobj = SWIG_Py_Void();
52421 return resultobj;
52422 fail:
52423 return NULL;
52424 }
52425
52426
52427 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52428 PyObject *resultobj = 0;
52429 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52430 wxButton *arg2 = (wxButton *) 0 ;
52431 void *argp1 = 0 ;
52432 int res1 = 0 ;
52433 void *argp2 = 0 ;
52434 int res2 = 0 ;
52435 PyObject * obj0 = 0 ;
52436 PyObject * obj1 = 0 ;
52437 char * kwnames[] = {
52438 (char *) "self",(char *) "button", NULL
52439 };
52440
52441 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52442 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52443 if (!SWIG_IsOK(res1)) {
52444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52445 }
52446 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52447 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52448 if (!SWIG_IsOK(res2)) {
52449 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52450 }
52451 arg2 = reinterpret_cast< wxButton * >(argp2);
52452 {
52453 PyThreadState* __tstate = wxPyBeginAllowThreads();
52454 (arg1)->SetAffirmativeButton(arg2);
52455 wxPyEndAllowThreads(__tstate);
52456 if (PyErr_Occurred()) SWIG_fail;
52457 }
52458 resultobj = SWIG_Py_Void();
52459 return resultobj;
52460 fail:
52461 return NULL;
52462 }
52463
52464
52465 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52466 PyObject *resultobj = 0;
52467 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52468 wxButton *arg2 = (wxButton *) 0 ;
52469 void *argp1 = 0 ;
52470 int res1 = 0 ;
52471 void *argp2 = 0 ;
52472 int res2 = 0 ;
52473 PyObject * obj0 = 0 ;
52474 PyObject * obj1 = 0 ;
52475 char * kwnames[] = {
52476 (char *) "self",(char *) "button", NULL
52477 };
52478
52479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
52480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52481 if (!SWIG_IsOK(res1)) {
52482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52483 }
52484 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52485 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52486 if (!SWIG_IsOK(res2)) {
52487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
52488 }
52489 arg2 = reinterpret_cast< wxButton * >(argp2);
52490 {
52491 PyThreadState* __tstate = wxPyBeginAllowThreads();
52492 (arg1)->SetNegativeButton(arg2);
52493 wxPyEndAllowThreads(__tstate);
52494 if (PyErr_Occurred()) SWIG_fail;
52495 }
52496 resultobj = SWIG_Py_Void();
52497 return resultobj;
52498 fail:
52499 return NULL;
52500 }
52501
52502
52503 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52504 PyObject *resultobj = 0;
52505 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52506 wxButton *arg2 = (wxButton *) 0 ;
52507 void *argp1 = 0 ;
52508 int res1 = 0 ;
52509 void *argp2 = 0 ;
52510 int res2 = 0 ;
52511 PyObject * obj0 = 0 ;
52512 PyObject * obj1 = 0 ;
52513 char * kwnames[] = {
52514 (char *) "self",(char *) "button", NULL
52515 };
52516
52517 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
52518 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52519 if (!SWIG_IsOK(res1)) {
52520 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
52521 }
52522 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52523 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
52524 if (!SWIG_IsOK(res2)) {
52525 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
52526 }
52527 arg2 = reinterpret_cast< wxButton * >(argp2);
52528 {
52529 PyThreadState* __tstate = wxPyBeginAllowThreads();
52530 (arg1)->SetCancelButton(arg2);
52531 wxPyEndAllowThreads(__tstate);
52532 if (PyErr_Occurred()) SWIG_fail;
52533 }
52534 resultobj = SWIG_Py_Void();
52535 return resultobj;
52536 fail:
52537 return NULL;
52538 }
52539
52540
52541 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52542 PyObject *resultobj = 0;
52543 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52544 wxButton *result = 0 ;
52545 void *argp1 = 0 ;
52546 int res1 = 0 ;
52547 PyObject *swig_obj[1] ;
52548
52549 if (!args) SWIG_fail;
52550 swig_obj[0] = args;
52551 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52552 if (!SWIG_IsOK(res1)) {
52553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52554 }
52555 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52556 {
52557 PyThreadState* __tstate = wxPyBeginAllowThreads();
52558 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
52559 wxPyEndAllowThreads(__tstate);
52560 if (PyErr_Occurred()) SWIG_fail;
52561 }
52562 {
52563 resultobj = wxPyMake_wxObject(result, (bool)0);
52564 }
52565 return resultobj;
52566 fail:
52567 return NULL;
52568 }
52569
52570
52571 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52572 PyObject *resultobj = 0;
52573 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52574 wxButton *result = 0 ;
52575 void *argp1 = 0 ;
52576 int res1 = 0 ;
52577 PyObject *swig_obj[1] ;
52578
52579 if (!args) SWIG_fail;
52580 swig_obj[0] = args;
52581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52582 if (!SWIG_IsOK(res1)) {
52583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52584 }
52585 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52586 {
52587 PyThreadState* __tstate = wxPyBeginAllowThreads();
52588 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
52589 wxPyEndAllowThreads(__tstate);
52590 if (PyErr_Occurred()) SWIG_fail;
52591 }
52592 {
52593 resultobj = wxPyMake_wxObject(result, (bool)0);
52594 }
52595 return resultobj;
52596 fail:
52597 return NULL;
52598 }
52599
52600
52601 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52602 PyObject *resultobj = 0;
52603 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52604 wxButton *result = 0 ;
52605 void *argp1 = 0 ;
52606 int res1 = 0 ;
52607 PyObject *swig_obj[1] ;
52608
52609 if (!args) SWIG_fail;
52610 swig_obj[0] = args;
52611 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52612 if (!SWIG_IsOK(res1)) {
52613 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52614 }
52615 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52616 {
52617 PyThreadState* __tstate = wxPyBeginAllowThreads();
52618 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
52619 wxPyEndAllowThreads(__tstate);
52620 if (PyErr_Occurred()) SWIG_fail;
52621 }
52622 {
52623 resultobj = wxPyMake_wxObject(result, (bool)0);
52624 }
52625 return resultobj;
52626 fail:
52627 return NULL;
52628 }
52629
52630
52631 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52632 PyObject *resultobj = 0;
52633 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52634 wxButton *result = 0 ;
52635 void *argp1 = 0 ;
52636 int res1 = 0 ;
52637 PyObject *swig_obj[1] ;
52638
52639 if (!args) SWIG_fail;
52640 swig_obj[0] = args;
52641 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52642 if (!SWIG_IsOK(res1)) {
52643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52644 }
52645 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52646 {
52647 PyThreadState* __tstate = wxPyBeginAllowThreads();
52648 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
52649 wxPyEndAllowThreads(__tstate);
52650 if (PyErr_Occurred()) SWIG_fail;
52651 }
52652 {
52653 resultobj = wxPyMake_wxObject(result, (bool)0);
52654 }
52655 return resultobj;
52656 fail:
52657 return NULL;
52658 }
52659
52660
52661 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52662 PyObject *resultobj = 0;
52663 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
52664 wxButton *result = 0 ;
52665 void *argp1 = 0 ;
52666 int res1 = 0 ;
52667 PyObject *swig_obj[1] ;
52668
52669 if (!args) SWIG_fail;
52670 swig_obj[0] = args;
52671 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
52672 if (!SWIG_IsOK(res1)) {
52673 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
52674 }
52675 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
52676 {
52677 PyThreadState* __tstate = wxPyBeginAllowThreads();
52678 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
52679 wxPyEndAllowThreads(__tstate);
52680 if (PyErr_Occurred()) SWIG_fail;
52681 }
52682 {
52683 resultobj = wxPyMake_wxObject(result, (bool)0);
52684 }
52685 return resultobj;
52686 fail:
52687 return NULL;
52688 }
52689
52690
52691 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52692 PyObject *obj;
52693 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52694 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
52695 return SWIG_Py_Void();
52696 }
52697
52698 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52699 return SWIG_Python_InitShadowInstance(args);
52700 }
52701
52702 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52703 PyObject *resultobj = 0;
52704 int arg1 = (int) 0 ;
52705 int arg2 = (int) 0 ;
52706 wxGBPosition *result = 0 ;
52707 int val1 ;
52708 int ecode1 = 0 ;
52709 int val2 ;
52710 int ecode2 = 0 ;
52711 PyObject * obj0 = 0 ;
52712 PyObject * obj1 = 0 ;
52713 char * kwnames[] = {
52714 (char *) "row",(char *) "col", NULL
52715 };
52716
52717 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
52718 if (obj0) {
52719 ecode1 = SWIG_AsVal_int(obj0, &val1);
52720 if (!SWIG_IsOK(ecode1)) {
52721 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
52722 }
52723 arg1 = static_cast< int >(val1);
52724 }
52725 if (obj1) {
52726 ecode2 = SWIG_AsVal_int(obj1, &val2);
52727 if (!SWIG_IsOK(ecode2)) {
52728 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
52729 }
52730 arg2 = static_cast< int >(val2);
52731 }
52732 {
52733 PyThreadState* __tstate = wxPyBeginAllowThreads();
52734 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
52735 wxPyEndAllowThreads(__tstate);
52736 if (PyErr_Occurred()) SWIG_fail;
52737 }
52738 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
52739 return resultobj;
52740 fail:
52741 return NULL;
52742 }
52743
52744
52745 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52746 PyObject *resultobj = 0;
52747 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52748 void *argp1 = 0 ;
52749 int res1 = 0 ;
52750 PyObject *swig_obj[1] ;
52751
52752 if (!args) SWIG_fail;
52753 swig_obj[0] = args;
52754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
52755 if (!SWIG_IsOK(res1)) {
52756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52757 }
52758 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52759 {
52760 PyThreadState* __tstate = wxPyBeginAllowThreads();
52761 delete arg1;
52762
52763 wxPyEndAllowThreads(__tstate);
52764 if (PyErr_Occurred()) SWIG_fail;
52765 }
52766 resultobj = SWIG_Py_Void();
52767 return resultobj;
52768 fail:
52769 return NULL;
52770 }
52771
52772
52773 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52774 PyObject *resultobj = 0;
52775 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52776 int result;
52777 void *argp1 = 0 ;
52778 int res1 = 0 ;
52779 PyObject *swig_obj[1] ;
52780
52781 if (!args) SWIG_fail;
52782 swig_obj[0] = args;
52783 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52784 if (!SWIG_IsOK(res1)) {
52785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52786 }
52787 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52788 {
52789 PyThreadState* __tstate = wxPyBeginAllowThreads();
52790 result = (int)((wxGBPosition const *)arg1)->GetRow();
52791 wxPyEndAllowThreads(__tstate);
52792 if (PyErr_Occurred()) SWIG_fail;
52793 }
52794 resultobj = SWIG_From_int(static_cast< int >(result));
52795 return resultobj;
52796 fail:
52797 return NULL;
52798 }
52799
52800
52801 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52802 PyObject *resultobj = 0;
52803 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52804 int result;
52805 void *argp1 = 0 ;
52806 int res1 = 0 ;
52807 PyObject *swig_obj[1] ;
52808
52809 if (!args) SWIG_fail;
52810 swig_obj[0] = args;
52811 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52812 if (!SWIG_IsOK(res1)) {
52813 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
52814 }
52815 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52816 {
52817 PyThreadState* __tstate = wxPyBeginAllowThreads();
52818 result = (int)((wxGBPosition const *)arg1)->GetCol();
52819 wxPyEndAllowThreads(__tstate);
52820 if (PyErr_Occurred()) SWIG_fail;
52821 }
52822 resultobj = SWIG_From_int(static_cast< int >(result));
52823 return resultobj;
52824 fail:
52825 return NULL;
52826 }
52827
52828
52829 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52830 PyObject *resultobj = 0;
52831 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52832 int arg2 ;
52833 void *argp1 = 0 ;
52834 int res1 = 0 ;
52835 int val2 ;
52836 int ecode2 = 0 ;
52837 PyObject * obj0 = 0 ;
52838 PyObject * obj1 = 0 ;
52839 char * kwnames[] = {
52840 (char *) "self",(char *) "row", NULL
52841 };
52842
52843 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
52844 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52845 if (!SWIG_IsOK(res1)) {
52846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52847 }
52848 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52849 ecode2 = SWIG_AsVal_int(obj1, &val2);
52850 if (!SWIG_IsOK(ecode2)) {
52851 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
52852 }
52853 arg2 = static_cast< int >(val2);
52854 {
52855 PyThreadState* __tstate = wxPyBeginAllowThreads();
52856 (arg1)->SetRow(arg2);
52857 wxPyEndAllowThreads(__tstate);
52858 if (PyErr_Occurred()) SWIG_fail;
52859 }
52860 resultobj = SWIG_Py_Void();
52861 return resultobj;
52862 fail:
52863 return NULL;
52864 }
52865
52866
52867 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52868 PyObject *resultobj = 0;
52869 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52870 int arg2 ;
52871 void *argp1 = 0 ;
52872 int res1 = 0 ;
52873 int val2 ;
52874 int ecode2 = 0 ;
52875 PyObject * obj0 = 0 ;
52876 PyObject * obj1 = 0 ;
52877 char * kwnames[] = {
52878 (char *) "self",(char *) "col", NULL
52879 };
52880
52881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
52882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52883 if (!SWIG_IsOK(res1)) {
52884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52885 }
52886 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52887 ecode2 = SWIG_AsVal_int(obj1, &val2);
52888 if (!SWIG_IsOK(ecode2)) {
52889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
52890 }
52891 arg2 = static_cast< int >(val2);
52892 {
52893 PyThreadState* __tstate = wxPyBeginAllowThreads();
52894 (arg1)->SetCol(arg2);
52895 wxPyEndAllowThreads(__tstate);
52896 if (PyErr_Occurred()) SWIG_fail;
52897 }
52898 resultobj = SWIG_Py_Void();
52899 return resultobj;
52900 fail:
52901 return NULL;
52902 }
52903
52904
52905 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52906 PyObject *resultobj = 0;
52907 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52908 PyObject *arg2 = (PyObject *) 0 ;
52909 bool result;
52910 void *argp1 = 0 ;
52911 int res1 = 0 ;
52912 PyObject * obj0 = 0 ;
52913 PyObject * obj1 = 0 ;
52914 char * kwnames[] = {
52915 (char *) "self",(char *) "other", NULL
52916 };
52917
52918 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
52919 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52920 if (!SWIG_IsOK(res1)) {
52921 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52922 }
52923 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52924 arg2 = obj1;
52925 {
52926 result = (bool)wxGBPosition___eq__(arg1,arg2);
52927 if (PyErr_Occurred()) SWIG_fail;
52928 }
52929 {
52930 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52931 }
52932 return resultobj;
52933 fail:
52934 return NULL;
52935 }
52936
52937
52938 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52939 PyObject *resultobj = 0;
52940 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52941 PyObject *arg2 = (PyObject *) 0 ;
52942 bool result;
52943 void *argp1 = 0 ;
52944 int res1 = 0 ;
52945 PyObject * obj0 = 0 ;
52946 PyObject * obj1 = 0 ;
52947 char * kwnames[] = {
52948 (char *) "self",(char *) "other", NULL
52949 };
52950
52951 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
52952 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52953 if (!SWIG_IsOK(res1)) {
52954 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52955 }
52956 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52957 arg2 = obj1;
52958 {
52959 result = (bool)wxGBPosition___ne__(arg1,arg2);
52960 if (PyErr_Occurred()) SWIG_fail;
52961 }
52962 {
52963 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52964 }
52965 return resultobj;
52966 fail:
52967 return NULL;
52968 }
52969
52970
52971 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52972 PyObject *resultobj = 0;
52973 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
52974 int arg2 = (int) 0 ;
52975 int arg3 = (int) 0 ;
52976 void *argp1 = 0 ;
52977 int res1 = 0 ;
52978 int val2 ;
52979 int ecode2 = 0 ;
52980 int val3 ;
52981 int ecode3 = 0 ;
52982 PyObject * obj0 = 0 ;
52983 PyObject * obj1 = 0 ;
52984 PyObject * obj2 = 0 ;
52985 char * kwnames[] = {
52986 (char *) "self",(char *) "row",(char *) "col", NULL
52987 };
52988
52989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
52991 if (!SWIG_IsOK(res1)) {
52992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
52993 }
52994 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
52995 if (obj1) {
52996 ecode2 = SWIG_AsVal_int(obj1, &val2);
52997 if (!SWIG_IsOK(ecode2)) {
52998 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
52999 }
53000 arg2 = static_cast< int >(val2);
53001 }
53002 if (obj2) {
53003 ecode3 = SWIG_AsVal_int(obj2, &val3);
53004 if (!SWIG_IsOK(ecode3)) {
53005 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
53006 }
53007 arg3 = static_cast< int >(val3);
53008 }
53009 {
53010 PyThreadState* __tstate = wxPyBeginAllowThreads();
53011 wxGBPosition_Set(arg1,arg2,arg3);
53012 wxPyEndAllowThreads(__tstate);
53013 if (PyErr_Occurred()) SWIG_fail;
53014 }
53015 resultobj = SWIG_Py_Void();
53016 return resultobj;
53017 fail:
53018 return NULL;
53019 }
53020
53021
53022 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53023 PyObject *resultobj = 0;
53024 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
53025 PyObject *result = 0 ;
53026 void *argp1 = 0 ;
53027 int res1 = 0 ;
53028 PyObject *swig_obj[1] ;
53029
53030 if (!args) SWIG_fail;
53031 swig_obj[0] = args;
53032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
53033 if (!SWIG_IsOK(res1)) {
53034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
53035 }
53036 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
53037 {
53038 PyThreadState* __tstate = wxPyBeginAllowThreads();
53039 result = (PyObject *)wxGBPosition_Get(arg1);
53040 wxPyEndAllowThreads(__tstate);
53041 if (PyErr_Occurred()) SWIG_fail;
53042 }
53043 resultobj = result;
53044 return resultobj;
53045 fail:
53046 return NULL;
53047 }
53048
53049
53050 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53051 PyObject *obj;
53052 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53053 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
53054 return SWIG_Py_Void();
53055 }
53056
53057 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53058 return SWIG_Python_InitShadowInstance(args);
53059 }
53060
53061 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53062 PyObject *resultobj = 0;
53063 int arg1 = (int) 1 ;
53064 int arg2 = (int) 1 ;
53065 wxGBSpan *result = 0 ;
53066 int val1 ;
53067 int ecode1 = 0 ;
53068 int val2 ;
53069 int ecode2 = 0 ;
53070 PyObject * obj0 = 0 ;
53071 PyObject * obj1 = 0 ;
53072 char * kwnames[] = {
53073 (char *) "rowspan",(char *) "colspan", NULL
53074 };
53075
53076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53077 if (obj0) {
53078 ecode1 = SWIG_AsVal_int(obj0, &val1);
53079 if (!SWIG_IsOK(ecode1)) {
53080 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
53081 }
53082 arg1 = static_cast< int >(val1);
53083 }
53084 if (obj1) {
53085 ecode2 = SWIG_AsVal_int(obj1, &val2);
53086 if (!SWIG_IsOK(ecode2)) {
53087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
53088 }
53089 arg2 = static_cast< int >(val2);
53090 }
53091 {
53092 PyThreadState* __tstate = wxPyBeginAllowThreads();
53093 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
53094 wxPyEndAllowThreads(__tstate);
53095 if (PyErr_Occurred()) SWIG_fail;
53096 }
53097 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
53098 return resultobj;
53099 fail:
53100 return NULL;
53101 }
53102
53103
53104 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53105 PyObject *resultobj = 0;
53106 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53107 void *argp1 = 0 ;
53108 int res1 = 0 ;
53109 PyObject *swig_obj[1] ;
53110
53111 if (!args) SWIG_fail;
53112 swig_obj[0] = args;
53113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
53114 if (!SWIG_IsOK(res1)) {
53115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53116 }
53117 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53118 {
53119 PyThreadState* __tstate = wxPyBeginAllowThreads();
53120 delete arg1;
53121
53122 wxPyEndAllowThreads(__tstate);
53123 if (PyErr_Occurred()) SWIG_fail;
53124 }
53125 resultobj = SWIG_Py_Void();
53126 return resultobj;
53127 fail:
53128 return NULL;
53129 }
53130
53131
53132 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53133 PyObject *resultobj = 0;
53134 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53135 int result;
53136 void *argp1 = 0 ;
53137 int res1 = 0 ;
53138 PyObject *swig_obj[1] ;
53139
53140 if (!args) SWIG_fail;
53141 swig_obj[0] = args;
53142 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53143 if (!SWIG_IsOK(res1)) {
53144 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53145 }
53146 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53147 {
53148 PyThreadState* __tstate = wxPyBeginAllowThreads();
53149 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
53150 wxPyEndAllowThreads(__tstate);
53151 if (PyErr_Occurred()) SWIG_fail;
53152 }
53153 resultobj = SWIG_From_int(static_cast< int >(result));
53154 return resultobj;
53155 fail:
53156 return NULL;
53157 }
53158
53159
53160 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53161 PyObject *resultobj = 0;
53162 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53163 int result;
53164 void *argp1 = 0 ;
53165 int res1 = 0 ;
53166 PyObject *swig_obj[1] ;
53167
53168 if (!args) SWIG_fail;
53169 swig_obj[0] = args;
53170 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53171 if (!SWIG_IsOK(res1)) {
53172 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
53173 }
53174 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53175 {
53176 PyThreadState* __tstate = wxPyBeginAllowThreads();
53177 result = (int)((wxGBSpan const *)arg1)->GetColspan();
53178 wxPyEndAllowThreads(__tstate);
53179 if (PyErr_Occurred()) SWIG_fail;
53180 }
53181 resultobj = SWIG_From_int(static_cast< int >(result));
53182 return resultobj;
53183 fail:
53184 return NULL;
53185 }
53186
53187
53188 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53189 PyObject *resultobj = 0;
53190 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53191 int arg2 ;
53192 void *argp1 = 0 ;
53193 int res1 = 0 ;
53194 int val2 ;
53195 int ecode2 = 0 ;
53196 PyObject * obj0 = 0 ;
53197 PyObject * obj1 = 0 ;
53198 char * kwnames[] = {
53199 (char *) "self",(char *) "rowspan", NULL
53200 };
53201
53202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
53203 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53204 if (!SWIG_IsOK(res1)) {
53205 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53206 }
53207 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53208 ecode2 = SWIG_AsVal_int(obj1, &val2);
53209 if (!SWIG_IsOK(ecode2)) {
53210 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
53211 }
53212 arg2 = static_cast< int >(val2);
53213 {
53214 PyThreadState* __tstate = wxPyBeginAllowThreads();
53215 (arg1)->SetRowspan(arg2);
53216 wxPyEndAllowThreads(__tstate);
53217 if (PyErr_Occurred()) SWIG_fail;
53218 }
53219 resultobj = SWIG_Py_Void();
53220 return resultobj;
53221 fail:
53222 return NULL;
53223 }
53224
53225
53226 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53227 PyObject *resultobj = 0;
53228 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53229 int arg2 ;
53230 void *argp1 = 0 ;
53231 int res1 = 0 ;
53232 int val2 ;
53233 int ecode2 = 0 ;
53234 PyObject * obj0 = 0 ;
53235 PyObject * obj1 = 0 ;
53236 char * kwnames[] = {
53237 (char *) "self",(char *) "colspan", NULL
53238 };
53239
53240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
53241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53242 if (!SWIG_IsOK(res1)) {
53243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53244 }
53245 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53246 ecode2 = SWIG_AsVal_int(obj1, &val2);
53247 if (!SWIG_IsOK(ecode2)) {
53248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
53249 }
53250 arg2 = static_cast< int >(val2);
53251 {
53252 PyThreadState* __tstate = wxPyBeginAllowThreads();
53253 (arg1)->SetColspan(arg2);
53254 wxPyEndAllowThreads(__tstate);
53255 if (PyErr_Occurred()) SWIG_fail;
53256 }
53257 resultobj = SWIG_Py_Void();
53258 return resultobj;
53259 fail:
53260 return NULL;
53261 }
53262
53263
53264 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53265 PyObject *resultobj = 0;
53266 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53267 PyObject *arg2 = (PyObject *) 0 ;
53268 bool result;
53269 void *argp1 = 0 ;
53270 int res1 = 0 ;
53271 PyObject * obj0 = 0 ;
53272 PyObject * obj1 = 0 ;
53273 char * kwnames[] = {
53274 (char *) "self",(char *) "other", NULL
53275 };
53276
53277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
53278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53279 if (!SWIG_IsOK(res1)) {
53280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53281 }
53282 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53283 arg2 = obj1;
53284 {
53285 result = (bool)wxGBSpan___eq__(arg1,arg2);
53286 if (PyErr_Occurred()) SWIG_fail;
53287 }
53288 {
53289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53290 }
53291 return resultobj;
53292 fail:
53293 return NULL;
53294 }
53295
53296
53297 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53298 PyObject *resultobj = 0;
53299 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53300 PyObject *arg2 = (PyObject *) 0 ;
53301 bool result;
53302 void *argp1 = 0 ;
53303 int res1 = 0 ;
53304 PyObject * obj0 = 0 ;
53305 PyObject * obj1 = 0 ;
53306 char * kwnames[] = {
53307 (char *) "self",(char *) "other", NULL
53308 };
53309
53310 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
53311 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53312 if (!SWIG_IsOK(res1)) {
53313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53314 }
53315 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53316 arg2 = obj1;
53317 {
53318 result = (bool)wxGBSpan___ne__(arg1,arg2);
53319 if (PyErr_Occurred()) SWIG_fail;
53320 }
53321 {
53322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53323 }
53324 return resultobj;
53325 fail:
53326 return NULL;
53327 }
53328
53329
53330 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53331 PyObject *resultobj = 0;
53332 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53333 int arg2 = (int) 1 ;
53334 int arg3 = (int) 1 ;
53335 void *argp1 = 0 ;
53336 int res1 = 0 ;
53337 int val2 ;
53338 int ecode2 = 0 ;
53339 int val3 ;
53340 int ecode3 = 0 ;
53341 PyObject * obj0 = 0 ;
53342 PyObject * obj1 = 0 ;
53343 PyObject * obj2 = 0 ;
53344 char * kwnames[] = {
53345 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
53346 };
53347
53348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53350 if (!SWIG_IsOK(res1)) {
53351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53352 }
53353 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53354 if (obj1) {
53355 ecode2 = SWIG_AsVal_int(obj1, &val2);
53356 if (!SWIG_IsOK(ecode2)) {
53357 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
53358 }
53359 arg2 = static_cast< int >(val2);
53360 }
53361 if (obj2) {
53362 ecode3 = SWIG_AsVal_int(obj2, &val3);
53363 if (!SWIG_IsOK(ecode3)) {
53364 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
53365 }
53366 arg3 = static_cast< int >(val3);
53367 }
53368 {
53369 PyThreadState* __tstate = wxPyBeginAllowThreads();
53370 wxGBSpan_Set(arg1,arg2,arg3);
53371 wxPyEndAllowThreads(__tstate);
53372 if (PyErr_Occurred()) SWIG_fail;
53373 }
53374 resultobj = SWIG_Py_Void();
53375 return resultobj;
53376 fail:
53377 return NULL;
53378 }
53379
53380
53381 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53382 PyObject *resultobj = 0;
53383 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
53384 PyObject *result = 0 ;
53385 void *argp1 = 0 ;
53386 int res1 = 0 ;
53387 PyObject *swig_obj[1] ;
53388
53389 if (!args) SWIG_fail;
53390 swig_obj[0] = args;
53391 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
53392 if (!SWIG_IsOK(res1)) {
53393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
53394 }
53395 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
53396 {
53397 PyThreadState* __tstate = wxPyBeginAllowThreads();
53398 result = (PyObject *)wxGBSpan_Get(arg1);
53399 wxPyEndAllowThreads(__tstate);
53400 if (PyErr_Occurred()) SWIG_fail;
53401 }
53402 resultobj = result;
53403 return resultobj;
53404 fail:
53405 return NULL;
53406 }
53407
53408
53409 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53410 PyObject *obj;
53411 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
53412 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
53413 return SWIG_Py_Void();
53414 }
53415
53416 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53417 return SWIG_Python_InitShadowInstance(args);
53418 }
53419
53420 SWIGINTERN int DefaultSpan_set(PyObject *) {
53421 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
53422 return 1;
53423 }
53424
53425
53426 SWIGINTERN PyObject *DefaultSpan_get(void) {
53427 PyObject *pyobj = 0;
53428
53429 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
53430 return pyobj;
53431 }
53432
53433
53434 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53435 PyObject *resultobj = 0;
53436 wxGBSizerItem *result = 0 ;
53437
53438 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
53439 {
53440 PyThreadState* __tstate = wxPyBeginAllowThreads();
53441 result = (wxGBSizerItem *)new wxGBSizerItem();
53442 wxPyEndAllowThreads(__tstate);
53443 if (PyErr_Occurred()) SWIG_fail;
53444 }
53445 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
53446 return resultobj;
53447 fail:
53448 return NULL;
53449 }
53450
53451
53452 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53453 PyObject *resultobj = 0;
53454 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53455 void *argp1 = 0 ;
53456 int res1 = 0 ;
53457 PyObject *swig_obj[1] ;
53458
53459 if (!args) SWIG_fail;
53460 swig_obj[0] = args;
53461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
53462 if (!SWIG_IsOK(res1)) {
53463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53464 }
53465 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53466 {
53467 PyThreadState* __tstate = wxPyBeginAllowThreads();
53468 delete arg1;
53469
53470 wxPyEndAllowThreads(__tstate);
53471 if (PyErr_Occurred()) SWIG_fail;
53472 }
53473 resultobj = SWIG_Py_Void();
53474 return resultobj;
53475 fail:
53476 return NULL;
53477 }
53478
53479
53480 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53481 PyObject *resultobj = 0;
53482 wxWindow *arg1 = (wxWindow *) 0 ;
53483 wxGBPosition *arg2 = 0 ;
53484 wxGBSpan *arg3 = 0 ;
53485 int arg4 ;
53486 int arg5 ;
53487 PyObject *arg6 = (PyObject *) NULL ;
53488 wxGBSizerItem *result = 0 ;
53489 void *argp1 = 0 ;
53490 int res1 = 0 ;
53491 wxGBPosition temp2 ;
53492 wxGBSpan temp3 ;
53493 int val4 ;
53494 int ecode4 = 0 ;
53495 int val5 ;
53496 int ecode5 = 0 ;
53497 PyObject * obj0 = 0 ;
53498 PyObject * obj1 = 0 ;
53499 PyObject * obj2 = 0 ;
53500 PyObject * obj3 = 0 ;
53501 PyObject * obj4 = 0 ;
53502 PyObject * obj5 = 0 ;
53503 char * kwnames[] = {
53504 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53505 };
53506
53507 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53508 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
53509 if (!SWIG_IsOK(res1)) {
53510 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
53511 }
53512 arg1 = reinterpret_cast< wxWindow * >(argp1);
53513 {
53514 arg2 = &temp2;
53515 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53516 }
53517 {
53518 arg3 = &temp3;
53519 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53520 }
53521 ecode4 = SWIG_AsVal_int(obj3, &val4);
53522 if (!SWIG_IsOK(ecode4)) {
53523 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
53524 }
53525 arg4 = static_cast< int >(val4);
53526 ecode5 = SWIG_AsVal_int(obj4, &val5);
53527 if (!SWIG_IsOK(ecode5)) {
53528 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
53529 }
53530 arg5 = static_cast< int >(val5);
53531 if (obj5) {
53532 arg6 = obj5;
53533 }
53534 {
53535 PyThreadState* __tstate = wxPyBeginAllowThreads();
53536 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53537 wxPyEndAllowThreads(__tstate);
53538 if (PyErr_Occurred()) SWIG_fail;
53539 }
53540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53541 return resultobj;
53542 fail:
53543 return NULL;
53544 }
53545
53546
53547 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53548 PyObject *resultobj = 0;
53549 wxSizer *arg1 = (wxSizer *) 0 ;
53550 wxGBPosition *arg2 = 0 ;
53551 wxGBSpan *arg3 = 0 ;
53552 int arg4 ;
53553 int arg5 ;
53554 PyObject *arg6 = (PyObject *) NULL ;
53555 wxGBSizerItem *result = 0 ;
53556 int res1 = 0 ;
53557 wxGBPosition temp2 ;
53558 wxGBSpan temp3 ;
53559 int val4 ;
53560 int ecode4 = 0 ;
53561 int val5 ;
53562 int ecode5 = 0 ;
53563 PyObject * obj0 = 0 ;
53564 PyObject * obj1 = 0 ;
53565 PyObject * obj2 = 0 ;
53566 PyObject * obj3 = 0 ;
53567 PyObject * obj4 = 0 ;
53568 PyObject * obj5 = 0 ;
53569 char * kwnames[] = {
53570 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53571 };
53572
53573 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
53574 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
53575 if (!SWIG_IsOK(res1)) {
53576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
53577 }
53578 {
53579 arg2 = &temp2;
53580 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53581 }
53582 {
53583 arg3 = &temp3;
53584 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53585 }
53586 ecode4 = SWIG_AsVal_int(obj3, &val4);
53587 if (!SWIG_IsOK(ecode4)) {
53588 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
53589 }
53590 arg4 = static_cast< int >(val4);
53591 ecode5 = SWIG_AsVal_int(obj4, &val5);
53592 if (!SWIG_IsOK(ecode5)) {
53593 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
53594 }
53595 arg5 = static_cast< int >(val5);
53596 if (obj5) {
53597 arg6 = obj5;
53598 }
53599 {
53600 PyThreadState* __tstate = wxPyBeginAllowThreads();
53601 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
53602 wxPyEndAllowThreads(__tstate);
53603 if (PyErr_Occurred()) SWIG_fail;
53604 }
53605 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53606 return resultobj;
53607 fail:
53608 return NULL;
53609 }
53610
53611
53612 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53613 PyObject *resultobj = 0;
53614 int arg1 ;
53615 int arg2 ;
53616 wxGBPosition *arg3 = 0 ;
53617 wxGBSpan *arg4 = 0 ;
53618 int arg5 ;
53619 int arg6 ;
53620 PyObject *arg7 = (PyObject *) NULL ;
53621 wxGBSizerItem *result = 0 ;
53622 int val1 ;
53623 int ecode1 = 0 ;
53624 int val2 ;
53625 int ecode2 = 0 ;
53626 wxGBPosition temp3 ;
53627 wxGBSpan temp4 ;
53628 int val5 ;
53629 int ecode5 = 0 ;
53630 int val6 ;
53631 int ecode6 = 0 ;
53632 PyObject * obj0 = 0 ;
53633 PyObject * obj1 = 0 ;
53634 PyObject * obj2 = 0 ;
53635 PyObject * obj3 = 0 ;
53636 PyObject * obj4 = 0 ;
53637 PyObject * obj5 = 0 ;
53638 PyObject * obj6 = 0 ;
53639 char * kwnames[] = {
53640 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
53641 };
53642
53643 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
53644 ecode1 = SWIG_AsVal_int(obj0, &val1);
53645 if (!SWIG_IsOK(ecode1)) {
53646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
53647 }
53648 arg1 = static_cast< int >(val1);
53649 ecode2 = SWIG_AsVal_int(obj1, &val2);
53650 if (!SWIG_IsOK(ecode2)) {
53651 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
53652 }
53653 arg2 = static_cast< int >(val2);
53654 {
53655 arg3 = &temp3;
53656 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
53657 }
53658 {
53659 arg4 = &temp4;
53660 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
53661 }
53662 ecode5 = SWIG_AsVal_int(obj4, &val5);
53663 if (!SWIG_IsOK(ecode5)) {
53664 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
53665 }
53666 arg5 = static_cast< int >(val5);
53667 ecode6 = SWIG_AsVal_int(obj5, &val6);
53668 if (!SWIG_IsOK(ecode6)) {
53669 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
53670 }
53671 arg6 = static_cast< int >(val6);
53672 if (obj6) {
53673 arg7 = obj6;
53674 }
53675 {
53676 PyThreadState* __tstate = wxPyBeginAllowThreads();
53677 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
53678 wxPyEndAllowThreads(__tstate);
53679 if (PyErr_Occurred()) SWIG_fail;
53680 }
53681 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
53682 return resultobj;
53683 fail:
53684 return NULL;
53685 }
53686
53687
53688 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53689 PyObject *resultobj = 0;
53690 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53691 wxGBPosition result;
53692 void *argp1 = 0 ;
53693 int res1 = 0 ;
53694 PyObject *swig_obj[1] ;
53695
53696 if (!args) SWIG_fail;
53697 swig_obj[0] = args;
53698 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53699 if (!SWIG_IsOK(res1)) {
53700 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53701 }
53702 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53703 {
53704 PyThreadState* __tstate = wxPyBeginAllowThreads();
53705 result = ((wxGBSizerItem const *)arg1)->GetPos();
53706 wxPyEndAllowThreads(__tstate);
53707 if (PyErr_Occurred()) SWIG_fail;
53708 }
53709 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53710 return resultobj;
53711 fail:
53712 return NULL;
53713 }
53714
53715
53716 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53717 PyObject *resultobj = 0;
53718 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53719 wxGBSpan result;
53720 void *argp1 = 0 ;
53721 int res1 = 0 ;
53722 PyObject *swig_obj[1] ;
53723
53724 if (!args) SWIG_fail;
53725 swig_obj[0] = args;
53726 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53727 if (!SWIG_IsOK(res1)) {
53728 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53729 }
53730 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53731 {
53732 PyThreadState* __tstate = wxPyBeginAllowThreads();
53733 result = ((wxGBSizerItem const *)arg1)->GetSpan();
53734 wxPyEndAllowThreads(__tstate);
53735 if (PyErr_Occurred()) SWIG_fail;
53736 }
53737 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
53738 return resultobj;
53739 fail:
53740 return NULL;
53741 }
53742
53743
53744 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53745 PyObject *resultobj = 0;
53746 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53747 wxGBPosition *arg2 = 0 ;
53748 bool result;
53749 void *argp1 = 0 ;
53750 int res1 = 0 ;
53751 wxGBPosition temp2 ;
53752 PyObject * obj0 = 0 ;
53753 PyObject * obj1 = 0 ;
53754 char * kwnames[] = {
53755 (char *) "self",(char *) "pos", NULL
53756 };
53757
53758 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
53759 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53760 if (!SWIG_IsOK(res1)) {
53761 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53762 }
53763 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53764 {
53765 arg2 = &temp2;
53766 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53767 }
53768 {
53769 PyThreadState* __tstate = wxPyBeginAllowThreads();
53770 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
53771 wxPyEndAllowThreads(__tstate);
53772 if (PyErr_Occurred()) SWIG_fail;
53773 }
53774 {
53775 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53776 }
53777 return resultobj;
53778 fail:
53779 return NULL;
53780 }
53781
53782
53783 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53784 PyObject *resultobj = 0;
53785 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53786 wxGBSpan *arg2 = 0 ;
53787 bool result;
53788 void *argp1 = 0 ;
53789 int res1 = 0 ;
53790 wxGBSpan temp2 ;
53791 PyObject * obj0 = 0 ;
53792 PyObject * obj1 = 0 ;
53793 char * kwnames[] = {
53794 (char *) "self",(char *) "span", NULL
53795 };
53796
53797 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
53798 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53799 if (!SWIG_IsOK(res1)) {
53800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53801 }
53802 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53803 {
53804 arg2 = &temp2;
53805 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
53806 }
53807 {
53808 PyThreadState* __tstate = wxPyBeginAllowThreads();
53809 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
53810 wxPyEndAllowThreads(__tstate);
53811 if (PyErr_Occurred()) SWIG_fail;
53812 }
53813 {
53814 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53815 }
53816 return resultobj;
53817 fail:
53818 return NULL;
53819 }
53820
53821
53822 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53823 PyObject *resultobj = 0;
53824 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53825 wxGBSizerItem *arg2 = 0 ;
53826 bool result;
53827 void *argp1 = 0 ;
53828 int res1 = 0 ;
53829 void *argp2 = 0 ;
53830 int res2 = 0 ;
53831 PyObject * obj0 = 0 ;
53832 PyObject * obj1 = 0 ;
53833 char * kwnames[] = {
53834 (char *) "self",(char *) "other", NULL
53835 };
53836
53837 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
53838 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53839 if (!SWIG_IsOK(res1)) {
53840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53841 }
53842 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53843 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
53844 if (!SWIG_IsOK(res2)) {
53845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53846 }
53847 if (!argp2) {
53848 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
53849 }
53850 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
53851 {
53852 PyThreadState* __tstate = wxPyBeginAllowThreads();
53853 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
53854 wxPyEndAllowThreads(__tstate);
53855 if (PyErr_Occurred()) SWIG_fail;
53856 }
53857 {
53858 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53859 }
53860 return resultobj;
53861 fail:
53862 return NULL;
53863 }
53864
53865
53866 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53867 PyObject *resultobj = 0;
53868 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53869 wxGBPosition *arg2 = 0 ;
53870 wxGBSpan *arg3 = 0 ;
53871 bool result;
53872 void *argp1 = 0 ;
53873 int res1 = 0 ;
53874 wxGBPosition temp2 ;
53875 wxGBSpan temp3 ;
53876 PyObject * obj0 = 0 ;
53877 PyObject * obj1 = 0 ;
53878 PyObject * obj2 = 0 ;
53879 char * kwnames[] = {
53880 (char *) "self",(char *) "pos",(char *) "span", NULL
53881 };
53882
53883 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
53884 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53885 if (!SWIG_IsOK(res1)) {
53886 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53887 }
53888 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53889 {
53890 arg2 = &temp2;
53891 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
53892 }
53893 {
53894 arg3 = &temp3;
53895 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
53896 }
53897 {
53898 PyThreadState* __tstate = wxPyBeginAllowThreads();
53899 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
53900 wxPyEndAllowThreads(__tstate);
53901 if (PyErr_Occurred()) SWIG_fail;
53902 }
53903 {
53904 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
53905 }
53906 return resultobj;
53907 fail:
53908 return NULL;
53909 }
53910
53911
53912 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53913 PyObject *resultobj = 0;
53914 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53915 wxGBPosition result;
53916 void *argp1 = 0 ;
53917 int res1 = 0 ;
53918 PyObject *swig_obj[1] ;
53919
53920 if (!args) SWIG_fail;
53921 swig_obj[0] = args;
53922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53923 if (!SWIG_IsOK(res1)) {
53924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53925 }
53926 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53927 {
53928 PyThreadState* __tstate = wxPyBeginAllowThreads();
53929 result = wxGBSizerItem_GetEndPos(arg1);
53930 wxPyEndAllowThreads(__tstate);
53931 if (PyErr_Occurred()) SWIG_fail;
53932 }
53933 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
53934 return resultobj;
53935 fail:
53936 return NULL;
53937 }
53938
53939
53940 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
53941 PyObject *resultobj = 0;
53942 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53943 wxGridBagSizer *result = 0 ;
53944 void *argp1 = 0 ;
53945 int res1 = 0 ;
53946 PyObject *swig_obj[1] ;
53947
53948 if (!args) SWIG_fail;
53949 swig_obj[0] = args;
53950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53951 if (!SWIG_IsOK(res1)) {
53952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
53953 }
53954 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53955 {
53956 PyThreadState* __tstate = wxPyBeginAllowThreads();
53957 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
53958 wxPyEndAllowThreads(__tstate);
53959 if (PyErr_Occurred()) SWIG_fail;
53960 }
53961 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53962 return resultobj;
53963 fail:
53964 return NULL;
53965 }
53966
53967
53968 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
53969 PyObject *resultobj = 0;
53970 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
53971 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
53972 void *argp1 = 0 ;
53973 int res1 = 0 ;
53974 void *argp2 = 0 ;
53975 int res2 = 0 ;
53976 PyObject * obj0 = 0 ;
53977 PyObject * obj1 = 0 ;
53978 char * kwnames[] = {
53979 (char *) "self",(char *) "sizer", NULL
53980 };
53981
53982 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
53983 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
53984 if (!SWIG_IsOK(res1)) {
53985 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
53986 }
53987 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
53988 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
53989 if (!SWIG_IsOK(res2)) {
53990 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
53991 }
53992 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
53993 {
53994 PyThreadState* __tstate = wxPyBeginAllowThreads();
53995 (arg1)->SetGBSizer(arg2);
53996 wxPyEndAllowThreads(__tstate);
53997 if (PyErr_Occurred()) SWIG_fail;
53998 }
53999 resultobj = SWIG_Py_Void();
54000 return resultobj;
54001 fail:
54002 return NULL;
54003 }
54004
54005
54006 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54007 PyObject *obj;
54008 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
54009 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
54010 return SWIG_Py_Void();
54011 }
54012
54013 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54014 return SWIG_Python_InitShadowInstance(args);
54015 }
54016
54017 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54018 PyObject *resultobj = 0;
54019 int arg1 = (int) 0 ;
54020 int arg2 = (int) 0 ;
54021 wxGridBagSizer *result = 0 ;
54022 int val1 ;
54023 int ecode1 = 0 ;
54024 int val2 ;
54025 int ecode2 = 0 ;
54026 PyObject * obj0 = 0 ;
54027 PyObject * obj1 = 0 ;
54028 char * kwnames[] = {
54029 (char *) "vgap",(char *) "hgap", NULL
54030 };
54031
54032 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
54033 if (obj0) {
54034 ecode1 = SWIG_AsVal_int(obj0, &val1);
54035 if (!SWIG_IsOK(ecode1)) {
54036 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
54037 }
54038 arg1 = static_cast< int >(val1);
54039 }
54040 if (obj1) {
54041 ecode2 = SWIG_AsVal_int(obj1, &val2);
54042 if (!SWIG_IsOK(ecode2)) {
54043 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
54044 }
54045 arg2 = static_cast< int >(val2);
54046 }
54047 {
54048 PyThreadState* __tstate = wxPyBeginAllowThreads();
54049 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
54050 wxPyEndAllowThreads(__tstate);
54051 if (PyErr_Occurred()) SWIG_fail;
54052 }
54053 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
54054 return resultobj;
54055 fail:
54056 return NULL;
54057 }
54058
54059
54060 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54061 PyObject *resultobj = 0;
54062 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54063 PyObject *arg2 = (PyObject *) 0 ;
54064 wxGBPosition *arg3 = 0 ;
54065 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
54066 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
54067 int arg5 = (int) 0 ;
54068 int arg6 = (int) 0 ;
54069 PyObject *arg7 = (PyObject *) NULL ;
54070 wxGBSizerItem *result = 0 ;
54071 void *argp1 = 0 ;
54072 int res1 = 0 ;
54073 wxGBPosition temp3 ;
54074 wxGBSpan temp4 ;
54075 int val5 ;
54076 int ecode5 = 0 ;
54077 int val6 ;
54078 int ecode6 = 0 ;
54079 PyObject * obj0 = 0 ;
54080 PyObject * obj1 = 0 ;
54081 PyObject * obj2 = 0 ;
54082 PyObject * obj3 = 0 ;
54083 PyObject * obj4 = 0 ;
54084 PyObject * obj5 = 0 ;
54085 PyObject * obj6 = 0 ;
54086 char * kwnames[] = {
54087 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
54088 };
54089
54090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
54091 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54092 if (!SWIG_IsOK(res1)) {
54093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54094 }
54095 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54096 arg2 = obj1;
54097 {
54098 arg3 = &temp3;
54099 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
54100 }
54101 if (obj3) {
54102 {
54103 arg4 = &temp4;
54104 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
54105 }
54106 }
54107 if (obj4) {
54108 ecode5 = SWIG_AsVal_int(obj4, &val5);
54109 if (!SWIG_IsOK(ecode5)) {
54110 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
54111 }
54112 arg5 = static_cast< int >(val5);
54113 }
54114 if (obj5) {
54115 ecode6 = SWIG_AsVal_int(obj5, &val6);
54116 if (!SWIG_IsOK(ecode6)) {
54117 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
54118 }
54119 arg6 = static_cast< int >(val6);
54120 }
54121 if (obj6) {
54122 arg7 = obj6;
54123 }
54124 {
54125 PyThreadState* __tstate = wxPyBeginAllowThreads();
54126 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
54127 wxPyEndAllowThreads(__tstate);
54128 if (PyErr_Occurred()) SWIG_fail;
54129 }
54130 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54131 return resultobj;
54132 fail:
54133 return NULL;
54134 }
54135
54136
54137 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54138 PyObject *resultobj = 0;
54139 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54140 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
54141 wxGBSizerItem *result = 0 ;
54142 void *argp1 = 0 ;
54143 int res1 = 0 ;
54144 int res2 = 0 ;
54145 PyObject * obj0 = 0 ;
54146 PyObject * obj1 = 0 ;
54147 char * kwnames[] = {
54148 (char *) "self",(char *) "item", NULL
54149 };
54150
54151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
54152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54153 if (!SWIG_IsOK(res1)) {
54154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54155 }
54156 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54157 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
54158 if (!SWIG_IsOK(res2)) {
54159 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
54160 }
54161 {
54162 PyThreadState* __tstate = wxPyBeginAllowThreads();
54163 result = (wxGBSizerItem *)(arg1)->Add(arg2);
54164 wxPyEndAllowThreads(__tstate);
54165 if (PyErr_Occurred()) SWIG_fail;
54166 }
54167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54168 return resultobj;
54169 fail:
54170 return NULL;
54171 }
54172
54173
54174 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54175 PyObject *resultobj = 0;
54176 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54177 int arg2 ;
54178 int arg3 ;
54179 wxSize result;
54180 void *argp1 = 0 ;
54181 int res1 = 0 ;
54182 int val2 ;
54183 int ecode2 = 0 ;
54184 int val3 ;
54185 int ecode3 = 0 ;
54186 PyObject * obj0 = 0 ;
54187 PyObject * obj1 = 0 ;
54188 PyObject * obj2 = 0 ;
54189 char * kwnames[] = {
54190 (char *) "self",(char *) "row",(char *) "col", NULL
54191 };
54192
54193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
54194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54195 if (!SWIG_IsOK(res1)) {
54196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54197 }
54198 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54199 ecode2 = SWIG_AsVal_int(obj1, &val2);
54200 if (!SWIG_IsOK(ecode2)) {
54201 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
54202 }
54203 arg2 = static_cast< int >(val2);
54204 ecode3 = SWIG_AsVal_int(obj2, &val3);
54205 if (!SWIG_IsOK(ecode3)) {
54206 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
54207 }
54208 arg3 = static_cast< int >(val3);
54209 {
54210 PyThreadState* __tstate = wxPyBeginAllowThreads();
54211 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
54212 wxPyEndAllowThreads(__tstate);
54213 if (PyErr_Occurred()) SWIG_fail;
54214 }
54215 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54216 return resultobj;
54217 fail:
54218 return NULL;
54219 }
54220
54221
54222 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
54223 PyObject *resultobj = 0;
54224 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54225 wxSize result;
54226 void *argp1 = 0 ;
54227 int res1 = 0 ;
54228 PyObject *swig_obj[1] ;
54229
54230 if (!args) SWIG_fail;
54231 swig_obj[0] = args;
54232 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54233 if (!SWIG_IsOK(res1)) {
54234 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
54235 }
54236 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54237 {
54238 PyThreadState* __tstate = wxPyBeginAllowThreads();
54239 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
54240 wxPyEndAllowThreads(__tstate);
54241 if (PyErr_Occurred()) SWIG_fail;
54242 }
54243 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
54244 return resultobj;
54245 fail:
54246 return NULL;
54247 }
54248
54249
54250 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54251 PyObject *resultobj = 0;
54252 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54253 wxSize *arg2 = 0 ;
54254 void *argp1 = 0 ;
54255 int res1 = 0 ;
54256 wxSize temp2 ;
54257 PyObject * obj0 = 0 ;
54258 PyObject * obj1 = 0 ;
54259 char * kwnames[] = {
54260 (char *) "self",(char *) "sz", NULL
54261 };
54262
54263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
54264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54265 if (!SWIG_IsOK(res1)) {
54266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54267 }
54268 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54269 {
54270 arg2 = &temp2;
54271 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
54272 }
54273 {
54274 PyThreadState* __tstate = wxPyBeginAllowThreads();
54275 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
54276 wxPyEndAllowThreads(__tstate);
54277 if (PyErr_Occurred()) SWIG_fail;
54278 }
54279 resultobj = SWIG_Py_Void();
54280 return resultobj;
54281 fail:
54282 return NULL;
54283 }
54284
54285
54286 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54287 PyObject *resultobj = 0;
54288 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54289 wxWindow *arg2 = (wxWindow *) 0 ;
54290 wxGBPosition result;
54291 void *argp1 = 0 ;
54292 int res1 = 0 ;
54293 void *argp2 = 0 ;
54294 int res2 = 0 ;
54295
54296 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54297 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54298 if (!SWIG_IsOK(res1)) {
54299 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54300 }
54301 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54302 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54303 if (!SWIG_IsOK(res2)) {
54304 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54305 }
54306 arg2 = reinterpret_cast< wxWindow * >(argp2);
54307 {
54308 PyThreadState* __tstate = wxPyBeginAllowThreads();
54309 result = (arg1)->GetItemPosition(arg2);
54310 wxPyEndAllowThreads(__tstate);
54311 if (PyErr_Occurred()) SWIG_fail;
54312 }
54313 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54314 return resultobj;
54315 fail:
54316 return NULL;
54317 }
54318
54319
54320 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54321 PyObject *resultobj = 0;
54322 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54323 wxSizer *arg2 = (wxSizer *) 0 ;
54324 wxGBPosition result;
54325 void *argp1 = 0 ;
54326 int res1 = 0 ;
54327 void *argp2 = 0 ;
54328 int res2 = 0 ;
54329
54330 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54331 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54332 if (!SWIG_IsOK(res1)) {
54333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54334 }
54335 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54336 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54337 if (!SWIG_IsOK(res2)) {
54338 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54339 }
54340 arg2 = reinterpret_cast< wxSizer * >(argp2);
54341 {
54342 PyThreadState* __tstate = wxPyBeginAllowThreads();
54343 result = (arg1)->GetItemPosition(arg2);
54344 wxPyEndAllowThreads(__tstate);
54345 if (PyErr_Occurred()) SWIG_fail;
54346 }
54347 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54348 return resultobj;
54349 fail:
54350 return NULL;
54351 }
54352
54353
54354 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54355 PyObject *resultobj = 0;
54356 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54357 size_t arg2 ;
54358 wxGBPosition result;
54359 void *argp1 = 0 ;
54360 int res1 = 0 ;
54361 size_t val2 ;
54362 int ecode2 = 0 ;
54363
54364 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54365 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54366 if (!SWIG_IsOK(res1)) {
54367 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54368 }
54369 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54370 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54371 if (!SWIG_IsOK(ecode2)) {
54372 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54373 }
54374 arg2 = static_cast< size_t >(val2);
54375 {
54376 PyThreadState* __tstate = wxPyBeginAllowThreads();
54377 result = (arg1)->GetItemPosition(arg2);
54378 wxPyEndAllowThreads(__tstate);
54379 if (PyErr_Occurred()) SWIG_fail;
54380 }
54381 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
54382 return resultobj;
54383 fail:
54384 return NULL;
54385 }
54386
54387
54388 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
54389 int argc;
54390 PyObject *argv[3];
54391
54392 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
54393 --argc;
54394 if (argc == 2) {
54395 int _v = 0;
54396 {
54397 void *vptr = 0;
54398 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54399 _v = SWIG_CheckState(res);
54400 }
54401 if (!_v) goto check_1;
54402 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
54403 }
54404 check_1:
54405
54406 if (argc == 2) {
54407 int _v = 0;
54408 {
54409 void *vptr = 0;
54410 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54411 _v = SWIG_CheckState(res);
54412 }
54413 if (!_v) goto check_2;
54414 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
54415 }
54416 check_2:
54417
54418 if (argc == 2) {
54419 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
54420 }
54421
54422 fail:
54423 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
54424 return NULL;
54425 }
54426
54427
54428 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54429 PyObject *resultobj = 0;
54430 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54431 wxWindow *arg2 = (wxWindow *) 0 ;
54432 wxGBPosition *arg3 = 0 ;
54433 bool result;
54434 void *argp1 = 0 ;
54435 int res1 = 0 ;
54436 void *argp2 = 0 ;
54437 int res2 = 0 ;
54438 wxGBPosition temp3 ;
54439
54440 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54441 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54442 if (!SWIG_IsOK(res1)) {
54443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54444 }
54445 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54446 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54447 if (!SWIG_IsOK(res2)) {
54448 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
54449 }
54450 arg2 = reinterpret_cast< wxWindow * >(argp2);
54451 {
54452 arg3 = &temp3;
54453 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54454 }
54455 {
54456 PyThreadState* __tstate = wxPyBeginAllowThreads();
54457 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54458 wxPyEndAllowThreads(__tstate);
54459 if (PyErr_Occurred()) SWIG_fail;
54460 }
54461 {
54462 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54463 }
54464 return resultobj;
54465 fail:
54466 return NULL;
54467 }
54468
54469
54470 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54471 PyObject *resultobj = 0;
54472 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54473 wxSizer *arg2 = (wxSizer *) 0 ;
54474 wxGBPosition *arg3 = 0 ;
54475 bool result;
54476 void *argp1 = 0 ;
54477 int res1 = 0 ;
54478 void *argp2 = 0 ;
54479 int res2 = 0 ;
54480 wxGBPosition temp3 ;
54481
54482 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54484 if (!SWIG_IsOK(res1)) {
54485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54486 }
54487 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54488 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54489 if (!SWIG_IsOK(res2)) {
54490 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
54491 }
54492 arg2 = reinterpret_cast< wxSizer * >(argp2);
54493 {
54494 arg3 = &temp3;
54495 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54496 }
54497 {
54498 PyThreadState* __tstate = wxPyBeginAllowThreads();
54499 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54500 wxPyEndAllowThreads(__tstate);
54501 if (PyErr_Occurred()) SWIG_fail;
54502 }
54503 {
54504 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54505 }
54506 return resultobj;
54507 fail:
54508 return NULL;
54509 }
54510
54511
54512 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54513 PyObject *resultobj = 0;
54514 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54515 size_t arg2 ;
54516 wxGBPosition *arg3 = 0 ;
54517 bool result;
54518 void *argp1 = 0 ;
54519 int res1 = 0 ;
54520 size_t val2 ;
54521 int ecode2 = 0 ;
54522 wxGBPosition temp3 ;
54523
54524 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54526 if (!SWIG_IsOK(res1)) {
54527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54528 }
54529 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54530 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54531 if (!SWIG_IsOK(ecode2)) {
54532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
54533 }
54534 arg2 = static_cast< size_t >(val2);
54535 {
54536 arg3 = &temp3;
54537 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
54538 }
54539 {
54540 PyThreadState* __tstate = wxPyBeginAllowThreads();
54541 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
54542 wxPyEndAllowThreads(__tstate);
54543 if (PyErr_Occurred()) SWIG_fail;
54544 }
54545 {
54546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54547 }
54548 return resultobj;
54549 fail:
54550 return NULL;
54551 }
54552
54553
54554 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
54555 int argc;
54556 PyObject *argv[4];
54557
54558 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
54559 --argc;
54560 if (argc == 3) {
54561 int _v = 0;
54562 {
54563 void *vptr = 0;
54564 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54565 _v = SWIG_CheckState(res);
54566 }
54567 if (!_v) goto check_1;
54568 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
54569 }
54570 check_1:
54571
54572 if (argc == 3) {
54573 int _v = 0;
54574 {
54575 void *vptr = 0;
54576 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54577 _v = SWIG_CheckState(res);
54578 }
54579 if (!_v) goto check_2;
54580 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
54581 }
54582 check_2:
54583
54584 if (argc == 3) {
54585 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
54586 }
54587
54588 fail:
54589 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
54590 return NULL;
54591 }
54592
54593
54594 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54595 PyObject *resultobj = 0;
54596 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54597 wxWindow *arg2 = (wxWindow *) 0 ;
54598 wxGBSpan result;
54599 void *argp1 = 0 ;
54600 int res1 = 0 ;
54601 void *argp2 = 0 ;
54602 int res2 = 0 ;
54603
54604 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54606 if (!SWIG_IsOK(res1)) {
54607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54608 }
54609 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54610 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54611 if (!SWIG_IsOK(res2)) {
54612 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54613 }
54614 arg2 = reinterpret_cast< wxWindow * >(argp2);
54615 {
54616 PyThreadState* __tstate = wxPyBeginAllowThreads();
54617 result = (arg1)->GetItemSpan(arg2);
54618 wxPyEndAllowThreads(__tstate);
54619 if (PyErr_Occurred()) SWIG_fail;
54620 }
54621 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54622 return resultobj;
54623 fail:
54624 return NULL;
54625 }
54626
54627
54628 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54629 PyObject *resultobj = 0;
54630 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54631 wxSizer *arg2 = (wxSizer *) 0 ;
54632 wxGBSpan result;
54633 void *argp1 = 0 ;
54634 int res1 = 0 ;
54635 void *argp2 = 0 ;
54636 int res2 = 0 ;
54637
54638 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54639 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54640 if (!SWIG_IsOK(res1)) {
54641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54642 }
54643 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54644 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54645 if (!SWIG_IsOK(res2)) {
54646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54647 }
54648 arg2 = reinterpret_cast< wxSizer * >(argp2);
54649 {
54650 PyThreadState* __tstate = wxPyBeginAllowThreads();
54651 result = (arg1)->GetItemSpan(arg2);
54652 wxPyEndAllowThreads(__tstate);
54653 if (PyErr_Occurred()) SWIG_fail;
54654 }
54655 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54656 return resultobj;
54657 fail:
54658 return NULL;
54659 }
54660
54661
54662 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54663 PyObject *resultobj = 0;
54664 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54665 size_t arg2 ;
54666 wxGBSpan result;
54667 void *argp1 = 0 ;
54668 int res1 = 0 ;
54669 size_t val2 ;
54670 int ecode2 = 0 ;
54671
54672 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54673 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54674 if (!SWIG_IsOK(res1)) {
54675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54676 }
54677 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54678 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54679 if (!SWIG_IsOK(ecode2)) {
54680 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54681 }
54682 arg2 = static_cast< size_t >(val2);
54683 {
54684 PyThreadState* __tstate = wxPyBeginAllowThreads();
54685 result = (arg1)->GetItemSpan(arg2);
54686 wxPyEndAllowThreads(__tstate);
54687 if (PyErr_Occurred()) SWIG_fail;
54688 }
54689 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
54690 return resultobj;
54691 fail:
54692 return NULL;
54693 }
54694
54695
54696 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
54697 int argc;
54698 PyObject *argv[3];
54699
54700 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
54701 --argc;
54702 if (argc == 2) {
54703 int _v = 0;
54704 {
54705 void *vptr = 0;
54706 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54707 _v = SWIG_CheckState(res);
54708 }
54709 if (!_v) goto check_1;
54710 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
54711 }
54712 check_1:
54713
54714 if (argc == 2) {
54715 int _v = 0;
54716 {
54717 void *vptr = 0;
54718 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54719 _v = SWIG_CheckState(res);
54720 }
54721 if (!_v) goto check_2;
54722 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
54723 }
54724 check_2:
54725
54726 if (argc == 2) {
54727 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
54728 }
54729
54730 fail:
54731 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
54732 return NULL;
54733 }
54734
54735
54736 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54737 PyObject *resultobj = 0;
54738 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54739 wxWindow *arg2 = (wxWindow *) 0 ;
54740 wxGBSpan *arg3 = 0 ;
54741 bool result;
54742 void *argp1 = 0 ;
54743 int res1 = 0 ;
54744 void *argp2 = 0 ;
54745 int res2 = 0 ;
54746 wxGBSpan temp3 ;
54747
54748 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54749 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54750 if (!SWIG_IsOK(res1)) {
54751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54752 }
54753 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54754 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54755 if (!SWIG_IsOK(res2)) {
54756 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
54757 }
54758 arg2 = reinterpret_cast< wxWindow * >(argp2);
54759 {
54760 arg3 = &temp3;
54761 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54762 }
54763 {
54764 PyThreadState* __tstate = wxPyBeginAllowThreads();
54765 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54766 wxPyEndAllowThreads(__tstate);
54767 if (PyErr_Occurred()) SWIG_fail;
54768 }
54769 {
54770 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54771 }
54772 return resultobj;
54773 fail:
54774 return NULL;
54775 }
54776
54777
54778 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54779 PyObject *resultobj = 0;
54780 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54781 wxSizer *arg2 = (wxSizer *) 0 ;
54782 wxGBSpan *arg3 = 0 ;
54783 bool result;
54784 void *argp1 = 0 ;
54785 int res1 = 0 ;
54786 void *argp2 = 0 ;
54787 int res2 = 0 ;
54788 wxGBSpan temp3 ;
54789
54790 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54792 if (!SWIG_IsOK(res1)) {
54793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54794 }
54795 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54796 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54797 if (!SWIG_IsOK(res2)) {
54798 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
54799 }
54800 arg2 = reinterpret_cast< wxSizer * >(argp2);
54801 {
54802 arg3 = &temp3;
54803 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54804 }
54805 {
54806 PyThreadState* __tstate = wxPyBeginAllowThreads();
54807 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54808 wxPyEndAllowThreads(__tstate);
54809 if (PyErr_Occurred()) SWIG_fail;
54810 }
54811 {
54812 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54813 }
54814 return resultobj;
54815 fail:
54816 return NULL;
54817 }
54818
54819
54820 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54821 PyObject *resultobj = 0;
54822 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54823 size_t arg2 ;
54824 wxGBSpan *arg3 = 0 ;
54825 bool result;
54826 void *argp1 = 0 ;
54827 int res1 = 0 ;
54828 size_t val2 ;
54829 int ecode2 = 0 ;
54830 wxGBSpan temp3 ;
54831
54832 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
54833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54834 if (!SWIG_IsOK(res1)) {
54835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54836 }
54837 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54838 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
54839 if (!SWIG_IsOK(ecode2)) {
54840 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
54841 }
54842 arg2 = static_cast< size_t >(val2);
54843 {
54844 arg3 = &temp3;
54845 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
54846 }
54847 {
54848 PyThreadState* __tstate = wxPyBeginAllowThreads();
54849 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
54850 wxPyEndAllowThreads(__tstate);
54851 if (PyErr_Occurred()) SWIG_fail;
54852 }
54853 {
54854 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
54855 }
54856 return resultobj;
54857 fail:
54858 return NULL;
54859 }
54860
54861
54862 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
54863 int argc;
54864 PyObject *argv[4];
54865
54866 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
54867 --argc;
54868 if (argc == 3) {
54869 int _v = 0;
54870 {
54871 void *vptr = 0;
54872 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54873 _v = SWIG_CheckState(res);
54874 }
54875 if (!_v) goto check_1;
54876 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
54877 }
54878 check_1:
54879
54880 if (argc == 3) {
54881 int _v = 0;
54882 {
54883 void *vptr = 0;
54884 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
54885 _v = SWIG_CheckState(res);
54886 }
54887 if (!_v) goto check_2;
54888 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
54889 }
54890 check_2:
54891
54892 if (argc == 3) {
54893 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
54894 }
54895
54896 fail:
54897 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
54898 return NULL;
54899 }
54900
54901
54902 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54903 PyObject *resultobj = 0;
54904 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54905 wxWindow *arg2 = (wxWindow *) 0 ;
54906 wxGBSizerItem *result = 0 ;
54907 void *argp1 = 0 ;
54908 int res1 = 0 ;
54909 void *argp2 = 0 ;
54910 int res2 = 0 ;
54911
54912 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54914 if (!SWIG_IsOK(res1)) {
54915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54916 }
54917 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54918 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
54919 if (!SWIG_IsOK(res2)) {
54920 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
54921 }
54922 arg2 = reinterpret_cast< wxWindow * >(argp2);
54923 {
54924 PyThreadState* __tstate = wxPyBeginAllowThreads();
54925 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54926 wxPyEndAllowThreads(__tstate);
54927 if (PyErr_Occurred()) SWIG_fail;
54928 }
54929 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54930 return resultobj;
54931 fail:
54932 return NULL;
54933 }
54934
54935
54936 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
54937 PyObject *resultobj = 0;
54938 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
54939 wxSizer *arg2 = (wxSizer *) 0 ;
54940 wxGBSizerItem *result = 0 ;
54941 void *argp1 = 0 ;
54942 int res1 = 0 ;
54943 void *argp2 = 0 ;
54944 int res2 = 0 ;
54945
54946 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
54947 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
54948 if (!SWIG_IsOK(res1)) {
54949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
54950 }
54951 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
54952 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
54953 if (!SWIG_IsOK(res2)) {
54954 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
54955 }
54956 arg2 = reinterpret_cast< wxSizer * >(argp2);
54957 {
54958 PyThreadState* __tstate = wxPyBeginAllowThreads();
54959 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
54960 wxPyEndAllowThreads(__tstate);
54961 if (PyErr_Occurred()) SWIG_fail;
54962 }
54963 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
54964 return resultobj;
54965 fail:
54966 return NULL;
54967 }
54968
54969
54970 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
54971 int argc;
54972 PyObject *argv[3];
54973
54974 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
54975 --argc;
54976 if (argc == 2) {
54977 int _v = 0;
54978 {
54979 void *vptr = 0;
54980 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
54981 _v = SWIG_CheckState(res);
54982 }
54983 if (!_v) goto check_1;
54984 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
54985 }
54986 check_1:
54987
54988 if (argc == 2) {
54989 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
54990 }
54991
54992 fail:
54993 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
54994 return NULL;
54995 }
54996
54997
54998 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
54999 PyObject *resultobj = 0;
55000 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55001 wxGBPosition *arg2 = 0 ;
55002 wxGBSizerItem *result = 0 ;
55003 void *argp1 = 0 ;
55004 int res1 = 0 ;
55005 wxGBPosition temp2 ;
55006 PyObject * obj0 = 0 ;
55007 PyObject * obj1 = 0 ;
55008 char * kwnames[] = {
55009 (char *) "self",(char *) "pos", NULL
55010 };
55011
55012 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
55013 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55014 if (!SWIG_IsOK(res1)) {
55015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55016 }
55017 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55018 {
55019 arg2 = &temp2;
55020 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55021 }
55022 {
55023 PyThreadState* __tstate = wxPyBeginAllowThreads();
55024 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
55025 wxPyEndAllowThreads(__tstate);
55026 if (PyErr_Occurred()) SWIG_fail;
55027 }
55028 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55029 return resultobj;
55030 fail:
55031 return NULL;
55032 }
55033
55034
55035 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55036 PyObject *resultobj = 0;
55037 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55038 wxPoint *arg2 = 0 ;
55039 wxGBSizerItem *result = 0 ;
55040 void *argp1 = 0 ;
55041 int res1 = 0 ;
55042 wxPoint temp2 ;
55043 PyObject * obj0 = 0 ;
55044 PyObject * obj1 = 0 ;
55045 char * kwnames[] = {
55046 (char *) "self",(char *) "pt", NULL
55047 };
55048
55049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
55050 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55051 if (!SWIG_IsOK(res1)) {
55052 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55053 }
55054 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55055 {
55056 arg2 = &temp2;
55057 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
55058 }
55059 {
55060 PyThreadState* __tstate = wxPyBeginAllowThreads();
55061 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
55062 wxPyEndAllowThreads(__tstate);
55063 if (PyErr_Occurred()) SWIG_fail;
55064 }
55065 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55066 return resultobj;
55067 fail:
55068 return NULL;
55069 }
55070
55071
55072 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55073 PyObject *resultobj = 0;
55074 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55075 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
55076 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
55077 bool result;
55078 void *argp1 = 0 ;
55079 int res1 = 0 ;
55080 void *argp2 = 0 ;
55081 int res2 = 0 ;
55082 void *argp3 = 0 ;
55083 int res3 = 0 ;
55084 PyObject * obj0 = 0 ;
55085 PyObject * obj1 = 0 ;
55086 PyObject * obj2 = 0 ;
55087 char * kwnames[] = {
55088 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
55089 };
55090
55091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55093 if (!SWIG_IsOK(res1)) {
55094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55095 }
55096 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55097 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55098 if (!SWIG_IsOK(res2)) {
55099 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
55100 }
55101 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
55102 if (obj2) {
55103 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55104 if (!SWIG_IsOK(res3)) {
55105 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
55106 }
55107 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
55108 }
55109 {
55110 PyThreadState* __tstate = wxPyBeginAllowThreads();
55111 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
55112 wxPyEndAllowThreads(__tstate);
55113 if (PyErr_Occurred()) SWIG_fail;
55114 }
55115 {
55116 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55117 }
55118 return resultobj;
55119 fail:
55120 return NULL;
55121 }
55122
55123
55124 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55125 PyObject *resultobj = 0;
55126 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
55127 wxGBPosition *arg2 = 0 ;
55128 wxGBSpan *arg3 = 0 ;
55129 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
55130 bool result;
55131 void *argp1 = 0 ;
55132 int res1 = 0 ;
55133 wxGBPosition temp2 ;
55134 wxGBSpan temp3 ;
55135 void *argp4 = 0 ;
55136 int res4 = 0 ;
55137 PyObject * obj0 = 0 ;
55138 PyObject * obj1 = 0 ;
55139 PyObject * obj2 = 0 ;
55140 PyObject * obj3 = 0 ;
55141 char * kwnames[] = {
55142 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
55143 };
55144
55145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55146 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
55147 if (!SWIG_IsOK(res1)) {
55148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
55149 }
55150 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
55151 {
55152 arg2 = &temp2;
55153 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
55154 }
55155 {
55156 arg3 = &temp3;
55157 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
55158 }
55159 if (obj3) {
55160 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
55161 if (!SWIG_IsOK(res4)) {
55162 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
55163 }
55164 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
55165 }
55166 {
55167 PyThreadState* __tstate = wxPyBeginAllowThreads();
55168 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
55169 wxPyEndAllowThreads(__tstate);
55170 if (PyErr_Occurred()) SWIG_fail;
55171 }
55172 {
55173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55174 }
55175 return resultobj;
55176 fail:
55177 return NULL;
55178 }
55179
55180
55181 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55182 PyObject *obj;
55183 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
55184 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
55185 return SWIG_Py_Void();
55186 }
55187
55188 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55189 return SWIG_Python_InitShadowInstance(args);
55190 }
55191
55192 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55193 PyObject *resultobj = 0;
55194 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55195 wxRelationship arg2 ;
55196 wxWindow *arg3 = (wxWindow *) 0 ;
55197 wxEdge arg4 ;
55198 int arg5 = (int) 0 ;
55199 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
55200 void *argp1 = 0 ;
55201 int res1 = 0 ;
55202 int val2 ;
55203 int ecode2 = 0 ;
55204 void *argp3 = 0 ;
55205 int res3 = 0 ;
55206 int val4 ;
55207 int ecode4 = 0 ;
55208 int val5 ;
55209 int ecode5 = 0 ;
55210 int val6 ;
55211 int ecode6 = 0 ;
55212 PyObject * obj0 = 0 ;
55213 PyObject * obj1 = 0 ;
55214 PyObject * obj2 = 0 ;
55215 PyObject * obj3 = 0 ;
55216 PyObject * obj4 = 0 ;
55217 PyObject * obj5 = 0 ;
55218 char * kwnames[] = {
55219 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
55220 };
55221
55222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
55223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55224 if (!SWIG_IsOK(res1)) {
55225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55226 }
55227 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55228 ecode2 = SWIG_AsVal_int(obj1, &val2);
55229 if (!SWIG_IsOK(ecode2)) {
55230 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
55231 }
55232 arg2 = static_cast< wxRelationship >(val2);
55233 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
55234 if (!SWIG_IsOK(res3)) {
55235 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
55236 }
55237 arg3 = reinterpret_cast< wxWindow * >(argp3);
55238 ecode4 = SWIG_AsVal_int(obj3, &val4);
55239 if (!SWIG_IsOK(ecode4)) {
55240 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
55241 }
55242 arg4 = static_cast< wxEdge >(val4);
55243 if (obj4) {
55244 ecode5 = SWIG_AsVal_int(obj4, &val5);
55245 if (!SWIG_IsOK(ecode5)) {
55246 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
55247 }
55248 arg5 = static_cast< int >(val5);
55249 }
55250 if (obj5) {
55251 ecode6 = SWIG_AsVal_int(obj5, &val6);
55252 if (!SWIG_IsOK(ecode6)) {
55253 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
55254 }
55255 arg6 = static_cast< int >(val6);
55256 }
55257 {
55258 PyThreadState* __tstate = wxPyBeginAllowThreads();
55259 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
55260 wxPyEndAllowThreads(__tstate);
55261 if (PyErr_Occurred()) SWIG_fail;
55262 }
55263 resultobj = SWIG_Py_Void();
55264 return resultobj;
55265 fail:
55266 return NULL;
55267 }
55268
55269
55270 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55271 PyObject *resultobj = 0;
55272 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55273 wxWindow *arg2 = (wxWindow *) 0 ;
55274 int arg3 = (int) 0 ;
55275 void *argp1 = 0 ;
55276 int res1 = 0 ;
55277 void *argp2 = 0 ;
55278 int res2 = 0 ;
55279 int val3 ;
55280 int ecode3 = 0 ;
55281 PyObject * obj0 = 0 ;
55282 PyObject * obj1 = 0 ;
55283 PyObject * obj2 = 0 ;
55284 char * kwnames[] = {
55285 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55286 };
55287
55288 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55289 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55290 if (!SWIG_IsOK(res1)) {
55291 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55292 }
55293 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55294 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55295 if (!SWIG_IsOK(res2)) {
55296 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55297 }
55298 arg2 = reinterpret_cast< wxWindow * >(argp2);
55299 if (obj2) {
55300 ecode3 = SWIG_AsVal_int(obj2, &val3);
55301 if (!SWIG_IsOK(ecode3)) {
55302 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
55303 }
55304 arg3 = static_cast< int >(val3);
55305 }
55306 {
55307 PyThreadState* __tstate = wxPyBeginAllowThreads();
55308 (arg1)->LeftOf(arg2,arg3);
55309 wxPyEndAllowThreads(__tstate);
55310 if (PyErr_Occurred()) SWIG_fail;
55311 }
55312 resultobj = SWIG_Py_Void();
55313 return resultobj;
55314 fail:
55315 return NULL;
55316 }
55317
55318
55319 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55320 PyObject *resultobj = 0;
55321 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55322 wxWindow *arg2 = (wxWindow *) 0 ;
55323 int arg3 = (int) 0 ;
55324 void *argp1 = 0 ;
55325 int res1 = 0 ;
55326 void *argp2 = 0 ;
55327 int res2 = 0 ;
55328 int val3 ;
55329 int ecode3 = 0 ;
55330 PyObject * obj0 = 0 ;
55331 PyObject * obj1 = 0 ;
55332 PyObject * obj2 = 0 ;
55333 char * kwnames[] = {
55334 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55335 };
55336
55337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55339 if (!SWIG_IsOK(res1)) {
55340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55341 }
55342 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55343 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55344 if (!SWIG_IsOK(res2)) {
55345 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55346 }
55347 arg2 = reinterpret_cast< wxWindow * >(argp2);
55348 if (obj2) {
55349 ecode3 = SWIG_AsVal_int(obj2, &val3);
55350 if (!SWIG_IsOK(ecode3)) {
55351 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
55352 }
55353 arg3 = static_cast< int >(val3);
55354 }
55355 {
55356 PyThreadState* __tstate = wxPyBeginAllowThreads();
55357 (arg1)->RightOf(arg2,arg3);
55358 wxPyEndAllowThreads(__tstate);
55359 if (PyErr_Occurred()) SWIG_fail;
55360 }
55361 resultobj = SWIG_Py_Void();
55362 return resultobj;
55363 fail:
55364 return NULL;
55365 }
55366
55367
55368 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55369 PyObject *resultobj = 0;
55370 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55371 wxWindow *arg2 = (wxWindow *) 0 ;
55372 int arg3 = (int) 0 ;
55373 void *argp1 = 0 ;
55374 int res1 = 0 ;
55375 void *argp2 = 0 ;
55376 int res2 = 0 ;
55377 int val3 ;
55378 int ecode3 = 0 ;
55379 PyObject * obj0 = 0 ;
55380 PyObject * obj1 = 0 ;
55381 PyObject * obj2 = 0 ;
55382 char * kwnames[] = {
55383 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55384 };
55385
55386 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55387 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55388 if (!SWIG_IsOK(res1)) {
55389 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55390 }
55391 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55392 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55393 if (!SWIG_IsOK(res2)) {
55394 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
55395 }
55396 arg2 = reinterpret_cast< wxWindow * >(argp2);
55397 if (obj2) {
55398 ecode3 = SWIG_AsVal_int(obj2, &val3);
55399 if (!SWIG_IsOK(ecode3)) {
55400 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
55401 }
55402 arg3 = static_cast< int >(val3);
55403 }
55404 {
55405 PyThreadState* __tstate = wxPyBeginAllowThreads();
55406 (arg1)->Above(arg2,arg3);
55407 wxPyEndAllowThreads(__tstate);
55408 if (PyErr_Occurred()) SWIG_fail;
55409 }
55410 resultobj = SWIG_Py_Void();
55411 return resultobj;
55412 fail:
55413 return NULL;
55414 }
55415
55416
55417 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55418 PyObject *resultobj = 0;
55419 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55420 wxWindow *arg2 = (wxWindow *) 0 ;
55421 int arg3 = (int) 0 ;
55422 void *argp1 = 0 ;
55423 int res1 = 0 ;
55424 void *argp2 = 0 ;
55425 int res2 = 0 ;
55426 int val3 ;
55427 int ecode3 = 0 ;
55428 PyObject * obj0 = 0 ;
55429 PyObject * obj1 = 0 ;
55430 PyObject * obj2 = 0 ;
55431 char * kwnames[] = {
55432 (char *) "self",(char *) "sibling",(char *) "marg", NULL
55433 };
55434
55435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
55436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55437 if (!SWIG_IsOK(res1)) {
55438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55439 }
55440 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55441 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55442 if (!SWIG_IsOK(res2)) {
55443 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
55444 }
55445 arg2 = reinterpret_cast< wxWindow * >(argp2);
55446 if (obj2) {
55447 ecode3 = SWIG_AsVal_int(obj2, &val3);
55448 if (!SWIG_IsOK(ecode3)) {
55449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
55450 }
55451 arg3 = static_cast< int >(val3);
55452 }
55453 {
55454 PyThreadState* __tstate = wxPyBeginAllowThreads();
55455 (arg1)->Below(arg2,arg3);
55456 wxPyEndAllowThreads(__tstate);
55457 if (PyErr_Occurred()) SWIG_fail;
55458 }
55459 resultobj = SWIG_Py_Void();
55460 return resultobj;
55461 fail:
55462 return NULL;
55463 }
55464
55465
55466 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55467 PyObject *resultobj = 0;
55468 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55469 wxWindow *arg2 = (wxWindow *) 0 ;
55470 wxEdge arg3 ;
55471 int arg4 = (int) 0 ;
55472 void *argp1 = 0 ;
55473 int res1 = 0 ;
55474 void *argp2 = 0 ;
55475 int res2 = 0 ;
55476 int val3 ;
55477 int ecode3 = 0 ;
55478 int val4 ;
55479 int ecode4 = 0 ;
55480 PyObject * obj0 = 0 ;
55481 PyObject * obj1 = 0 ;
55482 PyObject * obj2 = 0 ;
55483 PyObject * obj3 = 0 ;
55484 char * kwnames[] = {
55485 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
55486 };
55487
55488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55490 if (!SWIG_IsOK(res1)) {
55491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55492 }
55493 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55494 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55495 if (!SWIG_IsOK(res2)) {
55496 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
55497 }
55498 arg2 = reinterpret_cast< wxWindow * >(argp2);
55499 ecode3 = SWIG_AsVal_int(obj2, &val3);
55500 if (!SWIG_IsOK(ecode3)) {
55501 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
55502 }
55503 arg3 = static_cast< wxEdge >(val3);
55504 if (obj3) {
55505 ecode4 = SWIG_AsVal_int(obj3, &val4);
55506 if (!SWIG_IsOK(ecode4)) {
55507 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
55508 }
55509 arg4 = static_cast< int >(val4);
55510 }
55511 {
55512 PyThreadState* __tstate = wxPyBeginAllowThreads();
55513 (arg1)->SameAs(arg2,arg3,arg4);
55514 wxPyEndAllowThreads(__tstate);
55515 if (PyErr_Occurred()) SWIG_fail;
55516 }
55517 resultobj = SWIG_Py_Void();
55518 return resultobj;
55519 fail:
55520 return NULL;
55521 }
55522
55523
55524 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55525 PyObject *resultobj = 0;
55526 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55527 wxWindow *arg2 = (wxWindow *) 0 ;
55528 wxEdge arg3 ;
55529 int arg4 ;
55530 void *argp1 = 0 ;
55531 int res1 = 0 ;
55532 void *argp2 = 0 ;
55533 int res2 = 0 ;
55534 int val3 ;
55535 int ecode3 = 0 ;
55536 int val4 ;
55537 int ecode4 = 0 ;
55538 PyObject * obj0 = 0 ;
55539 PyObject * obj1 = 0 ;
55540 PyObject * obj2 = 0 ;
55541 PyObject * obj3 = 0 ;
55542 char * kwnames[] = {
55543 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
55544 };
55545
55546 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
55547 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55548 if (!SWIG_IsOK(res1)) {
55549 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55550 }
55551 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55552 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
55553 if (!SWIG_IsOK(res2)) {
55554 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
55555 }
55556 arg2 = reinterpret_cast< wxWindow * >(argp2);
55557 ecode3 = SWIG_AsVal_int(obj2, &val3);
55558 if (!SWIG_IsOK(ecode3)) {
55559 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
55560 }
55561 arg3 = static_cast< wxEdge >(val3);
55562 ecode4 = SWIG_AsVal_int(obj3, &val4);
55563 if (!SWIG_IsOK(ecode4)) {
55564 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
55565 }
55566 arg4 = static_cast< int >(val4);
55567 {
55568 PyThreadState* __tstate = wxPyBeginAllowThreads();
55569 (arg1)->PercentOf(arg2,arg3,arg4);
55570 wxPyEndAllowThreads(__tstate);
55571 if (PyErr_Occurred()) SWIG_fail;
55572 }
55573 resultobj = SWIG_Py_Void();
55574 return resultobj;
55575 fail:
55576 return NULL;
55577 }
55578
55579
55580 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55581 PyObject *resultobj = 0;
55582 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55583 int arg2 ;
55584 void *argp1 = 0 ;
55585 int res1 = 0 ;
55586 int val2 ;
55587 int ecode2 = 0 ;
55588 PyObject * obj0 = 0 ;
55589 PyObject * obj1 = 0 ;
55590 char * kwnames[] = {
55591 (char *) "self",(char *) "val", NULL
55592 };
55593
55594 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
55595 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55596 if (!SWIG_IsOK(res1)) {
55597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55598 }
55599 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55600 ecode2 = SWIG_AsVal_int(obj1, &val2);
55601 if (!SWIG_IsOK(ecode2)) {
55602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
55603 }
55604 arg2 = static_cast< int >(val2);
55605 {
55606 PyThreadState* __tstate = wxPyBeginAllowThreads();
55607 (arg1)->Absolute(arg2);
55608 wxPyEndAllowThreads(__tstate);
55609 if (PyErr_Occurred()) SWIG_fail;
55610 }
55611 resultobj = SWIG_Py_Void();
55612 return resultobj;
55613 fail:
55614 return NULL;
55615 }
55616
55617
55618 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55619 PyObject *resultobj = 0;
55620 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55621 void *argp1 = 0 ;
55622 int res1 = 0 ;
55623 PyObject *swig_obj[1] ;
55624
55625 if (!args) SWIG_fail;
55626 swig_obj[0] = args;
55627 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55628 if (!SWIG_IsOK(res1)) {
55629 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55630 }
55631 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55632 {
55633 PyThreadState* __tstate = wxPyBeginAllowThreads();
55634 (arg1)->Unconstrained();
55635 wxPyEndAllowThreads(__tstate);
55636 if (PyErr_Occurred()) SWIG_fail;
55637 }
55638 resultobj = SWIG_Py_Void();
55639 return resultobj;
55640 fail:
55641 return NULL;
55642 }
55643
55644
55645 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55646 PyObject *resultobj = 0;
55647 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55648 void *argp1 = 0 ;
55649 int res1 = 0 ;
55650 PyObject *swig_obj[1] ;
55651
55652 if (!args) SWIG_fail;
55653 swig_obj[0] = args;
55654 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55655 if (!SWIG_IsOK(res1)) {
55656 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55657 }
55658 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55659 {
55660 PyThreadState* __tstate = wxPyBeginAllowThreads();
55661 (arg1)->AsIs();
55662 wxPyEndAllowThreads(__tstate);
55663 if (PyErr_Occurred()) SWIG_fail;
55664 }
55665 resultobj = SWIG_Py_Void();
55666 return resultobj;
55667 fail:
55668 return NULL;
55669 }
55670
55671
55672 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55673 PyObject *resultobj = 0;
55674 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55675 wxWindow *result = 0 ;
55676 void *argp1 = 0 ;
55677 int res1 = 0 ;
55678 PyObject *swig_obj[1] ;
55679
55680 if (!args) SWIG_fail;
55681 swig_obj[0] = args;
55682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55683 if (!SWIG_IsOK(res1)) {
55684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55685 }
55686 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55687 {
55688 PyThreadState* __tstate = wxPyBeginAllowThreads();
55689 result = (wxWindow *)(arg1)->GetOtherWindow();
55690 wxPyEndAllowThreads(__tstate);
55691 if (PyErr_Occurred()) SWIG_fail;
55692 }
55693 {
55694 resultobj = wxPyMake_wxObject(result, 0);
55695 }
55696 return resultobj;
55697 fail:
55698 return NULL;
55699 }
55700
55701
55702 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55703 PyObject *resultobj = 0;
55704 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55705 wxEdge result;
55706 void *argp1 = 0 ;
55707 int res1 = 0 ;
55708 PyObject *swig_obj[1] ;
55709
55710 if (!args) SWIG_fail;
55711 swig_obj[0] = args;
55712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55713 if (!SWIG_IsOK(res1)) {
55714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55715 }
55716 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55717 {
55718 PyThreadState* __tstate = wxPyBeginAllowThreads();
55719 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
55720 wxPyEndAllowThreads(__tstate);
55721 if (PyErr_Occurred()) SWIG_fail;
55722 }
55723 resultobj = SWIG_From_int(static_cast< int >(result));
55724 return resultobj;
55725 fail:
55726 return NULL;
55727 }
55728
55729
55730 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55731 PyObject *resultobj = 0;
55732 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55733 wxEdge arg2 ;
55734 void *argp1 = 0 ;
55735 int res1 = 0 ;
55736 int val2 ;
55737 int ecode2 = 0 ;
55738 PyObject * obj0 = 0 ;
55739 PyObject * obj1 = 0 ;
55740 char * kwnames[] = {
55741 (char *) "self",(char *) "which", NULL
55742 };
55743
55744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
55745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55746 if (!SWIG_IsOK(res1)) {
55747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55748 }
55749 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55750 ecode2 = SWIG_AsVal_int(obj1, &val2);
55751 if (!SWIG_IsOK(ecode2)) {
55752 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
55753 }
55754 arg2 = static_cast< wxEdge >(val2);
55755 {
55756 PyThreadState* __tstate = wxPyBeginAllowThreads();
55757 (arg1)->SetEdge(arg2);
55758 wxPyEndAllowThreads(__tstate);
55759 if (PyErr_Occurred()) SWIG_fail;
55760 }
55761 resultobj = SWIG_Py_Void();
55762 return resultobj;
55763 fail:
55764 return NULL;
55765 }
55766
55767
55768 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55769 PyObject *resultobj = 0;
55770 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55771 int arg2 ;
55772 void *argp1 = 0 ;
55773 int res1 = 0 ;
55774 int val2 ;
55775 int ecode2 = 0 ;
55776 PyObject * obj0 = 0 ;
55777 PyObject * obj1 = 0 ;
55778 char * kwnames[] = {
55779 (char *) "self",(char *) "v", NULL
55780 };
55781
55782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
55783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55784 if (!SWIG_IsOK(res1)) {
55785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55786 }
55787 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55788 ecode2 = SWIG_AsVal_int(obj1, &val2);
55789 if (!SWIG_IsOK(ecode2)) {
55790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
55791 }
55792 arg2 = static_cast< int >(val2);
55793 {
55794 PyThreadState* __tstate = wxPyBeginAllowThreads();
55795 (arg1)->SetValue(arg2);
55796 wxPyEndAllowThreads(__tstate);
55797 if (PyErr_Occurred()) SWIG_fail;
55798 }
55799 resultobj = SWIG_Py_Void();
55800 return resultobj;
55801 fail:
55802 return NULL;
55803 }
55804
55805
55806 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55807 PyObject *resultobj = 0;
55808 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55809 int result;
55810 void *argp1 = 0 ;
55811 int res1 = 0 ;
55812 PyObject *swig_obj[1] ;
55813
55814 if (!args) SWIG_fail;
55815 swig_obj[0] = args;
55816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55817 if (!SWIG_IsOK(res1)) {
55818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55819 }
55820 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55821 {
55822 PyThreadState* __tstate = wxPyBeginAllowThreads();
55823 result = (int)(arg1)->GetMargin();
55824 wxPyEndAllowThreads(__tstate);
55825 if (PyErr_Occurred()) SWIG_fail;
55826 }
55827 resultobj = SWIG_From_int(static_cast< int >(result));
55828 return resultobj;
55829 fail:
55830 return NULL;
55831 }
55832
55833
55834 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55835 PyObject *resultobj = 0;
55836 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55837 int arg2 ;
55838 void *argp1 = 0 ;
55839 int res1 = 0 ;
55840 int val2 ;
55841 int ecode2 = 0 ;
55842 PyObject * obj0 = 0 ;
55843 PyObject * obj1 = 0 ;
55844 char * kwnames[] = {
55845 (char *) "self",(char *) "m", NULL
55846 };
55847
55848 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
55849 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55850 if (!SWIG_IsOK(res1)) {
55851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
55852 }
55853 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55854 ecode2 = SWIG_AsVal_int(obj1, &val2);
55855 if (!SWIG_IsOK(ecode2)) {
55856 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
55857 }
55858 arg2 = static_cast< int >(val2);
55859 {
55860 PyThreadState* __tstate = wxPyBeginAllowThreads();
55861 (arg1)->SetMargin(arg2);
55862 wxPyEndAllowThreads(__tstate);
55863 if (PyErr_Occurred()) SWIG_fail;
55864 }
55865 resultobj = SWIG_Py_Void();
55866 return resultobj;
55867 fail:
55868 return NULL;
55869 }
55870
55871
55872 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55873 PyObject *resultobj = 0;
55874 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55875 int result;
55876 void *argp1 = 0 ;
55877 int res1 = 0 ;
55878 PyObject *swig_obj[1] ;
55879
55880 if (!args) SWIG_fail;
55881 swig_obj[0] = args;
55882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55883 if (!SWIG_IsOK(res1)) {
55884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55885 }
55886 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55887 {
55888 PyThreadState* __tstate = wxPyBeginAllowThreads();
55889 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
55890 wxPyEndAllowThreads(__tstate);
55891 if (PyErr_Occurred()) SWIG_fail;
55892 }
55893 resultobj = SWIG_From_int(static_cast< int >(result));
55894 return resultobj;
55895 fail:
55896 return NULL;
55897 }
55898
55899
55900 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55901 PyObject *resultobj = 0;
55902 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55903 int result;
55904 void *argp1 = 0 ;
55905 int res1 = 0 ;
55906 PyObject *swig_obj[1] ;
55907
55908 if (!args) SWIG_fail;
55909 swig_obj[0] = args;
55910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55911 if (!SWIG_IsOK(res1)) {
55912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55913 }
55914 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55915 {
55916 PyThreadState* __tstate = wxPyBeginAllowThreads();
55917 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
55918 wxPyEndAllowThreads(__tstate);
55919 if (PyErr_Occurred()) SWIG_fail;
55920 }
55921 resultobj = SWIG_From_int(static_cast< int >(result));
55922 return resultobj;
55923 fail:
55924 return NULL;
55925 }
55926
55927
55928 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55929 PyObject *resultobj = 0;
55930 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55931 int result;
55932 void *argp1 = 0 ;
55933 int res1 = 0 ;
55934 PyObject *swig_obj[1] ;
55935
55936 if (!args) SWIG_fail;
55937 swig_obj[0] = args;
55938 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55939 if (!SWIG_IsOK(res1)) {
55940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55941 }
55942 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55943 {
55944 PyThreadState* __tstate = wxPyBeginAllowThreads();
55945 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
55946 wxPyEndAllowThreads(__tstate);
55947 if (PyErr_Occurred()) SWIG_fail;
55948 }
55949 resultobj = SWIG_From_int(static_cast< int >(result));
55950 return resultobj;
55951 fail:
55952 return NULL;
55953 }
55954
55955
55956 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
55957 PyObject *resultobj = 0;
55958 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55959 bool result;
55960 void *argp1 = 0 ;
55961 int res1 = 0 ;
55962 PyObject *swig_obj[1] ;
55963
55964 if (!args) SWIG_fail;
55965 swig_obj[0] = args;
55966 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
55967 if (!SWIG_IsOK(res1)) {
55968 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
55969 }
55970 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
55971 {
55972 PyThreadState* __tstate = wxPyBeginAllowThreads();
55973 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
55974 wxPyEndAllowThreads(__tstate);
55975 if (PyErr_Occurred()) SWIG_fail;
55976 }
55977 {
55978 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
55979 }
55980 return resultobj;
55981 fail:
55982 return NULL;
55983 }
55984
55985
55986 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
55987 PyObject *resultobj = 0;
55988 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
55989 bool arg2 ;
55990 void *argp1 = 0 ;
55991 int res1 = 0 ;
55992 bool val2 ;
55993 int ecode2 = 0 ;
55994 PyObject * obj0 = 0 ;
55995 PyObject * obj1 = 0 ;
55996 char * kwnames[] = {
55997 (char *) "self",(char *) "d", NULL
55998 };
55999
56000 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
56001 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56002 if (!SWIG_IsOK(res1)) {
56003 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56004 }
56005 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56006 ecode2 = SWIG_AsVal_bool(obj1, &val2);
56007 if (!SWIG_IsOK(ecode2)) {
56008 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
56009 }
56010 arg2 = static_cast< bool >(val2);
56011 {
56012 PyThreadState* __tstate = wxPyBeginAllowThreads();
56013 (arg1)->SetDone(arg2);
56014 wxPyEndAllowThreads(__tstate);
56015 if (PyErr_Occurred()) SWIG_fail;
56016 }
56017 resultobj = SWIG_Py_Void();
56018 return resultobj;
56019 fail:
56020 return NULL;
56021 }
56022
56023
56024 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56025 PyObject *resultobj = 0;
56026 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56027 wxRelationship result;
56028 void *argp1 = 0 ;
56029 int res1 = 0 ;
56030 PyObject *swig_obj[1] ;
56031
56032 if (!args) SWIG_fail;
56033 swig_obj[0] = args;
56034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56035 if (!SWIG_IsOK(res1)) {
56036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56037 }
56038 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56039 {
56040 PyThreadState* __tstate = wxPyBeginAllowThreads();
56041 result = (wxRelationship)(arg1)->GetRelationship();
56042 wxPyEndAllowThreads(__tstate);
56043 if (PyErr_Occurred()) SWIG_fail;
56044 }
56045 resultobj = SWIG_From_int(static_cast< int >(result));
56046 return resultobj;
56047 fail:
56048 return NULL;
56049 }
56050
56051
56052 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56053 PyObject *resultobj = 0;
56054 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56055 wxRelationship arg2 ;
56056 void *argp1 = 0 ;
56057 int res1 = 0 ;
56058 int val2 ;
56059 int ecode2 = 0 ;
56060 PyObject * obj0 = 0 ;
56061 PyObject * obj1 = 0 ;
56062 char * kwnames[] = {
56063 (char *) "self",(char *) "r", NULL
56064 };
56065
56066 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
56067 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56068 if (!SWIG_IsOK(res1)) {
56069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56070 }
56071 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56072 ecode2 = SWIG_AsVal_int(obj1, &val2);
56073 if (!SWIG_IsOK(ecode2)) {
56074 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
56075 }
56076 arg2 = static_cast< wxRelationship >(val2);
56077 {
56078 PyThreadState* __tstate = wxPyBeginAllowThreads();
56079 (arg1)->SetRelationship(arg2);
56080 wxPyEndAllowThreads(__tstate);
56081 if (PyErr_Occurred()) SWIG_fail;
56082 }
56083 resultobj = SWIG_Py_Void();
56084 return resultobj;
56085 fail:
56086 return NULL;
56087 }
56088
56089
56090 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56091 PyObject *resultobj = 0;
56092 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56093 wxWindow *arg2 = (wxWindow *) 0 ;
56094 bool result;
56095 void *argp1 = 0 ;
56096 int res1 = 0 ;
56097 void *argp2 = 0 ;
56098 int res2 = 0 ;
56099 PyObject * obj0 = 0 ;
56100 PyObject * obj1 = 0 ;
56101 char * kwnames[] = {
56102 (char *) "self",(char *) "otherW", NULL
56103 };
56104
56105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
56106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56107 if (!SWIG_IsOK(res1)) {
56108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56109 }
56110 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56111 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56112 if (!SWIG_IsOK(res2)) {
56113 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
56114 }
56115 arg2 = reinterpret_cast< wxWindow * >(argp2);
56116 {
56117 PyThreadState* __tstate = wxPyBeginAllowThreads();
56118 result = (bool)(arg1)->ResetIfWin(arg2);
56119 wxPyEndAllowThreads(__tstate);
56120 if (PyErr_Occurred()) SWIG_fail;
56121 }
56122 {
56123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56124 }
56125 return resultobj;
56126 fail:
56127 return NULL;
56128 }
56129
56130
56131 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56132 PyObject *resultobj = 0;
56133 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56134 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
56135 wxWindow *arg3 = (wxWindow *) 0 ;
56136 bool result;
56137 void *argp1 = 0 ;
56138 int res1 = 0 ;
56139 void *argp2 = 0 ;
56140 int res2 = 0 ;
56141 void *argp3 = 0 ;
56142 int res3 = 0 ;
56143 PyObject * obj0 = 0 ;
56144 PyObject * obj1 = 0 ;
56145 PyObject * obj2 = 0 ;
56146 char * kwnames[] = {
56147 (char *) "self",(char *) "constraints",(char *) "win", NULL
56148 };
56149
56150 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
56151 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56152 if (!SWIG_IsOK(res1)) {
56153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
56154 }
56155 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56156 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56157 if (!SWIG_IsOK(res2)) {
56158 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
56159 }
56160 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
56161 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56162 if (!SWIG_IsOK(res3)) {
56163 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
56164 }
56165 arg3 = reinterpret_cast< wxWindow * >(argp3);
56166 {
56167 PyThreadState* __tstate = wxPyBeginAllowThreads();
56168 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
56169 wxPyEndAllowThreads(__tstate);
56170 if (PyErr_Occurred()) SWIG_fail;
56171 }
56172 {
56173 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56174 }
56175 return resultobj;
56176 fail:
56177 return NULL;
56178 }
56179
56180
56181 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56182 PyObject *resultobj = 0;
56183 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
56184 wxEdge arg2 ;
56185 wxWindow *arg3 = (wxWindow *) 0 ;
56186 wxWindow *arg4 = (wxWindow *) 0 ;
56187 int result;
56188 void *argp1 = 0 ;
56189 int res1 = 0 ;
56190 int val2 ;
56191 int ecode2 = 0 ;
56192 void *argp3 = 0 ;
56193 int res3 = 0 ;
56194 void *argp4 = 0 ;
56195 int res4 = 0 ;
56196 PyObject * obj0 = 0 ;
56197 PyObject * obj1 = 0 ;
56198 PyObject * obj2 = 0 ;
56199 PyObject * obj3 = 0 ;
56200 char * kwnames[] = {
56201 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
56202 };
56203
56204 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
56205 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56206 if (!SWIG_IsOK(res1)) {
56207 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
56208 }
56209 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
56210 ecode2 = SWIG_AsVal_int(obj1, &val2);
56211 if (!SWIG_IsOK(ecode2)) {
56212 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
56213 }
56214 arg2 = static_cast< wxEdge >(val2);
56215 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
56216 if (!SWIG_IsOK(res3)) {
56217 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
56218 }
56219 arg3 = reinterpret_cast< wxWindow * >(argp3);
56220 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
56221 if (!SWIG_IsOK(res4)) {
56222 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
56223 }
56224 arg4 = reinterpret_cast< wxWindow * >(argp4);
56225 {
56226 PyThreadState* __tstate = wxPyBeginAllowThreads();
56227 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
56228 wxPyEndAllowThreads(__tstate);
56229 if (PyErr_Occurred()) SWIG_fail;
56230 }
56231 resultobj = SWIG_From_int(static_cast< int >(result));
56232 return resultobj;
56233 fail:
56234 return NULL;
56235 }
56236
56237
56238 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56239 PyObject *obj;
56240 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56241 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
56242 return SWIG_Py_Void();
56243 }
56244
56245 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56246 PyObject *resultobj = 0;
56247 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56248 wxIndividualLayoutConstraint *result = 0 ;
56249 void *argp1 = 0 ;
56250 int res1 = 0 ;
56251 PyObject *swig_obj[1] ;
56252
56253 if (!args) SWIG_fail;
56254 swig_obj[0] = args;
56255 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56256 if (!SWIG_IsOK(res1)) {
56257 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56258 }
56259 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56260 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
56261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56262 return resultobj;
56263 fail:
56264 return NULL;
56265 }
56266
56267
56268 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56269 PyObject *resultobj = 0;
56270 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56271 wxIndividualLayoutConstraint *result = 0 ;
56272 void *argp1 = 0 ;
56273 int res1 = 0 ;
56274 PyObject *swig_obj[1] ;
56275
56276 if (!args) SWIG_fail;
56277 swig_obj[0] = args;
56278 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56279 if (!SWIG_IsOK(res1)) {
56280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56281 }
56282 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56283 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
56284 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56285 return resultobj;
56286 fail:
56287 return NULL;
56288 }
56289
56290
56291 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56292 PyObject *resultobj = 0;
56293 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56294 wxIndividualLayoutConstraint *result = 0 ;
56295 void *argp1 = 0 ;
56296 int res1 = 0 ;
56297 PyObject *swig_obj[1] ;
56298
56299 if (!args) SWIG_fail;
56300 swig_obj[0] = args;
56301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56302 if (!SWIG_IsOK(res1)) {
56303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56304 }
56305 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56306 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
56307 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56308 return resultobj;
56309 fail:
56310 return NULL;
56311 }
56312
56313
56314 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56315 PyObject *resultobj = 0;
56316 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56317 wxIndividualLayoutConstraint *result = 0 ;
56318 void *argp1 = 0 ;
56319 int res1 = 0 ;
56320 PyObject *swig_obj[1] ;
56321
56322 if (!args) SWIG_fail;
56323 swig_obj[0] = args;
56324 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56325 if (!SWIG_IsOK(res1)) {
56326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56327 }
56328 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56329 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
56330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56331 return resultobj;
56332 fail:
56333 return NULL;
56334 }
56335
56336
56337 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56338 PyObject *resultobj = 0;
56339 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56340 wxIndividualLayoutConstraint *result = 0 ;
56341 void *argp1 = 0 ;
56342 int res1 = 0 ;
56343 PyObject *swig_obj[1] ;
56344
56345 if (!args) SWIG_fail;
56346 swig_obj[0] = args;
56347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56348 if (!SWIG_IsOK(res1)) {
56349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56350 }
56351 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56352 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
56353 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56354 return resultobj;
56355 fail:
56356 return NULL;
56357 }
56358
56359
56360 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56361 PyObject *resultobj = 0;
56362 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56363 wxIndividualLayoutConstraint *result = 0 ;
56364 void *argp1 = 0 ;
56365 int res1 = 0 ;
56366 PyObject *swig_obj[1] ;
56367
56368 if (!args) SWIG_fail;
56369 swig_obj[0] = args;
56370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56371 if (!SWIG_IsOK(res1)) {
56372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56373 }
56374 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56375 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
56376 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56377 return resultobj;
56378 fail:
56379 return NULL;
56380 }
56381
56382
56383 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56384 PyObject *resultobj = 0;
56385 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56386 wxIndividualLayoutConstraint *result = 0 ;
56387 void *argp1 = 0 ;
56388 int res1 = 0 ;
56389 PyObject *swig_obj[1] ;
56390
56391 if (!args) SWIG_fail;
56392 swig_obj[0] = args;
56393 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56394 if (!SWIG_IsOK(res1)) {
56395 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56396 }
56397 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56398 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
56399 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56400 return resultobj;
56401 fail:
56402 return NULL;
56403 }
56404
56405
56406 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56407 PyObject *resultobj = 0;
56408 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56409 wxIndividualLayoutConstraint *result = 0 ;
56410 void *argp1 = 0 ;
56411 int res1 = 0 ;
56412 PyObject *swig_obj[1] ;
56413
56414 if (!args) SWIG_fail;
56415 swig_obj[0] = args;
56416 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56417 if (!SWIG_IsOK(res1)) {
56418 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56419 }
56420 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56421 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
56422 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
56423 return resultobj;
56424 fail:
56425 return NULL;
56426 }
56427
56428
56429 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56430 PyObject *resultobj = 0;
56431 wxLayoutConstraints *result = 0 ;
56432
56433 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
56434 {
56435 PyThreadState* __tstate = wxPyBeginAllowThreads();
56436 result = (wxLayoutConstraints *)new wxLayoutConstraints();
56437 wxPyEndAllowThreads(__tstate);
56438 if (PyErr_Occurred()) SWIG_fail;
56439 }
56440 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
56441 return resultobj;
56442 fail:
56443 return NULL;
56444 }
56445
56446
56447 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56448 PyObject *resultobj = 0;
56449 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56450 void *argp1 = 0 ;
56451 int res1 = 0 ;
56452 PyObject *swig_obj[1] ;
56453
56454 if (!args) SWIG_fail;
56455 swig_obj[0] = args;
56456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
56457 if (!SWIG_IsOK(res1)) {
56458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56459 }
56460 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56461 {
56462 PyThreadState* __tstate = wxPyBeginAllowThreads();
56463 delete arg1;
56464
56465 wxPyEndAllowThreads(__tstate);
56466 if (PyErr_Occurred()) SWIG_fail;
56467 }
56468 resultobj = SWIG_Py_Void();
56469 return resultobj;
56470 fail:
56471 return NULL;
56472 }
56473
56474
56475 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
56476 PyObject *resultobj = 0;
56477 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56478 wxWindow *arg2 = (wxWindow *) 0 ;
56479 int *arg3 = (int *) 0 ;
56480 bool result;
56481 void *argp1 = 0 ;
56482 int res1 = 0 ;
56483 void *argp2 = 0 ;
56484 int res2 = 0 ;
56485 int temp3 ;
56486 int res3 = SWIG_TMPOBJ ;
56487 PyObject * obj0 = 0 ;
56488 PyObject * obj1 = 0 ;
56489 char * kwnames[] = {
56490 (char *) "self",(char *) "win", NULL
56491 };
56492
56493 arg3 = &temp3;
56494 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
56495 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56496 if (!SWIG_IsOK(res1)) {
56497 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
56498 }
56499 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56500 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
56501 if (!SWIG_IsOK(res2)) {
56502 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
56503 }
56504 arg2 = reinterpret_cast< wxWindow * >(argp2);
56505 {
56506 PyThreadState* __tstate = wxPyBeginAllowThreads();
56507 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
56508 wxPyEndAllowThreads(__tstate);
56509 if (PyErr_Occurred()) SWIG_fail;
56510 }
56511 {
56512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56513 }
56514 if (SWIG_IsTmpObj(res3)) {
56515 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
56516 } else {
56517 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
56518 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
56519 }
56520 return resultobj;
56521 fail:
56522 return NULL;
56523 }
56524
56525
56526 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56527 PyObject *resultobj = 0;
56528 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
56529 bool result;
56530 void *argp1 = 0 ;
56531 int res1 = 0 ;
56532 PyObject *swig_obj[1] ;
56533
56534 if (!args) SWIG_fail;
56535 swig_obj[0] = args;
56536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
56537 if (!SWIG_IsOK(res1)) {
56538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
56539 }
56540 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
56541 {
56542 PyThreadState* __tstate = wxPyBeginAllowThreads();
56543 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
56544 wxPyEndAllowThreads(__tstate);
56545 if (PyErr_Occurred()) SWIG_fail;
56546 }
56547 {
56548 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
56549 }
56550 return resultobj;
56551 fail:
56552 return NULL;
56553 }
56554
56555
56556 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56557 PyObject *obj;
56558 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
56559 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
56560 return SWIG_Py_Void();
56561 }
56562
56563 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
56564 return SWIG_Python_InitShadowInstance(args);
56565 }
56566
56567 static PyMethodDef SwigMethods[] = {
56568 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
56569 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
56570 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
56571 { (char *)"Object_IsSameAs", (PyCFunction) _wrap_Object_IsSameAs, METH_VARARGS | METH_KEYWORDS, NULL},
56572 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
56573 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
56574 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
56575 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
56576 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
56577 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56578 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
56579 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56580 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56581 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56582 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56583 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
56584 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
56585 { (char *)"Size_IncBy", (PyCFunction) _wrap_Size_IncBy, METH_VARARGS | METH_KEYWORDS, NULL},
56586 { (char *)"Size_DecBy", (PyCFunction) _wrap_Size_DecBy, METH_VARARGS | METH_KEYWORDS, NULL},
56587 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56588 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56589 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56590 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56591 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
56592 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
56593 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
56594 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
56595 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
56596 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
56597 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
56598 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
56599 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
56600 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
56601 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
56602 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56603 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
56604 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56605 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56606 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56607 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56608 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56609 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
56610 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
56611 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
56612 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
56613 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
56614 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
56615 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
56616 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
56617 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
56618 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56619 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56620 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56621 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
56622 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56623 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56624 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56625 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
56626 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
56627 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
56628 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
56629 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
56630 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
56631 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
56632 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
56633 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
56634 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
56635 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
56636 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
56637 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
56638 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
56639 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
56640 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
56641 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
56642 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
56643 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
56644 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
56645 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
56646 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
56647 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56648 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
56649 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
56650 { (char *)"Rect_GetTopRight", (PyCFunction)_wrap_Rect_GetTopRight, METH_O, NULL},
56651 { (char *)"Rect_SetTopRight", (PyCFunction) _wrap_Rect_SetTopRight, METH_VARARGS | METH_KEYWORDS, NULL},
56652 { (char *)"Rect_GetBottomLeft", (PyCFunction)_wrap_Rect_GetBottomLeft, METH_O, NULL},
56653 { (char *)"Rect_SetBottomLeft", (PyCFunction) _wrap_Rect_SetBottomLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56654 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
56655 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
56656 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
56657 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
56658 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56659 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56660 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56661 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56662 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
56663 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
56664 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
56665 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56666 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56667 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56668 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
56669 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56670 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56671 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56672 { (char *)"Rect_ContainsXY", (PyCFunction) _wrap_Rect_ContainsXY, METH_VARARGS | METH_KEYWORDS, NULL},
56673 { (char *)"Rect_Contains", (PyCFunction) _wrap_Rect_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56674 { (char *)"Rect_ContainsRect", (PyCFunction) _wrap_Rect_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56675 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56676 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
56677 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
56678 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
56679 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
56680 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
56681 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
56682 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
56683 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
56684 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
56685 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56686 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
56687 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
56688 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
56689 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
56690 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
56691 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
56692 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
56693 { (char *)"delete_Point2D", (PyCFunction)_wrap_delete_Point2D, METH_O, NULL},
56694 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
56695 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
56696 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
56697 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
56698 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
56699 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
56700 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
56701 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
56702 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56703 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
56704 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
56705 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
56706 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
56707 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
56708 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
56709 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56710 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56711 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
56712 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
56713 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
56714 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
56715 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56716 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
56717 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
56718 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
56719 { (char *)"new_Rect2D", (PyCFunction) _wrap_new_Rect2D, METH_VARARGS | METH_KEYWORDS, NULL},
56720 { (char *)"delete_Rect2D", (PyCFunction)_wrap_delete_Rect2D, METH_O, NULL},
56721 { (char *)"Rect2D_GetPosition", (PyCFunction)_wrap_Rect2D_GetPosition, METH_O, NULL},
56722 { (char *)"Rect2D_GetSize", (PyCFunction)_wrap_Rect2D_GetSize, METH_O, NULL},
56723 { (char *)"Rect2D_GetLeft", (PyCFunction)_wrap_Rect2D_GetLeft, METH_O, NULL},
56724 { (char *)"Rect2D_SetLeft", (PyCFunction) _wrap_Rect2D_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
56725 { (char *)"Rect2D_MoveLeftTo", (PyCFunction) _wrap_Rect2D_MoveLeftTo, METH_VARARGS | METH_KEYWORDS, NULL},
56726 { (char *)"Rect2D_GetTop", (PyCFunction)_wrap_Rect2D_GetTop, METH_O, NULL},
56727 { (char *)"Rect2D_SetTop", (PyCFunction) _wrap_Rect2D_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
56728 { (char *)"Rect2D_MoveTopTo", (PyCFunction) _wrap_Rect2D_MoveTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56729 { (char *)"Rect2D_GetBottom", (PyCFunction)_wrap_Rect2D_GetBottom, METH_O, NULL},
56730 { (char *)"Rect2D_SetBottom", (PyCFunction) _wrap_Rect2D_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56731 { (char *)"Rect2D_MoveBottomTo", (PyCFunction) _wrap_Rect2D_MoveBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56732 { (char *)"Rect2D_GetRight", (PyCFunction)_wrap_Rect2D_GetRight, METH_O, NULL},
56733 { (char *)"Rect2D_SetRight", (PyCFunction) _wrap_Rect2D_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
56734 { (char *)"Rect2D_MoveRightTo", (PyCFunction) _wrap_Rect2D_MoveRightTo, METH_VARARGS | METH_KEYWORDS, NULL},
56735 { (char *)"Rect2D_GetLeftTop", (PyCFunction)_wrap_Rect2D_GetLeftTop, METH_O, NULL},
56736 { (char *)"Rect2D_SetLeftTop", (PyCFunction) _wrap_Rect2D_SetLeftTop, METH_VARARGS | METH_KEYWORDS, NULL},
56737 { (char *)"Rect2D_MoveLeftTopTo", (PyCFunction) _wrap_Rect2D_MoveLeftTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56738 { (char *)"Rect2D_GetLeftBottom", (PyCFunction)_wrap_Rect2D_GetLeftBottom, METH_O, NULL},
56739 { (char *)"Rect2D_SetLeftBottom", (PyCFunction) _wrap_Rect2D_SetLeftBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56740 { (char *)"Rect2D_MoveLeftBottomTo", (PyCFunction) _wrap_Rect2D_MoveLeftBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56741 { (char *)"Rect2D_GetRightTop", (PyCFunction)_wrap_Rect2D_GetRightTop, METH_O, NULL},
56742 { (char *)"Rect2D_SetRightTop", (PyCFunction) _wrap_Rect2D_SetRightTop, METH_VARARGS | METH_KEYWORDS, NULL},
56743 { (char *)"Rect2D_MoveRightTopTo", (PyCFunction) _wrap_Rect2D_MoveRightTopTo, METH_VARARGS | METH_KEYWORDS, NULL},
56744 { (char *)"Rect2D_GetRightBottom", (PyCFunction)_wrap_Rect2D_GetRightBottom, METH_O, NULL},
56745 { (char *)"Rect2D_SetRightBottom", (PyCFunction) _wrap_Rect2D_SetRightBottom, METH_VARARGS | METH_KEYWORDS, NULL},
56746 { (char *)"Rect2D_MoveRightBottomTo", (PyCFunction) _wrap_Rect2D_MoveRightBottomTo, METH_VARARGS | METH_KEYWORDS, NULL},
56747 { (char *)"Rect2D_GetCentre", (PyCFunction)_wrap_Rect2D_GetCentre, METH_O, NULL},
56748 { (char *)"Rect2D_SetCentre", (PyCFunction) _wrap_Rect2D_SetCentre, METH_VARARGS | METH_KEYWORDS, NULL},
56749 { (char *)"Rect2D_MoveCentreTo", (PyCFunction) _wrap_Rect2D_MoveCentreTo, METH_VARARGS | METH_KEYWORDS, NULL},
56750 { (char *)"Rect2D_GetOutcode", (PyCFunction) _wrap_Rect2D_GetOutcode, METH_VARARGS | METH_KEYWORDS, NULL},
56751 { (char *)"Rect2D_Contains", (PyCFunction) _wrap_Rect2D_Contains, METH_VARARGS | METH_KEYWORDS, NULL},
56752 { (char *)"Rect2D_ContainsRect", (PyCFunction) _wrap_Rect2D_ContainsRect, METH_VARARGS | METH_KEYWORDS, NULL},
56753 { (char *)"Rect2D_IsEmpty", (PyCFunction)_wrap_Rect2D_IsEmpty, METH_O, NULL},
56754 { (char *)"Rect2D_HaveEqualSize", (PyCFunction) _wrap_Rect2D_HaveEqualSize, METH_VARARGS | METH_KEYWORDS, NULL},
56755 { (char *)"Rect2D_Inset", _wrap_Rect2D_Inset, METH_VARARGS, NULL},
56756 { (char *)"Rect2D_Offset", (PyCFunction) _wrap_Rect2D_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
56757 { (char *)"Rect2D_ConstrainTo", (PyCFunction) _wrap_Rect2D_ConstrainTo, METH_VARARGS | METH_KEYWORDS, NULL},
56758 { (char *)"Rect2D_Interpolate", (PyCFunction) _wrap_Rect2D_Interpolate, METH_VARARGS | METH_KEYWORDS, NULL},
56759 { (char *)"Rect2D_Intersect", (PyCFunction) _wrap_Rect2D_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
56760 { (char *)"Rect2D_CreateIntersection", (PyCFunction) _wrap_Rect2D_CreateIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
56761 { (char *)"Rect2D_Intersects", (PyCFunction) _wrap_Rect2D_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
56762 { (char *)"Rect2D_Union", (PyCFunction) _wrap_Rect2D_Union, METH_VARARGS | METH_KEYWORDS, NULL},
56763 { (char *)"Rect2D_CreateUnion", (PyCFunction) _wrap_Rect2D_CreateUnion, METH_VARARGS | METH_KEYWORDS, NULL},
56764 { (char *)"Rect2D_Scale", _wrap_Rect2D_Scale, METH_VARARGS, NULL},
56765 { (char *)"Rect2D___eq__", (PyCFunction) _wrap_Rect2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
56766 { (char *)"Rect2D___ne__", (PyCFunction) _wrap_Rect2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
56767 { (char *)"Rect2D_x_set", _wrap_Rect2D_x_set, METH_VARARGS, NULL},
56768 { (char *)"Rect2D_x_get", (PyCFunction)_wrap_Rect2D_x_get, METH_O, NULL},
56769 { (char *)"Rect2D_y_set", _wrap_Rect2D_y_set, METH_VARARGS, NULL},
56770 { (char *)"Rect2D_y_get", (PyCFunction)_wrap_Rect2D_y_get, METH_O, NULL},
56771 { (char *)"Rect2D_width_set", _wrap_Rect2D_width_set, METH_VARARGS, NULL},
56772 { (char *)"Rect2D_width_get", (PyCFunction)_wrap_Rect2D_width_get, METH_O, NULL},
56773 { (char *)"Rect2D_height_set", _wrap_Rect2D_height_set, METH_VARARGS, NULL},
56774 { (char *)"Rect2D_height_get", (PyCFunction)_wrap_Rect2D_height_get, METH_O, NULL},
56775 { (char *)"Rect2D_Set", (PyCFunction) _wrap_Rect2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
56776 { (char *)"Rect2D_Get", (PyCFunction)_wrap_Rect2D_Get, METH_O, NULL},
56777 { (char *)"Rect2D_swigregister", Rect2D_swigregister, METH_VARARGS, NULL},
56778 { (char *)"Rect2D_swiginit", Rect2D_swiginit, METH_VARARGS, NULL},
56779 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
56780 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
56781 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
56782 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
56783 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
56784 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
56785 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
56786 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
56787 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
56788 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
56789 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
56790 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
56791 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
56792 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
56793 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
56794 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
56795 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
56796 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
56797 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
56798 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
56799 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
56800 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
56801 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
56802 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
56803 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
56804 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
56805 { (char *)"FSFile_DetachStream", (PyCFunction)_wrap_FSFile_DetachStream, METH_O, NULL},
56806 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
56807 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
56808 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
56809 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
56810 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
56811 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
56812 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
56813 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
56814 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
56815 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
56816 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56817 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56818 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56819 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
56820 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
56821 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56822 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
56823 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
56824 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
56825 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
56826 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
56827 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
56828 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
56829 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
56830 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
56831 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56832 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56833 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
56834 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56835 { (char *)"FileSystem_RemoveHandler", (PyCFunction) _wrap_FileSystem_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56836 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
56837 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
56838 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
56839 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
56840 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
56841 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
56842 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56843 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56844 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
56845 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
56846 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
56847 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56848 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56849 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56850 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
56851 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
56852 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
56853 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
56854 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56855 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
56856 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
56857 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56858 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
56859 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
56860 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
56861 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
56862 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
56863 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
56864 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
56865 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
56866 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
56867 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
56868 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56869 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56870 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
56871 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
56872 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
56873 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
56874 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
56875 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
56876 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
56877 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
56878 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
56879 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
56880 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
56881 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56882 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
56883 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56884 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
56885 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
56886 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
56887 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
56888 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
56889 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
56890 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
56891 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
56892 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
56893 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
56894 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
56895 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
56896 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
56897 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
56898 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
56899 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
56900 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
56901 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
56902 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
56903 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
56904 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
56905 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
56906 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
56907 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
56908 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
56909 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
56910 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
56911 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56912 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
56913 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56914 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
56915 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
56916 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
56917 { (char *)"Image_ResampleBox", (PyCFunction) _wrap_Image_ResampleBox, METH_VARARGS | METH_KEYWORDS, NULL},
56918 { (char *)"Image_ResampleBicubic", (PyCFunction) _wrap_Image_ResampleBicubic, METH_VARARGS | METH_KEYWORDS, NULL},
56919 { (char *)"Image_Blur", (PyCFunction) _wrap_Image_Blur, METH_VARARGS | METH_KEYWORDS, NULL},
56920 { (char *)"Image_BlurHorizontal", (PyCFunction) _wrap_Image_BlurHorizontal, METH_VARARGS | METH_KEYWORDS, NULL},
56921 { (char *)"Image_BlurVertical", (PyCFunction) _wrap_Image_BlurVertical, METH_VARARGS | METH_KEYWORDS, NULL},
56922 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
56923 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
56924 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
56925 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56926 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
56927 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
56928 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
56929 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
56930 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56931 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56932 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
56933 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
56934 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
56935 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
56936 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
56937 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
56938 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
56939 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
56940 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
56941 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
56942 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56943 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
56944 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
56945 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56946 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
56947 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
56948 { (char *)"Image_IsOk", (PyCFunction)_wrap_Image_IsOk, METH_O, NULL},
56949 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
56950 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
56951 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
56952 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
56953 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
56954 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
56955 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
56956 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
56957 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
56958 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
56959 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56960 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
56961 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
56962 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
56963 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56964 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
56965 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
56966 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
56967 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
56968 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
56969 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
56970 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
56971 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
56972 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
56973 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
56974 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
56975 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
56976 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
56977 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56978 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56979 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
56980 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
56981 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
56982 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
56983 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
56984 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56985 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56986 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
56987 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
56988 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
56989 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56990 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
56991 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
56992 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
56993 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
56994 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
56995 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
56996 { (char *)"_ImageFromBuffer", (PyCFunction) _wrap__ImageFromBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
56997 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
56998 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
56999 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
57000 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
57001 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
57002 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
57003 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
57004 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
57005 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
57006 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
57007 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
57008 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
57009 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
57010 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
57011 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
57012 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
57013 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
57014 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
57015 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
57016 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
57017 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
57018 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
57019 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
57020 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
57021 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
57022 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
57023 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
57024 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
57025 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
57026 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
57027 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
57028 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
57029 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
57030 { (char *)"new_TGAHandler", (PyCFunction)_wrap_new_TGAHandler, METH_NOARGS, NULL},
57031 { (char *)"TGAHandler_swigregister", TGAHandler_swigregister, METH_VARARGS, NULL},
57032 { (char *)"TGAHandler_swiginit", TGAHandler_swiginit, METH_VARARGS, NULL},
57033 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
57034 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
57035 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
57036 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
57037 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
57038 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57039 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57040 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
57041 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57042 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57043 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57044 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
57045 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
57046 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
57047 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57048 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
57049 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
57050 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
57051 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
57052 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
57053 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
57054 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
57055 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
57056 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
57057 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
57058 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
57059 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57060 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
57061 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
57062 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
57063 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
57064 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
57065 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
57066 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
57067 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
57068 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
57069 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
57070 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
57071 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
57072 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
57073 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
57074 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
57075 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
57076 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57077 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
57078 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57079 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
57080 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
57081 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
57082 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
57083 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
57084 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
57085 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
57086 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
57087 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57088 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
57089 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
57090 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
57091 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57092 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
57093 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
57094 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
57095 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
57096 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
57097 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57098 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
57099 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
57100 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57101 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57102 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
57103 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
57104 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57105 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
57106 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
57107 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57108 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57109 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
57110 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
57111 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57112 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
57113 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
57114 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
57115 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
57116 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
57117 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
57118 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
57119 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
57120 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
57121 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
57122 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
57123 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
57124 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
57125 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
57126 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
57127 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
57128 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
57129 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
57130 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
57131 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
57132 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
57133 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
57134 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
57135 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
57136 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
57137 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
57138 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
57139 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
57140 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
57141 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
57142 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57143 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
57144 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
57145 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
57146 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
57147 { (char *)"MouseEvent_GetWheelAxis", (PyCFunction)_wrap_MouseEvent_GetWheelAxis, METH_O, NULL},
57148 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
57149 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
57150 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
57151 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
57152 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
57153 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
57154 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
57155 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
57156 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
57157 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
57158 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
57159 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
57160 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
57161 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
57162 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
57163 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
57164 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
57165 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
57166 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
57167 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
57168 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
57169 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
57170 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
57171 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
57172 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
57173 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
57174 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
57175 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
57176 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57177 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
57178 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
57179 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57180 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
57181 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
57182 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
57183 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
57184 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57185 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
57186 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
57187 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
57188 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
57189 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
57190 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
57191 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
57192 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
57193 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
57194 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
57195 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
57196 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
57197 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
57198 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
57199 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
57200 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
57201 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
57202 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
57203 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
57204 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
57205 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
57206 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
57207 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
57208 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
57209 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
57210 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
57211 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
57212 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
57213 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
57214 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
57215 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
57216 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
57217 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
57218 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
57219 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
57220 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
57221 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
57222 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
57223 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57224 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
57225 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
57226 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57227 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57228 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
57229 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
57230 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
57231 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
57232 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
57233 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
57234 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57235 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
57236 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
57237 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57238 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57239 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
57240 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
57241 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57242 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
57243 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
57244 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57245 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
57246 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
57247 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57248 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
57249 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
57250 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
57251 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57252 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
57253 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57254 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
57255 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
57256 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57257 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
57258 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
57259 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
57260 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57261 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
57262 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
57263 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
57264 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57265 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
57266 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
57267 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57268 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
57269 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
57270 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
57271 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
57272 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
57273 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57274 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
57275 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
57276 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
57277 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
57278 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
57279 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
57280 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
57281 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
57282 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57283 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
57284 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
57285 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
57286 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
57287 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57288 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
57289 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
57290 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
57291 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57292 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
57293 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
57294 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
57295 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
57296 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
57297 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
57298 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57299 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
57300 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
57301 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
57302 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
57303 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
57304 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
57305 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
57306 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
57307 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57308 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57309 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57310 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57311 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
57312 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
57313 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
57314 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
57315 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57316 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
57317 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
57318 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
57319 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
57320 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
57321 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
57322 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57323 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
57324 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
57325 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
57326 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57327 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
57328 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
57329 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
57330 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
57331 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
57332 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57333 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57334 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
57335 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
57336 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
57337 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57338 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
57339 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
57340 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
57341 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
57342 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
57343 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
57344 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57345 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
57346 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
57347 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
57348 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
57349 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
57350 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
57351 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
57352 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
57353 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
57354 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57355 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
57356 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
57357 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
57358 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57359 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
57360 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
57361 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
57362 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57363 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
57364 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57365 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
57366 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
57367 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
57368 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
57369 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
57370 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
57371 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
57372 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
57373 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
57374 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
57375 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57376 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
57377 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
57378 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57379 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
57380 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57381 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
57382 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
57383 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
57384 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57385 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
57386 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
57387 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
57388 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
57389 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
57390 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57391 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
57392 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
57393 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
57394 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
57395 { (char *)"new_EventBlocker", (PyCFunction) _wrap_new_EventBlocker, METH_VARARGS | METH_KEYWORDS, NULL},
57396 { (char *)"delete_EventBlocker", (PyCFunction)_wrap_delete_EventBlocker, METH_O, NULL},
57397 { (char *)"EventBlocker_Block", (PyCFunction) _wrap_EventBlocker_Block, METH_VARARGS | METH_KEYWORDS, NULL},
57398 { (char *)"EventBlocker_swigregister", EventBlocker_swigregister, METH_VARARGS, NULL},
57399 { (char *)"EventBlocker_swiginit", EventBlocker_swiginit, METH_VARARGS, NULL},
57400 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
57401 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
57402 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57403 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
57404 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
57405 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
57406 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
57407 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
57408 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
57409 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
57410 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
57411 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
57412 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
57413 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
57414 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
57415 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
57416 { (char *)"PyApp_GetLayoutDirection", (PyCFunction)_wrap_PyApp_GetLayoutDirection, METH_O, NULL},
57417 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
57418 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
57419 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
57420 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
57421 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
57422 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
57423 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57424 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
57425 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
57426 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
57427 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
57428 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
57429 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
57430 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
57431 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
57432 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
57433 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
57434 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
57435 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
57436 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
57437 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
57438 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
57439 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57440 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57441 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
57442 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
57443 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
57444 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
57445 { (char *)"PyApp_IsDisplayAvailable", (PyCFunction)_wrap_PyApp_IsDisplayAvailable, METH_NOARGS, NULL},
57446 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
57447 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
57448 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
57449 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
57450 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
57451 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
57452 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
57453 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
57454 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
57455 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
57456 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
57457 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
57458 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
57459 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
57460 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
57461 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
57462 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
57463 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
57464 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
57465 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
57466 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
57467 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
57468 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
57469 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
57470 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
57471 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
57472 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
57473 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
57474 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
57475 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
57476 { (char *)"AcceleratorEntry_Create", (PyCFunction) _wrap_AcceleratorEntry_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57477 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
57478 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
57479 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
57480 { (char *)"AcceleratorEntry_IsOk", (PyCFunction)_wrap_AcceleratorEntry_IsOk, METH_O, NULL},
57481 { (char *)"AcceleratorEntry_ToString", (PyCFunction)_wrap_AcceleratorEntry_ToString, METH_O, NULL},
57482 { (char *)"AcceleratorEntry_FromString", (PyCFunction) _wrap_AcceleratorEntry_FromString, METH_VARARGS | METH_KEYWORDS, NULL},
57483 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
57484 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
57485 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57486 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
57487 { (char *)"AcceleratorTable_IsOk", (PyCFunction)_wrap_AcceleratorTable_IsOk, METH_O, NULL},
57488 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
57489 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
57490 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
57491 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
57492 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
57493 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
57494 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
57495 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
57496 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
57497 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
57498 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
57499 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
57500 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
57501 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
57502 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
57503 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57504 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
57505 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
57506 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
57507 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
57508 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57509 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
57510 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
57511 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
57512 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
57513 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
57514 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57515 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
57516 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
57517 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57518 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
57519 { (char *)"Window_GetLayoutDirection", (PyCFunction)_wrap_Window_GetLayoutDirection, METH_O, NULL},
57520 { (char *)"Window_SetLayoutDirection", (PyCFunction) _wrap_Window_SetLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57521 { (char *)"Window_AdjustForLayoutDirection", (PyCFunction) _wrap_Window_AdjustForLayoutDirection, METH_VARARGS | METH_KEYWORDS, NULL},
57522 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
57523 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
57524 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
57525 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57526 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
57527 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
57528 { (char *)"Window_SetInitialSize", (PyCFunction) _wrap_Window_SetInitialSize, METH_VARARGS | METH_KEYWORDS, NULL},
57529 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
57530 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
57531 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
57532 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57533 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
57534 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
57535 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
57536 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
57537 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
57538 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
57539 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
57540 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
57541 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
57542 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
57543 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
57544 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
57545 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
57546 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
57547 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
57548 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
57549 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
57550 { (char *)"Window_GetEffectiveMinSize", (PyCFunction)_wrap_Window_GetEffectiveMinSize, METH_O, NULL},
57551 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
57552 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
57553 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
57554 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
57555 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57556 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57557 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57558 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
57559 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
57560 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
57561 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57562 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
57563 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
57564 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
57565 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
57566 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
57567 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
57568 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
57569 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
57570 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
57571 { (char *)"Window_GetWindowBorderSize", (PyCFunction)_wrap_Window_GetWindowBorderSize, METH_O, NULL},
57572 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
57573 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57574 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
57575 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57576 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
57577 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
57578 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
57579 { (char *)"Window_IsShownOnScreen", (PyCFunction)_wrap_Window_IsShownOnScreen, METH_O, NULL},
57580 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57581 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
57582 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57583 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
57584 { (char *)"Window_ToggleWindowStyle", (PyCFunction) _wrap_Window_ToggleWindowStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57585 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57586 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
57587 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
57588 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57589 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
57590 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
57591 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
57592 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
57593 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
57594 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
57595 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
57596 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57597 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
57598 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
57599 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
57600 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
57601 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
57602 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
57603 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
57604 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
57605 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
57606 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57607 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57608 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
57609 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57610 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57611 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57612 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57613 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
57614 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
57615 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
57616 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
57617 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
57618 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
57619 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
57620 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
57621 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57622 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
57623 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57624 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
57625 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
57626 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
57627 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57628 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
57629 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
57630 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
57631 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
57632 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
57633 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
57634 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
57635 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
57636 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
57637 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
57638 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
57639 { (char *)"Window_IsFrozen", (PyCFunction)_wrap_Window_IsFrozen, METH_O, NULL},
57640 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
57641 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
57642 { (char *)"Window_IsDoubleBuffered", (PyCFunction)_wrap_Window_IsDoubleBuffered, METH_O, NULL},
57643 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
57644 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
57645 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
57646 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57647 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
57648 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
57649 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57650 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57651 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57652 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57653 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57654 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
57655 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
57656 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
57657 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
57658 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
57659 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
57660 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
57661 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
57662 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
57663 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57664 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
57665 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
57666 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
57667 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
57668 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
57669 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
57670 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57671 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
57672 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
57673 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
57674 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
57675 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
57676 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
57677 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
57678 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
57679 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
57680 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
57681 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57682 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
57683 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
57684 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
57685 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
57686 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57687 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
57688 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57689 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
57690 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
57691 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
57692 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57693 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
57694 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
57695 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
57696 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
57697 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
57698 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
57699 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
57700 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
57701 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
57702 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
57703 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
57704 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
57705 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
57706 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
57707 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
57708 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
57709 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
57710 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
57711 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
57712 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
57713 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
57714 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57715 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
57716 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
57717 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57718 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
57719 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
57720 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
57721 { (char *)"Window_CanSetTransparent", (PyCFunction)_wrap_Window_CanSetTransparent, METH_O, NULL},
57722 { (char *)"Window_SetTransparent", (PyCFunction) _wrap_Window_SetTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
57723 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
57724 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
57725 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
57726 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
57727 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57728 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
57729 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
57730 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
57731 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
57732 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
57733 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
57734 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
57735 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
57736 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57737 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
57738 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
57739 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
57740 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
57741 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
57742 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57743 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
57744 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
57745 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
57746 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57747 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
57748 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57749 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57750 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57751 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57752 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
57753 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57754 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57755 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
57756 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57757 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
57758 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57759 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57760 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57761 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57762 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
57763 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
57764 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
57765 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57766 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57767 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
57768 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57769 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
57770 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
57771 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
57772 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
57773 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
57774 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
57775 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
57776 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57777 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
57778 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57779 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57780 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57781 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57782 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57783 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57784 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57785 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57786 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
57787 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
57788 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
57789 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
57790 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57791 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
57792 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
57793 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
57794 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
57795 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57796 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
57797 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
57798 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
57799 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
57800 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
57801 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
57802 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
57803 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57804 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57805 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
57806 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57807 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
57808 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57809 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
57810 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
57811 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57812 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
57813 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57814 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
57815 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57816 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57817 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57818 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
57819 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
57820 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57821 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
57822 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57823 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
57824 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
57825 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
57826 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
57827 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
57828 { (char *)"MenuBar_UpdateMenus", (PyCFunction)_wrap_MenuBar_UpdateMenus, METH_O, NULL},
57829 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57830 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
57831 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
57832 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
57833 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
57834 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
57835 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
57836 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57837 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
57838 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
57839 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
57840 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
57841 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
57842 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
57843 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
57844 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
57845 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
57846 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
57847 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
57848 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
57849 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
57850 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
57851 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
57852 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
57853 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
57854 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
57855 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
57856 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
57857 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
57858 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
57859 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
57860 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57861 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
57862 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
57863 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
57864 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
57865 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
57866 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
57867 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
57868 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
57869 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
57870 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
57871 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
57872 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
57873 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
57874 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
57875 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
57876 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
57877 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
57878 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
57879 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
57880 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
57881 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
57882 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
57883 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
57884 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
57885 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
57886 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
57887 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
57888 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
57889 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
57890 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57891 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
57892 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
57893 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57894 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
57895 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
57896 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
57897 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
57898 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
57899 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
57900 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
57901 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57902 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
57903 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
57904 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
57905 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
57906 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
57907 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
57908 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
57909 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
57910 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57911 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57912 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57913 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
57914 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
57915 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
57916 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
57917 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57918 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
57919 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
57920 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
57921 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
57922 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
57923 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
57924 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
57925 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
57926 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
57927 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
57928 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
57929 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
57930 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
57931 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
57932 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
57933 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
57934 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
57935 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
57936 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57937 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
57938 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57939 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
57940 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
57941 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57942 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
57943 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
57944 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
57945 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
57946 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
57947 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
57948 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
57949 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57950 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
57951 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
57952 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
57953 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
57954 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
57955 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
57956 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57957 { (char *)"Sizer__ReplaceWin", (PyCFunction) _wrap_Sizer__ReplaceWin, METH_VARARGS | METH_KEYWORDS, NULL},
57958 { (char *)"Sizer__ReplaceSizer", (PyCFunction) _wrap_Sizer__ReplaceSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57959 { (char *)"Sizer__ReplaceItem", (PyCFunction) _wrap_Sizer__ReplaceItem, METH_VARARGS | METH_KEYWORDS, NULL},
57960 { (char *)"Sizer_SetContainingWindow", (PyCFunction) _wrap_Sizer_SetContainingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
57961 { (char *)"Sizer_GetContainingWindow", (PyCFunction)_wrap_Sizer_GetContainingWindow, METH_O, NULL},
57962 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
57963 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
57964 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
57965 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
57966 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
57967 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
57968 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
57969 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
57970 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
57971 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
57972 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
57973 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
57974 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
57975 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57976 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
57977 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
57978 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
57979 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
57980 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
57981 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
57982 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
57983 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
57984 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
57985 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
57986 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
57987 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
57988 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57989 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
57990 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
57991 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
57992 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
57993 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57994 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
57995 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
57996 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
57997 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
57998 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
57999 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
58000 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
58001 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
58002 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
58003 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
58004 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
58005 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
58006 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
58007 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
58008 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58009 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
58010 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
58011 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
58012 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
58013 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
58014 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
58015 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
58016 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
58017 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
58018 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
58019 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
58020 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
58021 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
58022 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
58023 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
58024 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
58025 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
58026 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
58027 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
58028 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
58029 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
58030 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
58031 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
58032 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
58033 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
58034 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58035 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
58036 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
58037 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
58038 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
58039 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
58040 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58041 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58042 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58043 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
58044 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
58045 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
58046 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
58047 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
58048 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
58049 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
58050 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
58051 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
58052 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
58053 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
58054 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58055 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
58056 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
58057 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
58058 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
58059 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
58060 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
58061 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58062 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
58063 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
58064 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
58065 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
58066 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
58067 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
58068 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
58069 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
58070 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
58071 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58072 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
58073 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
58074 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
58075 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
58076 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
58077 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
58078 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
58079 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
58080 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
58081 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
58082 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
58083 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
58084 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
58085 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
58086 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
58087 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
58088 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
58089 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
58090 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
58091 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
58092 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
58093 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
58094 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
58095 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
58096 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
58097 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
58098 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
58099 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
58100 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
58101 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
58102 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
58103 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
58104 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
58105 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
58106 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
58107 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
58108 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
58109 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
58110 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
58111 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
58112 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
58113 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
58114 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
58115 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
58116 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
58117 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
58118 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
58119 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
58120 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
58121 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
58122 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
58123 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
58124 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
58125 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
58126 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
58127 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
58128 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
58129 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
58130 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
58131 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
58132 { NULL, NULL, 0, NULL }
58133 };
58134
58135
58136 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
58137
58138 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
58139 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
58140 }
58141 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
58142 return (void *)((wxSizer *) ((wxBoxSizer *) x));
58143 }
58144 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
58145 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
58146 }
58147 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
58148 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58149 }
58150 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
58151 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58152 }
58153 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
58154 return (void *)((wxSizer *) ((wxGridSizer *) x));
58155 }
58156 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
58157 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
58158 }
58159 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
58160 return (void *)((wxSizer *) ((wxPySizer *) x));
58161 }
58162 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
58163 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
58164 }
58165 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
58166 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58167 }
58168 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
58169 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
58170 }
58171 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
58172 return (void *)((wxEvent *) ((wxMenuEvent *) x));
58173 }
58174 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
58175 return (void *)((wxEvent *) ((wxCloseEvent *) x));
58176 }
58177 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
58178 return (void *)((wxEvent *) ((wxMouseEvent *) x));
58179 }
58180 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
58181 return (void *)((wxEvent *) ((wxEraseEvent *) x));
58182 }
58183 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
58184 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
58185 }
58186 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
58187 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
58188 }
58189 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
58190 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
58191 }
58192 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
58193 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
58194 }
58195 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
58196 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
58197 }
58198 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
58199 return (void *)((wxEvent *) ((wxPyEvent *) x));
58200 }
58201 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
58202 return (void *)((wxEvent *) ((wxIdleEvent *) x));
58203 }
58204 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
58205 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
58206 }
58207 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
58208 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
58209 }
58210 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
58211 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
58212 }
58213 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
58214 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
58215 }
58216 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
58217 return (void *)((wxEvent *) ((wxActivateEvent *) x));
58218 }
58219 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
58220 return (void *)((wxEvent *) ((wxSizeEvent *) x));
58221 }
58222 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
58223 return (void *)((wxEvent *) ((wxMoveEvent *) x));
58224 }
58225 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
58226 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
58227 }
58228 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
58229 return (void *)((wxEvent *) ((wxPaintEvent *) x));
58230 }
58231 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
58232 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
58233 }
58234 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
58235 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
58236 }
58237 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
58238 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
58239 }
58240 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
58241 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
58242 }
58243 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
58244 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
58245 }
58246 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
58247 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58248 }
58249 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
58250 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
58251 }
58252 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
58253 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
58254 }
58255 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
58256 return (void *)((wxEvent *) ((wxFocusEvent *) x));
58257 }
58258 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
58259 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
58260 }
58261 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
58262 return (void *)((wxEvent *) ((wxShowEvent *) x));
58263 }
58264 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
58265 return (void *)((wxEvent *) ((wxCommandEvent *) x));
58266 }
58267 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
58268 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
58269 }
58270 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
58271 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58272 }
58273 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
58274 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
58275 }
58276 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
58277 return (void *)((wxEvent *) ((wxKeyEvent *) x));
58278 }
58279 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
58280 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
58281 }
58282 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
58283 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
58284 }
58285 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
58286 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
58287 }
58288 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
58289 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
58290 }
58291 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
58292 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
58293 }
58294 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
58295 return (void *)((wxControl *) ((wxControlWithItems *) x));
58296 }
58297 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
58298 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
58299 }
58300 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
58301 return (void *)((wxEvtHandler *) ((wxWindow *) x));
58302 }
58303 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
58304 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58305 }
58306 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
58307 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
58308 }
58309 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
58310 return (void *)((wxEvtHandler *) ((wxValidator *) x));
58311 }
58312 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
58313 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
58314 }
58315 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
58316 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
58317 }
58318 static void *_p_wxEventBlockerTo_p_wxEvtHandler(void *x) {
58319 return (void *)((wxEvtHandler *) ((wxEventBlocker *) x));
58320 }
58321 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
58322 return (void *)((wxEvtHandler *) ((wxMenu *) x));
58323 }
58324 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
58325 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
58326 }
58327 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
58328 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
58329 }
58330 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
58331 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
58332 }
58333 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
58334 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
58335 }
58336 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
58337 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
58338 }
58339 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
58340 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58341 }
58342 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
58343 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
58344 }
58345 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
58346 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
58347 }
58348 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
58349 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
58350 }
58351 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
58352 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58353 }
58354 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
58355 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58356 }
58357 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
58358 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
58359 }
58360 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
58361 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
58362 }
58363 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
58364 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
58365 }
58366 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
58367 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
58368 }
58369 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
58370 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
58371 }
58372 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
58373 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
58374 }
58375 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
58376 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
58377 }
58378 static void *_p_wxTGAHandlerTo_p_wxImageHandler(void *x) {
58379 return (void *)((wxImageHandler *) ((wxTGAHandler *) x));
58380 }
58381 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
58382 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
58383 }
58384 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
58385 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
58386 }
58387 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
58388 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
58389 }
58390 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
58391 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
58392 }
58393 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
58394 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
58395 }
58396 static void *_p_wxEventBlockerTo_p_wxObject(void *x) {
58397 return (void *)((wxObject *) (wxEvtHandler *) ((wxEventBlocker *) x));
58398 }
58399 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
58400 return (void *)((wxObject *) ((wxSizerItem *) x));
58401 }
58402 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
58403 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
58404 }
58405 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
58406 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
58407 }
58408 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
58409 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
58410 }
58411 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
58412 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
58413 }
58414 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
58415 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
58416 }
58417 static void *_p_wxSizerTo_p_wxObject(void *x) {
58418 return (void *)((wxObject *) ((wxSizer *) x));
58419 }
58420 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
58421 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
58422 }
58423 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
58424 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
58425 }
58426 static void *_p_wxEventTo_p_wxObject(void *x) {
58427 return (void *)((wxObject *) ((wxEvent *) x));
58428 }
58429 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
58430 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
58431 }
58432 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
58433 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
58434 }
58435 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
58436 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
58437 }
58438 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
58439 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
58440 }
58441 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
58442 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
58443 }
58444 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
58445 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
58446 }
58447 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
58448 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
58449 }
58450 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
58451 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
58452 }
58453 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
58454 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
58455 }
58456 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
58457 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
58458 }
58459 static void *_p_wxControlTo_p_wxObject(void *x) {
58460 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
58461 }
58462 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
58463 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
58464 }
58465 static void *_p_wxFSFileTo_p_wxObject(void *x) {
58466 return (void *)((wxObject *) ((wxFSFile *) x));
58467 }
58468 static void *_p_wxPySizerTo_p_wxObject(void *x) {
58469 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
58470 }
58471 static void *_p_wxPyEventTo_p_wxObject(void *x) {
58472 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
58473 }
58474 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
58475 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
58476 }
58477 static void *_p_wxShowEventTo_p_wxObject(void *x) {
58478 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
58479 }
58480 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
58481 return (void *)((wxObject *) ((wxMenuItem *) x));
58482 }
58483 static void *_p_wxDateEventTo_p_wxObject(void *x) {
58484 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
58485 }
58486 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
58487 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
58488 }
58489 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
58490 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
58491 }
58492 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
58493 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
58494 }
58495 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
58496 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
58497 }
58498 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
58499 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
58500 }
58501 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
58502 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
58503 }
58504 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
58505 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
58506 }
58507 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
58508 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
58509 }
58510 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
58511 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
58512 }
58513 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
58514 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
58515 }
58516 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
58517 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
58518 }
58519 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
58520 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
58521 }
58522 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
58523 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
58524 }
58525 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
58526 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
58527 }
58528 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
58529 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
58530 }
58531 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
58532 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
58533 }
58534 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
58535 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
58536 }
58537 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
58538 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
58539 }
58540 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
58541 return (void *)((wxObject *) ((wxImageHandler *) x));
58542 }
58543 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
58544 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
58545 }
58546 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
58547 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
58548 }
58549 static void *_p_wxTGAHandlerTo_p_wxObject(void *x) {
58550 return (void *)((wxObject *) (wxImageHandler *) ((wxTGAHandler *) x));
58551 }
58552 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
58553 return (void *)((wxObject *) ((wxEvtHandler *) x));
58554 }
58555 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
58556 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
58557 }
58558 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
58559 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
58560 }
58561 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
58562 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
58563 }
58564 static void *_p_wxImageTo_p_wxObject(void *x) {
58565 return (void *)((wxObject *) ((wxImage *) x));
58566 }
58567 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
58568 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
58569 }
58570 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
58571 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58572 }
58573 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
58574 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
58575 }
58576 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
58577 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
58578 }
58579 static void *_p_wxWindowTo_p_wxObject(void *x) {
58580 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
58581 }
58582 static void *_p_wxMenuTo_p_wxObject(void *x) {
58583 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
58584 }
58585 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
58586 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
58587 }
58588 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
58589 return (void *)((wxObject *) ((wxFileSystem *) x));
58590 }
58591 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
58592 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
58593 }
58594 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
58595 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
58596 }
58597 static void *_p_wxPyAppTo_p_wxObject(void *x) {
58598 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
58599 }
58600 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
58601 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
58602 }
58603 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
58604 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
58605 }
58606 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
58607 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
58608 }
58609 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
58610 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
58611 }
58612 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
58613 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
58614 }
58615 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
58616 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
58617 }
58618 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
58619 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
58620 }
58621 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
58622 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
58623 }
58624 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
58625 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
58626 }
58627 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
58628 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
58629 }
58630 static void *_p_wxValidatorTo_p_wxObject(void *x) {
58631 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
58632 }
58633 static void *_p_wxControlTo_p_wxWindow(void *x) {
58634 return (void *)((wxWindow *) ((wxControl *) x));
58635 }
58636 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
58637 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
58638 }
58639 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
58640 return (void *)((wxWindow *) ((wxMenuBar *) x));
58641 }
58642 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
58643 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
58644 }
58645 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
58646 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
58647 }
58648 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
58649 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
58650 }
58651 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
58652 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
58653 }
58654 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
58655 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
58656 }
58657 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
58658 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
58659 }
58660 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
58661 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
58662 }
58663 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
58664 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
58665 }
58666 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
58667 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
58668 }
58669 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
58670 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
58671 }
58672 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
58673 return (void *)((wxValidator *) ((wxPyValidator *) x));
58674 }
58675 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
58676 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
58677 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};
58678 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
58679 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
58680 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
58681 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
58682 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
58683 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
58684 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
58685 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
58686 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
58687 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
58688 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
58689 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
58690 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
58691 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
58692 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
58693 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
58694 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
58695 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
58696 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
58697 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
58698 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
58699 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
58700 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
58701 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
58702 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
58703 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
58704 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
58705 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
58706 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
58707 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
58708 static swig_type_info _swigt__p_wxDouble = {"_p_wxDouble", "wxDouble *", 0, 0, (void*)0, 0};
58709 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
58710 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
58711 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
58712 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
58713 static swig_type_info _swigt__p_wxEventBlocker = {"_p_wxEventBlocker", "wxEventBlocker *", 0, 0, (void*)0, 0};
58714 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
58715 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
58716 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
58717 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
58718 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
58719 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
58720 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
58721 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
58722 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
58723 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
58724 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
58725 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
58726 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
58727 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
58728 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
58729 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
58730 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
58731 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
58732 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
58733 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
58734 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
58735 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
58736 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
58737 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
58738 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
58739 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
58740 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
58741 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
58742 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
58743 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
58744 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
58745 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
58746 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
58747 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
58748 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
58749 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
58750 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
58751 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
58752 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
58753 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
58754 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
58755 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
58756 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
58757 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
58758 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
58759 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
58760 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
58761 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
58762 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
58763 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
58764 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
58765 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
58766 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
58767 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
58768 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
58769 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
58770 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
58771 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
58772 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
58773 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
58774 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
58775 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
58776 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
58777 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
58778 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
58779 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
58780 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
58781 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
58782 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
58783 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
58784 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
58785 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
58786 static swig_type_info _swigt__p_wxRect2D = {"_p_wxRect2D", "wxRect2D *", 0, 0, (void*)0, 0};
58787 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
58788 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
58789 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
58790 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
58791 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
58792 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
58793 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
58794 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
58795 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
58796 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
58797 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
58798 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
58799 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
58800 static swig_type_info _swigt__p_wxTGAHandler = {"_p_wxTGAHandler", "wxTGAHandler *", 0, 0, (void*)0, 0};
58801 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
58802 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
58803 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
58804 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
58805 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
58806 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
58807 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
58808 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
58809 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
58810 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
58811
58812 static swig_type_info *swig_type_initial[] = {
58813 &_swigt__p_buffer,
58814 &_swigt__p_char,
58815 &_swigt__p_form_ops_t,
58816 &_swigt__p_int,
58817 &_swigt__p_long,
58818 &_swigt__p_unsigned_char,
58819 &_swigt__p_unsigned_int,
58820 &_swigt__p_unsigned_long,
58821 &_swigt__p_wxANIHandler,
58822 &_swigt__p_wxAcceleratorEntry,
58823 &_swigt__p_wxAcceleratorTable,
58824 &_swigt__p_wxActivateEvent,
58825 &_swigt__p_wxAppTraits,
58826 &_swigt__p_wxArrayString,
58827 &_swigt__p_wxBMPHandler,
58828 &_swigt__p_wxBitmap,
58829 &_swigt__p_wxBoxSizer,
58830 &_swigt__p_wxButton,
58831 &_swigt__p_wxCURHandler,
58832 &_swigt__p_wxCaret,
58833 &_swigt__p_wxChildFocusEvent,
58834 &_swigt__p_wxClipboardTextEvent,
58835 &_swigt__p_wxCloseEvent,
58836 &_swigt__p_wxColour,
58837 &_swigt__p_wxCommandEvent,
58838 &_swigt__p_wxContextMenuEvent,
58839 &_swigt__p_wxControl,
58840 &_swigt__p_wxControlWithItems,
58841 &_swigt__p_wxCursor,
58842 &_swigt__p_wxDC,
58843 &_swigt__p_wxDateEvent,
58844 &_swigt__p_wxDateTime,
58845 &_swigt__p_wxDisplayChangedEvent,
58846 &_swigt__p_wxDouble,
58847 &_swigt__p_wxDropFilesEvent,
58848 &_swigt__p_wxDuplexMode,
58849 &_swigt__p_wxEraseEvent,
58850 &_swigt__p_wxEvent,
58851 &_swigt__p_wxEventBlocker,
58852 &_swigt__p_wxEventLoop,
58853 &_swigt__p_wxEventLoopActivator,
58854 &_swigt__p_wxEvtHandler,
58855 &_swigt__p_wxFSFile,
58856 &_swigt__p_wxFileSystem,
58857 &_swigt__p_wxFileSystemHandler,
58858 &_swigt__p_wxFlexGridSizer,
58859 &_swigt__p_wxFocusEvent,
58860 &_swigt__p_wxFont,
58861 &_swigt__p_wxFrame,
58862 &_swigt__p_wxGBPosition,
58863 &_swigt__p_wxGBSizerItem,
58864 &_swigt__p_wxGBSpan,
58865 &_swigt__p_wxGIFHandler,
58866 &_swigt__p_wxGridBagSizer,
58867 &_swigt__p_wxGridSizer,
58868 &_swigt__p_wxHelpEvent__Origin,
58869 &_swigt__p_wxICOHandler,
58870 &_swigt__p_wxIconizeEvent,
58871 &_swigt__p_wxIdleEvent,
58872 &_swigt__p_wxImage,
58873 &_swigt__p_wxImageHandler,
58874 &_swigt__p_wxImageHistogram,
58875 &_swigt__p_wxImage_HSVValue,
58876 &_swigt__p_wxImage_RGBValue,
58877 &_swigt__p_wxIndividualLayoutConstraint,
58878 &_swigt__p_wxInitDialogEvent,
58879 &_swigt__p_wxInputStream,
58880 &_swigt__p_wxInternetFSHandler,
58881 &_swigt__p_wxItemContainer,
58882 &_swigt__p_wxJPEGHandler,
58883 &_swigt__p_wxKeyEvent,
58884 &_swigt__p_wxLayoutConstraints,
58885 &_swigt__p_wxMaximizeEvent,
58886 &_swigt__p_wxMemoryFSHandler,
58887 &_swigt__p_wxMenu,
58888 &_swigt__p_wxMenuBar,
58889 &_swigt__p_wxMenuBarBase,
58890 &_swigt__p_wxMenuEvent,
58891 &_swigt__p_wxMenuItem,
58892 &_swigt__p_wxMouseCaptureChangedEvent,
58893 &_swigt__p_wxMouseCaptureLostEvent,
58894 &_swigt__p_wxMouseEvent,
58895 &_swigt__p_wxMoveEvent,
58896 &_swigt__p_wxNavigationKeyEvent,
58897 &_swigt__p_wxNcPaintEvent,
58898 &_swigt__p_wxNotifyEvent,
58899 &_swigt__p_wxObject,
58900 &_swigt__p_wxOutputStream,
58901 &_swigt__p_wxPCXHandler,
58902 &_swigt__p_wxPNGHandler,
58903 &_swigt__p_wxPNMHandler,
58904 &_swigt__p_wxPaintEvent,
58905 &_swigt__p_wxPaletteChangedEvent,
58906 &_swigt__p_wxPaperSize,
58907 &_swigt__p_wxPoint,
58908 &_swigt__p_wxPoint2D,
58909 &_swigt__p_wxPropagateOnce,
58910 &_swigt__p_wxPropagationDisabler,
58911 &_swigt__p_wxPyApp,
58912 &_swigt__p_wxPyCommandEvent,
58913 &_swigt__p_wxPyDropTarget,
58914 &_swigt__p_wxPyEvent,
58915 &_swigt__p_wxPyFileSystemHandler,
58916 &_swigt__p_wxPyImageHandler,
58917 &_swigt__p_wxPyInputStream,
58918 &_swigt__p_wxPySizer,
58919 &_swigt__p_wxPyValidator,
58920 &_swigt__p_wxQuantize,
58921 &_swigt__p_wxQueryNewPaletteEvent,
58922 &_swigt__p_wxRealPoint,
58923 &_swigt__p_wxRect,
58924 &_swigt__p_wxRect2D,
58925 &_swigt__p_wxRegion,
58926 &_swigt__p_wxScrollEvent,
58927 &_swigt__p_wxScrollWinEvent,
58928 &_swigt__p_wxSetCursorEvent,
58929 &_swigt__p_wxShowEvent,
58930 &_swigt__p_wxSize,
58931 &_swigt__p_wxSizeEvent,
58932 &_swigt__p_wxSizer,
58933 &_swigt__p_wxSizerItem,
58934 &_swigt__p_wxStaticBox,
58935 &_swigt__p_wxStaticBoxSizer,
58936 &_swigt__p_wxStdDialogButtonSizer,
58937 &_swigt__p_wxSysColourChangedEvent,
58938 &_swigt__p_wxTGAHandler,
58939 &_swigt__p_wxTIFFHandler,
58940 &_swigt__p_wxToolTip,
58941 &_swigt__p_wxUpdateUIEvent,
58942 &_swigt__p_wxValidator,
58943 &_swigt__p_wxVisualAttributes,
58944 &_swigt__p_wxWindow,
58945 &_swigt__p_wxWindowCreateEvent,
58946 &_swigt__p_wxWindowDestroyEvent,
58947 &_swigt__p_wxXPMHandler,
58948 &_swigt__p_wxZipFSHandler,
58949 };
58950
58951 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
58952 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
58953 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
58954 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
58955 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
58956 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
58957 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
58958 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
58959 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
58960 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
58961 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
58962 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
58963 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
58964 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
58965 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}};
58966 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
58967 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}};
58968 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
58969 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}};
58970 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
58971 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58972 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
58973 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
58974 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
58975 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}};
58976 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
58977 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}};
58978 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
58979 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
58980 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
58981 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
58982 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
58983 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
58984 static swig_cast_info _swigc__p_wxDouble[] = { {&_swigt__p_wxDouble, 0, 0, 0},{0, 0, 0, 0}};
58985 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
58986 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
58987 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
58988 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}};
58989 static swig_cast_info _swigc__p_wxEventBlocker[] = { {&_swigt__p_wxEventBlocker, 0, 0, 0},{0, 0, 0, 0}};
58990 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
58991 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
58992 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}};
58993 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
58994 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
58995 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}};
58996 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}};
58997 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
58998 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
58999 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
59000 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
59001 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
59002 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
59003 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
59004 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
59005 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}};
59006 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
59007 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}};
59008 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59009 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
59010 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
59011 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}};
59012 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
59013 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
59014 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
59015 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
59016 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
59017 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
59018 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59019 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}};
59020 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
59021 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
59022 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
59023 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59024 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59025 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
59026 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
59027 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
59028 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
59029 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
59030 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59031 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
59032 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
59033 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
59034 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
59035 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
59036 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
59037 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}};
59038 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
59039 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
59040 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
59041 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
59042 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
59043 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59044 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
59045 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
59046 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
59047 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
59048 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
59049 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
59050 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
59051 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
59052 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
59053 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
59054 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
59055 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
59056 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
59057 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
59058 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
59059 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
59060 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
59061 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
59062 static swig_cast_info _swigc__p_wxRect2D[] = { {&_swigt__p_wxRect2D, 0, 0, 0},{0, 0, 0, 0}};
59063 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
59064 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
59065 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
59066 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
59067 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
59068 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
59069 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
59070 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}};
59071 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}};
59072 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
59073 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
59074 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
59075 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
59076 static swig_cast_info _swigc__p_wxTGAHandler[] = { {&_swigt__p_wxTGAHandler, 0, 0, 0},{0, 0, 0, 0}};
59077 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
59078 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
59079 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
59080 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}};
59081 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
59082 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}};
59083 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
59084 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
59085 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
59086 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
59087
59088 static swig_cast_info *swig_cast_initial[] = {
59089 _swigc__p_buffer,
59090 _swigc__p_char,
59091 _swigc__p_form_ops_t,
59092 _swigc__p_int,
59093 _swigc__p_long,
59094 _swigc__p_unsigned_char,
59095 _swigc__p_unsigned_int,
59096 _swigc__p_unsigned_long,
59097 _swigc__p_wxANIHandler,
59098 _swigc__p_wxAcceleratorEntry,
59099 _swigc__p_wxAcceleratorTable,
59100 _swigc__p_wxActivateEvent,
59101 _swigc__p_wxAppTraits,
59102 _swigc__p_wxArrayString,
59103 _swigc__p_wxBMPHandler,
59104 _swigc__p_wxBitmap,
59105 _swigc__p_wxBoxSizer,
59106 _swigc__p_wxButton,
59107 _swigc__p_wxCURHandler,
59108 _swigc__p_wxCaret,
59109 _swigc__p_wxChildFocusEvent,
59110 _swigc__p_wxClipboardTextEvent,
59111 _swigc__p_wxCloseEvent,
59112 _swigc__p_wxColour,
59113 _swigc__p_wxCommandEvent,
59114 _swigc__p_wxContextMenuEvent,
59115 _swigc__p_wxControl,
59116 _swigc__p_wxControlWithItems,
59117 _swigc__p_wxCursor,
59118 _swigc__p_wxDC,
59119 _swigc__p_wxDateEvent,
59120 _swigc__p_wxDateTime,
59121 _swigc__p_wxDisplayChangedEvent,
59122 _swigc__p_wxDouble,
59123 _swigc__p_wxDropFilesEvent,
59124 _swigc__p_wxDuplexMode,
59125 _swigc__p_wxEraseEvent,
59126 _swigc__p_wxEvent,
59127 _swigc__p_wxEventBlocker,
59128 _swigc__p_wxEventLoop,
59129 _swigc__p_wxEventLoopActivator,
59130 _swigc__p_wxEvtHandler,
59131 _swigc__p_wxFSFile,
59132 _swigc__p_wxFileSystem,
59133 _swigc__p_wxFileSystemHandler,
59134 _swigc__p_wxFlexGridSizer,
59135 _swigc__p_wxFocusEvent,
59136 _swigc__p_wxFont,
59137 _swigc__p_wxFrame,
59138 _swigc__p_wxGBPosition,
59139 _swigc__p_wxGBSizerItem,
59140 _swigc__p_wxGBSpan,
59141 _swigc__p_wxGIFHandler,
59142 _swigc__p_wxGridBagSizer,
59143 _swigc__p_wxGridSizer,
59144 _swigc__p_wxHelpEvent__Origin,
59145 _swigc__p_wxICOHandler,
59146 _swigc__p_wxIconizeEvent,
59147 _swigc__p_wxIdleEvent,
59148 _swigc__p_wxImage,
59149 _swigc__p_wxImageHandler,
59150 _swigc__p_wxImageHistogram,
59151 _swigc__p_wxImage_HSVValue,
59152 _swigc__p_wxImage_RGBValue,
59153 _swigc__p_wxIndividualLayoutConstraint,
59154 _swigc__p_wxInitDialogEvent,
59155 _swigc__p_wxInputStream,
59156 _swigc__p_wxInternetFSHandler,
59157 _swigc__p_wxItemContainer,
59158 _swigc__p_wxJPEGHandler,
59159 _swigc__p_wxKeyEvent,
59160 _swigc__p_wxLayoutConstraints,
59161 _swigc__p_wxMaximizeEvent,
59162 _swigc__p_wxMemoryFSHandler,
59163 _swigc__p_wxMenu,
59164 _swigc__p_wxMenuBar,
59165 _swigc__p_wxMenuBarBase,
59166 _swigc__p_wxMenuEvent,
59167 _swigc__p_wxMenuItem,
59168 _swigc__p_wxMouseCaptureChangedEvent,
59169 _swigc__p_wxMouseCaptureLostEvent,
59170 _swigc__p_wxMouseEvent,
59171 _swigc__p_wxMoveEvent,
59172 _swigc__p_wxNavigationKeyEvent,
59173 _swigc__p_wxNcPaintEvent,
59174 _swigc__p_wxNotifyEvent,
59175 _swigc__p_wxObject,
59176 _swigc__p_wxOutputStream,
59177 _swigc__p_wxPCXHandler,
59178 _swigc__p_wxPNGHandler,
59179 _swigc__p_wxPNMHandler,
59180 _swigc__p_wxPaintEvent,
59181 _swigc__p_wxPaletteChangedEvent,
59182 _swigc__p_wxPaperSize,
59183 _swigc__p_wxPoint,
59184 _swigc__p_wxPoint2D,
59185 _swigc__p_wxPropagateOnce,
59186 _swigc__p_wxPropagationDisabler,
59187 _swigc__p_wxPyApp,
59188 _swigc__p_wxPyCommandEvent,
59189 _swigc__p_wxPyDropTarget,
59190 _swigc__p_wxPyEvent,
59191 _swigc__p_wxPyFileSystemHandler,
59192 _swigc__p_wxPyImageHandler,
59193 _swigc__p_wxPyInputStream,
59194 _swigc__p_wxPySizer,
59195 _swigc__p_wxPyValidator,
59196 _swigc__p_wxQuantize,
59197 _swigc__p_wxQueryNewPaletteEvent,
59198 _swigc__p_wxRealPoint,
59199 _swigc__p_wxRect,
59200 _swigc__p_wxRect2D,
59201 _swigc__p_wxRegion,
59202 _swigc__p_wxScrollEvent,
59203 _swigc__p_wxScrollWinEvent,
59204 _swigc__p_wxSetCursorEvent,
59205 _swigc__p_wxShowEvent,
59206 _swigc__p_wxSize,
59207 _swigc__p_wxSizeEvent,
59208 _swigc__p_wxSizer,
59209 _swigc__p_wxSizerItem,
59210 _swigc__p_wxStaticBox,
59211 _swigc__p_wxStaticBoxSizer,
59212 _swigc__p_wxStdDialogButtonSizer,
59213 _swigc__p_wxSysColourChangedEvent,
59214 _swigc__p_wxTGAHandler,
59215 _swigc__p_wxTIFFHandler,
59216 _swigc__p_wxToolTip,
59217 _swigc__p_wxUpdateUIEvent,
59218 _swigc__p_wxValidator,
59219 _swigc__p_wxVisualAttributes,
59220 _swigc__p_wxWindow,
59221 _swigc__p_wxWindowCreateEvent,
59222 _swigc__p_wxWindowDestroyEvent,
59223 _swigc__p_wxXPMHandler,
59224 _swigc__p_wxZipFSHandler,
59225 };
59226
59227
59228 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
59229
59230 static swig_const_info swig_const_table[] = {
59231 {0, 0, 0, 0.0, 0, 0}};
59232
59233 #ifdef __cplusplus
59234 }
59235 #endif
59236 /* -----------------------------------------------------------------------------
59237 * Type initialization:
59238 * This problem is tough by the requirement that no dynamic
59239 * memory is used. Also, since swig_type_info structures store pointers to
59240 * swig_cast_info structures and swig_cast_info structures store pointers back
59241 * to swig_type_info structures, we need some lookup code at initialization.
59242 * The idea is that swig generates all the structures that are needed.
59243 * The runtime then collects these partially filled structures.
59244 * The SWIG_InitializeModule function takes these initial arrays out of
59245 * swig_module, and does all the lookup, filling in the swig_module.types
59246 * array with the correct data and linking the correct swig_cast_info
59247 * structures together.
59248 *
59249 * The generated swig_type_info structures are assigned staticly to an initial
59250 * array. We just loop though that array, and handle each type individually.
59251 * First we lookup if this type has been already loaded, and if so, use the
59252 * loaded structure instead of the generated one. Then we have to fill in the
59253 * cast linked list. The cast data is initially stored in something like a
59254 * two-dimensional array. Each row corresponds to a type (there are the same
59255 * number of rows as there are in the swig_type_initial array). Each entry in
59256 * a column is one of the swig_cast_info structures for that type.
59257 * The cast_initial array is actually an array of arrays, because each row has
59258 * a variable number of columns. So to actually build the cast linked list,
59259 * we find the array of casts associated with the type, and loop through it
59260 * adding the casts to the list. The one last trick we need to do is making
59261 * sure the type pointer in the swig_cast_info struct is correct.
59262 *
59263 * First off, we lookup the cast->type name to see if it is already loaded.
59264 * There are three cases to handle:
59265 * 1) If the cast->type has already been loaded AND the type we are adding
59266 * casting info to has not been loaded (it is in this module), THEN we
59267 * replace the cast->type pointer with the type pointer that has already
59268 * been loaded.
59269 * 2) If BOTH types (the one we are adding casting info to, and the
59270 * cast->type) are loaded, THEN the cast info has already been loaded by
59271 * the previous module so we just ignore it.
59272 * 3) Finally, if cast->type has not already been loaded, then we add that
59273 * swig_cast_info to the linked list (because the cast->type) pointer will
59274 * be correct.
59275 * ----------------------------------------------------------------------------- */
59276
59277 #ifdef __cplusplus
59278 extern "C" {
59279 #if 0
59280 } /* c-mode */
59281 #endif
59282 #endif
59283
59284 #if 0
59285 #define SWIGRUNTIME_DEBUG
59286 #endif
59287
59288 SWIGRUNTIME void
59289 SWIG_InitializeModule(void *clientdata) {
59290 size_t i;
59291 swig_module_info *module_head;
59292 static int init_run = 0;
59293
59294 clientdata = clientdata;
59295
59296 if (init_run) return;
59297 init_run = 1;
59298
59299 /* Initialize the swig_module */
59300 swig_module.type_initial = swig_type_initial;
59301 swig_module.cast_initial = swig_cast_initial;
59302
59303 /* Try and load any already created modules */
59304 module_head = SWIG_GetModule(clientdata);
59305 if (module_head) {
59306 swig_module.next = module_head->next;
59307 module_head->next = &swig_module;
59308 } else {
59309 /* This is the first module loaded */
59310 swig_module.next = &swig_module;
59311 SWIG_SetModule(clientdata, &swig_module);
59312 }
59313
59314 /* Now work on filling in swig_module.types */
59315 #ifdef SWIGRUNTIME_DEBUG
59316 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
59317 #endif
59318 for (i = 0; i < swig_module.size; ++i) {
59319 swig_type_info *type = 0;
59320 swig_type_info *ret;
59321 swig_cast_info *cast;
59322
59323 #ifdef SWIGRUNTIME_DEBUG
59324 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59325 #endif
59326
59327 /* if there is another module already loaded */
59328 if (swig_module.next != &swig_module) {
59329 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
59330 }
59331 if (type) {
59332 /* Overwrite clientdata field */
59333 #ifdef SWIGRUNTIME_DEBUG
59334 printf("SWIG_InitializeModule: found type %s\n", type->name);
59335 #endif
59336 if (swig_module.type_initial[i]->clientdata) {
59337 type->clientdata = swig_module.type_initial[i]->clientdata;
59338 #ifdef SWIGRUNTIME_DEBUG
59339 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
59340 #endif
59341 }
59342 } else {
59343 type = swig_module.type_initial[i];
59344 }
59345
59346 /* Insert casting types */
59347 cast = swig_module.cast_initial[i];
59348 while (cast->type) {
59349 /* Don't need to add information already in the list */
59350 ret = 0;
59351 #ifdef SWIGRUNTIME_DEBUG
59352 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
59353 #endif
59354 if (swig_module.next != &swig_module) {
59355 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
59356 #ifdef SWIGRUNTIME_DEBUG
59357 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
59358 #endif
59359 }
59360 if (ret) {
59361 if (type == swig_module.type_initial[i]) {
59362 #ifdef SWIGRUNTIME_DEBUG
59363 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
59364 #endif
59365 cast->type = ret;
59366 ret = 0;
59367 } else {
59368 /* Check for casting already in the list */
59369 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
59370 #ifdef SWIGRUNTIME_DEBUG
59371 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
59372 #endif
59373 if (!ocast) ret = 0;
59374 }
59375 }
59376
59377 if (!ret) {
59378 #ifdef SWIGRUNTIME_DEBUG
59379 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
59380 #endif
59381 if (type->cast) {
59382 type->cast->prev = cast;
59383 cast->next = type->cast;
59384 }
59385 type->cast = cast;
59386 }
59387 cast++;
59388 }
59389 /* Set entry in modules->types array equal to the type */
59390 swig_module.types[i] = type;
59391 }
59392 swig_module.types[i] = 0;
59393
59394 #ifdef SWIGRUNTIME_DEBUG
59395 printf("**** SWIG_InitializeModule: Cast List ******\n");
59396 for (i = 0; i < swig_module.size; ++i) {
59397 int j = 0;
59398 swig_cast_info *cast = swig_module.cast_initial[i];
59399 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
59400 while (cast->type) {
59401 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
59402 cast++;
59403 ++j;
59404 }
59405 printf("---- Total casts: %d\n",j);
59406 }
59407 printf("**** SWIG_InitializeModule: Cast List ******\n");
59408 #endif
59409 }
59410
59411 /* This function will propagate the clientdata field of type to
59412 * any new swig_type_info structures that have been added into the list
59413 * of equivalent types. It is like calling
59414 * SWIG_TypeClientData(type, clientdata) a second time.
59415 */
59416 SWIGRUNTIME void
59417 SWIG_PropagateClientData(void) {
59418 size_t i;
59419 swig_cast_info *equiv;
59420 static int init_run = 0;
59421
59422 if (init_run) return;
59423 init_run = 1;
59424
59425 for (i = 0; i < swig_module.size; i++) {
59426 if (swig_module.types[i]->clientdata) {
59427 equiv = swig_module.types[i]->cast;
59428 while (equiv) {
59429 if (!equiv->converter) {
59430 if (equiv->type && !equiv->type->clientdata)
59431 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
59432 }
59433 equiv = equiv->next;
59434 }
59435 }
59436 }
59437 }
59438
59439 #ifdef __cplusplus
59440 #if 0
59441 {
59442 /* c-mode */
59443 #endif
59444 }
59445 #endif
59446
59447
59448
59449 #ifdef __cplusplus
59450 extern "C" {
59451 #endif
59452
59453 /* Python-specific SWIG API */
59454 #define SWIG_newvarlink() SWIG_Python_newvarlink()
59455 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
59456 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
59457
59458 /* -----------------------------------------------------------------------------
59459 * global variable support code.
59460 * ----------------------------------------------------------------------------- */
59461
59462 typedef struct swig_globalvar {
59463 char *name; /* Name of global variable */
59464 PyObject *(*get_attr)(void); /* Return the current value */
59465 int (*set_attr)(PyObject *); /* Set the value */
59466 struct swig_globalvar *next;
59467 } swig_globalvar;
59468
59469 typedef struct swig_varlinkobject {
59470 PyObject_HEAD
59471 swig_globalvar *vars;
59472 } swig_varlinkobject;
59473
59474 SWIGINTERN PyObject *
59475 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
59476 return PyString_FromString("<Swig global variables>");
59477 }
59478
59479 SWIGINTERN PyObject *
59480 swig_varlink_str(swig_varlinkobject *v) {
59481 PyObject *str = PyString_FromString("(");
59482 swig_globalvar *var;
59483 for (var = v->vars; var; var=var->next) {
59484 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
59485 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
59486 }
59487 PyString_ConcatAndDel(&str,PyString_FromString(")"));
59488 return str;
59489 }
59490
59491 SWIGINTERN int
59492 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
59493 PyObject *str = swig_varlink_str(v);
59494 fprintf(fp,"Swig global variables ");
59495 fprintf(fp,"%s\n", PyString_AsString(str));
59496 Py_DECREF(str);
59497 return 0;
59498 }
59499
59500 SWIGINTERN void
59501 swig_varlink_dealloc(swig_varlinkobject *v) {
59502 swig_globalvar *var = v->vars;
59503 while (var) {
59504 swig_globalvar *n = var->next;
59505 free(var->name);
59506 free(var);
59507 var = n;
59508 }
59509 }
59510
59511 SWIGINTERN PyObject *
59512 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
59513 PyObject *res = NULL;
59514 swig_globalvar *var = v->vars;
59515 while (var) {
59516 if (strcmp(var->name,n) == 0) {
59517 res = (*var->get_attr)();
59518 break;
59519 }
59520 var = var->next;
59521 }
59522 if (res == NULL && !PyErr_Occurred()) {
59523 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59524 }
59525 return res;
59526 }
59527
59528 SWIGINTERN int
59529 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
59530 int res = 1;
59531 swig_globalvar *var = v->vars;
59532 while (var) {
59533 if (strcmp(var->name,n) == 0) {
59534 res = (*var->set_attr)(p);
59535 break;
59536 }
59537 var = var->next;
59538 }
59539 if (res == 1 && !PyErr_Occurred()) {
59540 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
59541 }
59542 return res;
59543 }
59544
59545 SWIGINTERN PyTypeObject*
59546 swig_varlink_type(void) {
59547 static char varlink__doc__[] = "Swig var link object";
59548 static PyTypeObject varlink_type;
59549 static int type_init = 0;
59550 if (!type_init) {
59551 const PyTypeObject tmp
59552 = {
59553 PyObject_HEAD_INIT(NULL)
59554 0, /* Number of items in variable part (ob_size) */
59555 (char *)"swigvarlink", /* Type name (tp_name) */
59556 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
59557 0, /* Itemsize (tp_itemsize) */
59558 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
59559 (printfunc) swig_varlink_print, /* Print (tp_print) */
59560 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
59561 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
59562 0, /* tp_compare */
59563 (reprfunc) swig_varlink_repr, /* tp_repr */
59564 0, /* tp_as_number */
59565 0, /* tp_as_sequence */
59566 0, /* tp_as_mapping */
59567 0, /* tp_hash */
59568 0, /* tp_call */
59569 (reprfunc)swig_varlink_str, /* tp_str */
59570 0, /* tp_getattro */
59571 0, /* tp_setattro */
59572 0, /* tp_as_buffer */
59573 0, /* tp_flags */
59574 varlink__doc__, /* tp_doc */
59575 0, /* tp_traverse */
59576 0, /* tp_clear */
59577 0, /* tp_richcompare */
59578 0, /* tp_weaklistoffset */
59579 #if PY_VERSION_HEX >= 0x02020000
59580 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
59581 #endif
59582 #if PY_VERSION_HEX >= 0x02030000
59583 0, /* tp_del */
59584 #endif
59585 #ifdef COUNT_ALLOCS
59586 0,0,0,0 /* tp_alloc -> tp_next */
59587 #endif
59588 };
59589 varlink_type = tmp;
59590 varlink_type.ob_type = &PyType_Type;
59591 type_init = 1;
59592 }
59593 return &varlink_type;
59594 }
59595
59596 /* Create a variable linking object for use later */
59597 SWIGINTERN PyObject *
59598 SWIG_Python_newvarlink(void) {
59599 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
59600 if (result) {
59601 result->vars = 0;
59602 }
59603 return ((PyObject*) result);
59604 }
59605
59606 SWIGINTERN void
59607 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
59608 swig_varlinkobject *v = (swig_varlinkobject *) p;
59609 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
59610 if (gv) {
59611 size_t size = strlen(name)+1;
59612 gv->name = (char *)malloc(size);
59613 if (gv->name) {
59614 strncpy(gv->name,name,size);
59615 gv->get_attr = get_attr;
59616 gv->set_attr = set_attr;
59617 gv->next = v->vars;
59618 }
59619 }
59620 v->vars = gv;
59621 }
59622
59623 SWIGINTERN PyObject *
59624 SWIG_globals() {
59625 static PyObject *_SWIG_globals = 0;
59626 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
59627 return _SWIG_globals;
59628 }
59629
59630 /* -----------------------------------------------------------------------------
59631 * constants/methods manipulation
59632 * ----------------------------------------------------------------------------- */
59633
59634 /* Install Constants */
59635 SWIGINTERN void
59636 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
59637 PyObject *obj = 0;
59638 size_t i;
59639 for (i = 0; constants[i].type; ++i) {
59640 switch(constants[i].type) {
59641 case SWIG_PY_POINTER:
59642 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
59643 break;
59644 case SWIG_PY_BINARY:
59645 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
59646 break;
59647 default:
59648 obj = 0;
59649 break;
59650 }
59651 if (obj) {
59652 PyDict_SetItemString(d, constants[i].name, obj);
59653 Py_DECREF(obj);
59654 }
59655 }
59656 }
59657
59658 /* -----------------------------------------------------------------------------*/
59659 /* Fix SwigMethods to carry the callback ptrs when needed */
59660 /* -----------------------------------------------------------------------------*/
59661
59662 SWIGINTERN void
59663 SWIG_Python_FixMethods(PyMethodDef *methods,
59664 swig_const_info *const_table,
59665 swig_type_info **types,
59666 swig_type_info **types_initial) {
59667 size_t i;
59668 for (i = 0; methods[i].ml_name; ++i) {
59669 const char *c = methods[i].ml_doc;
59670 if (c && (c = strstr(c, "swig_ptr: "))) {
59671 int j;
59672 swig_const_info *ci = 0;
59673 const char *name = c + 10;
59674 for (j = 0; const_table[j].type; ++j) {
59675 if (strncmp(const_table[j].name, name,
59676 strlen(const_table[j].name)) == 0) {
59677 ci = &(const_table[j]);
59678 break;
59679 }
59680 }
59681 if (ci) {
59682 size_t shift = (ci->ptype) - types;
59683 swig_type_info *ty = types_initial[shift];
59684 size_t ldoc = (c - methods[i].ml_doc);
59685 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
59686 char *ndoc = (char*)malloc(ldoc + lptr + 10);
59687 if (ndoc) {
59688 char *buff = ndoc;
59689 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
59690 if (ptr) {
59691 strncpy(buff, methods[i].ml_doc, ldoc);
59692 buff += ldoc;
59693 strncpy(buff, "swig_ptr: ", 10);
59694 buff += 10;
59695 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
59696 methods[i].ml_doc = ndoc;
59697 }
59698 }
59699 }
59700 }
59701 }
59702 }
59703
59704 #ifdef __cplusplus
59705 }
59706 #endif
59707
59708 /* -----------------------------------------------------------------------------*
59709 * Partial Init method
59710 * -----------------------------------------------------------------------------*/
59711
59712 #ifdef __cplusplus
59713 extern "C"
59714 #endif
59715 SWIGEXPORT void SWIG_init(void) {
59716 PyObject *m, *d;
59717
59718 /* Fix SwigMethods to carry the callback ptrs when needed */
59719 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
59720
59721 m = Py_InitModule((char *) SWIG_name, SwigMethods);
59722 d = PyModule_GetDict(m);
59723
59724 SWIG_InitializeModule(0);
59725 SWIG_InstallConstants(d,swig_const_table);
59726
59727
59728
59729 #ifndef wxPyUSE_EXPORT
59730 // Make our API structure a CObject so other modules can import it
59731 // from this module.
59732 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
59733 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
59734 Py_XDECREF(cobj);
59735 #endif
59736
59737 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
59738 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
59739 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
59740 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
59741 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
59742 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
59743 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
59744 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
59745 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
59746 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
59747 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
59748 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
59749 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
59750 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
59751 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
59752 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
59753 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
59754 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
59755 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
59756 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
59757 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
59758 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
59759 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
59760 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
59761 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
59762 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
59763 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
59764 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
59765 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
59766 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
59767 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
59768 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
59769 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
59770 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
59771 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
59772 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
59773 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
59774 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
59775 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
59776 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
59777 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
59778 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
59779 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
59780 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
59781 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
59782 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
59783 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
59784 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
59785 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
59786 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
59787 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
59788 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
59789 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
59790 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
59791 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
59792 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
59793 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
59794 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
59795 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
59796 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
59797 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
59798 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
59799 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
59800 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
59801 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
59802 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
59803 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
59804 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
59805 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
59806 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
59807 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
59808 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
59809 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
59810 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
59811 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
59812 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
59813 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
59814 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
59815 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
59816 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
59817 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
59818 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
59819 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
59820 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
59821 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
59822 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
59823 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
59824 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
59825 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
59826 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
59827 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
59828 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
59829 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
59830 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
59831 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
59832 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
59833 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
59834 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
59835 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
59836 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
59837 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
59838 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
59839 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
59840 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
59841 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
59842 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
59843 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
59844 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
59845 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
59846 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
59847 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
59848 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
59849 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
59850 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
59851 SWIG_Python_SetConstant(d, "ID_PAGE_SETUP",SWIG_From_int(static_cast< int >(wxID_PAGE_SETUP)));
59852 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
59853 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
59854 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
59855 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
59856 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
59857 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
59858 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
59859 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
59860 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
59861 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
59862 SWIG_Python_SetConstant(d, "ID_EDIT",SWIG_From_int(static_cast< int >(wxID_EDIT)));
59863 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
59864 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
59865 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
59866 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
59867 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
59868 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
59869 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
59870 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
59871 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
59872 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
59873 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
59874 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
59875 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
59876 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
59877 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
59878 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
59879 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
59880 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
59881 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
59882 SWIG_Python_SetConstant(d, "ID_FILE",SWIG_From_int(static_cast< int >(wxID_FILE)));
59883 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
59884 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
59885 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
59886 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
59887 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
59888 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
59889 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
59890 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
59891 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
59892 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
59893 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
59894 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
59895 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
59896 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
59897 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
59898 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
59899 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
59900 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
59901 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
59902 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
59903 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
59904 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
59905 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
59906 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
59907 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
59908 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
59909 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
59910 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
59911 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
59912 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
59913 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
59914 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
59915 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
59916 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
59917 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
59918 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
59919 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
59920 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
59921 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
59922 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
59923 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
59924 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
59925 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
59926 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
59927 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
59928 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
59929 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
59930 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
59931 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
59932 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
59933 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
59934 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
59935 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
59936 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
59937 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
59938 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
59939 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
59940 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
59941 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
59942 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
59943 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
59944 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
59945 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
59946 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
59947 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
59948 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
59949 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
59950 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
59951 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
59952 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
59953 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
59954 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
59955 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
59956 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
59957 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
59958 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
59959 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
59960 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
59961 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
59962 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
59963 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
59964 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
59965 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
59966 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
59967 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
59968 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
59969 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
59970 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
59971 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
59972 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
59973 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
59974 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
59975 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
59976 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
59977 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
59978 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
59979 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
59980 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
59981 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
59982 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
59983 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
59984 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
59985 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
59986 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
59987 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
59988 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
59989 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
59990 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
59991 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
59992 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
59993 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
59994 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
59995 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
59996 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
59997 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
59998 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
59999 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
60000 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
60001 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
60002 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
60003 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
60004 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
60005 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
60006 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
60007 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
60008 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
60009 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
60010 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
60011 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
60012 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
60013 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
60014 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
60015 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
60016 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
60017 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
60018 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
60019 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
60020 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
60021 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
60022 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
60023 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
60024 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
60025 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
60026 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
60027 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
60028 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
60029 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
60030 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
60031 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
60032 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
60033 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
60034 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
60035 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
60036 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
60037 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
60038 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
60039 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
60040 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
60041 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
60042 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
60043 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
60044 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
60045 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
60046 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
60047 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
60048 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
60049 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
60050 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
60051 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
60052 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
60053 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
60054 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
60055 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
60056 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
60057 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
60058 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
60059 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
60060 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
60061 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
60062 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
60063 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
60064 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
60065 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
60066 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
60067 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
60068 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
60069 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
60070 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
60071 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
60072 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
60073 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
60074 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
60075 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
60076 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
60077 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
60078 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
60079 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
60080 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
60081 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
60082 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
60083 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
60084 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
60085 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
60086 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
60087 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
60088 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
60089 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
60090 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
60091 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
60092 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
60093 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
60094 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
60095 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
60096 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
60097 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
60098 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
60099 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
60100 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
60101 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
60102 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
60103 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
60104 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
60105 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
60106 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
60107 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
60108 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
60109 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
60110 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
60111 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
60112 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
60113 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
60114 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
60115 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
60116 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
60117 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
60118 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
60119 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
60120 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
60121 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
60122 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
60123 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
60124 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
60125 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
60126 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
60127 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
60128 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
60129 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
60130 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
60131 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
60132 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
60133 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
60134 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
60135 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
60136 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
60137 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
60138 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
60139 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
60140 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
60141 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
60142 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
60143 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
60144 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
60145 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
60146 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
60147 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
60148 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
60149 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
60150 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
60151 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
60152 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
60153 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
60154 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
60155 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
60156 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
60157 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
60158 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
60159 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
60160 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
60161 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
60162 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
60163 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
60164 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
60165 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
60166 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
60167 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
60168 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
60169 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
60170 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
60171 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
60172 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
60173 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
60174 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
60175 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
60176 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
60177 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
60178 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
60179 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
60180 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
60181 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
60182 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
60183 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
60184 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
60185 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
60186 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
60187 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
60188 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
60189 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
60190 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
60191 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
60192 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
60193 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
60194 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
60195 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
60196 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
60197 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
60198 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
60199 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
60200 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
60201 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
60202 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
60203 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
60204 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
60205 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
60206 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
60207 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
60208 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
60209 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
60210 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
60211 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
60212 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
60213 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
60214 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
60215 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
60216 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
60217 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
60218 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
60219 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
60220 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
60221 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
60222 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
60223 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
60224 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
60225 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
60226 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
60227 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
60228 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
60229 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
60230 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
60231 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
60232 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
60233 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
60234 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
60235 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
60236 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
60237 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
60238 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
60239 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
60240 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
60241 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
60242 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
60243 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
60244 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
60245 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
60246 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
60247 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
60248 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
60249 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
60250 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
60251 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
60252 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
60253 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
60254 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
60255 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
60256 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
60257 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
60258 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
60259 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
60260 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
60261 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
60262 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
60263 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
60264 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
60265 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
60266 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
60267 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
60268 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
60269 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
60270 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
60271 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
60272 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
60273 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
60274 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
60275 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
60276 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
60277 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
60278 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
60279 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
60280 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
60281 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
60282 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
60283 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
60284 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
60285 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
60286 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
60287 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
60288 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
60289 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
60290 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
60291 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
60292 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
60293 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
60294 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
60295 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
60296 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
60297 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
60298 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
60299 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
60300 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
60301 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
60302 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
60303 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
60304 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
60305 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
60306 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
60307 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
60308 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
60309 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
60310 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
60311 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
60312 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
60313 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
60314 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
60315 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
60316 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
60317 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
60318 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
60319 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
60320 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
60321 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
60322 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
60323 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
60324 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
60325 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
60326 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
60327 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
60328 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
60329 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
60330 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
60331 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
60332 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
60333 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
60334 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
60335 SWIG_Python_SetConstant(d, "Layout_Default",SWIG_From_int(static_cast< int >(wxLayout_Default)));
60336 SWIG_Python_SetConstant(d, "Layout_LeftToRight",SWIG_From_int(static_cast< int >(wxLayout_LeftToRight)));
60337 SWIG_Python_SetConstant(d, "Layout_RightToLeft",SWIG_From_int(static_cast< int >(wxLayout_RightToLeft)));
60338 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
60339 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
60340 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
60341 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
60342 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
60343 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
60344 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
60345 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
60346 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
60347 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
60348 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
60349 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
60350 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
60351 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
60352 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
60353 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
60354 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
60355 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
60356 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
60357 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
60358 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TGA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TGA)));
60359 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
60360 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
60361 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
60362 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
60363 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
60364 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
60365 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
60366 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
60367 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
60368 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
60369 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
60370 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
60371 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
60372 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
60373 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
60374 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
60375 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
60376 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
60377 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
60378 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
60379 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
60380 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
60381 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
60382 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
60383 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
60384 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
60385 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
60386 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
60387 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
60388 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
60389 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
60390 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
60391 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
60392 SWIG_Python_SetConstant(d, "Inside",SWIG_From_int(static_cast< int >(wxInside)));
60393 SWIG_Python_SetConstant(d, "OutLeft",SWIG_From_int(static_cast< int >(wxOutLeft)));
60394 SWIG_Python_SetConstant(d, "OutRight",SWIG_From_int(static_cast< int >(wxOutRight)));
60395 SWIG_Python_SetConstant(d, "OutTop",SWIG_From_int(static_cast< int >(wxOutTop)));
60396 SWIG_Python_SetConstant(d, "OutBottom",SWIG_From_int(static_cast< int >(wxOutBottom)));
60397 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
60398 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
60399 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
60400 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
60401 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
60402
60403 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
60404
60405
60406 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
60407
60408 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
60409 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
60410 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
60411 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_NORMAL",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_NORMAL)));
60412 SWIG_Python_SetConstant(d, "IMAGE_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxIMAGE_QUALITY_HIGH)));
60413 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
60414 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
60415 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
60416 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
60417 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
60418 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
60419 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
60420 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
60421 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
60422 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
60423 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
60424 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
60425 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
60426 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
60427 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
60428 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
60429 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
60430 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
60431 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
60432 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
60433 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
60434 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
60435 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
60436 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
60437 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
60438 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
60439 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
60440 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
60441 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
60442 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
60443 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
60444 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
60445 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
60446 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
60447 PyDict_SetItemString(d, "wxEVT_ANY", PyInt_FromLong(wxEVT_ANY));
60448 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
60449 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
60450 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
60451 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
60452 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
60453 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
60454 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
60455 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
60456 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
60457 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
60458 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
60459 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
60460 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
60461 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
60462 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
60463 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
60464 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
60465 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
60466 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
60467 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
60468 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
60469 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
60470 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
60471 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
60472 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
60473 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
60474 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
60475 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
60476 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
60477 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
60478 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
60479 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
60480 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
60481 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
60482 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
60483 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
60484 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
60485 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
60486 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
60487 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
60488 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
60489 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
60490 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
60491 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
60492 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
60493 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
60494 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
60495 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
60496 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
60497 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
60498 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
60499 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
60500 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
60501 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
60502 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
60503 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
60504 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
60505 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
60506 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
60507 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
60508 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
60509 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
60510 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
60511 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
60512 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
60513 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
60514 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
60515 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
60516 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
60517 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
60518 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
60519 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
60520 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
60521 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
60522 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
60523 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
60524 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
60525 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
60526 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
60527 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
60528 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
60529 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
60530 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
60531 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
60532 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
60533 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
60534 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
60535 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
60536 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
60537 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
60538 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
60539 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
60540 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
60541 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
60542 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
60543 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
60544 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
60545 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
60546 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
60547 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
60548 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
60549 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
60550 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
60551 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
60552 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
60553 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
60554 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
60555 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
60556 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
60557 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
60558 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
60559 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
60560 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
60561 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
60562 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
60563 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
60564 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
60565 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
60566 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
60567 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
60568 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
60569 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
60570 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
60571 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
60572 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
60573 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
60574 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
60575 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
60576 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
60577 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
60578 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
60579 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
60580 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
60581 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
60582 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
60583 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
60584 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
60585 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
60586 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
60587 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
60588 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
60589 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
60590 SWIG_Python_SetConstant(d, "ACCEL_CMD",SWIG_From_int(static_cast< int >(wxACCEL_CMD)));
60591 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
60592 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
60593 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
60594 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
60595 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
60596 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
60597 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
60598 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
60599 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
60600 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
60601 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
60602 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
60603 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
60604 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
60605 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
60606 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
60607 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
60608 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
60609 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
60610 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
60611 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
60612 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
60613 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
60614 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
60615 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
60616 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
60617 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
60618 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
60619 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
60620 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
60621 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
60622 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
60623
60624 // Initialize threading, some globals and such
60625 __wxPyPreStart(d);
60626
60627
60628 // Although these are defined in __version__ they need to be here too so
60629 // that an assert can be done to ensure that the wxPython and the wxWindows
60630 // versions match.
60631 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
60632 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
60633 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
60634
60635 }
60636
wxWidgets (Impactor)