]> 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_wxDropFilesEvent swig_types[33]
2500 #define SWIGTYPE_p_wxDuplexMode swig_types[34]
2501 #define SWIGTYPE_p_wxEraseEvent swig_types[35]
2502 #define SWIGTYPE_p_wxEvent swig_types[36]
2503 #define SWIGTYPE_p_wxEventLoop swig_types[37]
2504 #define SWIGTYPE_p_wxEventLoopActivator swig_types[38]
2505 #define SWIGTYPE_p_wxEvtHandler swig_types[39]
2506 #define SWIGTYPE_p_wxFSFile swig_types[40]
2507 #define SWIGTYPE_p_wxFileSystem swig_types[41]
2508 #define SWIGTYPE_p_wxFileSystemHandler swig_types[42]
2509 #define SWIGTYPE_p_wxFlexGridSizer swig_types[43]
2510 #define SWIGTYPE_p_wxFocusEvent swig_types[44]
2511 #define SWIGTYPE_p_wxFont swig_types[45]
2512 #define SWIGTYPE_p_wxFrame swig_types[46]
2513 #define SWIGTYPE_p_wxGBPosition swig_types[47]
2514 #define SWIGTYPE_p_wxGBSizerItem swig_types[48]
2515 #define SWIGTYPE_p_wxGBSpan swig_types[49]
2516 #define SWIGTYPE_p_wxGIFHandler swig_types[50]
2517 #define SWIGTYPE_p_wxGridBagSizer swig_types[51]
2518 #define SWIGTYPE_p_wxGridSizer swig_types[52]
2519 #define SWIGTYPE_p_wxHelpEvent__Origin swig_types[53]
2520 #define SWIGTYPE_p_wxICOHandler swig_types[54]
2521 #define SWIGTYPE_p_wxIconizeEvent swig_types[55]
2522 #define SWIGTYPE_p_wxIdleEvent swig_types[56]
2523 #define SWIGTYPE_p_wxImage swig_types[57]
2524 #define SWIGTYPE_p_wxImageHandler swig_types[58]
2525 #define SWIGTYPE_p_wxImageHistogram swig_types[59]
2526 #define SWIGTYPE_p_wxImage_HSVValue swig_types[60]
2527 #define SWIGTYPE_p_wxImage_RGBValue swig_types[61]
2528 #define SWIGTYPE_p_wxIndividualLayoutConstraint swig_types[62]
2529 #define SWIGTYPE_p_wxInitDialogEvent swig_types[63]
2530 #define SWIGTYPE_p_wxInputStream swig_types[64]
2531 #define SWIGTYPE_p_wxInternetFSHandler swig_types[65]
2532 #define SWIGTYPE_p_wxItemContainer swig_types[66]
2533 #define SWIGTYPE_p_wxJPEGHandler swig_types[67]
2534 #define SWIGTYPE_p_wxKeyEvent swig_types[68]
2535 #define SWIGTYPE_p_wxLayoutConstraints swig_types[69]
2536 #define SWIGTYPE_p_wxMaximizeEvent swig_types[70]
2537 #define SWIGTYPE_p_wxMemoryFSHandler swig_types[71]
2538 #define SWIGTYPE_p_wxMenu swig_types[72]
2539 #define SWIGTYPE_p_wxMenuBar swig_types[73]
2540 #define SWIGTYPE_p_wxMenuBarBase swig_types[74]
2541 #define SWIGTYPE_p_wxMenuEvent swig_types[75]
2542 #define SWIGTYPE_p_wxMenuItem swig_types[76]
2543 #define SWIGTYPE_p_wxMouseCaptureChangedEvent swig_types[77]
2544 #define SWIGTYPE_p_wxMouseCaptureLostEvent swig_types[78]
2545 #define SWIGTYPE_p_wxMouseEvent swig_types[79]
2546 #define SWIGTYPE_p_wxMoveEvent swig_types[80]
2547 #define SWIGTYPE_p_wxNavigationKeyEvent swig_types[81]
2548 #define SWIGTYPE_p_wxNcPaintEvent swig_types[82]
2549 #define SWIGTYPE_p_wxNotifyEvent swig_types[83]
2550 #define SWIGTYPE_p_wxObject swig_types[84]
2551 #define SWIGTYPE_p_wxOutputStream swig_types[85]
2552 #define SWIGTYPE_p_wxPCXHandler swig_types[86]
2553 #define SWIGTYPE_p_wxPNGHandler swig_types[87]
2554 #define SWIGTYPE_p_wxPNMHandler swig_types[88]
2555 #define SWIGTYPE_p_wxPaintEvent swig_types[89]
2556 #define SWIGTYPE_p_wxPaletteChangedEvent swig_types[90]
2557 #define SWIGTYPE_p_wxPaperSize swig_types[91]
2558 #define SWIGTYPE_p_wxPoint swig_types[92]
2559 #define SWIGTYPE_p_wxPoint2D swig_types[93]
2560 #define SWIGTYPE_p_wxPropagateOnce swig_types[94]
2561 #define SWIGTYPE_p_wxPropagationDisabler swig_types[95]
2562 #define SWIGTYPE_p_wxPyApp swig_types[96]
2563 #define SWIGTYPE_p_wxPyCommandEvent swig_types[97]
2564 #define SWIGTYPE_p_wxPyDropTarget swig_types[98]
2565 #define SWIGTYPE_p_wxPyEvent swig_types[99]
2566 #define SWIGTYPE_p_wxPyFileSystemHandler swig_types[100]
2567 #define SWIGTYPE_p_wxPyImageHandler swig_types[101]
2568 #define SWIGTYPE_p_wxPyInputStream swig_types[102]
2569 #define SWIGTYPE_p_wxPySizer swig_types[103]
2570 #define SWIGTYPE_p_wxPyValidator swig_types[104]
2571 #define SWIGTYPE_p_wxQuantize swig_types[105]
2572 #define SWIGTYPE_p_wxQueryNewPaletteEvent swig_types[106]
2573 #define SWIGTYPE_p_wxRealPoint swig_types[107]
2574 #define SWIGTYPE_p_wxRect swig_types[108]
2575 #define SWIGTYPE_p_wxRegion swig_types[109]
2576 #define SWIGTYPE_p_wxScrollEvent swig_types[110]
2577 #define SWIGTYPE_p_wxScrollWinEvent swig_types[111]
2578 #define SWIGTYPE_p_wxSetCursorEvent swig_types[112]
2579 #define SWIGTYPE_p_wxShowEvent swig_types[113]
2580 #define SWIGTYPE_p_wxSize swig_types[114]
2581 #define SWIGTYPE_p_wxSizeEvent swig_types[115]
2582 #define SWIGTYPE_p_wxSizer swig_types[116]
2583 #define SWIGTYPE_p_wxSizerItem swig_types[117]
2584 #define SWIGTYPE_p_wxStaticBox swig_types[118]
2585 #define SWIGTYPE_p_wxStaticBoxSizer swig_types[119]
2586 #define SWIGTYPE_p_wxStdDialogButtonSizer swig_types[120]
2587 #define SWIGTYPE_p_wxSysColourChangedEvent swig_types[121]
2588 #define SWIGTYPE_p_wxTIFFHandler swig_types[122]
2589 #define SWIGTYPE_p_wxToolTip swig_types[123]
2590 #define SWIGTYPE_p_wxUpdateUIEvent swig_types[124]
2591 #define SWIGTYPE_p_wxValidator swig_types[125]
2592 #define SWIGTYPE_p_wxVisualAttributes swig_types[126]
2593 #define SWIGTYPE_p_wxWindow swig_types[127]
2594 #define SWIGTYPE_p_wxWindowCreateEvent swig_types[128]
2595 #define SWIGTYPE_p_wxWindowDestroyEvent swig_types[129]
2596 #define SWIGTYPE_p_wxXPMHandler swig_types[130]
2597 #define SWIGTYPE_p_wxZipFSHandler swig_types[131]
2598 static swig_type_info *swig_types[133];
2599 static swig_module_info swig_module = {swig_types, 132, 0, 0, 0, 0};
2600 #define SWIG_TypeQuery(name) SWIG_TypeQueryModule(&swig_module, &swig_module, name)
2601 #define SWIG_MangledTypeQuery(name) SWIG_MangledTypeQueryModule(&swig_module, &swig_module, name)
2602
2603 /* -------- TYPES TABLE (END) -------- */
2604
2605 #if (PY_VERSION_HEX <= 0x02000000)
2606 # if !defined(SWIG_PYTHON_CLASSIC)
2607 # error "This python version requires to use swig with the '-classic' option"
2608 # endif
2609 #endif
2610 #if (PY_VERSION_HEX <= 0x02020000)
2611 # error "This python version requires to use swig with the '-nomodern' option"
2612 #endif
2613 #if (PY_VERSION_HEX <= 0x02020000)
2614 # error "This python version requires to use swig with the '-nomodernargs' option"
2615 #endif
2616 #ifndef METH_O
2617 # error "This python version requires to use swig with the '-nofastunpack' option"
2618 #endif
2619
2620 /*-----------------------------------------------
2621 @(target):= _core_.so
2622 ------------------------------------------------*/
2623 #define SWIG_init init_core_
2624
2625 #define SWIG_name "_core_"
2626
2627 #define SWIGVERSION 0x010329
2628
2629
2630 #define SWIG_as_voidptr(a) const_cast< void * >(static_cast< const void * >(a))
2631 #define SWIG_as_voidptrptr(a) ((void)SWIG_as_voidptr(*a),reinterpret_cast< void** >(a))
2632
2633
2634 #include <stdexcept>
2635
2636
2637 namespace swig {
2638 class PyObject_ptr {
2639 protected:
2640 PyObject *_obj;
2641
2642 public:
2643 PyObject_ptr() :_obj(0)
2644 {
2645 }
2646
2647 PyObject_ptr(const PyObject_ptr& item) : _obj(item._obj)
2648 {
2649 Py_XINCREF(_obj);
2650 }
2651
2652 PyObject_ptr(PyObject *obj, bool initial_ref = true) :_obj(obj)
2653 {
2654 if (initial_ref) Py_XINCREF(_obj);
2655 }
2656
2657 PyObject_ptr & operator=(const PyObject_ptr& item)
2658 {
2659 Py_XINCREF(item._obj);
2660 Py_XDECREF(_obj);
2661 _obj = item._obj;
2662 return *this;
2663 }
2664
2665 ~PyObject_ptr()
2666 {
2667 Py_XDECREF(_obj);
2668 }
2669
2670 operator PyObject *() const
2671 {
2672 return _obj;
2673 }
2674
2675 PyObject *operator->() const
2676 {
2677 return _obj;
2678 }
2679 };
2680 }
2681
2682
2683 namespace swig {
2684 struct PyObject_var : PyObject_ptr {
2685 PyObject_var(PyObject* obj = 0) : PyObject_ptr(obj, false) { }
2686
2687 PyObject_var & operator = (PyObject* obj)
2688 {
2689 Py_XDECREF(_obj);
2690 _obj = obj;
2691 return *this;
2692 }
2693 };
2694 }
2695
2696
2697 #include "wx/wxPython/wxPython_int.h"
2698 #include "wx/wxPython/pyclasses.h"
2699 #include "wx/wxPython/twoitem.h"
2700
2701
2702 #ifndef wxPyUSE_EXPORT
2703 // Helper functions for dealing with SWIG objects and such. These are
2704 // located here so they know about the SWIG types and functions declared
2705 // in the wrapper code.
2706
2707 #include <wx/hashmap.h>
2708 WX_DECLARE_STRING_HASH_MAP( swig_type_info*, wxPyTypeInfoHashMap );
2709
2710
2711 // Maintains a hashmap of className to swig_type_info pointers. Given the
2712 // name of a class either looks up the type info in the cache, or scans the
2713 // SWIG tables for it.
2714 extern PyObject* wxPyPtrTypeMap;
2715 static
2716 swig_type_info* wxPyFindSwigType(const wxChar* className) {
2717
2718 static wxPyTypeInfoHashMap* typeInfoCache = NULL;
2719
2720 if (typeInfoCache == NULL)
2721 typeInfoCache = new wxPyTypeInfoHashMap;
2722
2723 wxString name(className);
2724 swig_type_info* swigType = (*typeInfoCache)[name];
2725
2726 if (! swigType) {
2727 // it wasn't in the cache, so look it up from SWIG
2728 name.Append(wxT(" *"));
2729 swigType = SWIG_TypeQuery(name.mb_str());
2730
2731 // if it still wasn't found, try looking for a mapped name
2732 if (!swigType) {
2733 PyObject* item;
2734 name = className;
2735
2736 if ((item = PyDict_GetItemString(wxPyPtrTypeMap,
2737 (char*)(const char*)name.mbc_str())) != NULL) {
2738 name = wxString(PyString_AsString(item), *wxConvCurrent);
2739 name.Append(wxT(" *"));
2740 swigType = SWIG_TypeQuery(name.mb_str());
2741 }
2742 }
2743 if (swigType) {
2744 // and add it to the map if found
2745 (*typeInfoCache)[className] = swigType;
2746 }
2747 }
2748 return swigType;
2749 }
2750
2751
2752 // Check if a class name is a type known to SWIG
2753 bool wxPyCheckSwigType(const wxChar* className) {
2754
2755 swig_type_info* swigType = wxPyFindSwigType(className);
2756 return swigType != NULL;
2757 }
2758
2759
2760 // Given a pointer to a C++ object and a class name, construct a Python proxy
2761 // object for it.
2762 PyObject* wxPyConstructObject(void* ptr,
2763 const wxChar* className,
2764 int setThisOwn) {
2765
2766 swig_type_info* swigType = wxPyFindSwigType(className);
2767 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyConstructObject"));
2768
2769 return SWIG_Python_NewPointerObj(ptr, swigType, setThisOwn);
2770 }
2771
2772
2773 // Extract a pointer to the wrapped C++ object from a Python proxy object.
2774 // Ensures that the proxy object is of the specified (or derived) type. If
2775 // not able to perform the conversion then a Python exception is set and the
2776 // error should be handled properly in the caller. Returns True on success.
2777 bool wxPyConvertSwigPtr(PyObject* obj, void **ptr,
2778 const wxChar* className) {
2779
2780 swig_type_info* swigType = wxPyFindSwigType(className);
2781 wxCHECK_MSG(swigType != NULL, false, wxT("Unknown type in wxPyConvertSwigPtr"));
2782
2783 return SWIG_Python_ConvertPtr(obj, ptr, swigType, SWIG_POINTER_EXCEPTION) != -1;
2784 }
2785
2786
2787
2788 // Make a SWIGified pointer object suitable for a .this attribute
2789 PyObject* wxPyMakeSwigPtr(void* ptr, const wxChar* className) {
2790
2791 PyObject* robj = NULL;
2792
2793 swig_type_info* swigType = wxPyFindSwigType(className);
2794 wxCHECK_MSG(swigType != NULL, NULL, wxT("Unknown type in wxPyMakeSwigPtr"));
2795
2796 robj = PySwigObject_New(ptr, swigType, 0);
2797 return robj;
2798 }
2799
2800
2801 // Python's PyInstance_Check does not return True for instances of new-style
2802 // classes. This should get close enough for both new and old classes but I
2803 // should re-evaluate the need for doing instance checks...
2804 bool wxPyInstance_Check(PyObject* obj) {
2805 return PyObject_HasAttrString(obj, "__class__") != 0;
2806 }
2807
2808
2809 // This one checks if the object is an instance of a SWIG proxy class (it has
2810 // a .this attribute, and the .this attribute is a PySwigObject.)
2811 bool wxPySwigInstance_Check(PyObject* obj) {
2812 static PyObject* this_str = NULL;
2813 if (this_str == NULL)
2814 this_str = PyString_FromString("this");
2815
2816 PyObject* this_attr = PyObject_GetAttr(obj, this_str);
2817 if (this_attr) {
2818 bool retval = (PySwigObject_Check(this_attr) != 0);
2819 Py_DECREF(this_attr);
2820 return retval;
2821 }
2822
2823 PyErr_Clear();
2824 return false;
2825 }
2826
2827
2828 // Export a C API in a struct. Other modules will be able to load this from
2829 // the wx._core_ module and will then have safe access to these functions,
2830 // even if they are located in another shared library.
2831 static wxPyCoreAPI API = {
2832
2833 wxPyCheckSwigType,
2834 wxPyConstructObject,
2835 wxPyConvertSwigPtr,
2836 wxPyMakeSwigPtr,
2837
2838 wxPyBeginAllowThreads,
2839 wxPyEndAllowThreads,
2840 wxPyBeginBlockThreads,
2841 wxPyEndBlockThreads,
2842
2843 wxPy_ConvertList,
2844
2845 wxString_in_helper,
2846 Py2wxString,
2847 wx2PyString,
2848
2849 byte_LIST_helper,
2850 int_LIST_helper,
2851 long_LIST_helper,
2852 string_LIST_helper,
2853 wxPoint_LIST_helper,
2854 wxBitmap_LIST_helper,
2855 wxString_LIST_helper,
2856 wxAcceleratorEntry_LIST_helper,
2857
2858 wxSize_helper,
2859 wxPoint_helper,
2860 wxRealPoint_helper,
2861 wxRect_helper,
2862 wxColour_helper,
2863 wxPoint2D_helper,
2864
2865 wxPySimple_typecheck,
2866 wxColour_typecheck,
2867
2868 wxPyCBH_setCallbackInfo,
2869 wxPyCBH_findCallback,
2870 wxPyCBH_callCallback,
2871 wxPyCBH_callCallbackObj,
2872 wxPyCBH_delete,
2873
2874 wxPyMake_wxObject,
2875 wxPyMake_wxSizer,
2876 wxPyPtrTypeMap_Add,
2877 wxPy2int_seq_helper,
2878 wxPy4int_seq_helper,
2879 wxArrayString2PyList_helper,
2880 wxArrayInt2PyList_helper,
2881
2882 wxPyClientData_dtor,
2883 wxPyUserData_dtor,
2884 wxPyOORClientData_dtor,
2885
2886 wxPyCBInputStream_create,
2887 wxPyCBInputStream_copy,
2888
2889 wxPyInstance_Check,
2890 wxPySwigInstance_Check,
2891
2892 wxPyCheckForApp
2893
2894 };
2895
2896 #endif
2897
2898
2899 #if !WXWIN_COMPATIBILITY_2_4
2900 #define wxHIDE_READONLY 0
2901 #endif
2902
2903
2904 #define SWIG_From_long PyInt_FromLong
2905
2906
2907 SWIGINTERNINLINE PyObject *
2908 SWIG_From_int (int value)
2909 {
2910 return SWIG_From_long (value);
2911 }
2912
2913 static const wxString wxPyEmptyString(wxEmptyString);
2914 SWIGINTERN wxString wxObject_GetClassName(wxObject *self){
2915 return self->GetClassInfo()->GetClassName();
2916 }
2917 SWIGINTERN void wxObject_Destroy(wxObject *self){
2918 delete self;
2919 }
2920
2921 #ifndef __WXMAC__
2922 #define wxCURSOR_COPY_ARROW wxCURSOR_ARROW
2923 #endif
2924
2925
2926 #include <limits.h>
2927 #ifndef LLONG_MIN
2928 # define LLONG_MIN LONG_LONG_MIN
2929 #endif
2930 #ifndef LLONG_MAX
2931 # define LLONG_MAX LONG_LONG_MAX
2932 #endif
2933 #ifndef ULLONG_MAX
2934 # define ULLONG_MAX ULONG_LONG_MAX
2935 #endif
2936
2937
2938 SWIGINTERN int
2939 SWIG_AsVal_long (PyObject* obj, long* val)
2940 {
2941 if (PyNumber_Check(obj)) {
2942 if (val) *val = PyInt_AsLong(obj);
2943 return SWIG_OK;
2944 }
2945 return SWIG_TypeError;
2946 }
2947
2948
2949 SWIGINTERN int
2950 SWIG_AsVal_int (PyObject * obj, int *val)
2951 {
2952 long v;
2953 int res = SWIG_AsVal_long (obj, &v);
2954 if (SWIG_IsOK(res)) {
2955 if ((v < INT_MIN || v > INT_MAX)) {
2956 return SWIG_OverflowError;
2957 } else {
2958 if (val) *val = static_cast< int >(v);
2959 }
2960 }
2961 return res;
2962 }
2963
2964 SWIGINTERN bool wxSize___eq__(wxSize *self,PyObject *other){
2965 wxSize temp, *obj = &temp;
2966 if ( other == Py_None ) return false;
2967 if ( ! wxSize_helper(other, &obj) ) {
2968 PyErr_Clear();
2969 return false;
2970 }
2971 return self->operator==(*obj);
2972 }
2973 SWIGINTERN bool wxSize___ne__(wxSize *self,PyObject *other){
2974 wxSize temp, *obj = &temp;
2975 if ( other == Py_None ) return true;
2976 if ( ! wxSize_helper(other, &obj)) {
2977 PyErr_Clear();
2978 return true;
2979 }
2980 return self->operator!=(*obj);
2981 }
2982
2983 #include <float.h>
2984
2985
2986 SWIGINTERN int
2987 SWIG_AsVal_double (PyObject *obj, double* val)
2988 {
2989 if (PyNumber_Check(obj)) {
2990 if (val) *val = PyFloat_AsDouble(obj);
2991 return SWIG_OK;
2992 }
2993 return SWIG_TypeError;
2994 }
2995
2996
2997 SWIGINTERN int
2998 SWIG_AsVal_float (PyObject * obj, float *val)
2999 {
3000 double v;
3001 int res = SWIG_AsVal_double (obj, &v);
3002 if (SWIG_IsOK(res)) {
3003 if ((v < -FLT_MAX || v > FLT_MAX)) {
3004 return SWIG_OverflowError;
3005 } else {
3006 if (val) *val = static_cast< float >(v);
3007 }
3008 }
3009 return res;
3010 }
3011
3012 SWIGINTERN PyObject *wxSize_Get(wxSize *self){
3013 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3014 PyObject* tup = PyTuple_New(2);
3015 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3016 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3017 wxPyEndBlockThreads(blocked);
3018 return tup;
3019 }
3020
3021 #define SWIG_From_double PyFloat_FromDouble
3022
3023 SWIGINTERN bool wxRealPoint___eq__(wxRealPoint *self,PyObject *other){
3024 wxRealPoint temp, *obj = &temp;
3025 if ( other == Py_None ) return false;
3026 if ( ! wxRealPoint_helper(other, &obj) ) {
3027 PyErr_Clear();
3028 return false;
3029 }
3030 return self->operator==(*obj);
3031 }
3032 SWIGINTERN bool wxRealPoint___ne__(wxRealPoint *self,PyObject *other){
3033 wxRealPoint temp, *obj = &temp;
3034 if ( other == Py_None ) return true;
3035 if ( ! wxRealPoint_helper(other, &obj)) {
3036 PyErr_Clear();
3037 return true;
3038 }
3039 return self->operator!=(*obj);
3040 }
3041 SWIGINTERN void wxRealPoint_Set(wxRealPoint *self,double x,double y){
3042 self->x = x;
3043 self->y = y;
3044 }
3045 SWIGINTERN PyObject *wxRealPoint_Get(wxRealPoint *self){
3046 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3047 PyObject* tup = PyTuple_New(2);
3048 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->x));
3049 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->y));
3050 wxPyEndBlockThreads(blocked);
3051 return tup;
3052 }
3053 SWIGINTERN bool wxPoint___eq__(wxPoint *self,PyObject *other){
3054 wxPoint temp, *obj = &temp;
3055 if ( other == Py_None ) return false;
3056 if ( ! wxPoint_helper(other, &obj) ) {
3057 PyErr_Clear();
3058 return false;
3059 }
3060 return self->operator==(*obj);
3061 }
3062 SWIGINTERN bool wxPoint___ne__(wxPoint *self,PyObject *other){
3063 wxPoint temp, *obj = &temp;
3064 if ( other == Py_None ) return true;
3065 if ( ! wxPoint_helper(other, &obj)) {
3066 PyErr_Clear();
3067 return true;
3068 }
3069 return self->operator!=(*obj);
3070 }
3071 SWIGINTERN void wxPoint_Set(wxPoint *self,long x,long y){
3072 self->x = x;
3073 self->y = y;
3074 }
3075 SWIGINTERN PyObject *wxPoint_Get(wxPoint *self){
3076 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3077 PyObject* tup = PyTuple_New(2);
3078 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3079 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3080 wxPyEndBlockThreads(blocked);
3081 return tup;
3082 }
3083 SWIGINTERN bool wxRect___eq__(wxRect *self,PyObject *other){
3084 wxRect temp, *obj = &temp;
3085 if ( other == Py_None ) return false;
3086 if ( ! wxRect_helper(other, &obj) ) {
3087 PyErr_Clear();
3088 return false;
3089 }
3090 return self->operator==(*obj);
3091 }
3092 SWIGINTERN bool wxRect___ne__(wxRect *self,PyObject *other){
3093 wxRect temp, *obj = &temp;
3094 if ( other == Py_None ) return true;
3095 if ( ! wxRect_helper(other, &obj)) {
3096 PyErr_Clear();
3097 return true;
3098 }
3099 return self->operator!=(*obj);
3100 }
3101 SWIGINTERN void wxRect_Set(wxRect *self,int x=0,int y=0,int width=0,int height=0){
3102 self->x = x;
3103 self->y = y;
3104 self->width = width;
3105 self->height = height;
3106 }
3107 SWIGINTERN PyObject *wxRect_Get(wxRect *self){
3108 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3109 PyObject* tup = PyTuple_New(4);
3110 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->x));
3111 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->y));
3112 PyTuple_SET_ITEM(tup, 2, PyInt_FromLong(self->width));
3113 PyTuple_SET_ITEM(tup, 3, PyInt_FromLong(self->height));
3114 wxPyEndBlockThreads(blocked);
3115 return tup;
3116 }
3117
3118 PyObject* wxIntersectRect(wxRect* r1, wxRect* r2) {
3119 wxRegion reg1(*r1);
3120 wxRegion reg2(*r2);
3121 wxRect dest(0,0,0,0);
3122 PyObject* obj;
3123
3124 reg1.Intersect(reg2);
3125 dest = reg1.GetBox();
3126
3127 if (dest != wxRect(0,0,0,0)) {
3128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3129 wxRect* newRect = new wxRect(dest);
3130 obj = wxPyConstructObject((void*)newRect, wxT("wxRect"), true);
3131 wxPyEndBlockThreads(blocked);
3132 return obj;
3133 }
3134 Py_INCREF(Py_None);
3135 return Py_None;
3136 }
3137
3138 SWIGINTERN bool wxPoint2D___eq__(wxPoint2D *self,PyObject *other){
3139 wxPoint2D temp, *obj = &temp;
3140 if ( other == Py_None ) return false;
3141 if ( ! wxPoint2D_helper(other, &obj) ) {
3142 PyErr_Clear();
3143 return false;
3144 }
3145 return self->operator==(*obj);
3146 }
3147 SWIGINTERN bool wxPoint2D___ne__(wxPoint2D *self,PyObject *other){
3148 wxPoint2D temp, *obj = &temp;
3149 if ( other == Py_None ) return true;
3150 if ( ! wxPoint2D_helper(other, &obj)) {
3151 PyErr_Clear();
3152 return true;
3153 }
3154 return self->operator!=(*obj);
3155 }
3156 SWIGINTERN void wxPoint2D_Set(wxPoint2D *self,double x=0,double y=0){
3157 self->m_x = x;
3158 self->m_y = y;
3159 }
3160 SWIGINTERN PyObject *wxPoint2D_Get(wxPoint2D *self){
3161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3162 PyObject* tup = PyTuple_New(2);
3163 PyTuple_SET_ITEM(tup, 0, PyFloat_FromDouble(self->m_x));
3164 PyTuple_SET_ITEM(tup, 1, PyFloat_FromDouble(self->m_y));
3165 wxPyEndBlockThreads(blocked);
3166 return tup;
3167 }
3168
3169 #include "wx/wxPython/pyistream.h"
3170
3171 SWIGINTERN wxPyInputStream *new_wxPyInputStream(PyObject *p){
3172 wxInputStream* wxis = wxPyCBInputStream::create(p);
3173 if (wxis)
3174 return new wxPyInputStream(wxis);
3175 else
3176 return NULL;
3177 }
3178
3179 SWIGINTERN swig_type_info*
3180 SWIG_pchar_descriptor()
3181 {
3182 static int init = 0;
3183 static swig_type_info* info = 0;
3184 if (!init) {
3185 info = SWIG_TypeQuery("_p_char");
3186 init = 1;
3187 }
3188 return info;
3189 }
3190
3191
3192 SWIGINTERNINLINE PyObject *
3193 SWIG_FromCharPtrAndSize(const char* carray, size_t size)
3194 {
3195 if (carray) {
3196 if (size > INT_MAX) {
3197 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3198 return pchar_descriptor ?
3199 SWIG_NewPointerObj(const_cast< char * >(carray), pchar_descriptor, 0) : SWIG_Py_Void();
3200 } else {
3201 return PyString_FromStringAndSize(carray, static_cast< int >(size));
3202 }
3203 } else {
3204 return SWIG_Py_Void();
3205 }
3206 }
3207
3208
3209 SWIGINTERNINLINE PyObject *
3210 SWIG_From_char (char c)
3211 {
3212 return SWIG_FromCharPtrAndSize(&c,1);
3213 }
3214
3215
3216 SWIGINTERNINLINE PyObject*
3217 SWIG_From_unsigned_SS_long (unsigned long value)
3218 {
3219 return (value > LONG_MAX) ?
3220 PyLong_FromUnsignedLong(value) : PyInt_FromLong(static_cast< long >(value));
3221 }
3222
3223
3224 SWIGINTERNINLINE PyObject *
3225 SWIG_From_size_t (size_t value)
3226 {
3227 return SWIG_From_unsigned_SS_long (static_cast< unsigned long >(value));
3228 }
3229
3230
3231 SWIGINTERN int
3232 SWIG_AsCharPtrAndSize(PyObject *obj, char** cptr, size_t* psize, int *alloc)
3233 {
3234 if (PyString_Check(obj)) {
3235 char *cstr; Py_ssize_t len;
3236 PyString_AsStringAndSize(obj, &cstr, &len);
3237 if (cptr) {
3238 if (alloc) {
3239 /*
3240 In python the user should not be able to modify the inner
3241 string representation. To warranty that, if you define
3242 SWIG_PYTHON_SAFE_CSTRINGS, a new/copy of the python string
3243 buffer is always returned.
3244
3245 The default behavior is just to return the pointer value,
3246 so, be careful.
3247 */
3248 #if defined(SWIG_PYTHON_SAFE_CSTRINGS)
3249 if (*alloc != SWIG_OLDOBJ)
3250 #else
3251 if (*alloc == SWIG_NEWOBJ)
3252 #endif
3253 {
3254 *cptr = reinterpret_cast< char* >(memcpy((new char[len + 1]), cstr, sizeof(char)*(len + 1)));
3255 *alloc = SWIG_NEWOBJ;
3256 }
3257 else {
3258 *cptr = cstr;
3259 *alloc = SWIG_OLDOBJ;
3260 }
3261 } else {
3262 *cptr = PyString_AsString(obj);
3263 }
3264 }
3265 if (psize) *psize = len + 1;
3266 return SWIG_OK;
3267 } else {
3268 swig_type_info* pchar_descriptor = SWIG_pchar_descriptor();
3269 if (pchar_descriptor) {
3270 void* vptr = 0;
3271 if (SWIG_ConvertPtr(obj, &vptr, pchar_descriptor, 0) == SWIG_OK) {
3272 if (cptr) *cptr = (char *) vptr;
3273 if (psize) *psize = vptr ? (strlen((char *)vptr) + 1) : 0;
3274 if (alloc) *alloc = SWIG_OLDOBJ;
3275 return SWIG_OK;
3276 }
3277 }
3278 }
3279 return SWIG_TypeError;
3280 }
3281
3282
3283 SWIGINTERN int
3284 SWIG_AsCharArray(PyObject * obj, char *val, size_t size)
3285 {
3286 char* cptr = 0; size_t csize = 0; int alloc = SWIG_OLDOBJ;
3287 int res = SWIG_AsCharPtrAndSize(obj, &cptr, &csize, &alloc);
3288 if (SWIG_IsOK(res)) {
3289 if ((csize == size + 1) && cptr && !(cptr[csize-1])) --csize;
3290 if (csize <= size) {
3291 if (val) {
3292 if (csize) memcpy(val, cptr, csize*sizeof(char));
3293 if (csize < size) memset(val + csize, 0, (size - csize)*sizeof(char));
3294 }
3295 if (alloc == SWIG_NEWOBJ) {
3296 delete[] cptr;
3297 res = SWIG_DelNewMask(res);
3298 }
3299 return res;
3300 }
3301 if (alloc == SWIG_NEWOBJ) delete[] cptr;
3302 }
3303 return SWIG_TypeError;
3304 }
3305
3306
3307 SWIGINTERN int
3308 SWIG_AsVal_char (PyObject * obj, char *val)
3309 {
3310 int res = SWIG_AsCharArray(obj, val, 1);
3311 if (!SWIG_IsOK(res)) {
3312 long v;
3313 res = SWIG_AddCast(SWIG_AsVal_long (obj, &v));
3314 if (SWIG_IsOK(res)) {
3315 if ((CHAR_MIN <= v) && (v <= CHAR_MAX)) {
3316 if (val) *val = static_cast< char >(v);
3317 } else {
3318 res = SWIG_OverflowError;
3319 }
3320 }
3321 }
3322 return res;
3323 }
3324
3325 SWIGINTERN void wxOutputStream_write(wxOutputStream *self,PyObject *obj){
3326 // We use only strings for the streams, not unicode
3327 PyObject* str = PyObject_Str(obj);
3328 if (! str) {
3329 PyErr_SetString(PyExc_TypeError, "Unable to convert to string");
3330 return;
3331 }
3332 self->Write(PyString_AS_STRING(str),
3333 PyString_GET_SIZE(str));
3334 Py_DECREF(str);
3335 }
3336
3337 #include "wx/wxPython/pyistream.h"
3338
3339
3340 class wxPyFileSystemHandler : public wxFileSystemHandler
3341 {
3342 public:
3343 wxPyFileSystemHandler() : wxFileSystemHandler() {}
3344
3345 DEC_PYCALLBACK_BOOL_STRING_pure(CanOpen);
3346 DEC_PYCALLBACK_FSF_FSSTRING_pure(OpenFile);
3347 DEC_PYCALLBACK_STRING_STRINGINT_pure(FindFirst);
3348 DEC_PYCALLBACK_STRING__pure(FindNext);
3349
3350 wxString GetProtocol(const wxString& location) {
3351 return wxFileSystemHandler::GetProtocol(location);
3352 }
3353
3354 wxString GetLeftLocation(const wxString& location) {
3355 return wxFileSystemHandler::GetLeftLocation(location);
3356 }
3357
3358 wxString GetAnchor(const wxString& location) {
3359 return wxFileSystemHandler::GetAnchor(location);
3360 }
3361
3362 wxString GetRightLocation(const wxString& location) {
3363 return wxFileSystemHandler::GetRightLocation(location);
3364 }
3365
3366 wxString GetMimeTypeFromExt(const wxString& location) {
3367 return wxFileSystemHandler::GetMimeTypeFromExt(location);
3368 }
3369
3370 PYPRIVATE;
3371 };
3372
3373
3374 IMP_PYCALLBACK_BOOL_STRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, CanOpen);
3375 IMP_PYCALLBACK_FSF_FSSTRING_pure(wxPyFileSystemHandler, wxFileSystemHandler, OpenFile);
3376 IMP_PYCALLBACK_STRING_STRINGINT_pure(wxPyFileSystemHandler, wxFileSystemHandler, FindFirst);
3377 IMP_PYCALLBACK_STRING__pure(wxPyFileSystemHandler, wxFileSystemHandler, FindNext);
3378
3379
3380 SWIGINTERN int
3381 SWIG_AsVal_bool (PyObject *obj, bool *val)
3382 {
3383 if (obj == Py_True) {
3384 if (val) *val = true;
3385 return SWIG_OK;
3386 } else if (obj == Py_False) {
3387 if (val) *val = false;
3388 return SWIG_OK;
3389 } else {
3390 long v = 0;
3391 int res = SWIG_AddCast(SWIG_AsVal_long (obj, val ? &v : 0));
3392 if (SWIG_IsOK(res) && val) *val = v ? true : false;
3393 return res;
3394 }
3395 }
3396
3397 SWIGINTERN wxString wxFileSystem_URLToFileName(wxString const &url){
3398 wxFileName fname = wxFileSystem::URLToFileName(url);
3399 return fname.GetFullPath();
3400 }
3401
3402 void __wxMemoryFSHandler_AddFile_wxImage(const wxString& filename,
3403 wxImage& image,
3404 long type) {
3405 wxMemoryFSHandler::AddFile(filename, image, type);
3406 }
3407
3408 void __wxMemoryFSHandler_AddFile_wxBitmap(const wxString& filename,
3409 const wxBitmap& bitmap,
3410 long type) {
3411 wxMemoryFSHandler::AddFile(filename, bitmap, type);
3412 }
3413
3414 void __wxMemoryFSHandler_AddFile_Data(const wxString& filename,
3415 PyObject* data) {
3416 if (! PyString_Check(data)) {
3417 wxPyBLOCK_THREADS(PyErr_SetString(PyExc_TypeError,
3418 "Expected string object"));
3419 return;
3420 }
3421
3422 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3423 void* ptr = (void*)PyString_AsString(data);
3424 size_t size = PyString_Size(data);
3425 wxPyEndBlockThreads(blocked);
3426
3427 wxMemoryFSHandler::AddFile(filename, ptr, size);
3428 }
3429
3430
3431 #include "wx/wxPython/pyistream.h"
3432
3433
3434 SWIGINTERN int
3435 SWIG_AsVal_unsigned_SS_long (PyObject* obj, unsigned long* val)
3436 {
3437 long v = 0;
3438 if (SWIG_AsVal_long(obj, &v) && v < 0) {
3439 return SWIG_TypeError;
3440 }
3441 else if (val)
3442 *val = (unsigned long)v;
3443 return SWIG_OK;
3444 }
3445
3446
3447 SWIGINTERN int
3448 SWIG_AsVal_unsigned_SS_char (PyObject * obj, unsigned char *val)
3449 {
3450 unsigned long v;
3451 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3452 if (SWIG_IsOK(res)) {
3453 if ((v > UCHAR_MAX)) {
3454 return SWIG_OverflowError;
3455 } else {
3456 if (val) *val = static_cast< unsigned char >(v);
3457 }
3458 }
3459 return res;
3460 }
3461
3462
3463 SWIGINTERNINLINE PyObject *
3464 SWIG_From_unsigned_SS_char (unsigned char value)
3465 {
3466 return SWIG_From_unsigned_SS_long (value);
3467 }
3468
3469 SWIGINTERN unsigned long wxImageHistogram_GetCount(wxImageHistogram *self,unsigned long key){
3470 wxImageHistogramEntry e = (*self)[key];
3471 return e.value;
3472 }
3473 SWIGINTERN unsigned long wxImageHistogram_GetCountRGB(wxImageHistogram *self,byte r,byte g,byte b){
3474 unsigned long key = wxImageHistogram::MakeKey(r, g, b);
3475 wxImageHistogramEntry e = (*self)[key];
3476 return e.value;
3477 }
3478 SWIGINTERN unsigned long wxImageHistogram_GetCountColour(wxImageHistogram *self,wxColour const &colour){
3479 unsigned long key = wxImageHistogram::MakeKey(colour.Red(),
3480 colour.Green(),
3481 colour.Blue());
3482 wxImageHistogramEntry e = (*self)[key];
3483 return e.value;
3484 }
3485
3486 typedef unsigned char* buffer;
3487
3488
3489 // Pull the nested class out to the top level for SWIG's sake
3490 #define wxImage_RGBValue wxImage::RGBValue
3491 #define wxImage_HSVValue wxImage::HSVValue
3492
3493 SWIGINTERN wxImage *new_wxImage(int width=0,int height=0,bool clear=true){
3494 if (width > 0 && height > 0)
3495 return new wxImage(width, height, clear);
3496 else
3497 return new wxImage;
3498 }
3499 SWIGINTERN wxImage *new_wxImage(wxBitmap const &bitmap){
3500 return new wxImage(bitmap.ConvertToImage());
3501 }
3502 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE){
3503 if (DATASIZE != width*height*3) {
3504 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3505 return NULL;
3506 }
3507
3508 // Copy the source data so the wxImage can clean it up later
3509 buffer copy = (buffer)malloc(DATASIZE);
3510 if (copy == NULL) {
3511 wxPyBLOCK_THREADS(PyErr_NoMemory());
3512 return NULL;
3513 }
3514 memcpy(copy, data, DATASIZE);
3515 return new wxImage(width, height, copy, false);
3516 }
3517 SWIGINTERN wxImage *new_wxImage(int width,int height,buffer data,int DATASIZE,buffer alpha,int ALPHASIZE){
3518 if (DATASIZE != width*height*3) {
3519 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3520 return NULL;
3521 }
3522 if (ALPHASIZE != width*height) {
3523 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3524 return NULL;
3525 }
3526
3527 // Copy the source data so the wxImage can clean it up later
3528 buffer dcopy = (buffer)malloc(DATASIZE);
3529 if (dcopy == NULL) {
3530 wxPyBLOCK_THREADS(PyErr_NoMemory());
3531 return NULL;
3532 }
3533 memcpy(dcopy, data, DATASIZE);
3534
3535 buffer acopy = (buffer)malloc(ALPHASIZE);
3536 if (acopy == NULL) {
3537 wxPyBLOCK_THREADS(PyErr_NoMemory());
3538 return NULL;
3539 }
3540 memcpy(acopy, alpha, ALPHASIZE);
3541
3542 return new wxImage(width, height, dcopy, acopy, false);
3543 }
3544 SWIGINTERN wxSize wxImage_GetSize(wxImage *self){
3545 wxSize size(self->GetWidth(), self->GetHeight());
3546 return size;
3547 }
3548 SWIGINTERN PyObject *wxImage_GetData(wxImage *self){
3549 buffer data = self->GetData();
3550 int len = self->GetWidth() * self->GetHeight() * 3;
3551 PyObject* rv;
3552 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len));
3553 return rv;
3554 }
3555 SWIGINTERN void wxImage_SetData(wxImage *self,buffer data,int DATASIZE){
3556 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3557 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3558 return;
3559 }
3560 buffer copy = (buffer)malloc(DATASIZE);
3561 if (copy == NULL) {
3562 wxPyBLOCK_THREADS(PyErr_NoMemory());
3563 return;
3564 }
3565 memcpy(copy, data, DATASIZE);
3566 self->SetData(copy, false);
3567 // wxImage takes ownership of copy...
3568 }
3569 SWIGINTERN PyObject *wxImage_GetDataBuffer(wxImage *self){
3570 buffer data = self->GetData();
3571 int len = self->GetWidth() * self->GetHeight() * 3;
3572 PyObject* rv;
3573 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3574 return rv;
3575 }
3576 SWIGINTERN void wxImage_SetDataBuffer(wxImage *self,buffer data,int DATASIZE){
3577 if (DATASIZE != self->GetWidth() * self->GetHeight() * 3) {
3578 wxPyErr_SetString(PyExc_ValueError, "Invalid data buffer size.");
3579 return;
3580 }
3581 self->SetData(data, true);
3582 }
3583 SWIGINTERN PyObject *wxImage_GetAlphaData(wxImage *self){
3584 buffer data = self->GetAlpha();
3585 if (! data) {
3586 RETURN_NONE();
3587 } else {
3588 int len = self->GetWidth() * self->GetHeight();
3589 PyObject* rv;
3590 wxPyBLOCK_THREADS( rv = PyString_FromStringAndSize((char*)data, len) );
3591 return rv;
3592 }
3593 }
3594 SWIGINTERN void wxImage_SetAlphaData(wxImage *self,buffer alpha,int ALPHASIZE){
3595 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3596 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3597 return;
3598 }
3599 buffer acopy = (buffer)malloc(ALPHASIZE);
3600 if (acopy == NULL) {
3601 wxPyBLOCK_THREADS(PyErr_NoMemory());
3602 return;
3603 }
3604 memcpy(acopy, alpha, ALPHASIZE);
3605 self->SetAlpha(acopy, false);
3606 // wxImage takes ownership of acopy...
3607 }
3608 SWIGINTERN PyObject *wxImage_GetAlphaBuffer(wxImage *self){
3609 buffer data = self->GetAlpha();
3610 int len = self->GetWidth() * self->GetHeight();
3611 PyObject* rv;
3612 wxPyBLOCK_THREADS( rv = PyBuffer_FromReadWriteMemory(data, len) );
3613 return rv;
3614 }
3615 SWIGINTERN void wxImage_SetAlphaBuffer(wxImage *self,buffer alpha,int ALPHASIZE){
3616 if (ALPHASIZE != self->GetWidth() * self->GetHeight()) {
3617 wxPyErr_SetString(PyExc_ValueError, "Invalid alpha buffer size.");
3618 return;
3619 }
3620 self->SetAlpha(alpha, true);
3621 }
3622 SWIGINTERN PyObject *wxImage_GetHandlers(){
3623 wxList& list = wxImage::GetHandlers();
3624 return wxPy_ConvertList(&list);
3625 }
3626 SWIGINTERN wxBitmap wxImage_ConvertToBitmap(wxImage *self,int depth=-1){
3627 wxBitmap bitmap(*self, depth);
3628 return bitmap;
3629 }
3630 SWIGINTERN wxBitmap wxImage_ConvertToMonoBitmap(wxImage *self,byte red,byte green,byte blue){
3631 wxImage mono = self->ConvertToMono( red, green, blue );
3632 wxBitmap bitmap( mono, 1 );
3633 return bitmap;
3634 }
3635 static const wxString wxPyIMAGE_OPTION_FILENAME(wxIMAGE_OPTION_FILENAME);
3636 static const wxString wxPyIMAGE_OPTION_BMP_FORMAT(wxIMAGE_OPTION_BMP_FORMAT);
3637 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_X(wxIMAGE_OPTION_CUR_HOTSPOT_X);
3638 static const wxString wxPyIMAGE_OPTION_CUR_HOTSPOT_Y(wxIMAGE_OPTION_CUR_HOTSPOT_Y);
3639 static const wxString wxPyIMAGE_OPTION_RESOLUTION(wxIMAGE_OPTION_RESOLUTION);
3640 static const wxString wxPyIMAGE_OPTION_RESOLUTIONX(wxIMAGE_OPTION_RESOLUTIONX);
3641 static const wxString wxPyIMAGE_OPTION_RESOLUTIONY(wxIMAGE_OPTION_RESOLUTIONY);
3642 static const wxString wxPyIMAGE_OPTION_RESOLUTIONUNIT(wxIMAGE_OPTION_RESOLUTIONUNIT);
3643 static const wxString wxPyIMAGE_OPTION_QUALITY(wxIMAGE_OPTION_QUALITY);
3644 static const wxString wxPyIMAGE_OPTION_BITSPERSAMPLE(wxIMAGE_OPTION_BITSPERSAMPLE);
3645 static const wxString wxPyIMAGE_OPTION_SAMPLESPERPIXEL(wxIMAGE_OPTION_SAMPLESPERPIXEL);
3646 static const wxString wxPyIMAGE_OPTION_COMPRESSION(wxIMAGE_OPTION_COMPRESSION);
3647 static const wxString wxPyIMAGE_OPTION_IMAGEDESCRIPTOR(wxIMAGE_OPTION_IMAGEDESCRIPTOR);
3648 static const wxString wxPyIMAGE_OPTION_PNG_FORMAT(wxIMAGE_OPTION_PNG_FORMAT);
3649 static const wxString wxPyIMAGE_OPTION_PNG_BITDEPTH(wxIMAGE_OPTION_PNG_BITDEPTH);
3650
3651 #include <wx/quantize.h>
3652
3653 SWIGINTERN bool wxQuantize_Quantize(wxImage const &src,wxImage &dest,int desiredNoColours=236,int flags=wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE){
3654 return wxQuantize::Quantize(src, dest,
3655 //NULL, // palette
3656 desiredNoColours,
3657 NULL, // eightBitData
3658 flags);
3659 }
3660 SWIGINTERN void wxEvtHandler_Connect(wxEvtHandler *self,int id,int lastId,int eventType,PyObject *func){
3661 if (PyCallable_Check(func)) {
3662 self->Connect(id, lastId, eventType,
3663 (wxObjectEventFunction) &wxPyCallback::EventThunker,
3664 new wxPyCallback(func));
3665 }
3666 else if (func == Py_None) {
3667 self->Disconnect(id, lastId, eventType,
3668 (wxObjectEventFunction)
3669 &wxPyCallback::EventThunker);
3670 }
3671 else {
3672 wxPyBLOCK_THREADS(
3673 PyErr_SetString(PyExc_TypeError, "Expected callable object or None."));
3674 }
3675 }
3676 SWIGINTERN bool wxEvtHandler_Disconnect(wxEvtHandler *self,int id,int lastId=-1,wxEventType eventType=wxEVT_NULL){
3677 return self->Disconnect(id, lastId, eventType,
3678 (wxObjectEventFunction)
3679 &wxPyCallback::EventThunker);
3680 }
3681 SWIGINTERN void wxEvtHandler__setOORInfo(wxEvtHandler *self,PyObject *_self,bool incref=true){
3682 if (_self && _self != Py_None) {
3683 self->SetClientObject(new wxPyOORClientData(_self, incref));
3684 }
3685 else {
3686 wxPyOORClientData* data = (wxPyOORClientData*)self->GetClientObject();
3687 if (data) {
3688 self->SetClientObject(NULL); // This will delete it too
3689 }
3690 }
3691 }
3692
3693 #if ! wxUSE_HOTKEY
3694 #define wxEVT_HOTKEY -9999
3695 #endif
3696
3697 SWIGINTERN PyObject *wxCommandEvent_GetClientData(wxCommandEvent *self){
3698 wxPyClientData* data = (wxPyClientData*)self->GetClientObject();
3699 if (data) {
3700 Py_INCREF(data->m_obj);
3701 return data->m_obj;
3702 } else {
3703 Py_INCREF(Py_None);
3704 return Py_None;
3705 }
3706 }
3707 SWIGINTERN void wxCommandEvent_SetClientData(wxCommandEvent *self,PyObject *clientData){
3708 wxPyClientData* data = new wxPyClientData(clientData);
3709 self->SetClientObject(data);
3710 }
3711 SWIGINTERN int wxKeyEvent_GetUnicodeKey(wxKeyEvent *self){
3712 #if wxUSE_UNICODE
3713 return self->GetUnicodeKey();
3714 #else
3715 return 0;
3716 #endif
3717 }
3718 SWIGINTERN void wxKeyEvent_SetUnicodeKey(wxKeyEvent *self,int uniChar){
3719 #if wxUSE_UNICODE
3720 self->m_uniChar = uniChar;
3721 #endif
3722 }
3723
3724 SWIGINTERNINLINE PyObject *
3725 SWIG_From_unsigned_SS_int (unsigned int value)
3726 {
3727 return SWIG_From_unsigned_SS_long (value);
3728 }
3729
3730
3731 SWIGINTERN int
3732 SWIG_AsVal_unsigned_SS_int (PyObject * obj, unsigned int *val)
3733 {
3734 unsigned long v;
3735 int res = SWIG_AsVal_unsigned_SS_long (obj, &v);
3736 if (SWIG_IsOK(res)) {
3737 if ((v > UINT_MAX)) {
3738 return SWIG_OverflowError;
3739 } else {
3740 if (val) *val = static_cast< unsigned int >(v);
3741 }
3742 }
3743 return res;
3744 }
3745
3746 SWIGINTERN void wxSizeEvent_SetSize(wxSizeEvent *self,wxSize size){
3747 self->m_size = size;
3748 }
3749 SWIGINTERN PyObject *wxDropFilesEvent_GetFiles(wxDropFilesEvent *self){
3750 int count = self->GetNumberOfFiles();
3751 wxString* files = self->GetFiles();
3752 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3753 PyObject* list = PyList_New(count);
3754
3755 if (!list) {
3756 PyErr_SetString(PyExc_MemoryError, "Can't allocate list of files!");
3757 wxPyEndBlockThreads(blocked);
3758 return NULL;
3759 }
3760
3761 for (int i=0; i<count; i++) {
3762 PyList_SetItem(list, i, wx2PyString(files[i]));
3763 }
3764 wxPyEndBlockThreads(blocked);
3765 return list;
3766 }
3767
3768
3769 SWIGINTERN wxPyApp *new_wxPyApp(){
3770 wxPythonApp = new wxPyApp();
3771 return wxPythonApp;
3772 }
3773 SWIGINTERN int wxPyApp_GetComCtl32Version(){ wxPyRaiseNotImplemented(); return 0; }
3774
3775 void wxApp_CleanUp() {
3776 __wxPyCleanup();
3777 }
3778
3779
3780 wxPyApp* wxPyGetApp() { return (wxPyApp*)wxTheApp; }
3781
3782
3783
3784
3785
3786 SWIGINTERNINLINE PyObject *
3787 SWIG_FromCharPtr(const char *cptr)
3788 {
3789 return SWIG_FromCharPtrAndSize(cptr, (cptr ? strlen(cptr) : 0));
3790 }
3791
3792
3793 #if 0 // #ifdef __WXMAC__
3794
3795 // A dummy class that raises an exception if used...
3796 class wxEventLoop
3797 {
3798 public:
3799 wxEventLoop() { wxPyRaiseNotImplemented(); }
3800 int Run() { return 0; }
3801 void Exit(int rc = 0) {}
3802 bool Pending() const { return false; }
3803 bool Dispatch() { return false; }
3804 bool IsRunning() const { return false; }
3805 static wxEventLoop *GetActive() { wxPyRaiseNotImplemented(); return NULL; }
3806 static void SetActive(wxEventLoop* loop) { wxPyRaiseNotImplemented(); }
3807 };
3808
3809 #else
3810
3811 #include <wx/evtloop.h>
3812
3813 #endif
3814
3815
3816
3817 static const wxString wxPyPanelNameStr(wxPanelNameStr);
3818 SWIGINTERN wxVisualAttributes *new_wxVisualAttributes(){ return new wxVisualAttributes; }
3819 SWIGINTERN void delete_wxVisualAttributes(wxVisualAttributes *self){ delete self; }
3820 SWIGINTERN PyObject *wxWindow_GetChildren(wxWindow *self){
3821 wxWindowList& list = self->GetChildren();
3822 return wxPy_ConvertList(&list);
3823 }
3824 SWIGINTERN void wxWindow_SetDoubleBuffered(wxWindow *self,bool on){}
3825 SWIGINTERN bool wxWindow_RegisterHotKey(wxWindow *self,int hotkeyId,int modifiers,int keycode){
3826 #if wxUSE_HOTKEY
3827 return self->RegisterHotKey(hotkeyId, modifiers, keycode);
3828 #else
3829 return false;
3830 #endif
3831 }
3832 SWIGINTERN bool wxWindow_UnregisterHotKey(wxWindow *self,int hotkeyId){
3833
3834
3835
3836 return false;
3837
3838 }
3839 SWIGINTERN long wxWindow_GetHandle(wxWindow *self){
3840 return wxPyGetWinHandle(self);
3841 }
3842 SWIGINTERN void wxWindow_AssociateHandle(wxWindow *self,long handle){
3843 self->AssociateHandle((WXWidget)handle);
3844 }
3845 SWIGINTERN void wxWindow_DragAcceptFiles(wxWindow *self,bool accept){}
3846
3847 wxWindow* wxFindWindowById( long id, const wxWindow *parent = NULL ) {
3848 return wxWindow::FindWindowById(id, parent);
3849 }
3850
3851 wxWindow* wxFindWindowByName( const wxString& name,
3852 const wxWindow *parent = NULL ) {
3853 return wxWindow::FindWindowByName(name, parent);
3854 }
3855
3856 wxWindow* wxFindWindowByLabel( const wxString& label,
3857 const wxWindow *parent = NULL ) {
3858 return wxWindow::FindWindowByLabel(label, parent);
3859 }
3860
3861
3862 #ifdef __WXMSW__
3863 #include <wx/msw/private.h> // to get wxGetWindowId
3864 #endif
3865
3866
3867 wxWindow* wxWindow_FromHWND(wxWindow* parent, unsigned long _hWnd) {
3868 #ifdef __WXMSW__
3869 WXHWND hWnd = (WXHWND)_hWnd;
3870 long id = wxGetWindowId(hWnd);
3871 wxWindow* win = new wxWindow;
3872 if (parent)
3873 parent->AddChild(win);
3874 win->SetEventHandler(win);
3875 win->SetHWND(hWnd);
3876 win->SetId(id);
3877 win->SubclassWin(hWnd);
3878 win->AdoptAttributesFromHWND();
3879 win->SetupColours();
3880 return win;
3881 #else
3882 wxPyRaiseNotImplemented();
3883 return NULL;
3884 #endif
3885 }
3886
3887
3888 PyObject* GetTopLevelWindows() {
3889 return wxPy_ConvertList(&wxTopLevelWindows);
3890 }
3891
3892
3893 IMP_PYCALLBACK_BOOL_WXWIN(wxPyValidator, wxValidator, Validate);
3894 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferToWindow);
3895 IMP_PYCALLBACK_BOOL_(wxPyValidator, wxValidator, TransferFromWindow);
3896
3897 IMPLEMENT_DYNAMIC_CLASS(wxPyValidator, wxValidator);
3898
3899
3900 SWIGINTERNINLINE int
3901 SWIG_AsVal_size_t (PyObject * obj, size_t *val)
3902 {
3903 unsigned long v;
3904 int res = SWIG_AsVal_unsigned_SS_long (obj, val ? &v : 0);
3905 if (SWIG_IsOK(res) && val) *val = static_cast< size_t >(v);
3906 return res;
3907 }
3908
3909 SWIGINTERN void wxMenu_Destroy(wxMenu *self){ delete self; }
3910 SWIGINTERN PyObject *wxMenu_GetMenuItems(wxMenu *self){
3911 wxMenuItemList& list = self->GetMenuItems();
3912 return wxPy_ConvertList(&list);
3913 }
3914 SWIGINTERN void wxMenuItem_SetFont(wxMenuItem *self,wxFont const &font){}
3915 SWIGINTERN wxFont wxMenuItem_GetFont(wxMenuItem *self){ return wxNullFont; }
3916 SWIGINTERN void wxMenuItem_SetTextColour(wxMenuItem *self,wxColour const &colText){}
3917 SWIGINTERN wxColour wxMenuItem_GetTextColour(wxMenuItem *self){ return wxNullColour; }
3918 SWIGINTERN void wxMenuItem_SetBackgroundColour(wxMenuItem *self,wxColour const &colBack){}
3919 SWIGINTERN wxColour wxMenuItem_GetBackgroundColour(wxMenuItem *self){ return wxNullColour; }
3920 SWIGINTERN void wxMenuItem_SetBitmaps(wxMenuItem *self,wxBitmap const &bmpChecked,wxBitmap const &bmpUnchecked=wxNullBitmap){ self->SetBitmap( bmpChecked ); }
3921 SWIGINTERN void wxMenuItem_SetDisabledBitmap(wxMenuItem *self,wxBitmap const &bmpDisabled){}
3922 SWIGINTERN wxBitmap const &wxMenuItem_GetDisabledBitmap(wxMenuItem const *self){ return wxNullBitmap; }
3923 SWIGINTERN void wxMenuItem_SetMarginWidth(wxMenuItem *self,int nWidth){}
3924 SWIGINTERN int wxMenuItem_GetMarginWidth(wxMenuItem *self){ return 0; }
3925 SWIGINTERN int wxMenuItem_GetDefaultMarginWidth(){ return 0; }
3926 SWIGINTERN bool wxMenuItem_IsOwnerDrawn(wxMenuItem *self){ return false; }
3927 SWIGINTERN void wxMenuItem_SetOwnerDrawn(wxMenuItem *self,bool ownerDrawn=true){}
3928 SWIGINTERN void wxMenuItem_ResetOwnerDrawn(wxMenuItem *self){}
3929 static const wxString wxPyControlNameStr(wxControlNameStr);
3930 SWIGINTERN int wxItemContainer_Append(wxItemContainer *self,wxString const &item,PyObject *clientData=NULL){
3931 if (clientData) {
3932 wxPyClientData* data = new wxPyClientData(clientData);
3933 return self->Append(item, data);
3934 } else
3935 return self->Append(item);
3936 }
3937 SWIGINTERN int wxItemContainer_Insert(wxItemContainer *self,wxString const &item,unsigned int pos,PyObject *clientData=NULL){
3938 if (clientData) {
3939 wxPyClientData* data = new wxPyClientData(clientData);
3940 return self->Insert(item, pos, data);
3941 } else
3942 return self->Insert(item, pos);
3943 }
3944 SWIGINTERN PyObject *wxItemContainer_GetClientData(wxItemContainer *self,unsigned int n){
3945 wxPyClientData* data = (wxPyClientData*)self->GetClientObject(n);
3946 if (data) {
3947 Py_INCREF(data->m_obj);
3948 return data->m_obj;
3949 } else {
3950 Py_INCREF(Py_None);
3951 return Py_None;
3952 }
3953 }
3954 SWIGINTERN void wxItemContainer_SetClientData(wxItemContainer *self,unsigned int n,PyObject *clientData){
3955 wxPyClientData* data = new wxPyClientData(clientData);
3956 self->SetClientObject(n, data);
3957 }
3958
3959
3960 SWIGINTERN wxSizerItem *new_wxSizerItem(wxWindow *window,int proportion,int flag,int border,PyObject *userData=NULL){
3961 wxPyUserData* data = NULL;
3962 if ( userData ) {
3963 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3964 data = new wxPyUserData(userData);
3965 wxPyEndBlockThreads(blocked);
3966 }
3967 return new wxSizerItem(window, proportion, flag, border, data);
3968 }
3969 SWIGINTERN wxSizerItem *new_wxSizerItem(int width,int height,int proportion,int flag,int border,PyObject *userData=NULL){
3970 wxPyUserData* data = NULL;
3971 if ( userData ) {
3972 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3973 data = new wxPyUserData(userData);
3974 wxPyEndBlockThreads(blocked);
3975 }
3976 return new wxSizerItem(width, height, proportion, flag, border, data);
3977 }
3978 SWIGINTERN wxSizerItem *new_wxSizerItem(wxSizer *sizer,int proportion,int flag,int border,PyObject *userData=NULL){
3979 wxPyUserData* data = NULL;
3980 if ( userData ) {
3981 wxPyBlock_t blocked = wxPyBeginBlockThreads();
3982 data = new wxPyUserData(userData);
3983 wxPyEndBlockThreads(blocked);
3984 }
3985 return new wxSizerItem(sizer, proportion, flag, border, data);
3986 }
3987
3988 SWIGINTERNINLINE PyObject *
3989 SWIG_From_float (float value)
3990 {
3991 return SWIG_From_double (value);
3992 }
3993
3994 SWIGINTERN PyObject *wxSizerItem_GetUserData(wxSizerItem *self){
3995 wxPyUserData* data = (wxPyUserData*)self->GetUserData();
3996 if (data) {
3997 Py_INCREF(data->m_obj);
3998 return data->m_obj;
3999 } else {
4000 Py_INCREF(Py_None);
4001 return Py_None;
4002 }
4003 }
4004 SWIGINTERN void wxSizerItem_SetUserData(wxSizerItem *self,PyObject *userData){
4005 wxPyUserData* data = NULL;
4006 if ( userData ) {
4007 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4008 data = new wxPyUserData(userData);
4009 wxPyEndBlockThreads(blocked);
4010 }
4011 self->SetUserData(data);
4012 }
4013
4014 // Figure out the type of the sizer item
4015
4016 struct wxPySizerItemInfo {
4017 wxPySizerItemInfo()
4018 : window(NULL), sizer(NULL), gotSize(false),
4019 size(wxDefaultSize), gotPos(false), pos(-1)
4020 {}
4021
4022 wxWindow* window;
4023 wxSizer* sizer;
4024 bool gotSize;
4025 wxSize size;
4026 bool gotPos;
4027 int pos;
4028 };
4029
4030 static wxPySizerItemInfo wxPySizerItemTypeHelper(PyObject* item, bool checkSize, bool checkIdx ) {
4031
4032 wxPySizerItemInfo info;
4033 wxSize size;
4034 wxSize* sizePtr = &size;
4035
4036 // Find out what the type of the item is
4037 // try wxWindow
4038 if ( ! wxPyConvertSwigPtr(item, (void**)&info.window, wxT("wxWindow")) ) {
4039 PyErr_Clear();
4040 info.window = NULL;
4041
4042 // try wxSizer
4043 if ( ! wxPyConvertSwigPtr(item, (void**)&info.sizer, wxT("wxSizer")) ) {
4044 PyErr_Clear();
4045 info.sizer = NULL;
4046
4047 // try wxSize or (w,h)
4048 if ( checkSize && wxSize_helper(item, &sizePtr)) {
4049 info.size = *sizePtr;
4050 info.gotSize = true;
4051 }
4052
4053 // or a single int
4054 if (checkIdx && PyInt_Check(item)) {
4055 info.pos = PyInt_AsLong(item);
4056 info.gotPos = true;
4057 }
4058 }
4059 }
4060
4061 if ( !(info.window || info.sizer || (checkSize && info.gotSize) || (checkIdx && info.gotPos)) ) {
4062 // no expected type, figure out what kind of error message to generate
4063 if ( !checkSize && !checkIdx )
4064 PyErr_SetString(PyExc_TypeError, "wx.Window or wx.Sizer expected for item");
4065 else if ( checkSize && !checkIdx )
4066 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) expected for item");
4067 else if ( !checkSize && checkIdx)
4068 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer or int (position) expected for item");
4069 else
4070 // can this one happen?
4071 PyErr_SetString(PyExc_TypeError, "wx.Window, wx.Sizer, wx.Size, or (w,h) or int (position) expected for item");
4072 }
4073
4074 return info;
4075 }
4076
4077 SWIGINTERN void wxSizer__setOORInfo(wxSizer *self,PyObject *_self){
4078 if (!self->GetClientObject())
4079 self->SetClientObject(new wxPyOORClientData(_self));
4080 }
4081 SWIGINTERN wxSizerItem *wxSizer_Add(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4082
4083 wxPyUserData* data = NULL;
4084 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4085 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4086 if ( userData && (info.window || info.sizer || info.gotSize) )
4087 data = new wxPyUserData(userData);
4088 if ( info.sizer )
4089 PyObject_SetAttrString(item,"thisown",Py_False);
4090 wxPyEndBlockThreads(blocked);
4091
4092 // Now call the real Add method if a valid item type was found
4093 if ( info.window )
4094 return self->Add(info.window, proportion, flag, border, data);
4095 else if ( info.sizer )
4096 return self->Add(info.sizer, proportion, flag, border, data);
4097 else if (info.gotSize)
4098 return self->Add(info.size.GetWidth(), info.size.GetHeight(),
4099 proportion, flag, border, data);
4100 else
4101 return NULL;
4102 }
4103 SWIGINTERN wxSizerItem *wxSizer_Insert(wxSizer *self,int before,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4104
4105 wxPyUserData* data = NULL;
4106 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4107 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4108 if ( userData && (info.window || info.sizer || info.gotSize) )
4109 data = new wxPyUserData(userData);
4110 if ( info.sizer )
4111 PyObject_SetAttrString(item,"thisown",Py_False);
4112 wxPyEndBlockThreads(blocked);
4113
4114 // Now call the real Insert method if a valid item type was found
4115 if ( info.window )
4116 return self->Insert(before, info.window, proportion, flag, border, data);
4117 else if ( info.sizer )
4118 return self->Insert(before, info.sizer, proportion, flag, border, data);
4119 else if (info.gotSize)
4120 return self->Insert(before, info.size.GetWidth(), info.size.GetHeight(),
4121 proportion, flag, border, data);
4122 else
4123 return NULL;
4124 }
4125 SWIGINTERN wxSizerItem *wxSizer_Prepend(wxSizer *self,PyObject *item,int proportion=0,int flag=0,int border=0,PyObject *userData=NULL){
4126
4127 wxPyUserData* data = NULL;
4128 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4129 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4130 if ( userData && (info.window || info.sizer || info.gotSize) )
4131 data = new wxPyUserData(userData);
4132 if ( info.sizer )
4133 PyObject_SetAttrString(item,"thisown",Py_False);
4134 wxPyEndBlockThreads(blocked);
4135
4136 // Now call the real Prepend method if a valid item type was found
4137 if ( info.window )
4138 return self->Prepend(info.window, proportion, flag, border, data);
4139 else if ( info.sizer )
4140 return self->Prepend(info.sizer, proportion, flag, border, data);
4141 else if (info.gotSize)
4142 return self->Prepend(info.size.GetWidth(), info.size.GetHeight(),
4143 proportion, flag, border, data);
4144 else
4145 return NULL;
4146 }
4147 SWIGINTERN bool wxSizer_Remove(wxSizer *self,PyObject *item){
4148 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4149 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4150 wxPyEndBlockThreads(blocked);
4151 if ( info.window )
4152 return self->Remove(info.window);
4153 else if ( info.sizer )
4154 return self->Remove(info.sizer);
4155 else if ( info.gotPos )
4156 return self->Remove(info.pos);
4157 else
4158 return false;
4159 }
4160 SWIGINTERN bool wxSizer_Detach(wxSizer *self,PyObject *item){
4161 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4162 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4163 wxPyEndBlockThreads(blocked);
4164 if ( info.window )
4165 return self->Detach(info.window);
4166 else if ( info.sizer )
4167 return self->Detach(info.sizer);
4168 else if ( info.gotPos )
4169 return self->Detach(info.pos);
4170 else
4171 return false;
4172 }
4173 SWIGINTERN wxSizerItem *wxSizer_GetItem(wxSizer *self,PyObject *item){
4174 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4175 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4176 wxPyEndBlockThreads(blocked);
4177 if ( info.window )
4178 return self->GetItem(info.window);
4179 else if ( info.sizer )
4180 return self->GetItem(info.sizer);
4181 else if ( info.gotPos )
4182 return self->GetItem(info.pos);
4183 else
4184 return NULL;
4185 }
4186 SWIGINTERN void wxSizer__SetItemMinSize(wxSizer *self,PyObject *item,wxSize const &size){
4187 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4188 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4189 wxPyEndBlockThreads(blocked);
4190 if ( info.window )
4191 self->SetItemMinSize(info.window, size);
4192 else if ( info.sizer )
4193 self->SetItemMinSize(info.sizer, size);
4194 else if ( info.gotPos )
4195 self->SetItemMinSize(info.pos, size);
4196 }
4197 SWIGINTERN PyObject *wxSizer_GetChildren(wxSizer *self){
4198 wxSizerItemList& list = self->GetChildren();
4199 return wxPy_ConvertList(&list);
4200 }
4201 SWIGINTERN bool wxSizer_Show(wxSizer *self,PyObject *item,bool show=true,bool recursive=false){
4202 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4203 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, true);
4204 wxPyEndBlockThreads(blocked);
4205 if ( info.window )
4206 return self->Show(info.window, show, recursive);
4207 else if ( info.sizer )
4208 return self->Show(info.sizer, show, recursive);
4209 else if ( info.gotPos )
4210 return self->Show(info.pos, show);
4211 else
4212 return false;
4213 }
4214 SWIGINTERN bool wxSizer_IsShown(wxSizer *self,PyObject *item){
4215 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4216 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, false, false);
4217 wxPyEndBlockThreads(blocked);
4218 if ( info.window )
4219 return self->IsShown(info.window);
4220 else if ( info.sizer )
4221 return self->IsShown(info.sizer);
4222 else if ( info.gotPos )
4223 return self->IsShown(info.pos);
4224 else
4225 return false;
4226 }
4227
4228 // See pyclasses.h
4229 IMP_PYCALLBACK___pure(wxPySizer, wxSizer, RecalcSizes);
4230 IMP_PYCALLBACK_wxSize__pure(wxPySizer, wxSizer, CalcMin);
4231 IMPLEMENT_DYNAMIC_CLASS(wxPySizer, wxSizer);
4232
4233
4234
4235
4236 bool wxGBPosition_helper(PyObject* source, wxGBPosition** obj)
4237 {
4238 if (source == Py_None) {
4239 **obj = wxGBPosition(-1,-1);
4240 return true;
4241 }
4242 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBPosition"));
4243 }
4244
4245 bool wxGBSpan_helper(PyObject* source, wxGBSpan** obj)
4246 {
4247 if (source == Py_None) {
4248 **obj = wxGBSpan(-1,-1);
4249 return true;
4250 }
4251 return wxPyTwoIntItem_helper(source, obj, wxT("wxGBSpan"));
4252 }
4253
4254
4255 SWIGINTERN bool wxGBPosition___eq__(wxGBPosition *self,PyObject *other){
4256 wxGBPosition temp, *obj = &temp;
4257 if ( other == Py_None ) return false;
4258 if ( ! wxGBPosition_helper(other, &obj) ) {
4259 PyErr_Clear();
4260 return false;
4261 }
4262 return self->operator==(*obj);
4263 }
4264 SWIGINTERN bool wxGBPosition___ne__(wxGBPosition *self,PyObject *other){
4265 wxGBPosition temp, *obj = &temp;
4266 if ( other == Py_None ) return true;
4267 if ( ! wxGBPosition_helper(other, &obj)) {
4268 PyErr_Clear();
4269 return true;
4270 }
4271 return self->operator!=(*obj);
4272 }
4273 SWIGINTERN void wxGBPosition_Set(wxGBPosition *self,int row=0,int col=0){
4274 self->SetRow(row);
4275 self->SetCol(col);
4276 }
4277 SWIGINTERN PyObject *wxGBPosition_Get(wxGBPosition *self){
4278 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4279 PyObject* tup = PyTuple_New(2);
4280 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRow()));
4281 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetCol()));
4282 wxPyEndBlockThreads(blocked);
4283 return tup;
4284 }
4285 SWIGINTERN bool wxGBSpan___eq__(wxGBSpan *self,PyObject *other){
4286 wxGBSpan temp, *obj = &temp;
4287 if ( other == Py_None ) return false;
4288 if ( ! wxGBSpan_helper(other, &obj) ) {
4289 PyErr_Clear();
4290 return false;
4291 }
4292 return self->operator==(*obj);
4293 }
4294 SWIGINTERN bool wxGBSpan___ne__(wxGBSpan *self,PyObject *other){
4295 wxGBSpan temp, *obj = &temp;
4296 if ( other == Py_None ) return true;
4297 if ( ! wxGBSpan_helper(other, &obj)) {
4298 PyErr_Clear();
4299 return true;
4300 }
4301 return self->operator!=(*obj);
4302 }
4303 SWIGINTERN void wxGBSpan_Set(wxGBSpan *self,int rowspan=1,int colspan=1){
4304 self->SetRowspan(rowspan);
4305 self->SetColspan(colspan);
4306 }
4307 SWIGINTERN PyObject *wxGBSpan_Get(wxGBSpan *self){
4308 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4309 PyObject* tup = PyTuple_New(2);
4310 PyTuple_SET_ITEM(tup, 0, PyInt_FromLong(self->GetRowspan()));
4311 PyTuple_SET_ITEM(tup, 1, PyInt_FromLong(self->GetColspan()));
4312 wxPyEndBlockThreads(blocked);
4313 return tup;
4314 }
4315 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxWindow *window,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4316 wxPyUserData* data = NULL;
4317 if ( userData ) {
4318 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4319 data = new wxPyUserData(userData);
4320 wxPyEndBlockThreads(blocked);
4321 }
4322 return new wxGBSizerItem(window, pos, span, flag, border, data);
4323 }
4324 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(wxSizer *sizer,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4325 wxPyUserData* data = NULL;
4326 if ( userData ) {
4327 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4328 data = new wxPyUserData(userData);
4329 wxPyEndBlockThreads(blocked);
4330 }
4331 return new wxGBSizerItem(sizer, pos, span, flag, border, data);
4332 }
4333 SWIGINTERN wxGBSizerItem *new_wxGBSizerItem(int width,int height,wxGBPosition const &pos,wxGBSpan const &span,int flag,int border,PyObject *userData=NULL){
4334 wxPyUserData* data = NULL;
4335 if ( userData ) {
4336 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4337 data = new wxPyUserData(userData);
4338 wxPyEndBlockThreads(blocked);
4339 }
4340 return new wxGBSizerItem(width, height, pos, span, flag, border, data);
4341 }
4342 SWIGINTERN wxGBPosition wxGBSizerItem_GetEndPos(wxGBSizerItem *self){
4343 int row, col;
4344 self->GetEndPos(row, col);
4345 return wxGBPosition(row, col);
4346 }
4347 SWIGINTERN wxGBSizerItem *wxGridBagSizer_Add(wxGridBagSizer *self,PyObject *item,wxGBPosition const &pos,wxGBSpan const &span=wxDefaultSpan,int flag=0,int border=0,PyObject *userData=NULL){
4348
4349 wxPyUserData* data = NULL;
4350 wxPyBlock_t blocked = wxPyBeginBlockThreads();
4351 wxPySizerItemInfo info = wxPySizerItemTypeHelper(item, true, false);
4352 if ( userData && (info.window || info.sizer || info.gotSize) )
4353 data = new wxPyUserData(userData);
4354 if ( info.sizer )
4355 PyObject_SetAttrString(item,"thisown",Py_False);
4356 wxPyEndBlockThreads(blocked);
4357
4358 // Now call the real Add method if a valid item type was found
4359 if ( info.window )
4360 return (wxGBSizerItem*)self->Add(info.window, pos, span, flag, border, data);
4361 else if ( info.sizer )
4362 return (wxGBSizerItem*)self->Add(info.sizer, pos, span, flag, border, data);
4363 else if (info.gotSize)
4364 return (wxGBSizerItem*)self->Add(info.size.GetWidth(), info.size.GetHeight(),
4365 pos, span, flag, border, data);
4366 return NULL;
4367 }
4368
4369
4370 #ifdef __cplusplus
4371 extern "C" {
4372 #endif
4373 SWIGINTERN int EmptyString_set(PyObject *) {
4374 SWIG_Error(SWIG_AttributeError,"Variable EmptyString is read-only.");
4375 return 1;
4376 }
4377
4378
4379 SWIGINTERN PyObject *EmptyString_get(void) {
4380 PyObject *pyobj = 0;
4381
4382 {
4383 #if wxUSE_UNICODE
4384 pyobj = PyUnicode_FromWideChar((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4385 #else
4386 pyobj = PyString_FromStringAndSize((&wxPyEmptyString)->c_str(), (&wxPyEmptyString)->Len());
4387 #endif
4388 }
4389 return pyobj;
4390 }
4391
4392
4393 SWIGINTERN PyObject *_wrap_Object_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4394 PyObject *resultobj = 0;
4395 wxObject *arg1 = (wxObject *) 0 ;
4396 wxString result;
4397 void *argp1 = 0 ;
4398 int res1 = 0 ;
4399 PyObject *swig_obj[1] ;
4400
4401 if (!args) SWIG_fail;
4402 swig_obj[0] = args;
4403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4404 if (!SWIG_IsOK(res1)) {
4405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_GetClassName" "', expected argument " "1"" of type '" "wxObject *""'");
4406 }
4407 arg1 = reinterpret_cast< wxObject * >(argp1);
4408 {
4409 PyThreadState* __tstate = wxPyBeginAllowThreads();
4410 result = wxObject_GetClassName(arg1);
4411 wxPyEndAllowThreads(__tstate);
4412 if (PyErr_Occurred()) SWIG_fail;
4413 }
4414 {
4415 #if wxUSE_UNICODE
4416 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
4417 #else
4418 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
4419 #endif
4420 }
4421 return resultobj;
4422 fail:
4423 return NULL;
4424 }
4425
4426
4427 SWIGINTERN PyObject *_wrap_Object_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4428 PyObject *resultobj = 0;
4429 wxObject *arg1 = (wxObject *) 0 ;
4430 void *argp1 = 0 ;
4431 int res1 = 0 ;
4432 PyObject *swig_obj[1] ;
4433
4434 if (!args) SWIG_fail;
4435 swig_obj[0] = args;
4436 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxObject, 0 | 0 );
4437 if (!SWIG_IsOK(res1)) {
4438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Object_Destroy" "', expected argument " "1"" of type '" "wxObject *""'");
4439 }
4440 arg1 = reinterpret_cast< wxObject * >(argp1);
4441 {
4442 PyThreadState* __tstate = wxPyBeginAllowThreads();
4443 wxObject_Destroy(arg1);
4444 wxPyEndAllowThreads(__tstate);
4445 if (PyErr_Occurred()) SWIG_fail;
4446 }
4447 resultobj = SWIG_Py_Void();
4448 return resultobj;
4449 fail:
4450 return NULL;
4451 }
4452
4453
4454 SWIGINTERN PyObject *Object_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4455 PyObject *obj;
4456 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
4457 SWIG_TypeNewClientData(SWIGTYPE_p_wxObject, SWIG_NewClientData(obj));
4458 return SWIG_Py_Void();
4459 }
4460
4461 SWIGINTERN PyObject *_wrap_Size_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4462 PyObject *resultobj = 0;
4463 wxSize *arg1 = (wxSize *) 0 ;
4464 int arg2 ;
4465 void *argp1 = 0 ;
4466 int res1 = 0 ;
4467 int val2 ;
4468 int ecode2 = 0 ;
4469 PyObject *swig_obj[2] ;
4470
4471 if (!SWIG_Python_UnpackTuple(args,"Size_width_set",2,2,swig_obj)) SWIG_fail;
4472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4473 if (!SWIG_IsOK(res1)) {
4474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_set" "', expected argument " "1"" of type '" "wxSize *""'");
4475 }
4476 arg1 = reinterpret_cast< wxSize * >(argp1);
4477 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4478 if (!SWIG_IsOK(ecode2)) {
4479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_width_set" "', expected argument " "2"" of type '" "int""'");
4480 }
4481 arg2 = static_cast< int >(val2);
4482 if (arg1) (arg1)->x = arg2;
4483
4484 resultobj = SWIG_Py_Void();
4485 return resultobj;
4486 fail:
4487 return NULL;
4488 }
4489
4490
4491 SWIGINTERN PyObject *_wrap_Size_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4492 PyObject *resultobj = 0;
4493 wxSize *arg1 = (wxSize *) 0 ;
4494 int result;
4495 void *argp1 = 0 ;
4496 int res1 = 0 ;
4497 PyObject *swig_obj[1] ;
4498
4499 if (!args) SWIG_fail;
4500 swig_obj[0] = args;
4501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4502 if (!SWIG_IsOK(res1)) {
4503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_width_get" "', expected argument " "1"" of type '" "wxSize *""'");
4504 }
4505 arg1 = reinterpret_cast< wxSize * >(argp1);
4506 result = (int) ((arg1)->x);
4507 resultobj = SWIG_From_int(static_cast< int >(result));
4508 return resultobj;
4509 fail:
4510 return NULL;
4511 }
4512
4513
4514 SWIGINTERN PyObject *_wrap_Size_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4515 PyObject *resultobj = 0;
4516 wxSize *arg1 = (wxSize *) 0 ;
4517 int arg2 ;
4518 void *argp1 = 0 ;
4519 int res1 = 0 ;
4520 int val2 ;
4521 int ecode2 = 0 ;
4522 PyObject *swig_obj[2] ;
4523
4524 if (!SWIG_Python_UnpackTuple(args,"Size_height_set",2,2,swig_obj)) SWIG_fail;
4525 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4526 if (!SWIG_IsOK(res1)) {
4527 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_set" "', expected argument " "1"" of type '" "wxSize *""'");
4528 }
4529 arg1 = reinterpret_cast< wxSize * >(argp1);
4530 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
4531 if (!SWIG_IsOK(ecode2)) {
4532 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_height_set" "', expected argument " "2"" of type '" "int""'");
4533 }
4534 arg2 = static_cast< int >(val2);
4535 if (arg1) (arg1)->y = arg2;
4536
4537 resultobj = SWIG_Py_Void();
4538 return resultobj;
4539 fail:
4540 return NULL;
4541 }
4542
4543
4544 SWIGINTERN PyObject *_wrap_Size_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4545 PyObject *resultobj = 0;
4546 wxSize *arg1 = (wxSize *) 0 ;
4547 int result;
4548 void *argp1 = 0 ;
4549 int res1 = 0 ;
4550 PyObject *swig_obj[1] ;
4551
4552 if (!args) SWIG_fail;
4553 swig_obj[0] = args;
4554 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4555 if (!SWIG_IsOK(res1)) {
4556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_height_get" "', expected argument " "1"" of type '" "wxSize *""'");
4557 }
4558 arg1 = reinterpret_cast< wxSize * >(argp1);
4559 result = (int) ((arg1)->y);
4560 resultobj = SWIG_From_int(static_cast< int >(result));
4561 return resultobj;
4562 fail:
4563 return NULL;
4564 }
4565
4566
4567 SWIGINTERN PyObject *_wrap_new_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4568 PyObject *resultobj = 0;
4569 int arg1 = (int) 0 ;
4570 int arg2 = (int) 0 ;
4571 wxSize *result = 0 ;
4572 int val1 ;
4573 int ecode1 = 0 ;
4574 int val2 ;
4575 int ecode2 = 0 ;
4576 PyObject * obj0 = 0 ;
4577 PyObject * obj1 = 0 ;
4578 char * kwnames[] = {
4579 (char *) "w",(char *) "h", NULL
4580 };
4581
4582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Size",kwnames,&obj0,&obj1)) SWIG_fail;
4583 if (obj0) {
4584 ecode1 = SWIG_AsVal_int(obj0, &val1);
4585 if (!SWIG_IsOK(ecode1)) {
4586 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Size" "', expected argument " "1"" of type '" "int""'");
4587 }
4588 arg1 = static_cast< int >(val1);
4589 }
4590 if (obj1) {
4591 ecode2 = SWIG_AsVal_int(obj1, &val2);
4592 if (!SWIG_IsOK(ecode2)) {
4593 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Size" "', expected argument " "2"" of type '" "int""'");
4594 }
4595 arg2 = static_cast< int >(val2);
4596 }
4597 {
4598 PyThreadState* __tstate = wxPyBeginAllowThreads();
4599 result = (wxSize *)new wxSize(arg1,arg2);
4600 wxPyEndAllowThreads(__tstate);
4601 if (PyErr_Occurred()) SWIG_fail;
4602 }
4603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, SWIG_POINTER_NEW | 0 );
4604 return resultobj;
4605 fail:
4606 return NULL;
4607 }
4608
4609
4610 SWIGINTERN PyObject *_wrap_delete_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
4611 PyObject *resultobj = 0;
4612 wxSize *arg1 = (wxSize *) 0 ;
4613 void *argp1 = 0 ;
4614 int res1 = 0 ;
4615 PyObject *swig_obj[1] ;
4616
4617 if (!args) SWIG_fail;
4618 swig_obj[0] = args;
4619 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, SWIG_POINTER_DISOWN | 0 );
4620 if (!SWIG_IsOK(res1)) {
4621 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Size" "', expected argument " "1"" of type '" "wxSize *""'");
4622 }
4623 arg1 = reinterpret_cast< wxSize * >(argp1);
4624 {
4625 PyThreadState* __tstate = wxPyBeginAllowThreads();
4626 delete arg1;
4627
4628 wxPyEndAllowThreads(__tstate);
4629 if (PyErr_Occurred()) SWIG_fail;
4630 }
4631 resultobj = SWIG_Py_Void();
4632 return resultobj;
4633 fail:
4634 return NULL;
4635 }
4636
4637
4638 SWIGINTERN PyObject *_wrap_Size___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4639 PyObject *resultobj = 0;
4640 wxSize *arg1 = (wxSize *) 0 ;
4641 PyObject *arg2 = (PyObject *) 0 ;
4642 bool result;
4643 void *argp1 = 0 ;
4644 int res1 = 0 ;
4645 PyObject * obj0 = 0 ;
4646 PyObject * obj1 = 0 ;
4647 char * kwnames[] = {
4648 (char *) "self",(char *) "other", NULL
4649 };
4650
4651 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
4652 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4653 if (!SWIG_IsOK(res1)) {
4654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___eq__" "', expected argument " "1"" of type '" "wxSize *""'");
4655 }
4656 arg1 = reinterpret_cast< wxSize * >(argp1);
4657 arg2 = obj1;
4658 {
4659 result = (bool)wxSize___eq__(arg1,arg2);
4660 if (PyErr_Occurred()) SWIG_fail;
4661 }
4662 {
4663 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4664 }
4665 return resultobj;
4666 fail:
4667 return NULL;
4668 }
4669
4670
4671 SWIGINTERN PyObject *_wrap_Size___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4672 PyObject *resultobj = 0;
4673 wxSize *arg1 = (wxSize *) 0 ;
4674 PyObject *arg2 = (PyObject *) 0 ;
4675 bool result;
4676 void *argp1 = 0 ;
4677 int res1 = 0 ;
4678 PyObject * obj0 = 0 ;
4679 PyObject * obj1 = 0 ;
4680 char * kwnames[] = {
4681 (char *) "self",(char *) "other", NULL
4682 };
4683
4684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
4685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4686 if (!SWIG_IsOK(res1)) {
4687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___ne__" "', expected argument " "1"" of type '" "wxSize *""'");
4688 }
4689 arg1 = reinterpret_cast< wxSize * >(argp1);
4690 arg2 = obj1;
4691 {
4692 result = (bool)wxSize___ne__(arg1,arg2);
4693 if (PyErr_Occurred()) SWIG_fail;
4694 }
4695 {
4696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
4697 }
4698 return resultobj;
4699 fail:
4700 return NULL;
4701 }
4702
4703
4704 SWIGINTERN PyObject *_wrap_Size___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4705 PyObject *resultobj = 0;
4706 wxSize *arg1 = (wxSize *) 0 ;
4707 wxSize *arg2 = 0 ;
4708 wxSize result;
4709 void *argp1 = 0 ;
4710 int res1 = 0 ;
4711 wxSize temp2 ;
4712 PyObject * obj0 = 0 ;
4713 PyObject * obj1 = 0 ;
4714 char * kwnames[] = {
4715 (char *) "self",(char *) "sz", NULL
4716 };
4717
4718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___add__",kwnames,&obj0,&obj1)) SWIG_fail;
4719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4720 if (!SWIG_IsOK(res1)) {
4721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size___add__" "', expected argument " "1"" of type '" "wxSize *""'");
4722 }
4723 arg1 = reinterpret_cast< wxSize * >(argp1);
4724 {
4725 arg2 = &temp2;
4726 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4727 }
4728 {
4729 PyThreadState* __tstate = wxPyBeginAllowThreads();
4730 result = (arg1)->operator +((wxSize const &)*arg2);
4731 wxPyEndAllowThreads(__tstate);
4732 if (PyErr_Occurred()) SWIG_fail;
4733 }
4734 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4735 return resultobj;
4736 fail:
4737 return NULL;
4738 }
4739
4740
4741 SWIGINTERN PyObject *_wrap_Size___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4742 PyObject *resultobj = 0;
4743 wxSize *arg1 = (wxSize *) 0 ;
4744 wxSize *arg2 = 0 ;
4745 wxSize result;
4746 void *argp1 = 0 ;
4747 int res1 = 0 ;
4748 wxSize temp2 ;
4749 PyObject * obj0 = 0 ;
4750 PyObject * obj1 = 0 ;
4751 char * kwnames[] = {
4752 (char *) "self",(char *) "sz", NULL
4753 };
4754
4755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size___sub__",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___sub__" "', expected argument " "1"" of type '" "wxSize *""'");
4759 }
4760 arg1 = reinterpret_cast< wxSize * >(argp1);
4761 {
4762 arg2 = &temp2;
4763 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4764 }
4765 {
4766 PyThreadState* __tstate = wxPyBeginAllowThreads();
4767 result = (arg1)->operator -((wxSize const &)*arg2);
4768 wxPyEndAllowThreads(__tstate);
4769 if (PyErr_Occurred()) SWIG_fail;
4770 }
4771 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
4772 return resultobj;
4773 fail:
4774 return NULL;
4775 }
4776
4777
4778 SWIGINTERN PyObject *_wrap_Size_IncTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4779 PyObject *resultobj = 0;
4780 wxSize *arg1 = (wxSize *) 0 ;
4781 wxSize *arg2 = 0 ;
4782 void *argp1 = 0 ;
4783 int res1 = 0 ;
4784 wxSize temp2 ;
4785 PyObject * obj0 = 0 ;
4786 PyObject * obj1 = 0 ;
4787 char * kwnames[] = {
4788 (char *) "self",(char *) "sz", NULL
4789 };
4790
4791 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_IncTo",kwnames,&obj0,&obj1)) SWIG_fail;
4792 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4793 if (!SWIG_IsOK(res1)) {
4794 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IncTo" "', expected argument " "1"" of type '" "wxSize *""'");
4795 }
4796 arg1 = reinterpret_cast< wxSize * >(argp1);
4797 {
4798 arg2 = &temp2;
4799 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4800 }
4801 {
4802 PyThreadState* __tstate = wxPyBeginAllowThreads();
4803 (arg1)->IncTo((wxSize const &)*arg2);
4804 wxPyEndAllowThreads(__tstate);
4805 if (PyErr_Occurred()) SWIG_fail;
4806 }
4807 resultobj = SWIG_Py_Void();
4808 return resultobj;
4809 fail:
4810 return NULL;
4811 }
4812
4813
4814 SWIGINTERN PyObject *_wrap_Size_DecTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4815 PyObject *resultobj = 0;
4816 wxSize *arg1 = (wxSize *) 0 ;
4817 wxSize *arg2 = 0 ;
4818 void *argp1 = 0 ;
4819 int res1 = 0 ;
4820 wxSize temp2 ;
4821 PyObject * obj0 = 0 ;
4822 PyObject * obj1 = 0 ;
4823 char * kwnames[] = {
4824 (char *) "self",(char *) "sz", NULL
4825 };
4826
4827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_DecTo",kwnames,&obj0,&obj1)) SWIG_fail;
4828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4829 if (!SWIG_IsOK(res1)) {
4830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_DecTo" "', expected argument " "1"" of type '" "wxSize *""'");
4831 }
4832 arg1 = reinterpret_cast< wxSize * >(argp1);
4833 {
4834 arg2 = &temp2;
4835 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
4836 }
4837 {
4838 PyThreadState* __tstate = wxPyBeginAllowThreads();
4839 (arg1)->DecTo((wxSize const &)*arg2);
4840 wxPyEndAllowThreads(__tstate);
4841 if (PyErr_Occurred()) SWIG_fail;
4842 }
4843 resultobj = SWIG_Py_Void();
4844 return resultobj;
4845 fail:
4846 return NULL;
4847 }
4848
4849
4850 SWIGINTERN PyObject *_wrap_Size_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4851 PyObject *resultobj = 0;
4852 wxSize *arg1 = (wxSize *) 0 ;
4853 float arg2 ;
4854 float arg3 ;
4855 void *argp1 = 0 ;
4856 int res1 = 0 ;
4857 float val2 ;
4858 int ecode2 = 0 ;
4859 float val3 ;
4860 int ecode3 = 0 ;
4861 PyObject * obj0 = 0 ;
4862 PyObject * obj1 = 0 ;
4863 PyObject * obj2 = 0 ;
4864 char * kwnames[] = {
4865 (char *) "self",(char *) "xscale",(char *) "yscale", NULL
4866 };
4867
4868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4869 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4870 if (!SWIG_IsOK(res1)) {
4871 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Scale" "', expected argument " "1"" of type '" "wxSize *""'");
4872 }
4873 arg1 = reinterpret_cast< wxSize * >(argp1);
4874 ecode2 = SWIG_AsVal_float(obj1, &val2);
4875 if (!SWIG_IsOK(ecode2)) {
4876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Scale" "', expected argument " "2"" of type '" "float""'");
4877 }
4878 arg2 = static_cast< float >(val2);
4879 ecode3 = SWIG_AsVal_float(obj2, &val3);
4880 if (!SWIG_IsOK(ecode3)) {
4881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Scale" "', expected argument " "3"" of type '" "float""'");
4882 }
4883 arg3 = static_cast< float >(val3);
4884 {
4885 PyThreadState* __tstate = wxPyBeginAllowThreads();
4886 (arg1)->Scale(arg2,arg3);
4887 wxPyEndAllowThreads(__tstate);
4888 if (PyErr_Occurred()) SWIG_fail;
4889 }
4890 resultobj = SWIG_Py_Void();
4891 return resultobj;
4892 fail:
4893 return NULL;
4894 }
4895
4896
4897 SWIGINTERN PyObject *_wrap_Size_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4898 PyObject *resultobj = 0;
4899 wxSize *arg1 = (wxSize *) 0 ;
4900 int arg2 ;
4901 int arg3 ;
4902 void *argp1 = 0 ;
4903 int res1 = 0 ;
4904 int val2 ;
4905 int ecode2 = 0 ;
4906 int val3 ;
4907 int ecode3 = 0 ;
4908 PyObject * obj0 = 0 ;
4909 PyObject * obj1 = 0 ;
4910 PyObject * obj2 = 0 ;
4911 char * kwnames[] = {
4912 (char *) "self",(char *) "w",(char *) "h", NULL
4913 };
4914
4915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Size_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
4916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4917 if (!SWIG_IsOK(res1)) {
4918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Set" "', expected argument " "1"" of type '" "wxSize *""'");
4919 }
4920 arg1 = reinterpret_cast< wxSize * >(argp1);
4921 ecode2 = SWIG_AsVal_int(obj1, &val2);
4922 if (!SWIG_IsOK(ecode2)) {
4923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_Set" "', expected argument " "2"" of type '" "int""'");
4924 }
4925 arg2 = static_cast< int >(val2);
4926 ecode3 = SWIG_AsVal_int(obj2, &val3);
4927 if (!SWIG_IsOK(ecode3)) {
4928 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Size_Set" "', expected argument " "3"" of type '" "int""'");
4929 }
4930 arg3 = static_cast< int >(val3);
4931 {
4932 PyThreadState* __tstate = wxPyBeginAllowThreads();
4933 (arg1)->Set(arg2,arg3);
4934 wxPyEndAllowThreads(__tstate);
4935 if (PyErr_Occurred()) SWIG_fail;
4936 }
4937 resultobj = SWIG_Py_Void();
4938 return resultobj;
4939 fail:
4940 return NULL;
4941 }
4942
4943
4944 SWIGINTERN PyObject *_wrap_Size_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4945 PyObject *resultobj = 0;
4946 wxSize *arg1 = (wxSize *) 0 ;
4947 int arg2 ;
4948 void *argp1 = 0 ;
4949 int res1 = 0 ;
4950 int val2 ;
4951 int ecode2 = 0 ;
4952 PyObject * obj0 = 0 ;
4953 PyObject * obj1 = 0 ;
4954 char * kwnames[] = {
4955 (char *) "self",(char *) "w", NULL
4956 };
4957
4958 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
4959 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4960 if (!SWIG_IsOK(res1)) {
4961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetWidth" "', expected argument " "1"" of type '" "wxSize *""'");
4962 }
4963 arg1 = reinterpret_cast< wxSize * >(argp1);
4964 ecode2 = SWIG_AsVal_int(obj1, &val2);
4965 if (!SWIG_IsOK(ecode2)) {
4966 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetWidth" "', expected argument " "2"" of type '" "int""'");
4967 }
4968 arg2 = static_cast< int >(val2);
4969 {
4970 PyThreadState* __tstate = wxPyBeginAllowThreads();
4971 (arg1)->SetWidth(arg2);
4972 wxPyEndAllowThreads(__tstate);
4973 if (PyErr_Occurred()) SWIG_fail;
4974 }
4975 resultobj = SWIG_Py_Void();
4976 return resultobj;
4977 fail:
4978 return NULL;
4979 }
4980
4981
4982 SWIGINTERN PyObject *_wrap_Size_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
4983 PyObject *resultobj = 0;
4984 wxSize *arg1 = (wxSize *) 0 ;
4985 int arg2 ;
4986 void *argp1 = 0 ;
4987 int res1 = 0 ;
4988 int val2 ;
4989 int ecode2 = 0 ;
4990 PyObject * obj0 = 0 ;
4991 PyObject * obj1 = 0 ;
4992 char * kwnames[] = {
4993 (char *) "self",(char *) "h", NULL
4994 };
4995
4996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
4997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
4998 if (!SWIG_IsOK(res1)) {
4999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetHeight" "', expected argument " "1"" of type '" "wxSize *""'");
5000 }
5001 arg1 = reinterpret_cast< wxSize * >(argp1);
5002 ecode2 = SWIG_AsVal_int(obj1, &val2);
5003 if (!SWIG_IsOK(ecode2)) {
5004 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Size_SetHeight" "', expected argument " "2"" of type '" "int""'");
5005 }
5006 arg2 = static_cast< int >(val2);
5007 {
5008 PyThreadState* __tstate = wxPyBeginAllowThreads();
5009 (arg1)->SetHeight(arg2);
5010 wxPyEndAllowThreads(__tstate);
5011 if (PyErr_Occurred()) SWIG_fail;
5012 }
5013 resultobj = SWIG_Py_Void();
5014 return resultobj;
5015 fail:
5016 return NULL;
5017 }
5018
5019
5020 SWIGINTERN PyObject *_wrap_Size_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5021 PyObject *resultobj = 0;
5022 wxSize *arg1 = (wxSize *) 0 ;
5023 int result;
5024 void *argp1 = 0 ;
5025 int res1 = 0 ;
5026 PyObject *swig_obj[1] ;
5027
5028 if (!args) SWIG_fail;
5029 swig_obj[0] = args;
5030 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5031 if (!SWIG_IsOK(res1)) {
5032 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetWidth" "', expected argument " "1"" of type '" "wxSize const *""'");
5033 }
5034 arg1 = reinterpret_cast< wxSize * >(argp1);
5035 {
5036 PyThreadState* __tstate = wxPyBeginAllowThreads();
5037 result = (int)((wxSize const *)arg1)->GetWidth();
5038 wxPyEndAllowThreads(__tstate);
5039 if (PyErr_Occurred()) SWIG_fail;
5040 }
5041 resultobj = SWIG_From_int(static_cast< int >(result));
5042 return resultobj;
5043 fail:
5044 return NULL;
5045 }
5046
5047
5048 SWIGINTERN PyObject *_wrap_Size_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5049 PyObject *resultobj = 0;
5050 wxSize *arg1 = (wxSize *) 0 ;
5051 int result;
5052 void *argp1 = 0 ;
5053 int res1 = 0 ;
5054 PyObject *swig_obj[1] ;
5055
5056 if (!args) SWIG_fail;
5057 swig_obj[0] = args;
5058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5059 if (!SWIG_IsOK(res1)) {
5060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_GetHeight" "', expected argument " "1"" of type '" "wxSize const *""'");
5061 }
5062 arg1 = reinterpret_cast< wxSize * >(argp1);
5063 {
5064 PyThreadState* __tstate = wxPyBeginAllowThreads();
5065 result = (int)((wxSize const *)arg1)->GetHeight();
5066 wxPyEndAllowThreads(__tstate);
5067 if (PyErr_Occurred()) SWIG_fail;
5068 }
5069 resultobj = SWIG_From_int(static_cast< int >(result));
5070 return resultobj;
5071 fail:
5072 return NULL;
5073 }
5074
5075
5076 SWIGINTERN PyObject *_wrap_Size_IsFullySpecified(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5077 PyObject *resultobj = 0;
5078 wxSize *arg1 = (wxSize *) 0 ;
5079 bool result;
5080 void *argp1 = 0 ;
5081 int res1 = 0 ;
5082 PyObject *swig_obj[1] ;
5083
5084 if (!args) SWIG_fail;
5085 swig_obj[0] = args;
5086 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5087 if (!SWIG_IsOK(res1)) {
5088 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_IsFullySpecified" "', expected argument " "1"" of type '" "wxSize const *""'");
5089 }
5090 arg1 = reinterpret_cast< wxSize * >(argp1);
5091 {
5092 PyThreadState* __tstate = wxPyBeginAllowThreads();
5093 result = (bool)((wxSize const *)arg1)->IsFullySpecified();
5094 wxPyEndAllowThreads(__tstate);
5095 if (PyErr_Occurred()) SWIG_fail;
5096 }
5097 {
5098 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5099 }
5100 return resultobj;
5101 fail:
5102 return NULL;
5103 }
5104
5105
5106 SWIGINTERN PyObject *_wrap_Size_SetDefaults(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5107 PyObject *resultobj = 0;
5108 wxSize *arg1 = (wxSize *) 0 ;
5109 wxSize *arg2 = 0 ;
5110 void *argp1 = 0 ;
5111 int res1 = 0 ;
5112 wxSize temp2 ;
5113 PyObject * obj0 = 0 ;
5114 PyObject * obj1 = 0 ;
5115 char * kwnames[] = {
5116 (char *) "self",(char *) "size", NULL
5117 };
5118
5119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Size_SetDefaults",kwnames,&obj0,&obj1)) SWIG_fail;
5120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5121 if (!SWIG_IsOK(res1)) {
5122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_SetDefaults" "', expected argument " "1"" of type '" "wxSize *""'");
5123 }
5124 arg1 = reinterpret_cast< wxSize * >(argp1);
5125 {
5126 arg2 = &temp2;
5127 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
5128 }
5129 {
5130 PyThreadState* __tstate = wxPyBeginAllowThreads();
5131 (arg1)->SetDefaults((wxSize const &)*arg2);
5132 wxPyEndAllowThreads(__tstate);
5133 if (PyErr_Occurred()) SWIG_fail;
5134 }
5135 resultobj = SWIG_Py_Void();
5136 return resultobj;
5137 fail:
5138 return NULL;
5139 }
5140
5141
5142 SWIGINTERN PyObject *_wrap_Size_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5143 PyObject *resultobj = 0;
5144 wxSize *arg1 = (wxSize *) 0 ;
5145 PyObject *result = 0 ;
5146 void *argp1 = 0 ;
5147 int res1 = 0 ;
5148 PyObject *swig_obj[1] ;
5149
5150 if (!args) SWIG_fail;
5151 swig_obj[0] = args;
5152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSize, 0 | 0 );
5153 if (!SWIG_IsOK(res1)) {
5154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Size_Get" "', expected argument " "1"" of type '" "wxSize *""'");
5155 }
5156 arg1 = reinterpret_cast< wxSize * >(argp1);
5157 {
5158 PyThreadState* __tstate = wxPyBeginAllowThreads();
5159 result = (PyObject *)wxSize_Get(arg1);
5160 wxPyEndAllowThreads(__tstate);
5161 if (PyErr_Occurred()) SWIG_fail;
5162 }
5163 resultobj = result;
5164 return resultobj;
5165 fail:
5166 return NULL;
5167 }
5168
5169
5170 SWIGINTERN PyObject *Size_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5171 PyObject *obj;
5172 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5173 SWIG_TypeNewClientData(SWIGTYPE_p_wxSize, SWIG_NewClientData(obj));
5174 return SWIG_Py_Void();
5175 }
5176
5177 SWIGINTERN PyObject *Size_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5178 return SWIG_Python_InitShadowInstance(args);
5179 }
5180
5181 SWIGINTERN PyObject *_wrap_RealPoint_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5182 PyObject *resultobj = 0;
5183 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5184 double arg2 ;
5185 void *argp1 = 0 ;
5186 int res1 = 0 ;
5187 double val2 ;
5188 int ecode2 = 0 ;
5189 PyObject *swig_obj[2] ;
5190
5191 if (!SWIG_Python_UnpackTuple(args,"RealPoint_x_set",2,2,swig_obj)) SWIG_fail;
5192 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5193 if (!SWIG_IsOK(res1)) {
5194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5195 }
5196 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5197 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5198 if (!SWIG_IsOK(ecode2)) {
5199 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_x_set" "', expected argument " "2"" of type '" "double""'");
5200 }
5201 arg2 = static_cast< double >(val2);
5202 if (arg1) (arg1)->x = arg2;
5203
5204 resultobj = SWIG_Py_Void();
5205 return resultobj;
5206 fail:
5207 return NULL;
5208 }
5209
5210
5211 SWIGINTERN PyObject *_wrap_RealPoint_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5212 PyObject *resultobj = 0;
5213 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5214 double result;
5215 void *argp1 = 0 ;
5216 int res1 = 0 ;
5217 PyObject *swig_obj[1] ;
5218
5219 if (!args) SWIG_fail;
5220 swig_obj[0] = args;
5221 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5222 if (!SWIG_IsOK(res1)) {
5223 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_x_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5224 }
5225 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5226 result = (double) ((arg1)->x);
5227 resultobj = SWIG_From_double(static_cast< double >(result));
5228 return resultobj;
5229 fail:
5230 return NULL;
5231 }
5232
5233
5234 SWIGINTERN PyObject *_wrap_RealPoint_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5235 PyObject *resultobj = 0;
5236 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5237 double arg2 ;
5238 void *argp1 = 0 ;
5239 int res1 = 0 ;
5240 double val2 ;
5241 int ecode2 = 0 ;
5242 PyObject *swig_obj[2] ;
5243
5244 if (!SWIG_Python_UnpackTuple(args,"RealPoint_y_set",2,2,swig_obj)) SWIG_fail;
5245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5246 if (!SWIG_IsOK(res1)) {
5247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5248 }
5249 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5250 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
5251 if (!SWIG_IsOK(ecode2)) {
5252 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_y_set" "', expected argument " "2"" of type '" "double""'");
5253 }
5254 arg2 = static_cast< double >(val2);
5255 if (arg1) (arg1)->y = arg2;
5256
5257 resultobj = SWIG_Py_Void();
5258 return resultobj;
5259 fail:
5260 return NULL;
5261 }
5262
5263
5264 SWIGINTERN PyObject *_wrap_RealPoint_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5265 PyObject *resultobj = 0;
5266 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5267 double result;
5268 void *argp1 = 0 ;
5269 int res1 = 0 ;
5270 PyObject *swig_obj[1] ;
5271
5272 if (!args) SWIG_fail;
5273 swig_obj[0] = args;
5274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5275 if (!SWIG_IsOK(res1)) {
5276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_y_get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5277 }
5278 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5279 result = (double) ((arg1)->y);
5280 resultobj = SWIG_From_double(static_cast< double >(result));
5281 return resultobj;
5282 fail:
5283 return NULL;
5284 }
5285
5286
5287 SWIGINTERN PyObject *_wrap_new_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5288 PyObject *resultobj = 0;
5289 double arg1 = (double) 0.0 ;
5290 double arg2 = (double) 0.0 ;
5291 wxRealPoint *result = 0 ;
5292 double val1 ;
5293 int ecode1 = 0 ;
5294 double val2 ;
5295 int ecode2 = 0 ;
5296 PyObject * obj0 = 0 ;
5297 PyObject * obj1 = 0 ;
5298 char * kwnames[] = {
5299 (char *) "x",(char *) "y", NULL
5300 };
5301
5302 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_RealPoint",kwnames,&obj0,&obj1)) SWIG_fail;
5303 if (obj0) {
5304 ecode1 = SWIG_AsVal_double(obj0, &val1);
5305 if (!SWIG_IsOK(ecode1)) {
5306 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_RealPoint" "', expected argument " "1"" of type '" "double""'");
5307 }
5308 arg1 = static_cast< double >(val1);
5309 }
5310 if (obj1) {
5311 ecode2 = SWIG_AsVal_double(obj1, &val2);
5312 if (!SWIG_IsOK(ecode2)) {
5313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_RealPoint" "', expected argument " "2"" of type '" "double""'");
5314 }
5315 arg2 = static_cast< double >(val2);
5316 }
5317 {
5318 PyThreadState* __tstate = wxPyBeginAllowThreads();
5319 result = (wxRealPoint *)new wxRealPoint(arg1,arg2);
5320 wxPyEndAllowThreads(__tstate);
5321 if (PyErr_Occurred()) SWIG_fail;
5322 }
5323 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_NEW | 0 );
5324 return resultobj;
5325 fail:
5326 return NULL;
5327 }
5328
5329
5330 SWIGINTERN PyObject *_wrap_delete_RealPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5331 PyObject *resultobj = 0;
5332 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5333 void *argp1 = 0 ;
5334 int res1 = 0 ;
5335 PyObject *swig_obj[1] ;
5336
5337 if (!args) SWIG_fail;
5338 swig_obj[0] = args;
5339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, SWIG_POINTER_DISOWN | 0 );
5340 if (!SWIG_IsOK(res1)) {
5341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_RealPoint" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5342 }
5343 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5344 {
5345 PyThreadState* __tstate = wxPyBeginAllowThreads();
5346 delete arg1;
5347
5348 wxPyEndAllowThreads(__tstate);
5349 if (PyErr_Occurred()) SWIG_fail;
5350 }
5351 resultobj = SWIG_Py_Void();
5352 return resultobj;
5353 fail:
5354 return NULL;
5355 }
5356
5357
5358 SWIGINTERN PyObject *_wrap_RealPoint___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5359 PyObject *resultobj = 0;
5360 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5361 PyObject *arg2 = (PyObject *) 0 ;
5362 bool result;
5363 void *argp1 = 0 ;
5364 int res1 = 0 ;
5365 PyObject * obj0 = 0 ;
5366 PyObject * obj1 = 0 ;
5367 char * kwnames[] = {
5368 (char *) "self",(char *) "other", NULL
5369 };
5370
5371 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5372 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5373 if (!SWIG_IsOK(res1)) {
5374 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___eq__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5375 }
5376 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5377 arg2 = obj1;
5378 {
5379 result = (bool)wxRealPoint___eq__(arg1,arg2);
5380 if (PyErr_Occurred()) SWIG_fail;
5381 }
5382 {
5383 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5384 }
5385 return resultobj;
5386 fail:
5387 return NULL;
5388 }
5389
5390
5391 SWIGINTERN PyObject *_wrap_RealPoint___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5392 PyObject *resultobj = 0;
5393 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5394 PyObject *arg2 = (PyObject *) 0 ;
5395 bool result;
5396 void *argp1 = 0 ;
5397 int res1 = 0 ;
5398 PyObject * obj0 = 0 ;
5399 PyObject * obj1 = 0 ;
5400 char * kwnames[] = {
5401 (char *) "self",(char *) "other", NULL
5402 };
5403
5404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5406 if (!SWIG_IsOK(res1)) {
5407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___ne__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5408 }
5409 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5410 arg2 = obj1;
5411 {
5412 result = (bool)wxRealPoint___ne__(arg1,arg2);
5413 if (PyErr_Occurred()) SWIG_fail;
5414 }
5415 {
5416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5417 }
5418 return resultobj;
5419 fail:
5420 return NULL;
5421 }
5422
5423
5424 SWIGINTERN PyObject *_wrap_RealPoint___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5425 PyObject *resultobj = 0;
5426 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5427 wxRealPoint *arg2 = 0 ;
5428 wxRealPoint result;
5429 void *argp1 = 0 ;
5430 int res1 = 0 ;
5431 wxRealPoint temp2 ;
5432 PyObject * obj0 = 0 ;
5433 PyObject * obj1 = 0 ;
5434 char * kwnames[] = {
5435 (char *) "self",(char *) "pt", NULL
5436 };
5437
5438 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5439 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5440 if (!SWIG_IsOK(res1)) {
5441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___add__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5442 }
5443 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5444 {
5445 arg2 = &temp2;
5446 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5447 }
5448 {
5449 PyThreadState* __tstate = wxPyBeginAllowThreads();
5450 result = (arg1)->operator +((wxRealPoint const &)*arg2);
5451 wxPyEndAllowThreads(__tstate);
5452 if (PyErr_Occurred()) SWIG_fail;
5453 }
5454 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5455 return resultobj;
5456 fail:
5457 return NULL;
5458 }
5459
5460
5461 SWIGINTERN PyObject *_wrap_RealPoint___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5462 PyObject *resultobj = 0;
5463 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5464 wxRealPoint *arg2 = 0 ;
5465 wxRealPoint result;
5466 void *argp1 = 0 ;
5467 int res1 = 0 ;
5468 wxRealPoint temp2 ;
5469 PyObject * obj0 = 0 ;
5470 PyObject * obj1 = 0 ;
5471 char * kwnames[] = {
5472 (char *) "self",(char *) "pt", NULL
5473 };
5474
5475 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:RealPoint___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5476 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5477 if (!SWIG_IsOK(res1)) {
5478 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint___sub__" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5479 }
5480 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5481 {
5482 arg2 = &temp2;
5483 if ( ! wxRealPoint_helper(obj1, &arg2)) SWIG_fail;
5484 }
5485 {
5486 PyThreadState* __tstate = wxPyBeginAllowThreads();
5487 result = (arg1)->operator -((wxRealPoint const &)*arg2);
5488 wxPyEndAllowThreads(__tstate);
5489 if (PyErr_Occurred()) SWIG_fail;
5490 }
5491 resultobj = SWIG_NewPointerObj((new wxRealPoint(static_cast< const wxRealPoint& >(result))), SWIGTYPE_p_wxRealPoint, SWIG_POINTER_OWN | 0 );
5492 return resultobj;
5493 fail:
5494 return NULL;
5495 }
5496
5497
5498 SWIGINTERN PyObject *_wrap_RealPoint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5499 PyObject *resultobj = 0;
5500 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5501 double arg2 ;
5502 double arg3 ;
5503 void *argp1 = 0 ;
5504 int res1 = 0 ;
5505 double val2 ;
5506 int ecode2 = 0 ;
5507 double val3 ;
5508 int ecode3 = 0 ;
5509 PyObject * obj0 = 0 ;
5510 PyObject * obj1 = 0 ;
5511 PyObject * obj2 = 0 ;
5512 char * kwnames[] = {
5513 (char *) "self",(char *) "x",(char *) "y", NULL
5514 };
5515
5516 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:RealPoint_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
5517 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5518 if (!SWIG_IsOK(res1)) {
5519 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Set" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5520 }
5521 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5522 ecode2 = SWIG_AsVal_double(obj1, &val2);
5523 if (!SWIG_IsOK(ecode2)) {
5524 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "RealPoint_Set" "', expected argument " "2"" of type '" "double""'");
5525 }
5526 arg2 = static_cast< double >(val2);
5527 ecode3 = SWIG_AsVal_double(obj2, &val3);
5528 if (!SWIG_IsOK(ecode3)) {
5529 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "RealPoint_Set" "', expected argument " "3"" of type '" "double""'");
5530 }
5531 arg3 = static_cast< double >(val3);
5532 {
5533 PyThreadState* __tstate = wxPyBeginAllowThreads();
5534 wxRealPoint_Set(arg1,arg2,arg3);
5535 wxPyEndAllowThreads(__tstate);
5536 if (PyErr_Occurred()) SWIG_fail;
5537 }
5538 resultobj = SWIG_Py_Void();
5539 return resultobj;
5540 fail:
5541 return NULL;
5542 }
5543
5544
5545 SWIGINTERN PyObject *_wrap_RealPoint_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5546 PyObject *resultobj = 0;
5547 wxRealPoint *arg1 = (wxRealPoint *) 0 ;
5548 PyObject *result = 0 ;
5549 void *argp1 = 0 ;
5550 int res1 = 0 ;
5551 PyObject *swig_obj[1] ;
5552
5553 if (!args) SWIG_fail;
5554 swig_obj[0] = args;
5555 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRealPoint, 0 | 0 );
5556 if (!SWIG_IsOK(res1)) {
5557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "RealPoint_Get" "', expected argument " "1"" of type '" "wxRealPoint *""'");
5558 }
5559 arg1 = reinterpret_cast< wxRealPoint * >(argp1);
5560 {
5561 PyThreadState* __tstate = wxPyBeginAllowThreads();
5562 result = (PyObject *)wxRealPoint_Get(arg1);
5563 wxPyEndAllowThreads(__tstate);
5564 if (PyErr_Occurred()) SWIG_fail;
5565 }
5566 resultobj = result;
5567 return resultobj;
5568 fail:
5569 return NULL;
5570 }
5571
5572
5573 SWIGINTERN PyObject *RealPoint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5574 PyObject *obj;
5575 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
5576 SWIG_TypeNewClientData(SWIGTYPE_p_wxRealPoint, SWIG_NewClientData(obj));
5577 return SWIG_Py_Void();
5578 }
5579
5580 SWIGINTERN PyObject *RealPoint_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5581 return SWIG_Python_InitShadowInstance(args);
5582 }
5583
5584 SWIGINTERN PyObject *_wrap_Point_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5585 PyObject *resultobj = 0;
5586 wxPoint *arg1 = (wxPoint *) 0 ;
5587 int arg2 ;
5588 void *argp1 = 0 ;
5589 int res1 = 0 ;
5590 int val2 ;
5591 int ecode2 = 0 ;
5592 PyObject *swig_obj[2] ;
5593
5594 if (!SWIG_Python_UnpackTuple(args,"Point_x_set",2,2,swig_obj)) SWIG_fail;
5595 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5596 if (!SWIG_IsOK(res1)) {
5597 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5598 }
5599 arg1 = reinterpret_cast< wxPoint * >(argp1);
5600 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5601 if (!SWIG_IsOK(ecode2)) {
5602 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_x_set" "', expected argument " "2"" of type '" "int""'");
5603 }
5604 arg2 = static_cast< int >(val2);
5605 if (arg1) (arg1)->x = arg2;
5606
5607 resultobj = SWIG_Py_Void();
5608 return resultobj;
5609 fail:
5610 return NULL;
5611 }
5612
5613
5614 SWIGINTERN PyObject *_wrap_Point_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5615 PyObject *resultobj = 0;
5616 wxPoint *arg1 = (wxPoint *) 0 ;
5617 int result;
5618 void *argp1 = 0 ;
5619 int res1 = 0 ;
5620 PyObject *swig_obj[1] ;
5621
5622 if (!args) SWIG_fail;
5623 swig_obj[0] = args;
5624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5625 if (!SWIG_IsOK(res1)) {
5626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_x_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5627 }
5628 arg1 = reinterpret_cast< wxPoint * >(argp1);
5629 result = (int) ((arg1)->x);
5630 resultobj = SWIG_From_int(static_cast< int >(result));
5631 return resultobj;
5632 fail:
5633 return NULL;
5634 }
5635
5636
5637 SWIGINTERN PyObject *_wrap_Point_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5638 PyObject *resultobj = 0;
5639 wxPoint *arg1 = (wxPoint *) 0 ;
5640 int arg2 ;
5641 void *argp1 = 0 ;
5642 int res1 = 0 ;
5643 int val2 ;
5644 int ecode2 = 0 ;
5645 PyObject *swig_obj[2] ;
5646
5647 if (!SWIG_Python_UnpackTuple(args,"Point_y_set",2,2,swig_obj)) SWIG_fail;
5648 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5649 if (!SWIG_IsOK(res1)) {
5650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_set" "', expected argument " "1"" of type '" "wxPoint *""'");
5651 }
5652 arg1 = reinterpret_cast< wxPoint * >(argp1);
5653 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
5654 if (!SWIG_IsOK(ecode2)) {
5655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_y_set" "', expected argument " "2"" of type '" "int""'");
5656 }
5657 arg2 = static_cast< int >(val2);
5658 if (arg1) (arg1)->y = arg2;
5659
5660 resultobj = SWIG_Py_Void();
5661 return resultobj;
5662 fail:
5663 return NULL;
5664 }
5665
5666
5667 SWIGINTERN PyObject *_wrap_Point_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5668 PyObject *resultobj = 0;
5669 wxPoint *arg1 = (wxPoint *) 0 ;
5670 int result;
5671 void *argp1 = 0 ;
5672 int res1 = 0 ;
5673 PyObject *swig_obj[1] ;
5674
5675 if (!args) SWIG_fail;
5676 swig_obj[0] = args;
5677 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5678 if (!SWIG_IsOK(res1)) {
5679 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_y_get" "', expected argument " "1"" of type '" "wxPoint *""'");
5680 }
5681 arg1 = reinterpret_cast< wxPoint * >(argp1);
5682 result = (int) ((arg1)->y);
5683 resultobj = SWIG_From_int(static_cast< int >(result));
5684 return resultobj;
5685 fail:
5686 return NULL;
5687 }
5688
5689
5690 SWIGINTERN PyObject *_wrap_new_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5691 PyObject *resultobj = 0;
5692 int arg1 = (int) 0 ;
5693 int arg2 = (int) 0 ;
5694 wxPoint *result = 0 ;
5695 int val1 ;
5696 int ecode1 = 0 ;
5697 int val2 ;
5698 int ecode2 = 0 ;
5699 PyObject * obj0 = 0 ;
5700 PyObject * obj1 = 0 ;
5701 char * kwnames[] = {
5702 (char *) "x",(char *) "y", NULL
5703 };
5704
5705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point",kwnames,&obj0,&obj1)) SWIG_fail;
5706 if (obj0) {
5707 ecode1 = SWIG_AsVal_int(obj0, &val1);
5708 if (!SWIG_IsOK(ecode1)) {
5709 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point" "', expected argument " "1"" of type '" "int""'");
5710 }
5711 arg1 = static_cast< int >(val1);
5712 }
5713 if (obj1) {
5714 ecode2 = SWIG_AsVal_int(obj1, &val2);
5715 if (!SWIG_IsOK(ecode2)) {
5716 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point" "', expected argument " "2"" of type '" "int""'");
5717 }
5718 arg2 = static_cast< int >(val2);
5719 }
5720 {
5721 PyThreadState* __tstate = wxPyBeginAllowThreads();
5722 result = (wxPoint *)new wxPoint(arg1,arg2);
5723 wxPyEndAllowThreads(__tstate);
5724 if (PyErr_Occurred()) SWIG_fail;
5725 }
5726 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_NEW | 0 );
5727 return resultobj;
5728 fail:
5729 return NULL;
5730 }
5731
5732
5733 SWIGINTERN PyObject *_wrap_delete_Point(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
5734 PyObject *resultobj = 0;
5735 wxPoint *arg1 = (wxPoint *) 0 ;
5736 void *argp1 = 0 ;
5737 int res1 = 0 ;
5738 PyObject *swig_obj[1] ;
5739
5740 if (!args) SWIG_fail;
5741 swig_obj[0] = args;
5742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5743 if (!SWIG_IsOK(res1)) {
5744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Point" "', expected argument " "1"" of type '" "wxPoint *""'");
5745 }
5746 arg1 = reinterpret_cast< wxPoint * >(argp1);
5747 {
5748 PyThreadState* __tstate = wxPyBeginAllowThreads();
5749 delete arg1;
5750
5751 wxPyEndAllowThreads(__tstate);
5752 if (PyErr_Occurred()) SWIG_fail;
5753 }
5754 resultobj = SWIG_Py_Void();
5755 return resultobj;
5756 fail:
5757 return NULL;
5758 }
5759
5760
5761 SWIGINTERN PyObject *_wrap_Point___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5762 PyObject *resultobj = 0;
5763 wxPoint *arg1 = (wxPoint *) 0 ;
5764 PyObject *arg2 = (PyObject *) 0 ;
5765 bool result;
5766 void *argp1 = 0 ;
5767 int res1 = 0 ;
5768 PyObject * obj0 = 0 ;
5769 PyObject * obj1 = 0 ;
5770 char * kwnames[] = {
5771 (char *) "self",(char *) "other", NULL
5772 };
5773
5774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
5775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5776 if (!SWIG_IsOK(res1)) {
5777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___eq__" "', expected argument " "1"" of type '" "wxPoint *""'");
5778 }
5779 arg1 = reinterpret_cast< wxPoint * >(argp1);
5780 arg2 = obj1;
5781 {
5782 result = (bool)wxPoint___eq__(arg1,arg2);
5783 if (PyErr_Occurred()) SWIG_fail;
5784 }
5785 {
5786 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5787 }
5788 return resultobj;
5789 fail:
5790 return NULL;
5791 }
5792
5793
5794 SWIGINTERN PyObject *_wrap_Point___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5795 PyObject *resultobj = 0;
5796 wxPoint *arg1 = (wxPoint *) 0 ;
5797 PyObject *arg2 = (PyObject *) 0 ;
5798 bool result;
5799 void *argp1 = 0 ;
5800 int res1 = 0 ;
5801 PyObject * obj0 = 0 ;
5802 PyObject * obj1 = 0 ;
5803 char * kwnames[] = {
5804 (char *) "self",(char *) "other", NULL
5805 };
5806
5807 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
5808 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5809 if (!SWIG_IsOK(res1)) {
5810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___ne__" "', expected argument " "1"" of type '" "wxPoint *""'");
5811 }
5812 arg1 = reinterpret_cast< wxPoint * >(argp1);
5813 arg2 = obj1;
5814 {
5815 result = (bool)wxPoint___ne__(arg1,arg2);
5816 if (PyErr_Occurred()) SWIG_fail;
5817 }
5818 {
5819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
5820 }
5821 return resultobj;
5822 fail:
5823 return NULL;
5824 }
5825
5826
5827 SWIGINTERN PyObject *_wrap_Point___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5828 PyObject *resultobj = 0;
5829 wxPoint *arg1 = (wxPoint *) 0 ;
5830 wxPoint *arg2 = 0 ;
5831 wxPoint result;
5832 void *argp1 = 0 ;
5833 int res1 = 0 ;
5834 wxPoint temp2 ;
5835 PyObject * obj0 = 0 ;
5836 PyObject * obj1 = 0 ;
5837 char * kwnames[] = {
5838 (char *) "self",(char *) "pt", NULL
5839 };
5840
5841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___add__",kwnames,&obj0,&obj1)) SWIG_fail;
5842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5843 if (!SWIG_IsOK(res1)) {
5844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___add__" "', expected argument " "1"" of type '" "wxPoint *""'");
5845 }
5846 arg1 = reinterpret_cast< wxPoint * >(argp1);
5847 {
5848 arg2 = &temp2;
5849 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5850 }
5851 {
5852 PyThreadState* __tstate = wxPyBeginAllowThreads();
5853 result = (arg1)->operator +((wxPoint const &)*arg2);
5854 wxPyEndAllowThreads(__tstate);
5855 if (PyErr_Occurred()) SWIG_fail;
5856 }
5857 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5858 return resultobj;
5859 fail:
5860 return NULL;
5861 }
5862
5863
5864 SWIGINTERN PyObject *_wrap_Point___sub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5865 PyObject *resultobj = 0;
5866 wxPoint *arg1 = (wxPoint *) 0 ;
5867 wxPoint *arg2 = 0 ;
5868 wxPoint result;
5869 void *argp1 = 0 ;
5870 int res1 = 0 ;
5871 wxPoint temp2 ;
5872 PyObject * obj0 = 0 ;
5873 PyObject * obj1 = 0 ;
5874 char * kwnames[] = {
5875 (char *) "self",(char *) "pt", NULL
5876 };
5877
5878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___sub__",kwnames,&obj0,&obj1)) SWIG_fail;
5879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
5880 if (!SWIG_IsOK(res1)) {
5881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___sub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5882 }
5883 arg1 = reinterpret_cast< wxPoint * >(argp1);
5884 {
5885 arg2 = &temp2;
5886 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5887 }
5888 {
5889 PyThreadState* __tstate = wxPyBeginAllowThreads();
5890 result = (arg1)->operator -((wxPoint const &)*arg2);
5891 wxPyEndAllowThreads(__tstate);
5892 if (PyErr_Occurred()) SWIG_fail;
5893 }
5894 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5895 return resultobj;
5896 fail:
5897 return NULL;
5898 }
5899
5900
5901 SWIGINTERN PyObject *_wrap_Point___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5902 PyObject *resultobj = 0;
5903 wxPoint *arg1 = (wxPoint *) 0 ;
5904 wxPoint *arg2 = 0 ;
5905 wxPoint *result = 0 ;
5906 void *argp1 = 0 ;
5907 int res1 = 0 ;
5908 wxPoint temp2 ;
5909 PyObject * obj0 = 0 ;
5910 PyObject * obj1 = 0 ;
5911 char * kwnames[] = {
5912 (char *) "self",(char *) "pt", NULL
5913 };
5914
5915 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
5916 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5917 if (!SWIG_IsOK(res1)) {
5918 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___iadd__" "', expected argument " "1"" of type '" "wxPoint *""'");
5919 }
5920 arg1 = reinterpret_cast< wxPoint * >(argp1);
5921 {
5922 arg2 = &temp2;
5923 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5924 }
5925 {
5926 PyThreadState* __tstate = wxPyBeginAllowThreads();
5927 {
5928 wxPoint &_result_ref = (arg1)->operator +=((wxPoint const &)*arg2);
5929 result = (wxPoint *) &_result_ref;
5930 }
5931 wxPyEndAllowThreads(__tstate);
5932 if (PyErr_Occurred()) SWIG_fail;
5933 }
5934 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5935 return resultobj;
5936 fail:
5937 return NULL;
5938 }
5939
5940
5941 SWIGINTERN PyObject *_wrap_Point___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5942 PyObject *resultobj = 0;
5943 wxPoint *arg1 = (wxPoint *) 0 ;
5944 wxPoint *arg2 = 0 ;
5945 wxPoint *result = 0 ;
5946 void *argp1 = 0 ;
5947 int res1 = 0 ;
5948 wxPoint temp2 ;
5949 PyObject * obj0 = 0 ;
5950 PyObject * obj1 = 0 ;
5951 char * kwnames[] = {
5952 (char *) "self",(char *) "pt", NULL
5953 };
5954
5955 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
5956 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, SWIG_POINTER_DISOWN | 0 );
5957 if (!SWIG_IsOK(res1)) {
5958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point___isub__" "', expected argument " "1"" of type '" "wxPoint *""'");
5959 }
5960 arg1 = reinterpret_cast< wxPoint * >(argp1);
5961 {
5962 arg2 = &temp2;
5963 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
5964 }
5965 {
5966 PyThreadState* __tstate = wxPyBeginAllowThreads();
5967 {
5968 wxPoint &_result_ref = (arg1)->operator -=((wxPoint const &)*arg2);
5969 result = (wxPoint *) &_result_ref;
5970 }
5971 wxPyEndAllowThreads(__tstate);
5972 if (PyErr_Occurred()) SWIG_fail;
5973 }
5974 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
5975 return resultobj;
5976 fail:
5977 return NULL;
5978 }
5979
5980
5981 SWIGINTERN PyObject *_wrap_Point_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
5982 PyObject *resultobj = 0;
5983 wxPoint *arg1 = (wxPoint *) 0 ;
5984 long arg2 ;
5985 long arg3 ;
5986 void *argp1 = 0 ;
5987 int res1 = 0 ;
5988 long val2 ;
5989 int ecode2 = 0 ;
5990 long val3 ;
5991 int ecode3 = 0 ;
5992 PyObject * obj0 = 0 ;
5993 PyObject * obj1 = 0 ;
5994 PyObject * obj2 = 0 ;
5995 char * kwnames[] = {
5996 (char *) "self",(char *) "x",(char *) "y", NULL
5997 };
5998
5999 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Point_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
6000 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6001 if (!SWIG_IsOK(res1)) {
6002 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Set" "', expected argument " "1"" of type '" "wxPoint *""'");
6003 }
6004 arg1 = reinterpret_cast< wxPoint * >(argp1);
6005 ecode2 = SWIG_AsVal_long(obj1, &val2);
6006 if (!SWIG_IsOK(ecode2)) {
6007 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point_Set" "', expected argument " "2"" of type '" "long""'");
6008 }
6009 arg2 = static_cast< long >(val2);
6010 ecode3 = SWIG_AsVal_long(obj2, &val3);
6011 if (!SWIG_IsOK(ecode3)) {
6012 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point_Set" "', expected argument " "3"" of type '" "long""'");
6013 }
6014 arg3 = static_cast< long >(val3);
6015 {
6016 PyThreadState* __tstate = wxPyBeginAllowThreads();
6017 wxPoint_Set(arg1,arg2,arg3);
6018 wxPyEndAllowThreads(__tstate);
6019 if (PyErr_Occurred()) SWIG_fail;
6020 }
6021 resultobj = SWIG_Py_Void();
6022 return resultobj;
6023 fail:
6024 return NULL;
6025 }
6026
6027
6028 SWIGINTERN PyObject *_wrap_Point_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6029 PyObject *resultobj = 0;
6030 wxPoint *arg1 = (wxPoint *) 0 ;
6031 PyObject *result = 0 ;
6032 void *argp1 = 0 ;
6033 int res1 = 0 ;
6034 PyObject *swig_obj[1] ;
6035
6036 if (!args) SWIG_fail;
6037 swig_obj[0] = args;
6038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint, 0 | 0 );
6039 if (!SWIG_IsOK(res1)) {
6040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point_Get" "', expected argument " "1"" of type '" "wxPoint *""'");
6041 }
6042 arg1 = reinterpret_cast< wxPoint * >(argp1);
6043 {
6044 PyThreadState* __tstate = wxPyBeginAllowThreads();
6045 result = (PyObject *)wxPoint_Get(arg1);
6046 wxPyEndAllowThreads(__tstate);
6047 if (PyErr_Occurred()) SWIG_fail;
6048 }
6049 resultobj = result;
6050 return resultobj;
6051 fail:
6052 return NULL;
6053 }
6054
6055
6056 SWIGINTERN PyObject *Point_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6057 PyObject *obj;
6058 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
6059 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint, SWIG_NewClientData(obj));
6060 return SWIG_Py_Void();
6061 }
6062
6063 SWIGINTERN PyObject *Point_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6064 return SWIG_Python_InitShadowInstance(args);
6065 }
6066
6067 SWIGINTERN PyObject *_wrap_new_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6068 PyObject *resultobj = 0;
6069 int arg1 = (int) 0 ;
6070 int arg2 = (int) 0 ;
6071 int arg3 = (int) 0 ;
6072 int arg4 = (int) 0 ;
6073 wxRect *result = 0 ;
6074 int val1 ;
6075 int ecode1 = 0 ;
6076 int val2 ;
6077 int ecode2 = 0 ;
6078 int val3 ;
6079 int ecode3 = 0 ;
6080 int val4 ;
6081 int ecode4 = 0 ;
6082 PyObject * obj0 = 0 ;
6083 PyObject * obj1 = 0 ;
6084 PyObject * obj2 = 0 ;
6085 PyObject * obj3 = 0 ;
6086 char * kwnames[] = {
6087 (char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
6088 };
6089
6090 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_Rect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
6091 if (obj0) {
6092 ecode1 = SWIG_AsVal_int(obj0, &val1);
6093 if (!SWIG_IsOK(ecode1)) {
6094 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Rect" "', expected argument " "1"" of type '" "int""'");
6095 }
6096 arg1 = static_cast< int >(val1);
6097 }
6098 if (obj1) {
6099 ecode2 = SWIG_AsVal_int(obj1, &val2);
6100 if (!SWIG_IsOK(ecode2)) {
6101 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Rect" "', expected argument " "2"" of type '" "int""'");
6102 }
6103 arg2 = static_cast< int >(val2);
6104 }
6105 if (obj2) {
6106 ecode3 = SWIG_AsVal_int(obj2, &val3);
6107 if (!SWIG_IsOK(ecode3)) {
6108 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Rect" "', expected argument " "3"" of type '" "int""'");
6109 }
6110 arg3 = static_cast< int >(val3);
6111 }
6112 if (obj3) {
6113 ecode4 = SWIG_AsVal_int(obj3, &val4);
6114 if (!SWIG_IsOK(ecode4)) {
6115 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_Rect" "', expected argument " "4"" of type '" "int""'");
6116 }
6117 arg4 = static_cast< int >(val4);
6118 }
6119 {
6120 PyThreadState* __tstate = wxPyBeginAllowThreads();
6121 result = (wxRect *)new wxRect(arg1,arg2,arg3,arg4);
6122 wxPyEndAllowThreads(__tstate);
6123 if (PyErr_Occurred()) SWIG_fail;
6124 }
6125 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_NEW | 0 );
6126 return resultobj;
6127 fail:
6128 return NULL;
6129 }
6130
6131
6132 SWIGINTERN PyObject *_wrap_new_RectPP(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6133 PyObject *resultobj = 0;
6134 wxPoint *arg1 = 0 ;
6135 wxPoint *arg2 = 0 ;
6136 wxRect *result = 0 ;
6137 wxPoint temp1 ;
6138 wxPoint temp2 ;
6139 PyObject * obj0 = 0 ;
6140 PyObject * obj1 = 0 ;
6141 char * kwnames[] = {
6142 (char *) "topLeft",(char *) "bottomRight", NULL
6143 };
6144
6145 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPP",kwnames,&obj0,&obj1)) SWIG_fail;
6146 {
6147 arg1 = &temp1;
6148 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6149 }
6150 {
6151 arg2 = &temp2;
6152 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6153 }
6154 {
6155 PyThreadState* __tstate = wxPyBeginAllowThreads();
6156 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxPoint const &)*arg2);
6157 wxPyEndAllowThreads(__tstate);
6158 if (PyErr_Occurred()) SWIG_fail;
6159 }
6160 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6161 return resultobj;
6162 fail:
6163 return NULL;
6164 }
6165
6166
6167 SWIGINTERN PyObject *_wrap_new_RectPS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6168 PyObject *resultobj = 0;
6169 wxPoint *arg1 = 0 ;
6170 wxSize *arg2 = 0 ;
6171 wxRect *result = 0 ;
6172 wxPoint temp1 ;
6173 wxSize temp2 ;
6174 PyObject * obj0 = 0 ;
6175 PyObject * obj1 = 0 ;
6176 char * kwnames[] = {
6177 (char *) "pos",(char *) "size", NULL
6178 };
6179
6180 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:new_RectPS",kwnames,&obj0,&obj1)) SWIG_fail;
6181 {
6182 arg1 = &temp1;
6183 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
6184 }
6185 {
6186 arg2 = &temp2;
6187 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6188 }
6189 {
6190 PyThreadState* __tstate = wxPyBeginAllowThreads();
6191 result = (wxRect *)new wxRect((wxPoint const &)*arg1,(wxSize const &)*arg2);
6192 wxPyEndAllowThreads(__tstate);
6193 if (PyErr_Occurred()) SWIG_fail;
6194 }
6195 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6196 return resultobj;
6197 fail:
6198 return NULL;
6199 }
6200
6201
6202 SWIGINTERN PyObject *_wrap_new_RectS(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6203 PyObject *resultobj = 0;
6204 wxSize *arg1 = 0 ;
6205 wxRect *result = 0 ;
6206 wxSize temp1 ;
6207 PyObject * obj0 = 0 ;
6208 char * kwnames[] = {
6209 (char *) "size", NULL
6210 };
6211
6212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_RectS",kwnames,&obj0)) SWIG_fail;
6213 {
6214 arg1 = &temp1;
6215 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
6216 }
6217 {
6218 PyThreadState* __tstate = wxPyBeginAllowThreads();
6219 result = (wxRect *)new wxRect((wxSize const &)*arg1);
6220 wxPyEndAllowThreads(__tstate);
6221 if (PyErr_Occurred()) SWIG_fail;
6222 }
6223 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
6224 return resultobj;
6225 fail:
6226 return NULL;
6227 }
6228
6229
6230 SWIGINTERN PyObject *_wrap_delete_Rect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6231 PyObject *resultobj = 0;
6232 wxRect *arg1 = (wxRect *) 0 ;
6233 void *argp1 = 0 ;
6234 int res1 = 0 ;
6235 PyObject *swig_obj[1] ;
6236
6237 if (!args) SWIG_fail;
6238 swig_obj[0] = args;
6239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
6240 if (!SWIG_IsOK(res1)) {
6241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Rect" "', expected argument " "1"" of type '" "wxRect *""'");
6242 }
6243 arg1 = reinterpret_cast< wxRect * >(argp1);
6244 {
6245 PyThreadState* __tstate = wxPyBeginAllowThreads();
6246 delete arg1;
6247
6248 wxPyEndAllowThreads(__tstate);
6249 if (PyErr_Occurred()) SWIG_fail;
6250 }
6251 resultobj = SWIG_Py_Void();
6252 return resultobj;
6253 fail:
6254 return NULL;
6255 }
6256
6257
6258 SWIGINTERN PyObject *_wrap_Rect_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6259 PyObject *resultobj = 0;
6260 wxRect *arg1 = (wxRect *) 0 ;
6261 int result;
6262 void *argp1 = 0 ;
6263 int res1 = 0 ;
6264 PyObject *swig_obj[1] ;
6265
6266 if (!args) SWIG_fail;
6267 swig_obj[0] = args;
6268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6269 if (!SWIG_IsOK(res1)) {
6270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetX" "', expected argument " "1"" of type '" "wxRect const *""'");
6271 }
6272 arg1 = reinterpret_cast< wxRect * >(argp1);
6273 {
6274 PyThreadState* __tstate = wxPyBeginAllowThreads();
6275 result = (int)((wxRect const *)arg1)->GetX();
6276 wxPyEndAllowThreads(__tstate);
6277 if (PyErr_Occurred()) SWIG_fail;
6278 }
6279 resultobj = SWIG_From_int(static_cast< int >(result));
6280 return resultobj;
6281 fail:
6282 return NULL;
6283 }
6284
6285
6286 SWIGINTERN PyObject *_wrap_Rect_SetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6287 PyObject *resultobj = 0;
6288 wxRect *arg1 = (wxRect *) 0 ;
6289 int arg2 ;
6290 void *argp1 = 0 ;
6291 int res1 = 0 ;
6292 int val2 ;
6293 int ecode2 = 0 ;
6294 PyObject * obj0 = 0 ;
6295 PyObject * obj1 = 0 ;
6296 char * kwnames[] = {
6297 (char *) "self",(char *) "x", NULL
6298 };
6299
6300 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetX",kwnames,&obj0,&obj1)) SWIG_fail;
6301 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6302 if (!SWIG_IsOK(res1)) {
6303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetX" "', expected argument " "1"" of type '" "wxRect *""'");
6304 }
6305 arg1 = reinterpret_cast< wxRect * >(argp1);
6306 ecode2 = SWIG_AsVal_int(obj1, &val2);
6307 if (!SWIG_IsOK(ecode2)) {
6308 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetX" "', expected argument " "2"" of type '" "int""'");
6309 }
6310 arg2 = static_cast< int >(val2);
6311 {
6312 PyThreadState* __tstate = wxPyBeginAllowThreads();
6313 (arg1)->SetX(arg2);
6314 wxPyEndAllowThreads(__tstate);
6315 if (PyErr_Occurred()) SWIG_fail;
6316 }
6317 resultobj = SWIG_Py_Void();
6318 return resultobj;
6319 fail:
6320 return NULL;
6321 }
6322
6323
6324 SWIGINTERN PyObject *_wrap_Rect_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6325 PyObject *resultobj = 0;
6326 wxRect *arg1 = (wxRect *) 0 ;
6327 int result;
6328 void *argp1 = 0 ;
6329 int res1 = 0 ;
6330 PyObject *swig_obj[1] ;
6331
6332 if (!args) SWIG_fail;
6333 swig_obj[0] = args;
6334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6335 if (!SWIG_IsOK(res1)) {
6336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetY" "', expected argument " "1"" of type '" "wxRect *""'");
6337 }
6338 arg1 = reinterpret_cast< wxRect * >(argp1);
6339 {
6340 PyThreadState* __tstate = wxPyBeginAllowThreads();
6341 result = (int)(arg1)->GetY();
6342 wxPyEndAllowThreads(__tstate);
6343 if (PyErr_Occurred()) SWIG_fail;
6344 }
6345 resultobj = SWIG_From_int(static_cast< int >(result));
6346 return resultobj;
6347 fail:
6348 return NULL;
6349 }
6350
6351
6352 SWIGINTERN PyObject *_wrap_Rect_SetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6353 PyObject *resultobj = 0;
6354 wxRect *arg1 = (wxRect *) 0 ;
6355 int arg2 ;
6356 void *argp1 = 0 ;
6357 int res1 = 0 ;
6358 int val2 ;
6359 int ecode2 = 0 ;
6360 PyObject * obj0 = 0 ;
6361 PyObject * obj1 = 0 ;
6362 char * kwnames[] = {
6363 (char *) "self",(char *) "y", NULL
6364 };
6365
6366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetY",kwnames,&obj0,&obj1)) SWIG_fail;
6367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6368 if (!SWIG_IsOK(res1)) {
6369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetY" "', expected argument " "1"" of type '" "wxRect *""'");
6370 }
6371 arg1 = reinterpret_cast< wxRect * >(argp1);
6372 ecode2 = SWIG_AsVal_int(obj1, &val2);
6373 if (!SWIG_IsOK(ecode2)) {
6374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetY" "', expected argument " "2"" of type '" "int""'");
6375 }
6376 arg2 = static_cast< int >(val2);
6377 {
6378 PyThreadState* __tstate = wxPyBeginAllowThreads();
6379 (arg1)->SetY(arg2);
6380 wxPyEndAllowThreads(__tstate);
6381 if (PyErr_Occurred()) SWIG_fail;
6382 }
6383 resultobj = SWIG_Py_Void();
6384 return resultobj;
6385 fail:
6386 return NULL;
6387 }
6388
6389
6390 SWIGINTERN PyObject *_wrap_Rect_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6391 PyObject *resultobj = 0;
6392 wxRect *arg1 = (wxRect *) 0 ;
6393 int result;
6394 void *argp1 = 0 ;
6395 int res1 = 0 ;
6396 PyObject *swig_obj[1] ;
6397
6398 if (!args) SWIG_fail;
6399 swig_obj[0] = args;
6400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6401 if (!SWIG_IsOK(res1)) {
6402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetWidth" "', expected argument " "1"" of type '" "wxRect const *""'");
6403 }
6404 arg1 = reinterpret_cast< wxRect * >(argp1);
6405 {
6406 PyThreadState* __tstate = wxPyBeginAllowThreads();
6407 result = (int)((wxRect const *)arg1)->GetWidth();
6408 wxPyEndAllowThreads(__tstate);
6409 if (PyErr_Occurred()) SWIG_fail;
6410 }
6411 resultobj = SWIG_From_int(static_cast< int >(result));
6412 return resultobj;
6413 fail:
6414 return NULL;
6415 }
6416
6417
6418 SWIGINTERN PyObject *_wrap_Rect_SetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6419 PyObject *resultobj = 0;
6420 wxRect *arg1 = (wxRect *) 0 ;
6421 int arg2 ;
6422 void *argp1 = 0 ;
6423 int res1 = 0 ;
6424 int val2 ;
6425 int ecode2 = 0 ;
6426 PyObject * obj0 = 0 ;
6427 PyObject * obj1 = 0 ;
6428 char * kwnames[] = {
6429 (char *) "self",(char *) "w", NULL
6430 };
6431
6432 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetWidth",kwnames,&obj0,&obj1)) SWIG_fail;
6433 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6434 if (!SWIG_IsOK(res1)) {
6435 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetWidth" "', expected argument " "1"" of type '" "wxRect *""'");
6436 }
6437 arg1 = reinterpret_cast< wxRect * >(argp1);
6438 ecode2 = SWIG_AsVal_int(obj1, &val2);
6439 if (!SWIG_IsOK(ecode2)) {
6440 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetWidth" "', expected argument " "2"" of type '" "int""'");
6441 }
6442 arg2 = static_cast< int >(val2);
6443 {
6444 PyThreadState* __tstate = wxPyBeginAllowThreads();
6445 (arg1)->SetWidth(arg2);
6446 wxPyEndAllowThreads(__tstate);
6447 if (PyErr_Occurred()) SWIG_fail;
6448 }
6449 resultobj = SWIG_Py_Void();
6450 return resultobj;
6451 fail:
6452 return NULL;
6453 }
6454
6455
6456 SWIGINTERN PyObject *_wrap_Rect_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6457 PyObject *resultobj = 0;
6458 wxRect *arg1 = (wxRect *) 0 ;
6459 int result;
6460 void *argp1 = 0 ;
6461 int res1 = 0 ;
6462 PyObject *swig_obj[1] ;
6463
6464 if (!args) SWIG_fail;
6465 swig_obj[0] = args;
6466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6467 if (!SWIG_IsOK(res1)) {
6468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetHeight" "', expected argument " "1"" of type '" "wxRect const *""'");
6469 }
6470 arg1 = reinterpret_cast< wxRect * >(argp1);
6471 {
6472 PyThreadState* __tstate = wxPyBeginAllowThreads();
6473 result = (int)((wxRect const *)arg1)->GetHeight();
6474 wxPyEndAllowThreads(__tstate);
6475 if (PyErr_Occurred()) SWIG_fail;
6476 }
6477 resultobj = SWIG_From_int(static_cast< int >(result));
6478 return resultobj;
6479 fail:
6480 return NULL;
6481 }
6482
6483
6484 SWIGINTERN PyObject *_wrap_Rect_SetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6485 PyObject *resultobj = 0;
6486 wxRect *arg1 = (wxRect *) 0 ;
6487 int arg2 ;
6488 void *argp1 = 0 ;
6489 int res1 = 0 ;
6490 int val2 ;
6491 int ecode2 = 0 ;
6492 PyObject * obj0 = 0 ;
6493 PyObject * obj1 = 0 ;
6494 char * kwnames[] = {
6495 (char *) "self",(char *) "h", NULL
6496 };
6497
6498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetHeight",kwnames,&obj0,&obj1)) SWIG_fail;
6499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6500 if (!SWIG_IsOK(res1)) {
6501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetHeight" "', expected argument " "1"" of type '" "wxRect *""'");
6502 }
6503 arg1 = reinterpret_cast< wxRect * >(argp1);
6504 ecode2 = SWIG_AsVal_int(obj1, &val2);
6505 if (!SWIG_IsOK(ecode2)) {
6506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetHeight" "', expected argument " "2"" of type '" "int""'");
6507 }
6508 arg2 = static_cast< int >(val2);
6509 {
6510 PyThreadState* __tstate = wxPyBeginAllowThreads();
6511 (arg1)->SetHeight(arg2);
6512 wxPyEndAllowThreads(__tstate);
6513 if (PyErr_Occurred()) SWIG_fail;
6514 }
6515 resultobj = SWIG_Py_Void();
6516 return resultobj;
6517 fail:
6518 return NULL;
6519 }
6520
6521
6522 SWIGINTERN PyObject *_wrap_Rect_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6523 PyObject *resultobj = 0;
6524 wxRect *arg1 = (wxRect *) 0 ;
6525 wxPoint result;
6526 void *argp1 = 0 ;
6527 int res1 = 0 ;
6528 PyObject *swig_obj[1] ;
6529
6530 if (!args) SWIG_fail;
6531 swig_obj[0] = args;
6532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6533 if (!SWIG_IsOK(res1)) {
6534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetPosition" "', expected argument " "1"" of type '" "wxRect const *""'");
6535 }
6536 arg1 = reinterpret_cast< wxRect * >(argp1);
6537 {
6538 PyThreadState* __tstate = wxPyBeginAllowThreads();
6539 result = ((wxRect const *)arg1)->GetPosition();
6540 wxPyEndAllowThreads(__tstate);
6541 if (PyErr_Occurred()) SWIG_fail;
6542 }
6543 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6544 return resultobj;
6545 fail:
6546 return NULL;
6547 }
6548
6549
6550 SWIGINTERN PyObject *_wrap_Rect_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6551 PyObject *resultobj = 0;
6552 wxRect *arg1 = (wxRect *) 0 ;
6553 wxPoint *arg2 = 0 ;
6554 void *argp1 = 0 ;
6555 int res1 = 0 ;
6556 wxPoint temp2 ;
6557 PyObject * obj0 = 0 ;
6558 PyObject * obj1 = 0 ;
6559 char * kwnames[] = {
6560 (char *) "self",(char *) "p", NULL
6561 };
6562
6563 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
6564 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6565 if (!SWIG_IsOK(res1)) {
6566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetPosition" "', expected argument " "1"" of type '" "wxRect *""'");
6567 }
6568 arg1 = reinterpret_cast< wxRect * >(argp1);
6569 {
6570 arg2 = &temp2;
6571 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6572 }
6573 {
6574 PyThreadState* __tstate = wxPyBeginAllowThreads();
6575 (arg1)->SetPosition((wxPoint const &)*arg2);
6576 wxPyEndAllowThreads(__tstate);
6577 if (PyErr_Occurred()) SWIG_fail;
6578 }
6579 resultobj = SWIG_Py_Void();
6580 return resultobj;
6581 fail:
6582 return NULL;
6583 }
6584
6585
6586 SWIGINTERN PyObject *_wrap_Rect_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6587 PyObject *resultobj = 0;
6588 wxRect *arg1 = (wxRect *) 0 ;
6589 wxSize result;
6590 void *argp1 = 0 ;
6591 int res1 = 0 ;
6592 PyObject *swig_obj[1] ;
6593
6594 if (!args) SWIG_fail;
6595 swig_obj[0] = args;
6596 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6597 if (!SWIG_IsOK(res1)) {
6598 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetSize" "', expected argument " "1"" of type '" "wxRect const *""'");
6599 }
6600 arg1 = reinterpret_cast< wxRect * >(argp1);
6601 {
6602 PyThreadState* __tstate = wxPyBeginAllowThreads();
6603 result = ((wxRect const *)arg1)->GetSize();
6604 wxPyEndAllowThreads(__tstate);
6605 if (PyErr_Occurred()) SWIG_fail;
6606 }
6607 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
6608 return resultobj;
6609 fail:
6610 return NULL;
6611 }
6612
6613
6614 SWIGINTERN PyObject *_wrap_Rect_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6615 PyObject *resultobj = 0;
6616 wxRect *arg1 = (wxRect *) 0 ;
6617 wxSize *arg2 = 0 ;
6618 void *argp1 = 0 ;
6619 int res1 = 0 ;
6620 wxSize temp2 ;
6621 PyObject * obj0 = 0 ;
6622 PyObject * obj1 = 0 ;
6623 char * kwnames[] = {
6624 (char *) "self",(char *) "s", NULL
6625 };
6626
6627 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
6628 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6629 if (!SWIG_IsOK(res1)) {
6630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetSize" "', expected argument " "1"" of type '" "wxRect *""'");
6631 }
6632 arg1 = reinterpret_cast< wxRect * >(argp1);
6633 {
6634 arg2 = &temp2;
6635 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
6636 }
6637 {
6638 PyThreadState* __tstate = wxPyBeginAllowThreads();
6639 (arg1)->SetSize((wxSize const &)*arg2);
6640 wxPyEndAllowThreads(__tstate);
6641 if (PyErr_Occurred()) SWIG_fail;
6642 }
6643 resultobj = SWIG_Py_Void();
6644 return resultobj;
6645 fail:
6646 return NULL;
6647 }
6648
6649
6650 SWIGINTERN PyObject *_wrap_Rect_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6651 PyObject *resultobj = 0;
6652 wxRect *arg1 = (wxRect *) 0 ;
6653 bool result;
6654 void *argp1 = 0 ;
6655 int res1 = 0 ;
6656 PyObject *swig_obj[1] ;
6657
6658 if (!args) SWIG_fail;
6659 swig_obj[0] = args;
6660 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6661 if (!SWIG_IsOK(res1)) {
6662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_IsEmpty" "', expected argument " "1"" of type '" "wxRect const *""'");
6663 }
6664 arg1 = reinterpret_cast< wxRect * >(argp1);
6665 {
6666 PyThreadState* __tstate = wxPyBeginAllowThreads();
6667 result = (bool)((wxRect const *)arg1)->IsEmpty();
6668 wxPyEndAllowThreads(__tstate);
6669 if (PyErr_Occurred()) SWIG_fail;
6670 }
6671 {
6672 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
6673 }
6674 return resultobj;
6675 fail:
6676 return NULL;
6677 }
6678
6679
6680 SWIGINTERN PyObject *_wrap_Rect_GetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6681 PyObject *resultobj = 0;
6682 wxRect *arg1 = (wxRect *) 0 ;
6683 wxPoint result;
6684 void *argp1 = 0 ;
6685 int res1 = 0 ;
6686 PyObject *swig_obj[1] ;
6687
6688 if (!args) SWIG_fail;
6689 swig_obj[0] = args;
6690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6691 if (!SWIG_IsOK(res1)) {
6692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTopLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6693 }
6694 arg1 = reinterpret_cast< wxRect * >(argp1);
6695 {
6696 PyThreadState* __tstate = wxPyBeginAllowThreads();
6697 result = ((wxRect const *)arg1)->GetTopLeft();
6698 wxPyEndAllowThreads(__tstate);
6699 if (PyErr_Occurred()) SWIG_fail;
6700 }
6701 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6702 return resultobj;
6703 fail:
6704 return NULL;
6705 }
6706
6707
6708 SWIGINTERN PyObject *_wrap_Rect_SetTopLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6709 PyObject *resultobj = 0;
6710 wxRect *arg1 = (wxRect *) 0 ;
6711 wxPoint *arg2 = 0 ;
6712 void *argp1 = 0 ;
6713 int res1 = 0 ;
6714 wxPoint temp2 ;
6715 PyObject * obj0 = 0 ;
6716 PyObject * obj1 = 0 ;
6717 char * kwnames[] = {
6718 (char *) "self",(char *) "p", NULL
6719 };
6720
6721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTopLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6723 if (!SWIG_IsOK(res1)) {
6724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTopLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6725 }
6726 arg1 = reinterpret_cast< wxRect * >(argp1);
6727 {
6728 arg2 = &temp2;
6729 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6730 }
6731 {
6732 PyThreadState* __tstate = wxPyBeginAllowThreads();
6733 (arg1)->SetTopLeft((wxPoint const &)*arg2);
6734 wxPyEndAllowThreads(__tstate);
6735 if (PyErr_Occurred()) SWIG_fail;
6736 }
6737 resultobj = SWIG_Py_Void();
6738 return resultobj;
6739 fail:
6740 return NULL;
6741 }
6742
6743
6744 SWIGINTERN PyObject *_wrap_Rect_GetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6745 PyObject *resultobj = 0;
6746 wxRect *arg1 = (wxRect *) 0 ;
6747 wxPoint result;
6748 void *argp1 = 0 ;
6749 int res1 = 0 ;
6750 PyObject *swig_obj[1] ;
6751
6752 if (!args) SWIG_fail;
6753 swig_obj[0] = args;
6754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6755 if (!SWIG_IsOK(res1)) {
6756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottomRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6757 }
6758 arg1 = reinterpret_cast< wxRect * >(argp1);
6759 {
6760 PyThreadState* __tstate = wxPyBeginAllowThreads();
6761 result = ((wxRect const *)arg1)->GetBottomRight();
6762 wxPyEndAllowThreads(__tstate);
6763 if (PyErr_Occurred()) SWIG_fail;
6764 }
6765 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
6766 return resultobj;
6767 fail:
6768 return NULL;
6769 }
6770
6771
6772 SWIGINTERN PyObject *_wrap_Rect_SetBottomRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6773 PyObject *resultobj = 0;
6774 wxRect *arg1 = (wxRect *) 0 ;
6775 wxPoint *arg2 = 0 ;
6776 void *argp1 = 0 ;
6777 int res1 = 0 ;
6778 wxPoint temp2 ;
6779 PyObject * obj0 = 0 ;
6780 PyObject * obj1 = 0 ;
6781 char * kwnames[] = {
6782 (char *) "self",(char *) "p", NULL
6783 };
6784
6785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottomRight",kwnames,&obj0,&obj1)) SWIG_fail;
6786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6787 if (!SWIG_IsOK(res1)) {
6788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottomRight" "', expected argument " "1"" of type '" "wxRect *""'");
6789 }
6790 arg1 = reinterpret_cast< wxRect * >(argp1);
6791 {
6792 arg2 = &temp2;
6793 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
6794 }
6795 {
6796 PyThreadState* __tstate = wxPyBeginAllowThreads();
6797 (arg1)->SetBottomRight((wxPoint const &)*arg2);
6798 wxPyEndAllowThreads(__tstate);
6799 if (PyErr_Occurred()) SWIG_fail;
6800 }
6801 resultobj = SWIG_Py_Void();
6802 return resultobj;
6803 fail:
6804 return NULL;
6805 }
6806
6807
6808 SWIGINTERN PyObject *_wrap_Rect_GetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6809 PyObject *resultobj = 0;
6810 wxRect *arg1 = (wxRect *) 0 ;
6811 int result;
6812 void *argp1 = 0 ;
6813 int res1 = 0 ;
6814 PyObject *swig_obj[1] ;
6815
6816 if (!args) SWIG_fail;
6817 swig_obj[0] = args;
6818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6819 if (!SWIG_IsOK(res1)) {
6820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetLeft" "', expected argument " "1"" of type '" "wxRect const *""'");
6821 }
6822 arg1 = reinterpret_cast< wxRect * >(argp1);
6823 {
6824 PyThreadState* __tstate = wxPyBeginAllowThreads();
6825 result = (int)((wxRect const *)arg1)->GetLeft();
6826 wxPyEndAllowThreads(__tstate);
6827 if (PyErr_Occurred()) SWIG_fail;
6828 }
6829 resultobj = SWIG_From_int(static_cast< int >(result));
6830 return resultobj;
6831 fail:
6832 return NULL;
6833 }
6834
6835
6836 SWIGINTERN PyObject *_wrap_Rect_GetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6837 PyObject *resultobj = 0;
6838 wxRect *arg1 = (wxRect *) 0 ;
6839 int result;
6840 void *argp1 = 0 ;
6841 int res1 = 0 ;
6842 PyObject *swig_obj[1] ;
6843
6844 if (!args) SWIG_fail;
6845 swig_obj[0] = args;
6846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6847 if (!SWIG_IsOK(res1)) {
6848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetTop" "', expected argument " "1"" of type '" "wxRect const *""'");
6849 }
6850 arg1 = reinterpret_cast< wxRect * >(argp1);
6851 {
6852 PyThreadState* __tstate = wxPyBeginAllowThreads();
6853 result = (int)((wxRect const *)arg1)->GetTop();
6854 wxPyEndAllowThreads(__tstate);
6855 if (PyErr_Occurred()) SWIG_fail;
6856 }
6857 resultobj = SWIG_From_int(static_cast< int >(result));
6858 return resultobj;
6859 fail:
6860 return NULL;
6861 }
6862
6863
6864 SWIGINTERN PyObject *_wrap_Rect_GetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6865 PyObject *resultobj = 0;
6866 wxRect *arg1 = (wxRect *) 0 ;
6867 int result;
6868 void *argp1 = 0 ;
6869 int res1 = 0 ;
6870 PyObject *swig_obj[1] ;
6871
6872 if (!args) SWIG_fail;
6873 swig_obj[0] = args;
6874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6875 if (!SWIG_IsOK(res1)) {
6876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetBottom" "', expected argument " "1"" of type '" "wxRect const *""'");
6877 }
6878 arg1 = reinterpret_cast< wxRect * >(argp1);
6879 {
6880 PyThreadState* __tstate = wxPyBeginAllowThreads();
6881 result = (int)((wxRect const *)arg1)->GetBottom();
6882 wxPyEndAllowThreads(__tstate);
6883 if (PyErr_Occurred()) SWIG_fail;
6884 }
6885 resultobj = SWIG_From_int(static_cast< int >(result));
6886 return resultobj;
6887 fail:
6888 return NULL;
6889 }
6890
6891
6892 SWIGINTERN PyObject *_wrap_Rect_GetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
6893 PyObject *resultobj = 0;
6894 wxRect *arg1 = (wxRect *) 0 ;
6895 int result;
6896 void *argp1 = 0 ;
6897 int res1 = 0 ;
6898 PyObject *swig_obj[1] ;
6899
6900 if (!args) SWIG_fail;
6901 swig_obj[0] = args;
6902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6903 if (!SWIG_IsOK(res1)) {
6904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_GetRight" "', expected argument " "1"" of type '" "wxRect const *""'");
6905 }
6906 arg1 = reinterpret_cast< wxRect * >(argp1);
6907 {
6908 PyThreadState* __tstate = wxPyBeginAllowThreads();
6909 result = (int)((wxRect const *)arg1)->GetRight();
6910 wxPyEndAllowThreads(__tstate);
6911 if (PyErr_Occurred()) SWIG_fail;
6912 }
6913 resultobj = SWIG_From_int(static_cast< int >(result));
6914 return resultobj;
6915 fail:
6916 return NULL;
6917 }
6918
6919
6920 SWIGINTERN PyObject *_wrap_Rect_SetLeft(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6921 PyObject *resultobj = 0;
6922 wxRect *arg1 = (wxRect *) 0 ;
6923 int arg2 ;
6924 void *argp1 = 0 ;
6925 int res1 = 0 ;
6926 int val2 ;
6927 int ecode2 = 0 ;
6928 PyObject * obj0 = 0 ;
6929 PyObject * obj1 = 0 ;
6930 char * kwnames[] = {
6931 (char *) "self",(char *) "left", NULL
6932 };
6933
6934 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetLeft",kwnames,&obj0,&obj1)) SWIG_fail;
6935 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6936 if (!SWIG_IsOK(res1)) {
6937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetLeft" "', expected argument " "1"" of type '" "wxRect *""'");
6938 }
6939 arg1 = reinterpret_cast< wxRect * >(argp1);
6940 ecode2 = SWIG_AsVal_int(obj1, &val2);
6941 if (!SWIG_IsOK(ecode2)) {
6942 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetLeft" "', expected argument " "2"" of type '" "int""'");
6943 }
6944 arg2 = static_cast< int >(val2);
6945 {
6946 PyThreadState* __tstate = wxPyBeginAllowThreads();
6947 (arg1)->SetLeft(arg2);
6948 wxPyEndAllowThreads(__tstate);
6949 if (PyErr_Occurred()) SWIG_fail;
6950 }
6951 resultobj = SWIG_Py_Void();
6952 return resultobj;
6953 fail:
6954 return NULL;
6955 }
6956
6957
6958 SWIGINTERN PyObject *_wrap_Rect_SetRight(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6959 PyObject *resultobj = 0;
6960 wxRect *arg1 = (wxRect *) 0 ;
6961 int arg2 ;
6962 void *argp1 = 0 ;
6963 int res1 = 0 ;
6964 int val2 ;
6965 int ecode2 = 0 ;
6966 PyObject * obj0 = 0 ;
6967 PyObject * obj1 = 0 ;
6968 char * kwnames[] = {
6969 (char *) "self",(char *) "right", NULL
6970 };
6971
6972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetRight",kwnames,&obj0,&obj1)) SWIG_fail;
6973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
6974 if (!SWIG_IsOK(res1)) {
6975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetRight" "', expected argument " "1"" of type '" "wxRect *""'");
6976 }
6977 arg1 = reinterpret_cast< wxRect * >(argp1);
6978 ecode2 = SWIG_AsVal_int(obj1, &val2);
6979 if (!SWIG_IsOK(ecode2)) {
6980 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetRight" "', expected argument " "2"" of type '" "int""'");
6981 }
6982 arg2 = static_cast< int >(val2);
6983 {
6984 PyThreadState* __tstate = wxPyBeginAllowThreads();
6985 (arg1)->SetRight(arg2);
6986 wxPyEndAllowThreads(__tstate);
6987 if (PyErr_Occurred()) SWIG_fail;
6988 }
6989 resultobj = SWIG_Py_Void();
6990 return resultobj;
6991 fail:
6992 return NULL;
6993 }
6994
6995
6996 SWIGINTERN PyObject *_wrap_Rect_SetTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
6997 PyObject *resultobj = 0;
6998 wxRect *arg1 = (wxRect *) 0 ;
6999 int arg2 ;
7000 void *argp1 = 0 ;
7001 int res1 = 0 ;
7002 int val2 ;
7003 int ecode2 = 0 ;
7004 PyObject * obj0 = 0 ;
7005 PyObject * obj1 = 0 ;
7006 char * kwnames[] = {
7007 (char *) "self",(char *) "top", NULL
7008 };
7009
7010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetTop",kwnames,&obj0,&obj1)) SWIG_fail;
7011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7012 if (!SWIG_IsOK(res1)) {
7013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetTop" "', expected argument " "1"" of type '" "wxRect *""'");
7014 }
7015 arg1 = reinterpret_cast< wxRect * >(argp1);
7016 ecode2 = SWIG_AsVal_int(obj1, &val2);
7017 if (!SWIG_IsOK(ecode2)) {
7018 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetTop" "', expected argument " "2"" of type '" "int""'");
7019 }
7020 arg2 = static_cast< int >(val2);
7021 {
7022 PyThreadState* __tstate = wxPyBeginAllowThreads();
7023 (arg1)->SetTop(arg2);
7024 wxPyEndAllowThreads(__tstate);
7025 if (PyErr_Occurred()) SWIG_fail;
7026 }
7027 resultobj = SWIG_Py_Void();
7028 return resultobj;
7029 fail:
7030 return NULL;
7031 }
7032
7033
7034 SWIGINTERN PyObject *_wrap_Rect_SetBottom(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7035 PyObject *resultobj = 0;
7036 wxRect *arg1 = (wxRect *) 0 ;
7037 int arg2 ;
7038 void *argp1 = 0 ;
7039 int res1 = 0 ;
7040 int val2 ;
7041 int ecode2 = 0 ;
7042 PyObject * obj0 = 0 ;
7043 PyObject * obj1 = 0 ;
7044 char * kwnames[] = {
7045 (char *) "self",(char *) "bottom", NULL
7046 };
7047
7048 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_SetBottom",kwnames,&obj0,&obj1)) SWIG_fail;
7049 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7050 if (!SWIG_IsOK(res1)) {
7051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_SetBottom" "', expected argument " "1"" of type '" "wxRect *""'");
7052 }
7053 arg1 = reinterpret_cast< wxRect * >(argp1);
7054 ecode2 = SWIG_AsVal_int(obj1, &val2);
7055 if (!SWIG_IsOK(ecode2)) {
7056 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_SetBottom" "', expected argument " "2"" of type '" "int""'");
7057 }
7058 arg2 = static_cast< int >(val2);
7059 {
7060 PyThreadState* __tstate = wxPyBeginAllowThreads();
7061 (arg1)->SetBottom(arg2);
7062 wxPyEndAllowThreads(__tstate);
7063 if (PyErr_Occurred()) SWIG_fail;
7064 }
7065 resultobj = SWIG_Py_Void();
7066 return resultobj;
7067 fail:
7068 return NULL;
7069 }
7070
7071
7072 SWIGINTERN PyObject *_wrap_Rect_Inflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7073 PyObject *resultobj = 0;
7074 wxRect *arg1 = (wxRect *) 0 ;
7075 int arg2 ;
7076 int arg3 ;
7077 wxRect *result = 0 ;
7078 void *argp1 = 0 ;
7079 int res1 = 0 ;
7080 int val2 ;
7081 int ecode2 = 0 ;
7082 int val3 ;
7083 int ecode3 = 0 ;
7084 PyObject * obj0 = 0 ;
7085 PyObject * obj1 = 0 ;
7086 PyObject * obj2 = 0 ;
7087 char * kwnames[] = {
7088 (char *) "self",(char *) "dx",(char *) "dy", NULL
7089 };
7090
7091 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Inflate",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7092 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7093 if (!SWIG_IsOK(res1)) {
7094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inflate" "', expected argument " "1"" of type '" "wxRect *""'");
7095 }
7096 arg1 = reinterpret_cast< wxRect * >(argp1);
7097 ecode2 = SWIG_AsVal_int(obj1, &val2);
7098 if (!SWIG_IsOK(ecode2)) {
7099 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Inflate" "', expected argument " "2"" of type '" "int""'");
7100 }
7101 arg2 = static_cast< int >(val2);
7102 ecode3 = SWIG_AsVal_int(obj2, &val3);
7103 if (!SWIG_IsOK(ecode3)) {
7104 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Inflate" "', expected argument " "3"" of type '" "int""'");
7105 }
7106 arg3 = static_cast< int >(val3);
7107 {
7108 PyThreadState* __tstate = wxPyBeginAllowThreads();
7109 {
7110 wxRect &_result_ref = (arg1)->Inflate(arg2,arg3);
7111 result = (wxRect *) &_result_ref;
7112 }
7113 wxPyEndAllowThreads(__tstate);
7114 if (PyErr_Occurred()) SWIG_fail;
7115 }
7116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7117 return resultobj;
7118 fail:
7119 return NULL;
7120 }
7121
7122
7123 SWIGINTERN PyObject *_wrap_Rect_Deflate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7124 PyObject *resultobj = 0;
7125 wxRect *arg1 = (wxRect *) 0 ;
7126 int arg2 ;
7127 int arg3 ;
7128 wxRect *result = 0 ;
7129 void *argp1 = 0 ;
7130 int res1 = 0 ;
7131 int val2 ;
7132 int ecode2 = 0 ;
7133 int val3 ;
7134 int ecode3 = 0 ;
7135 PyObject * obj0 = 0 ;
7136 PyObject * obj1 = 0 ;
7137 PyObject * obj2 = 0 ;
7138 char * kwnames[] = {
7139 (char *) "self",(char *) "dx",(char *) "dy", NULL
7140 };
7141
7142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_Deflate",kwnames,&obj0,&obj1,&obj2)) 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_Deflate" "', 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_Deflate" "', expected argument " "2"" of type '" "int""'");
7151 }
7152 arg2 = static_cast< int >(val2);
7153 ecode3 = SWIG_AsVal_int(obj2, &val3);
7154 if (!SWIG_IsOK(ecode3)) {
7155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Deflate" "', expected argument " "3"" of type '" "int""'");
7156 }
7157 arg3 = static_cast< int >(val3);
7158 {
7159 PyThreadState* __tstate = wxPyBeginAllowThreads();
7160 {
7161 wxRect &_result_ref = (arg1)->Deflate(arg2,arg3);
7162 result = (wxRect *) &_result_ref;
7163 }
7164 wxPyEndAllowThreads(__tstate);
7165 if (PyErr_Occurred()) SWIG_fail;
7166 }
7167 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
7168 return resultobj;
7169 fail:
7170 return NULL;
7171 }
7172
7173
7174 SWIGINTERN PyObject *_wrap_Rect_OffsetXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7175 PyObject *resultobj = 0;
7176 wxRect *arg1 = (wxRect *) 0 ;
7177 int arg2 ;
7178 int arg3 ;
7179 void *argp1 = 0 ;
7180 int res1 = 0 ;
7181 int val2 ;
7182 int ecode2 = 0 ;
7183 int val3 ;
7184 int ecode3 = 0 ;
7185 PyObject * obj0 = 0 ;
7186 PyObject * obj1 = 0 ;
7187 PyObject * obj2 = 0 ;
7188 char * kwnames[] = {
7189 (char *) "self",(char *) "dx",(char *) "dy", NULL
7190 };
7191
7192 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_OffsetXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7193 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7194 if (!SWIG_IsOK(res1)) {
7195 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_OffsetXY" "', expected argument " "1"" of type '" "wxRect *""'");
7196 }
7197 arg1 = reinterpret_cast< wxRect * >(argp1);
7198 ecode2 = SWIG_AsVal_int(obj1, &val2);
7199 if (!SWIG_IsOK(ecode2)) {
7200 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_OffsetXY" "', expected argument " "2"" of type '" "int""'");
7201 }
7202 arg2 = static_cast< int >(val2);
7203 ecode3 = SWIG_AsVal_int(obj2, &val3);
7204 if (!SWIG_IsOK(ecode3)) {
7205 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_OffsetXY" "', expected argument " "3"" of type '" "int""'");
7206 }
7207 arg3 = static_cast< int >(val3);
7208 {
7209 PyThreadState* __tstate = wxPyBeginAllowThreads();
7210 (arg1)->Offset(arg2,arg3);
7211 wxPyEndAllowThreads(__tstate);
7212 if (PyErr_Occurred()) SWIG_fail;
7213 }
7214 resultobj = SWIG_Py_Void();
7215 return resultobj;
7216 fail:
7217 return NULL;
7218 }
7219
7220
7221 SWIGINTERN PyObject *_wrap_Rect_Offset(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7222 PyObject *resultobj = 0;
7223 wxRect *arg1 = (wxRect *) 0 ;
7224 wxPoint *arg2 = 0 ;
7225 void *argp1 = 0 ;
7226 int res1 = 0 ;
7227 wxPoint temp2 ;
7228 PyObject * obj0 = 0 ;
7229 PyObject * obj1 = 0 ;
7230 char * kwnames[] = {
7231 (char *) "self",(char *) "pt", NULL
7232 };
7233
7234 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Offset",kwnames,&obj0,&obj1)) SWIG_fail;
7235 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7236 if (!SWIG_IsOK(res1)) {
7237 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Offset" "', expected argument " "1"" of type '" "wxRect *""'");
7238 }
7239 arg1 = reinterpret_cast< wxRect * >(argp1);
7240 {
7241 arg2 = &temp2;
7242 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7243 }
7244 {
7245 PyThreadState* __tstate = wxPyBeginAllowThreads();
7246 (arg1)->Offset((wxPoint const &)*arg2);
7247 wxPyEndAllowThreads(__tstate);
7248 if (PyErr_Occurred()) SWIG_fail;
7249 }
7250 resultobj = SWIG_Py_Void();
7251 return resultobj;
7252 fail:
7253 return NULL;
7254 }
7255
7256
7257 SWIGINTERN PyObject *_wrap_Rect_Intersect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7258 PyObject *resultobj = 0;
7259 wxRect *arg1 = (wxRect *) 0 ;
7260 wxRect *arg2 = 0 ;
7261 wxRect result;
7262 void *argp1 = 0 ;
7263 int res1 = 0 ;
7264 wxRect temp2 ;
7265 PyObject * obj0 = 0 ;
7266 PyObject * obj1 = 0 ;
7267 char * kwnames[] = {
7268 (char *) "self",(char *) "rect", NULL
7269 };
7270
7271 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersect",kwnames,&obj0,&obj1)) SWIG_fail;
7272 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7273 if (!SWIG_IsOK(res1)) {
7274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersect" "', expected argument " "1"" of type '" "wxRect *""'");
7275 }
7276 arg1 = reinterpret_cast< wxRect * >(argp1);
7277 {
7278 arg2 = &temp2;
7279 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7280 }
7281 {
7282 PyThreadState* __tstate = wxPyBeginAllowThreads();
7283 result = (arg1)->Intersect((wxRect const &)*arg2);
7284 wxPyEndAllowThreads(__tstate);
7285 if (PyErr_Occurred()) SWIG_fail;
7286 }
7287 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7288 return resultobj;
7289 fail:
7290 return NULL;
7291 }
7292
7293
7294 SWIGINTERN PyObject *_wrap_Rect_Union(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7295 PyObject *resultobj = 0;
7296 wxRect *arg1 = (wxRect *) 0 ;
7297 wxRect *arg2 = 0 ;
7298 wxRect result;
7299 void *argp1 = 0 ;
7300 int res1 = 0 ;
7301 wxRect temp2 ;
7302 PyObject * obj0 = 0 ;
7303 PyObject * obj1 = 0 ;
7304 char * kwnames[] = {
7305 (char *) "self",(char *) "rect", NULL
7306 };
7307
7308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Union",kwnames,&obj0,&obj1)) SWIG_fail;
7309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7310 if (!SWIG_IsOK(res1)) {
7311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Union" "', expected argument " "1"" of type '" "wxRect *""'");
7312 }
7313 arg1 = reinterpret_cast< wxRect * >(argp1);
7314 {
7315 arg2 = &temp2;
7316 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7317 }
7318 {
7319 PyThreadState* __tstate = wxPyBeginAllowThreads();
7320 result = (arg1)->Union((wxRect const &)*arg2);
7321 wxPyEndAllowThreads(__tstate);
7322 if (PyErr_Occurred()) SWIG_fail;
7323 }
7324 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7325 return resultobj;
7326 fail:
7327 return NULL;
7328 }
7329
7330
7331 SWIGINTERN PyObject *_wrap_Rect___add__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7332 PyObject *resultobj = 0;
7333 wxRect *arg1 = (wxRect *) 0 ;
7334 wxRect *arg2 = 0 ;
7335 wxRect result;
7336 void *argp1 = 0 ;
7337 int res1 = 0 ;
7338 wxRect temp2 ;
7339 PyObject * obj0 = 0 ;
7340 PyObject * obj1 = 0 ;
7341 char * kwnames[] = {
7342 (char *) "self",(char *) "rect", NULL
7343 };
7344
7345 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___add__",kwnames,&obj0,&obj1)) SWIG_fail;
7346 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7347 if (!SWIG_IsOK(res1)) {
7348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___add__" "', expected argument " "1"" of type '" "wxRect const *""'");
7349 }
7350 arg1 = reinterpret_cast< wxRect * >(argp1);
7351 {
7352 arg2 = &temp2;
7353 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7354 }
7355 {
7356 PyThreadState* __tstate = wxPyBeginAllowThreads();
7357 result = ((wxRect const *)arg1)->operator +((wxRect const &)*arg2);
7358 wxPyEndAllowThreads(__tstate);
7359 if (PyErr_Occurred()) SWIG_fail;
7360 }
7361 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7362 return resultobj;
7363 fail:
7364 return NULL;
7365 }
7366
7367
7368 SWIGINTERN PyObject *_wrap_Rect___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7369 PyObject *resultobj = 0;
7370 wxRect *arg1 = (wxRect *) 0 ;
7371 wxRect *arg2 = 0 ;
7372 wxRect *result = 0 ;
7373 void *argp1 = 0 ;
7374 int res1 = 0 ;
7375 wxRect temp2 ;
7376 PyObject * obj0 = 0 ;
7377 PyObject * obj1 = 0 ;
7378 char * kwnames[] = {
7379 (char *) "self",(char *) "rect", NULL
7380 };
7381
7382 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
7383 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, SWIG_POINTER_DISOWN | 0 );
7384 if (!SWIG_IsOK(res1)) {
7385 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___iadd__" "', expected argument " "1"" of type '" "wxRect *""'");
7386 }
7387 arg1 = reinterpret_cast< wxRect * >(argp1);
7388 {
7389 arg2 = &temp2;
7390 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7391 }
7392 {
7393 PyThreadState* __tstate = wxPyBeginAllowThreads();
7394 {
7395 wxRect &_result_ref = (arg1)->operator +=((wxRect const &)*arg2);
7396 result = (wxRect *) &_result_ref;
7397 }
7398 wxPyEndAllowThreads(__tstate);
7399 if (PyErr_Occurred()) SWIG_fail;
7400 }
7401 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7402 return resultobj;
7403 fail:
7404 return NULL;
7405 }
7406
7407
7408 SWIGINTERN PyObject *_wrap_Rect___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7409 PyObject *resultobj = 0;
7410 wxRect *arg1 = (wxRect *) 0 ;
7411 PyObject *arg2 = (PyObject *) 0 ;
7412 bool result;
7413 void *argp1 = 0 ;
7414 int res1 = 0 ;
7415 PyObject * obj0 = 0 ;
7416 PyObject * obj1 = 0 ;
7417 char * kwnames[] = {
7418 (char *) "self",(char *) "other", NULL
7419 };
7420
7421 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
7422 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7423 if (!SWIG_IsOK(res1)) {
7424 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___eq__" "', expected argument " "1"" of type '" "wxRect *""'");
7425 }
7426 arg1 = reinterpret_cast< wxRect * >(argp1);
7427 arg2 = obj1;
7428 {
7429 result = (bool)wxRect___eq__(arg1,arg2);
7430 if (PyErr_Occurred()) SWIG_fail;
7431 }
7432 {
7433 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7434 }
7435 return resultobj;
7436 fail:
7437 return NULL;
7438 }
7439
7440
7441 SWIGINTERN PyObject *_wrap_Rect___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7442 PyObject *resultobj = 0;
7443 wxRect *arg1 = (wxRect *) 0 ;
7444 PyObject *arg2 = (PyObject *) 0 ;
7445 bool result;
7446 void *argp1 = 0 ;
7447 int res1 = 0 ;
7448 PyObject * obj0 = 0 ;
7449 PyObject * obj1 = 0 ;
7450 char * kwnames[] = {
7451 (char *) "self",(char *) "other", NULL
7452 };
7453
7454 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
7455 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7456 if (!SWIG_IsOK(res1)) {
7457 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect___ne__" "', expected argument " "1"" of type '" "wxRect *""'");
7458 }
7459 arg1 = reinterpret_cast< wxRect * >(argp1);
7460 arg2 = obj1;
7461 {
7462 result = (bool)wxRect___ne__(arg1,arg2);
7463 if (PyErr_Occurred()) SWIG_fail;
7464 }
7465 {
7466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7467 }
7468 return resultobj;
7469 fail:
7470 return NULL;
7471 }
7472
7473
7474 SWIGINTERN PyObject *_wrap_Rect_InsideXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7475 PyObject *resultobj = 0;
7476 wxRect *arg1 = (wxRect *) 0 ;
7477 int arg2 ;
7478 int arg3 ;
7479 bool result;
7480 void *argp1 = 0 ;
7481 int res1 = 0 ;
7482 int val2 ;
7483 int ecode2 = 0 ;
7484 int val3 ;
7485 int ecode3 = 0 ;
7486 PyObject * obj0 = 0 ;
7487 PyObject * obj1 = 0 ;
7488 PyObject * obj2 = 0 ;
7489 char * kwnames[] = {
7490 (char *) "self",(char *) "x",(char *) "y", NULL
7491 };
7492
7493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Rect_InsideXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7495 if (!SWIG_IsOK(res1)) {
7496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_InsideXY" "', expected argument " "1"" of type '" "wxRect const *""'");
7497 }
7498 arg1 = reinterpret_cast< wxRect * >(argp1);
7499 ecode2 = SWIG_AsVal_int(obj1, &val2);
7500 if (!SWIG_IsOK(ecode2)) {
7501 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_InsideXY" "', expected argument " "2"" of type '" "int""'");
7502 }
7503 arg2 = static_cast< int >(val2);
7504 ecode3 = SWIG_AsVal_int(obj2, &val3);
7505 if (!SWIG_IsOK(ecode3)) {
7506 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_InsideXY" "', expected argument " "3"" of type '" "int""'");
7507 }
7508 arg3 = static_cast< int >(val3);
7509 {
7510 PyThreadState* __tstate = wxPyBeginAllowThreads();
7511 result = (bool)((wxRect const *)arg1)->Inside(arg2,arg3);
7512 wxPyEndAllowThreads(__tstate);
7513 if (PyErr_Occurred()) SWIG_fail;
7514 }
7515 {
7516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7517 }
7518 return resultobj;
7519 fail:
7520 return NULL;
7521 }
7522
7523
7524 SWIGINTERN PyObject *_wrap_Rect_Inside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7525 PyObject *resultobj = 0;
7526 wxRect *arg1 = (wxRect *) 0 ;
7527 wxPoint *arg2 = 0 ;
7528 bool result;
7529 void *argp1 = 0 ;
7530 int res1 = 0 ;
7531 wxPoint temp2 ;
7532 PyObject * obj0 = 0 ;
7533 PyObject * obj1 = 0 ;
7534 char * kwnames[] = {
7535 (char *) "self",(char *) "pt", NULL
7536 };
7537
7538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Inside",kwnames,&obj0,&obj1)) SWIG_fail;
7539 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7540 if (!SWIG_IsOK(res1)) {
7541 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Inside" "', expected argument " "1"" of type '" "wxRect const *""'");
7542 }
7543 arg1 = reinterpret_cast< wxRect * >(argp1);
7544 {
7545 arg2 = &temp2;
7546 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
7547 }
7548 {
7549 PyThreadState* __tstate = wxPyBeginAllowThreads();
7550 result = (bool)((wxRect const *)arg1)->Inside((wxPoint const &)*arg2);
7551 wxPyEndAllowThreads(__tstate);
7552 if (PyErr_Occurred()) SWIG_fail;
7553 }
7554 {
7555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7556 }
7557 return resultobj;
7558 fail:
7559 return NULL;
7560 }
7561
7562
7563 SWIGINTERN PyObject *_wrap_Rect_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7564 PyObject *resultobj = 0;
7565 wxRect *arg1 = (wxRect *) 0 ;
7566 wxRect *arg2 = 0 ;
7567 bool result;
7568 void *argp1 = 0 ;
7569 int res1 = 0 ;
7570 wxRect temp2 ;
7571 PyObject * obj0 = 0 ;
7572 PyObject * obj1 = 0 ;
7573 char * kwnames[] = {
7574 (char *) "self",(char *) "rect", NULL
7575 };
7576
7577 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Rect_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
7578 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7579 if (!SWIG_IsOK(res1)) {
7580 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Intersects" "', expected argument " "1"" of type '" "wxRect const *""'");
7581 }
7582 arg1 = reinterpret_cast< wxRect * >(argp1);
7583 {
7584 arg2 = &temp2;
7585 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7586 }
7587 {
7588 PyThreadState* __tstate = wxPyBeginAllowThreads();
7589 result = (bool)((wxRect const *)arg1)->Intersects((wxRect const &)*arg2);
7590 wxPyEndAllowThreads(__tstate);
7591 if (PyErr_Occurred()) SWIG_fail;
7592 }
7593 {
7594 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
7595 }
7596 return resultobj;
7597 fail:
7598 return NULL;
7599 }
7600
7601
7602 SWIGINTERN PyObject *_wrap_Rect_CenterIn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7603 PyObject *resultobj = 0;
7604 wxRect *arg1 = (wxRect *) 0 ;
7605 wxRect *arg2 = 0 ;
7606 int arg3 = (int) wxBOTH ;
7607 wxRect result;
7608 void *argp1 = 0 ;
7609 int res1 = 0 ;
7610 wxRect temp2 ;
7611 int val3 ;
7612 int ecode3 = 0 ;
7613 PyObject * obj0 = 0 ;
7614 PyObject * obj1 = 0 ;
7615 PyObject * obj2 = 0 ;
7616 char * kwnames[] = {
7617 (char *) "self",(char *) "r",(char *) "dir", NULL
7618 };
7619
7620 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Rect_CenterIn",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
7621 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7622 if (!SWIG_IsOK(res1)) {
7623 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_CenterIn" "', expected argument " "1"" of type '" "wxRect *""'");
7624 }
7625 arg1 = reinterpret_cast< wxRect * >(argp1);
7626 {
7627 arg2 = &temp2;
7628 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
7629 }
7630 if (obj2) {
7631 ecode3 = SWIG_AsVal_int(obj2, &val3);
7632 if (!SWIG_IsOK(ecode3)) {
7633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_CenterIn" "', expected argument " "3"" of type '" "int""'");
7634 }
7635 arg3 = static_cast< int >(val3);
7636 }
7637 {
7638 PyThreadState* __tstate = wxPyBeginAllowThreads();
7639 result = (arg1)->CenterIn((wxRect const &)*arg2,arg3);
7640 wxPyEndAllowThreads(__tstate);
7641 if (PyErr_Occurred()) SWIG_fail;
7642 }
7643 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
7644 return resultobj;
7645 fail:
7646 return NULL;
7647 }
7648
7649
7650 SWIGINTERN PyObject *_wrap_Rect_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7651 PyObject *resultobj = 0;
7652 wxRect *arg1 = (wxRect *) 0 ;
7653 int arg2 ;
7654 void *argp1 = 0 ;
7655 int res1 = 0 ;
7656 int val2 ;
7657 int ecode2 = 0 ;
7658 PyObject *swig_obj[2] ;
7659
7660 if (!SWIG_Python_UnpackTuple(args,"Rect_x_set",2,2,swig_obj)) SWIG_fail;
7661 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7662 if (!SWIG_IsOK(res1)) {
7663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_set" "', expected argument " "1"" of type '" "wxRect *""'");
7664 }
7665 arg1 = reinterpret_cast< wxRect * >(argp1);
7666 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7667 if (!SWIG_IsOK(ecode2)) {
7668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_x_set" "', expected argument " "2"" of type '" "int""'");
7669 }
7670 arg2 = static_cast< int >(val2);
7671 if (arg1) (arg1)->x = arg2;
7672
7673 resultobj = SWIG_Py_Void();
7674 return resultobj;
7675 fail:
7676 return NULL;
7677 }
7678
7679
7680 SWIGINTERN PyObject *_wrap_Rect_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7681 PyObject *resultobj = 0;
7682 wxRect *arg1 = (wxRect *) 0 ;
7683 int result;
7684 void *argp1 = 0 ;
7685 int res1 = 0 ;
7686 PyObject *swig_obj[1] ;
7687
7688 if (!args) SWIG_fail;
7689 swig_obj[0] = args;
7690 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7691 if (!SWIG_IsOK(res1)) {
7692 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_x_get" "', expected argument " "1"" of type '" "wxRect *""'");
7693 }
7694 arg1 = reinterpret_cast< wxRect * >(argp1);
7695 result = (int) ((arg1)->x);
7696 resultobj = SWIG_From_int(static_cast< int >(result));
7697 return resultobj;
7698 fail:
7699 return NULL;
7700 }
7701
7702
7703 SWIGINTERN PyObject *_wrap_Rect_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7704 PyObject *resultobj = 0;
7705 wxRect *arg1 = (wxRect *) 0 ;
7706 int arg2 ;
7707 void *argp1 = 0 ;
7708 int res1 = 0 ;
7709 int val2 ;
7710 int ecode2 = 0 ;
7711 PyObject *swig_obj[2] ;
7712
7713 if (!SWIG_Python_UnpackTuple(args,"Rect_y_set",2,2,swig_obj)) SWIG_fail;
7714 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7715 if (!SWIG_IsOK(res1)) {
7716 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_set" "', expected argument " "1"" of type '" "wxRect *""'");
7717 }
7718 arg1 = reinterpret_cast< wxRect * >(argp1);
7719 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7720 if (!SWIG_IsOK(ecode2)) {
7721 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_y_set" "', expected argument " "2"" of type '" "int""'");
7722 }
7723 arg2 = static_cast< int >(val2);
7724 if (arg1) (arg1)->y = arg2;
7725
7726 resultobj = SWIG_Py_Void();
7727 return resultobj;
7728 fail:
7729 return NULL;
7730 }
7731
7732
7733 SWIGINTERN PyObject *_wrap_Rect_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7734 PyObject *resultobj = 0;
7735 wxRect *arg1 = (wxRect *) 0 ;
7736 int result;
7737 void *argp1 = 0 ;
7738 int res1 = 0 ;
7739 PyObject *swig_obj[1] ;
7740
7741 if (!args) SWIG_fail;
7742 swig_obj[0] = args;
7743 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7744 if (!SWIG_IsOK(res1)) {
7745 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_y_get" "', expected argument " "1"" of type '" "wxRect *""'");
7746 }
7747 arg1 = reinterpret_cast< wxRect * >(argp1);
7748 result = (int) ((arg1)->y);
7749 resultobj = SWIG_From_int(static_cast< int >(result));
7750 return resultobj;
7751 fail:
7752 return NULL;
7753 }
7754
7755
7756 SWIGINTERN PyObject *_wrap_Rect_width_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7757 PyObject *resultobj = 0;
7758 wxRect *arg1 = (wxRect *) 0 ;
7759 int arg2 ;
7760 void *argp1 = 0 ;
7761 int res1 = 0 ;
7762 int val2 ;
7763 int ecode2 = 0 ;
7764 PyObject *swig_obj[2] ;
7765
7766 if (!SWIG_Python_UnpackTuple(args,"Rect_width_set",2,2,swig_obj)) SWIG_fail;
7767 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7768 if (!SWIG_IsOK(res1)) {
7769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_set" "', expected argument " "1"" of type '" "wxRect *""'");
7770 }
7771 arg1 = reinterpret_cast< wxRect * >(argp1);
7772 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7773 if (!SWIG_IsOK(ecode2)) {
7774 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_width_set" "', expected argument " "2"" of type '" "int""'");
7775 }
7776 arg2 = static_cast< int >(val2);
7777 if (arg1) (arg1)->width = arg2;
7778
7779 resultobj = SWIG_Py_Void();
7780 return resultobj;
7781 fail:
7782 return NULL;
7783 }
7784
7785
7786 SWIGINTERN PyObject *_wrap_Rect_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7787 PyObject *resultobj = 0;
7788 wxRect *arg1 = (wxRect *) 0 ;
7789 int result;
7790 void *argp1 = 0 ;
7791 int res1 = 0 ;
7792 PyObject *swig_obj[1] ;
7793
7794 if (!args) SWIG_fail;
7795 swig_obj[0] = args;
7796 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7797 if (!SWIG_IsOK(res1)) {
7798 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_width_get" "', expected argument " "1"" of type '" "wxRect *""'");
7799 }
7800 arg1 = reinterpret_cast< wxRect * >(argp1);
7801 result = (int) ((arg1)->width);
7802 resultobj = SWIG_From_int(static_cast< int >(result));
7803 return resultobj;
7804 fail:
7805 return NULL;
7806 }
7807
7808
7809 SWIGINTERN PyObject *_wrap_Rect_height_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7810 PyObject *resultobj = 0;
7811 wxRect *arg1 = (wxRect *) 0 ;
7812 int arg2 ;
7813 void *argp1 = 0 ;
7814 int res1 = 0 ;
7815 int val2 ;
7816 int ecode2 = 0 ;
7817 PyObject *swig_obj[2] ;
7818
7819 if (!SWIG_Python_UnpackTuple(args,"Rect_height_set",2,2,swig_obj)) SWIG_fail;
7820 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7821 if (!SWIG_IsOK(res1)) {
7822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_set" "', expected argument " "1"" of type '" "wxRect *""'");
7823 }
7824 arg1 = reinterpret_cast< wxRect * >(argp1);
7825 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
7826 if (!SWIG_IsOK(ecode2)) {
7827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_height_set" "', expected argument " "2"" of type '" "int""'");
7828 }
7829 arg2 = static_cast< int >(val2);
7830 if (arg1) (arg1)->height = arg2;
7831
7832 resultobj = SWIG_Py_Void();
7833 return resultobj;
7834 fail:
7835 return NULL;
7836 }
7837
7838
7839 SWIGINTERN PyObject *_wrap_Rect_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7840 PyObject *resultobj = 0;
7841 wxRect *arg1 = (wxRect *) 0 ;
7842 int result;
7843 void *argp1 = 0 ;
7844 int res1 = 0 ;
7845 PyObject *swig_obj[1] ;
7846
7847 if (!args) SWIG_fail;
7848 swig_obj[0] = args;
7849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7850 if (!SWIG_IsOK(res1)) {
7851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_height_get" "', expected argument " "1"" of type '" "wxRect *""'");
7852 }
7853 arg1 = reinterpret_cast< wxRect * >(argp1);
7854 result = (int) ((arg1)->height);
7855 resultobj = SWIG_From_int(static_cast< int >(result));
7856 return resultobj;
7857 fail:
7858 return NULL;
7859 }
7860
7861
7862 SWIGINTERN PyObject *_wrap_Rect_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7863 PyObject *resultobj = 0;
7864 wxRect *arg1 = (wxRect *) 0 ;
7865 int arg2 = (int) 0 ;
7866 int arg3 = (int) 0 ;
7867 int arg4 = (int) 0 ;
7868 int arg5 = (int) 0 ;
7869 void *argp1 = 0 ;
7870 int res1 = 0 ;
7871 int val2 ;
7872 int ecode2 = 0 ;
7873 int val3 ;
7874 int ecode3 = 0 ;
7875 int val4 ;
7876 int ecode4 = 0 ;
7877 int val5 ;
7878 int ecode5 = 0 ;
7879 PyObject * obj0 = 0 ;
7880 PyObject * obj1 = 0 ;
7881 PyObject * obj2 = 0 ;
7882 PyObject * obj3 = 0 ;
7883 PyObject * obj4 = 0 ;
7884 char * kwnames[] = {
7885 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
7886 };
7887
7888 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOO:Rect_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
7889 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7890 if (!SWIG_IsOK(res1)) {
7891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Set" "', expected argument " "1"" of type '" "wxRect *""'");
7892 }
7893 arg1 = reinterpret_cast< wxRect * >(argp1);
7894 if (obj1) {
7895 ecode2 = SWIG_AsVal_int(obj1, &val2);
7896 if (!SWIG_IsOK(ecode2)) {
7897 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Rect_Set" "', expected argument " "2"" of type '" "int""'");
7898 }
7899 arg2 = static_cast< int >(val2);
7900 }
7901 if (obj2) {
7902 ecode3 = SWIG_AsVal_int(obj2, &val3);
7903 if (!SWIG_IsOK(ecode3)) {
7904 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Rect_Set" "', expected argument " "3"" of type '" "int""'");
7905 }
7906 arg3 = static_cast< int >(val3);
7907 }
7908 if (obj3) {
7909 ecode4 = SWIG_AsVal_int(obj3, &val4);
7910 if (!SWIG_IsOK(ecode4)) {
7911 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Rect_Set" "', expected argument " "4"" of type '" "int""'");
7912 }
7913 arg4 = static_cast< int >(val4);
7914 }
7915 if (obj4) {
7916 ecode5 = SWIG_AsVal_int(obj4, &val5);
7917 if (!SWIG_IsOK(ecode5)) {
7918 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Rect_Set" "', expected argument " "5"" of type '" "int""'");
7919 }
7920 arg5 = static_cast< int >(val5);
7921 }
7922 {
7923 PyThreadState* __tstate = wxPyBeginAllowThreads();
7924 wxRect_Set(arg1,arg2,arg3,arg4,arg5);
7925 wxPyEndAllowThreads(__tstate);
7926 if (PyErr_Occurred()) SWIG_fail;
7927 }
7928 resultobj = SWIG_Py_Void();
7929 return resultobj;
7930 fail:
7931 return NULL;
7932 }
7933
7934
7935 SWIGINTERN PyObject *_wrap_Rect_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7936 PyObject *resultobj = 0;
7937 wxRect *arg1 = (wxRect *) 0 ;
7938 PyObject *result = 0 ;
7939 void *argp1 = 0 ;
7940 int res1 = 0 ;
7941 PyObject *swig_obj[1] ;
7942
7943 if (!args) SWIG_fail;
7944 swig_obj[0] = args;
7945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7946 if (!SWIG_IsOK(res1)) {
7947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Rect_Get" "', expected argument " "1"" of type '" "wxRect *""'");
7948 }
7949 arg1 = reinterpret_cast< wxRect * >(argp1);
7950 {
7951 PyThreadState* __tstate = wxPyBeginAllowThreads();
7952 result = (PyObject *)wxRect_Get(arg1);
7953 wxPyEndAllowThreads(__tstate);
7954 if (PyErr_Occurred()) SWIG_fail;
7955 }
7956 resultobj = result;
7957 return resultobj;
7958 fail:
7959 return NULL;
7960 }
7961
7962
7963 SWIGINTERN PyObject *Rect_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7964 PyObject *obj;
7965 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
7966 SWIG_TypeNewClientData(SWIGTYPE_p_wxRect, SWIG_NewClientData(obj));
7967 return SWIG_Py_Void();
7968 }
7969
7970 SWIGINTERN PyObject *Rect_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
7971 return SWIG_Python_InitShadowInstance(args);
7972 }
7973
7974 SWIGINTERN PyObject *_wrap_IntersectRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
7975 PyObject *resultobj = 0;
7976 wxRect *arg1 = (wxRect *) 0 ;
7977 wxRect *arg2 = (wxRect *) 0 ;
7978 PyObject *result = 0 ;
7979 void *argp1 = 0 ;
7980 int res1 = 0 ;
7981 void *argp2 = 0 ;
7982 int res2 = 0 ;
7983 PyObject * obj0 = 0 ;
7984 PyObject * obj1 = 0 ;
7985 char * kwnames[] = {
7986 (char *) "r1",(char *) "r2", NULL
7987 };
7988
7989 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IntersectRect",kwnames,&obj0,&obj1)) SWIG_fail;
7990 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxRect, 0 | 0 );
7991 if (!SWIG_IsOK(res1)) {
7992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IntersectRect" "', expected argument " "1"" of type '" "wxRect *""'");
7993 }
7994 arg1 = reinterpret_cast< wxRect * >(argp1);
7995 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
7996 if (!SWIG_IsOK(res2)) {
7997 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IntersectRect" "', expected argument " "2"" of type '" "wxRect *""'");
7998 }
7999 arg2 = reinterpret_cast< wxRect * >(argp2);
8000 {
8001 if (!wxPyCheckForApp()) SWIG_fail;
8002 PyThreadState* __tstate = wxPyBeginAllowThreads();
8003 result = (PyObject *)wxIntersectRect(arg1,arg2);
8004 wxPyEndAllowThreads(__tstate);
8005 if (PyErr_Occurred()) SWIG_fail;
8006 }
8007 resultobj = result;
8008 return resultobj;
8009 fail:
8010 return NULL;
8011 }
8012
8013
8014 SWIGINTERN PyObject *_wrap_new_Point2D(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8015 PyObject *resultobj = 0;
8016 double arg1 = (double) 0.0 ;
8017 double arg2 = (double) 0.0 ;
8018 wxPoint2D *result = 0 ;
8019 double val1 ;
8020 int ecode1 = 0 ;
8021 double val2 ;
8022 int ecode2 = 0 ;
8023 PyObject * obj0 = 0 ;
8024 PyObject * obj1 = 0 ;
8025 char * kwnames[] = {
8026 (char *) "x",(char *) "y", NULL
8027 };
8028
8029 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Point2D",kwnames,&obj0,&obj1)) SWIG_fail;
8030 if (obj0) {
8031 ecode1 = SWIG_AsVal_double(obj0, &val1);
8032 if (!SWIG_IsOK(ecode1)) {
8033 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Point2D" "', expected argument " "1"" of type '" "double""'");
8034 }
8035 arg1 = static_cast< double >(val1);
8036 }
8037 if (obj1) {
8038 ecode2 = SWIG_AsVal_double(obj1, &val2);
8039 if (!SWIG_IsOK(ecode2)) {
8040 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Point2D" "', expected argument " "2"" of type '" "double""'");
8041 }
8042 arg2 = static_cast< double >(val2);
8043 }
8044 {
8045 PyThreadState* __tstate = wxPyBeginAllowThreads();
8046 result = (wxPoint2D *)new wxPoint2D(arg1,arg2);
8047 wxPyEndAllowThreads(__tstate);
8048 if (PyErr_Occurred()) SWIG_fail;
8049 }
8050 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_NEW | 0 );
8051 return resultobj;
8052 fail:
8053 return NULL;
8054 }
8055
8056
8057 SWIGINTERN PyObject *_wrap_new_Point2DCopy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8058 PyObject *resultobj = 0;
8059 wxPoint2D *arg1 = 0 ;
8060 wxPoint2D *result = 0 ;
8061 wxPoint2D temp1 ;
8062 PyObject * obj0 = 0 ;
8063 char * kwnames[] = {
8064 (char *) "pt", NULL
8065 };
8066
8067 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DCopy",kwnames,&obj0)) SWIG_fail;
8068 {
8069 arg1 = &temp1;
8070 if ( ! wxPoint2D_helper(obj0, &arg1)) SWIG_fail;
8071 }
8072 {
8073 PyThreadState* __tstate = wxPyBeginAllowThreads();
8074 result = (wxPoint2D *)new wxPoint2D((wxPoint2D const &)*arg1);
8075 wxPyEndAllowThreads(__tstate);
8076 if (PyErr_Occurred()) SWIG_fail;
8077 }
8078 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8079 return resultobj;
8080 fail:
8081 return NULL;
8082 }
8083
8084
8085 SWIGINTERN PyObject *_wrap_new_Point2DFromPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8086 PyObject *resultobj = 0;
8087 wxPoint *arg1 = 0 ;
8088 wxPoint2D *result = 0 ;
8089 wxPoint temp1 ;
8090 PyObject * obj0 = 0 ;
8091 char * kwnames[] = {
8092 (char *) "pt", NULL
8093 };
8094
8095 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_Point2DFromPoint",kwnames,&obj0)) SWIG_fail;
8096 {
8097 arg1 = &temp1;
8098 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
8099 }
8100 {
8101 PyThreadState* __tstate = wxPyBeginAllowThreads();
8102 result = (wxPoint2D *)new wxPoint2D((wxPoint const &)*arg1);
8103 wxPyEndAllowThreads(__tstate);
8104 if (PyErr_Occurred()) SWIG_fail;
8105 }
8106 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8107 return resultobj;
8108 fail:
8109 return NULL;
8110 }
8111
8112
8113 SWIGINTERN PyObject *_wrap_Point2D_GetFloor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8114 PyObject *resultobj = 0;
8115 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8116 int *arg2 = (int *) 0 ;
8117 int *arg3 = (int *) 0 ;
8118 void *argp1 = 0 ;
8119 int res1 = 0 ;
8120 int temp2 ;
8121 int res2 = SWIG_TMPOBJ ;
8122 int temp3 ;
8123 int res3 = SWIG_TMPOBJ ;
8124 PyObject *swig_obj[1] ;
8125
8126 arg2 = &temp2;
8127 arg3 = &temp3;
8128 if (!args) SWIG_fail;
8129 swig_obj[0] = args;
8130 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8131 if (!SWIG_IsOK(res1)) {
8132 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetFloor" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8133 }
8134 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8135 {
8136 PyThreadState* __tstate = wxPyBeginAllowThreads();
8137 ((wxPoint2D const *)arg1)->GetFloor(arg2,arg3);
8138 wxPyEndAllowThreads(__tstate);
8139 if (PyErr_Occurred()) SWIG_fail;
8140 }
8141 resultobj = SWIG_Py_Void();
8142 if (SWIG_IsTmpObj(res2)) {
8143 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8144 } else {
8145 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8146 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8147 }
8148 if (SWIG_IsTmpObj(res3)) {
8149 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8150 } else {
8151 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8152 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8153 }
8154 return resultobj;
8155 fail:
8156 return NULL;
8157 }
8158
8159
8160 SWIGINTERN PyObject *_wrap_Point2D_GetRounded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8161 PyObject *resultobj = 0;
8162 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8163 int *arg2 = (int *) 0 ;
8164 int *arg3 = (int *) 0 ;
8165 void *argp1 = 0 ;
8166 int res1 = 0 ;
8167 int temp2 ;
8168 int res2 = SWIG_TMPOBJ ;
8169 int temp3 ;
8170 int res3 = SWIG_TMPOBJ ;
8171 PyObject *swig_obj[1] ;
8172
8173 arg2 = &temp2;
8174 arg3 = &temp3;
8175 if (!args) SWIG_fail;
8176 swig_obj[0] = args;
8177 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8178 if (!SWIG_IsOK(res1)) {
8179 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetRounded" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8180 }
8181 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8182 {
8183 PyThreadState* __tstate = wxPyBeginAllowThreads();
8184 ((wxPoint2D const *)arg1)->GetRounded(arg2,arg3);
8185 wxPyEndAllowThreads(__tstate);
8186 if (PyErr_Occurred()) SWIG_fail;
8187 }
8188 resultobj = SWIG_Py_Void();
8189 if (SWIG_IsTmpObj(res2)) {
8190 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
8191 } else {
8192 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8193 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
8194 }
8195 if (SWIG_IsTmpObj(res3)) {
8196 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
8197 } else {
8198 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
8199 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
8200 }
8201 return resultobj;
8202 fail:
8203 return NULL;
8204 }
8205
8206
8207 SWIGINTERN PyObject *_wrap_Point2D_GetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8208 PyObject *resultobj = 0;
8209 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8210 double result;
8211 void *argp1 = 0 ;
8212 int res1 = 0 ;
8213 PyObject *swig_obj[1] ;
8214
8215 if (!args) SWIG_fail;
8216 swig_obj[0] = args;
8217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8218 if (!SWIG_IsOK(res1)) {
8219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8220 }
8221 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8222 {
8223 PyThreadState* __tstate = wxPyBeginAllowThreads();
8224 result = (double)((wxPoint2D const *)arg1)->GetVectorLength();
8225 wxPyEndAllowThreads(__tstate);
8226 if (PyErr_Occurred()) SWIG_fail;
8227 }
8228 resultobj = SWIG_From_double(static_cast< double >(result));
8229 return resultobj;
8230 fail:
8231 return NULL;
8232 }
8233
8234
8235 SWIGINTERN PyObject *_wrap_Point2D_GetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8236 PyObject *resultobj = 0;
8237 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8238 double result;
8239 void *argp1 = 0 ;
8240 int res1 = 0 ;
8241 PyObject *swig_obj[1] ;
8242
8243 if (!args) SWIG_fail;
8244 swig_obj[0] = args;
8245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8246 if (!SWIG_IsOK(res1)) {
8247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8248 }
8249 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8250 {
8251 PyThreadState* __tstate = wxPyBeginAllowThreads();
8252 result = (double)((wxPoint2D const *)arg1)->GetVectorAngle();
8253 wxPyEndAllowThreads(__tstate);
8254 if (PyErr_Occurred()) SWIG_fail;
8255 }
8256 resultobj = SWIG_From_double(static_cast< double >(result));
8257 return resultobj;
8258 fail:
8259 return NULL;
8260 }
8261
8262
8263 SWIGINTERN PyObject *_wrap_Point2D_SetVectorLength(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8264 PyObject *resultobj = 0;
8265 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8266 double arg2 ;
8267 void *argp1 = 0 ;
8268 int res1 = 0 ;
8269 double val2 ;
8270 int ecode2 = 0 ;
8271 PyObject * obj0 = 0 ;
8272 PyObject * obj1 = 0 ;
8273 char * kwnames[] = {
8274 (char *) "self",(char *) "length", NULL
8275 };
8276
8277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorLength",kwnames,&obj0,&obj1)) SWIG_fail;
8278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8279 if (!SWIG_IsOK(res1)) {
8280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorLength" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8281 }
8282 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8283 ecode2 = SWIG_AsVal_double(obj1, &val2);
8284 if (!SWIG_IsOK(ecode2)) {
8285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorLength" "', expected argument " "2"" of type '" "double""'");
8286 }
8287 arg2 = static_cast< double >(val2);
8288 {
8289 PyThreadState* __tstate = wxPyBeginAllowThreads();
8290 (arg1)->SetVectorLength(arg2);
8291 wxPyEndAllowThreads(__tstate);
8292 if (PyErr_Occurred()) SWIG_fail;
8293 }
8294 resultobj = SWIG_Py_Void();
8295 return resultobj;
8296 fail:
8297 return NULL;
8298 }
8299
8300
8301 SWIGINTERN PyObject *_wrap_Point2D_SetVectorAngle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8302 PyObject *resultobj = 0;
8303 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8304 double arg2 ;
8305 void *argp1 = 0 ;
8306 int res1 = 0 ;
8307 double val2 ;
8308 int ecode2 = 0 ;
8309 PyObject * obj0 = 0 ;
8310 PyObject * obj1 = 0 ;
8311 char * kwnames[] = {
8312 (char *) "self",(char *) "degrees", NULL
8313 };
8314
8315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_SetVectorAngle",kwnames,&obj0,&obj1)) SWIG_fail;
8316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8317 if (!SWIG_IsOK(res1)) {
8318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_SetVectorAngle" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8319 }
8320 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8321 ecode2 = SWIG_AsVal_double(obj1, &val2);
8322 if (!SWIG_IsOK(ecode2)) {
8323 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_SetVectorAngle" "', expected argument " "2"" of type '" "double""'");
8324 }
8325 arg2 = static_cast< double >(val2);
8326 {
8327 PyThreadState* __tstate = wxPyBeginAllowThreads();
8328 (arg1)->SetVectorAngle(arg2);
8329 wxPyEndAllowThreads(__tstate);
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_GetDistance(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8340 PyObject *resultobj = 0;
8341 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8342 wxPoint2D *arg2 = 0 ;
8343 double result;
8344 void *argp1 = 0 ;
8345 int res1 = 0 ;
8346 wxPoint2D temp2 ;
8347 PyObject * obj0 = 0 ;
8348 PyObject * obj1 = 0 ;
8349 char * kwnames[] = {
8350 (char *) "self",(char *) "pt", NULL
8351 };
8352
8353 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistance",kwnames,&obj0,&obj1)) SWIG_fail;
8354 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8355 if (!SWIG_IsOK(res1)) {
8356 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistance" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8357 }
8358 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8359 {
8360 arg2 = &temp2;
8361 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8362 }
8363 {
8364 PyThreadState* __tstate = wxPyBeginAllowThreads();
8365 result = (double)((wxPoint2D const *)arg1)->GetDistance((wxPoint2D const &)*arg2);
8366 wxPyEndAllowThreads(__tstate);
8367 if (PyErr_Occurred()) SWIG_fail;
8368 }
8369 resultobj = SWIG_From_double(static_cast< double >(result));
8370 return resultobj;
8371 fail:
8372 return NULL;
8373 }
8374
8375
8376 SWIGINTERN PyObject *_wrap_Point2D_GetDistanceSquare(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8377 PyObject *resultobj = 0;
8378 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8379 wxPoint2D *arg2 = 0 ;
8380 double result;
8381 void *argp1 = 0 ;
8382 int res1 = 0 ;
8383 wxPoint2D temp2 ;
8384 PyObject * obj0 = 0 ;
8385 PyObject * obj1 = 0 ;
8386 char * kwnames[] = {
8387 (char *) "self",(char *) "pt", NULL
8388 };
8389
8390 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDistanceSquare",kwnames,&obj0,&obj1)) SWIG_fail;
8391 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8392 if (!SWIG_IsOK(res1)) {
8393 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDistanceSquare" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8394 }
8395 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8396 {
8397 arg2 = &temp2;
8398 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8399 }
8400 {
8401 PyThreadState* __tstate = wxPyBeginAllowThreads();
8402 result = (double)((wxPoint2D const *)arg1)->GetDistanceSquare((wxPoint2D const &)*arg2);
8403 wxPyEndAllowThreads(__tstate);
8404 if (PyErr_Occurred()) SWIG_fail;
8405 }
8406 resultobj = SWIG_From_double(static_cast< double >(result));
8407 return resultobj;
8408 fail:
8409 return NULL;
8410 }
8411
8412
8413 SWIGINTERN PyObject *_wrap_Point2D_GetDotProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8414 PyObject *resultobj = 0;
8415 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8416 wxPoint2D *arg2 = 0 ;
8417 double result;
8418 void *argp1 = 0 ;
8419 int res1 = 0 ;
8420 wxPoint2D temp2 ;
8421 PyObject * obj0 = 0 ;
8422 PyObject * obj1 = 0 ;
8423 char * kwnames[] = {
8424 (char *) "self",(char *) "vec", NULL
8425 };
8426
8427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetDotProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8429 if (!SWIG_IsOK(res1)) {
8430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetDotProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8431 }
8432 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8433 {
8434 arg2 = &temp2;
8435 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8436 }
8437 {
8438 PyThreadState* __tstate = wxPyBeginAllowThreads();
8439 result = (double)((wxPoint2D const *)arg1)->GetDotProduct((wxPoint2D const &)*arg2);
8440 wxPyEndAllowThreads(__tstate);
8441 if (PyErr_Occurred()) SWIG_fail;
8442 }
8443 resultobj = SWIG_From_double(static_cast< double >(result));
8444 return resultobj;
8445 fail:
8446 return NULL;
8447 }
8448
8449
8450 SWIGINTERN PyObject *_wrap_Point2D_GetCrossProduct(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8451 PyObject *resultobj = 0;
8452 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8453 wxPoint2D *arg2 = 0 ;
8454 double result;
8455 void *argp1 = 0 ;
8456 int res1 = 0 ;
8457 wxPoint2D temp2 ;
8458 PyObject * obj0 = 0 ;
8459 PyObject * obj1 = 0 ;
8460 char * kwnames[] = {
8461 (char *) "self",(char *) "vec", NULL
8462 };
8463
8464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D_GetCrossProduct",kwnames,&obj0,&obj1)) SWIG_fail;
8465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8466 if (!SWIG_IsOK(res1)) {
8467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_GetCrossProduct" "', expected argument " "1"" of type '" "wxPoint2D const *""'");
8468 }
8469 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8470 {
8471 arg2 = &temp2;
8472 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8473 }
8474 {
8475 PyThreadState* __tstate = wxPyBeginAllowThreads();
8476 result = (double)((wxPoint2D const *)arg1)->GetCrossProduct((wxPoint2D const &)*arg2);
8477 wxPyEndAllowThreads(__tstate);
8478 if (PyErr_Occurred()) SWIG_fail;
8479 }
8480 resultobj = SWIG_From_double(static_cast< double >(result));
8481 return resultobj;
8482 fail:
8483 return NULL;
8484 }
8485
8486
8487 SWIGINTERN PyObject *_wrap_Point2D___neg__(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8488 PyObject *resultobj = 0;
8489 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8490 wxPoint2D result;
8491 void *argp1 = 0 ;
8492 int res1 = 0 ;
8493 PyObject *swig_obj[1] ;
8494
8495 if (!args) SWIG_fail;
8496 swig_obj[0] = args;
8497 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8498 if (!SWIG_IsOK(res1)) {
8499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___neg__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8500 }
8501 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8502 {
8503 PyThreadState* __tstate = wxPyBeginAllowThreads();
8504 result = (arg1)->operator -();
8505 wxPyEndAllowThreads(__tstate);
8506 if (PyErr_Occurred()) SWIG_fail;
8507 }
8508 resultobj = SWIG_NewPointerObj((new wxPoint2D(static_cast< const wxPoint2D& >(result))), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8509 return resultobj;
8510 fail:
8511 return NULL;
8512 }
8513
8514
8515 SWIGINTERN PyObject *_wrap_Point2D___iadd__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8516 PyObject *resultobj = 0;
8517 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8518 wxPoint2D *arg2 = 0 ;
8519 wxPoint2D *result = 0 ;
8520 void *argp1 = 0 ;
8521 int res1 = 0 ;
8522 wxPoint2D temp2 ;
8523 PyObject * obj0 = 0 ;
8524 PyObject * obj1 = 0 ;
8525 char * kwnames[] = {
8526 (char *) "self",(char *) "pt", NULL
8527 };
8528
8529 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___iadd__",kwnames,&obj0,&obj1)) SWIG_fail;
8530 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8531 if (!SWIG_IsOK(res1)) {
8532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___iadd__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8533 }
8534 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8535 {
8536 arg2 = &temp2;
8537 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8538 }
8539 {
8540 PyThreadState* __tstate = wxPyBeginAllowThreads();
8541 {
8542 wxPoint2D &_result_ref = (arg1)->operator +=((wxPoint2D const &)*arg2);
8543 result = (wxPoint2D *) &_result_ref;
8544 }
8545 wxPyEndAllowThreads(__tstate);
8546 if (PyErr_Occurred()) SWIG_fail;
8547 }
8548 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8549 return resultobj;
8550 fail:
8551 return NULL;
8552 }
8553
8554
8555 SWIGINTERN PyObject *_wrap_Point2D___isub__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8556 PyObject *resultobj = 0;
8557 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8558 wxPoint2D *arg2 = 0 ;
8559 wxPoint2D *result = 0 ;
8560 void *argp1 = 0 ;
8561 int res1 = 0 ;
8562 wxPoint2D temp2 ;
8563 PyObject * obj0 = 0 ;
8564 PyObject * obj1 = 0 ;
8565 char * kwnames[] = {
8566 (char *) "self",(char *) "pt", NULL
8567 };
8568
8569 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___isub__",kwnames,&obj0,&obj1)) SWIG_fail;
8570 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8571 if (!SWIG_IsOK(res1)) {
8572 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___isub__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8573 }
8574 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8575 {
8576 arg2 = &temp2;
8577 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8578 }
8579 {
8580 PyThreadState* __tstate = wxPyBeginAllowThreads();
8581 {
8582 wxPoint2D &_result_ref = (arg1)->operator -=((wxPoint2D const &)*arg2);
8583 result = (wxPoint2D *) &_result_ref;
8584 }
8585 wxPyEndAllowThreads(__tstate);
8586 if (PyErr_Occurred()) SWIG_fail;
8587 }
8588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8589 return resultobj;
8590 fail:
8591 return NULL;
8592 }
8593
8594
8595 SWIGINTERN PyObject *_wrap_Point2D___imul__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8596 PyObject *resultobj = 0;
8597 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8598 wxPoint2D *arg2 = 0 ;
8599 wxPoint2D *result = 0 ;
8600 void *argp1 = 0 ;
8601 int res1 = 0 ;
8602 wxPoint2D temp2 ;
8603 PyObject * obj0 = 0 ;
8604 PyObject * obj1 = 0 ;
8605 char * kwnames[] = {
8606 (char *) "self",(char *) "pt", NULL
8607 };
8608
8609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___imul__",kwnames,&obj0,&obj1)) SWIG_fail;
8610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8611 if (!SWIG_IsOK(res1)) {
8612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___imul__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8613 }
8614 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8615 {
8616 arg2 = &temp2;
8617 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8618 }
8619 {
8620 PyThreadState* __tstate = wxPyBeginAllowThreads();
8621 {
8622 wxPoint2D &_result_ref = (arg1)->operator *=((wxPoint2D const &)*arg2);
8623 result = (wxPoint2D *) &_result_ref;
8624 }
8625 wxPyEndAllowThreads(__tstate);
8626 if (PyErr_Occurred()) SWIG_fail;
8627 }
8628 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8629 return resultobj;
8630 fail:
8631 return NULL;
8632 }
8633
8634
8635 SWIGINTERN PyObject *_wrap_Point2D___idiv__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8636 PyObject *resultobj = 0;
8637 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8638 wxPoint2D *arg2 = 0 ;
8639 wxPoint2D *result = 0 ;
8640 void *argp1 = 0 ;
8641 int res1 = 0 ;
8642 wxPoint2D temp2 ;
8643 PyObject * obj0 = 0 ;
8644 PyObject * obj1 = 0 ;
8645 char * kwnames[] = {
8646 (char *) "self",(char *) "pt", NULL
8647 };
8648
8649 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___idiv__",kwnames,&obj0,&obj1)) SWIG_fail;
8650 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, SWIG_POINTER_DISOWN | 0 );
8651 if (!SWIG_IsOK(res1)) {
8652 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___idiv__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8653 }
8654 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8655 {
8656 arg2 = &temp2;
8657 if ( ! wxPoint2D_helper(obj1, &arg2)) SWIG_fail;
8658 }
8659 {
8660 PyThreadState* __tstate = wxPyBeginAllowThreads();
8661 {
8662 wxPoint2D &_result_ref = (arg1)->operator /=((wxPoint2D const &)*arg2);
8663 result = (wxPoint2D *) &_result_ref;
8664 }
8665 wxPyEndAllowThreads(__tstate);
8666 if (PyErr_Occurred()) SWIG_fail;
8667 }
8668 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint2D, SWIG_POINTER_OWN | 0 );
8669 return resultobj;
8670 fail:
8671 return NULL;
8672 }
8673
8674
8675 SWIGINTERN PyObject *_wrap_Point2D___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8676 PyObject *resultobj = 0;
8677 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8678 PyObject *arg2 = (PyObject *) 0 ;
8679 bool result;
8680 void *argp1 = 0 ;
8681 int res1 = 0 ;
8682 PyObject * obj0 = 0 ;
8683 PyObject * obj1 = 0 ;
8684 char * kwnames[] = {
8685 (char *) "self",(char *) "other", NULL
8686 };
8687
8688 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
8689 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8690 if (!SWIG_IsOK(res1)) {
8691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___eq__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8692 }
8693 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8694 arg2 = obj1;
8695 {
8696 result = (bool)wxPoint2D___eq__(arg1,arg2);
8697 if (PyErr_Occurred()) SWIG_fail;
8698 }
8699 {
8700 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8701 }
8702 return resultobj;
8703 fail:
8704 return NULL;
8705 }
8706
8707
8708 SWIGINTERN PyObject *_wrap_Point2D___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8709 PyObject *resultobj = 0;
8710 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8711 PyObject *arg2 = (PyObject *) 0 ;
8712 bool result;
8713 void *argp1 = 0 ;
8714 int res1 = 0 ;
8715 PyObject * obj0 = 0 ;
8716 PyObject * obj1 = 0 ;
8717 char * kwnames[] = {
8718 (char *) "self",(char *) "other", NULL
8719 };
8720
8721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Point2D___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
8722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8723 if (!SWIG_IsOK(res1)) {
8724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D___ne__" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8725 }
8726 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8727 arg2 = obj1;
8728 {
8729 result = (bool)wxPoint2D___ne__(arg1,arg2);
8730 if (PyErr_Occurred()) SWIG_fail;
8731 }
8732 {
8733 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
8734 }
8735 return resultobj;
8736 fail:
8737 return NULL;
8738 }
8739
8740
8741 SWIGINTERN PyObject *_wrap_Point2D_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8742 PyObject *resultobj = 0;
8743 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8744 double arg2 ;
8745 void *argp1 = 0 ;
8746 int res1 = 0 ;
8747 double val2 ;
8748 int ecode2 = 0 ;
8749 PyObject *swig_obj[2] ;
8750
8751 if (!SWIG_Python_UnpackTuple(args,"Point2D_x_set",2,2,swig_obj)) SWIG_fail;
8752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8753 if (!SWIG_IsOK(res1)) {
8754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8755 }
8756 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8757 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8758 if (!SWIG_IsOK(ecode2)) {
8759 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_x_set" "', expected argument " "2"" of type '" "double""'");
8760 }
8761 arg2 = static_cast< double >(val2);
8762 if (arg1) (arg1)->m_x = arg2;
8763
8764 resultobj = SWIG_Py_Void();
8765 return resultobj;
8766 fail:
8767 return NULL;
8768 }
8769
8770
8771 SWIGINTERN PyObject *_wrap_Point2D_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8772 PyObject *resultobj = 0;
8773 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8774 double result;
8775 void *argp1 = 0 ;
8776 int res1 = 0 ;
8777 PyObject *swig_obj[1] ;
8778
8779 if (!args) SWIG_fail;
8780 swig_obj[0] = args;
8781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8782 if (!SWIG_IsOK(res1)) {
8783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_x_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8784 }
8785 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8786 result = (double) ((arg1)->m_x);
8787 resultobj = SWIG_From_double(static_cast< double >(result));
8788 return resultobj;
8789 fail:
8790 return NULL;
8791 }
8792
8793
8794 SWIGINTERN PyObject *_wrap_Point2D_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8795 PyObject *resultobj = 0;
8796 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8797 double arg2 ;
8798 void *argp1 = 0 ;
8799 int res1 = 0 ;
8800 double val2 ;
8801 int ecode2 = 0 ;
8802 PyObject *swig_obj[2] ;
8803
8804 if (!SWIG_Python_UnpackTuple(args,"Point2D_y_set",2,2,swig_obj)) SWIG_fail;
8805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8806 if (!SWIG_IsOK(res1)) {
8807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8808 }
8809 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8810 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
8811 if (!SWIG_IsOK(ecode2)) {
8812 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_y_set" "', expected argument " "2"" of type '" "double""'");
8813 }
8814 arg2 = static_cast< double >(val2);
8815 if (arg1) (arg1)->m_y = arg2;
8816
8817 resultobj = SWIG_Py_Void();
8818 return resultobj;
8819 fail:
8820 return NULL;
8821 }
8822
8823
8824 SWIGINTERN PyObject *_wrap_Point2D_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8825 PyObject *resultobj = 0;
8826 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8827 double result;
8828 void *argp1 = 0 ;
8829 int res1 = 0 ;
8830 PyObject *swig_obj[1] ;
8831
8832 if (!args) SWIG_fail;
8833 swig_obj[0] = args;
8834 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8835 if (!SWIG_IsOK(res1)) {
8836 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_y_get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8837 }
8838 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8839 result = (double) ((arg1)->m_y);
8840 resultobj = SWIG_From_double(static_cast< double >(result));
8841 return resultobj;
8842 fail:
8843 return NULL;
8844 }
8845
8846
8847 SWIGINTERN PyObject *_wrap_Point2D_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8848 PyObject *resultobj = 0;
8849 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8850 double arg2 = (double) 0 ;
8851 double arg3 = (double) 0 ;
8852 void *argp1 = 0 ;
8853 int res1 = 0 ;
8854 double val2 ;
8855 int ecode2 = 0 ;
8856 double val3 ;
8857 int ecode3 = 0 ;
8858 PyObject * obj0 = 0 ;
8859 PyObject * obj1 = 0 ;
8860 PyObject * obj2 = 0 ;
8861 char * kwnames[] = {
8862 (char *) "self",(char *) "x",(char *) "y", NULL
8863 };
8864
8865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Point2D_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
8866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8867 if (!SWIG_IsOK(res1)) {
8868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Set" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8869 }
8870 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8871 if (obj1) {
8872 ecode2 = SWIG_AsVal_double(obj1, &val2);
8873 if (!SWIG_IsOK(ecode2)) {
8874 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Point2D_Set" "', expected argument " "2"" of type '" "double""'");
8875 }
8876 arg2 = static_cast< double >(val2);
8877 }
8878 if (obj2) {
8879 ecode3 = SWIG_AsVal_double(obj2, &val3);
8880 if (!SWIG_IsOK(ecode3)) {
8881 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Point2D_Set" "', expected argument " "3"" of type '" "double""'");
8882 }
8883 arg3 = static_cast< double >(val3);
8884 }
8885 {
8886 PyThreadState* __tstate = wxPyBeginAllowThreads();
8887 wxPoint2D_Set(arg1,arg2,arg3);
8888 wxPyEndAllowThreads(__tstate);
8889 if (PyErr_Occurred()) SWIG_fail;
8890 }
8891 resultobj = SWIG_Py_Void();
8892 return resultobj;
8893 fail:
8894 return NULL;
8895 }
8896
8897
8898 SWIGINTERN PyObject *_wrap_Point2D_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8899 PyObject *resultobj = 0;
8900 wxPoint2D *arg1 = (wxPoint2D *) 0 ;
8901 PyObject *result = 0 ;
8902 void *argp1 = 0 ;
8903 int res1 = 0 ;
8904 PyObject *swig_obj[1] ;
8905
8906 if (!args) SWIG_fail;
8907 swig_obj[0] = args;
8908 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPoint2D, 0 | 0 );
8909 if (!SWIG_IsOK(res1)) {
8910 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Point2D_Get" "', expected argument " "1"" of type '" "wxPoint2D *""'");
8911 }
8912 arg1 = reinterpret_cast< wxPoint2D * >(argp1);
8913 {
8914 PyThreadState* __tstate = wxPyBeginAllowThreads();
8915 result = (PyObject *)wxPoint2D_Get(arg1);
8916 wxPyEndAllowThreads(__tstate);
8917 if (PyErr_Occurred()) SWIG_fail;
8918 }
8919 resultobj = result;
8920 return resultobj;
8921 fail:
8922 return NULL;
8923 }
8924
8925
8926 SWIGINTERN PyObject *Point2D_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8927 PyObject *obj;
8928 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
8929 SWIG_TypeNewClientData(SWIGTYPE_p_wxPoint2D, SWIG_NewClientData(obj));
8930 return SWIG_Py_Void();
8931 }
8932
8933 SWIGINTERN PyObject *Point2D_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8934 return SWIG_Python_InitShadowInstance(args);
8935 }
8936
8937 SWIGINTERN int DefaultPosition_set(PyObject *) {
8938 SWIG_Error(SWIG_AttributeError,"Variable DefaultPosition is read-only.");
8939 return 1;
8940 }
8941
8942
8943 SWIGINTERN PyObject *DefaultPosition_get(void) {
8944 PyObject *pyobj = 0;
8945
8946 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultPosition), SWIGTYPE_p_wxPoint, 0 );
8947 return pyobj;
8948 }
8949
8950
8951 SWIGINTERN int DefaultSize_set(PyObject *) {
8952 SWIG_Error(SWIG_AttributeError,"Variable DefaultSize is read-only.");
8953 return 1;
8954 }
8955
8956
8957 SWIGINTERN PyObject *DefaultSize_get(void) {
8958 PyObject *pyobj = 0;
8959
8960 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSize), SWIGTYPE_p_wxSize, 0 );
8961 return pyobj;
8962 }
8963
8964
8965 SWIGINTERN PyObject *_wrap_new_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
8966 PyObject *resultobj = 0;
8967 PyObject *arg1 = (PyObject *) 0 ;
8968 wxPyInputStream *result = 0 ;
8969 PyObject * obj0 = 0 ;
8970 char * kwnames[] = {
8971 (char *) "p", NULL
8972 };
8973
8974 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_InputStream",kwnames,&obj0)) SWIG_fail;
8975 arg1 = obj0;
8976 {
8977 PyThreadState* __tstate = wxPyBeginAllowThreads();
8978 result = (wxPyInputStream *)new_wxPyInputStream(arg1);
8979 wxPyEndAllowThreads(__tstate);
8980 if (PyErr_Occurred()) SWIG_fail;
8981 }
8982 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_NEW | 0 );
8983 return resultobj;
8984 fail:
8985 return NULL;
8986 }
8987
8988
8989 SWIGINTERN PyObject *_wrap_delete_InputStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
8990 PyObject *resultobj = 0;
8991 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
8992 void *argp1 = 0 ;
8993 int res1 = 0 ;
8994 PyObject *swig_obj[1] ;
8995
8996 if (!args) SWIG_fail;
8997 swig_obj[0] = args;
8998 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, SWIG_POINTER_DISOWN | 0 );
8999 if (!SWIG_IsOK(res1)) {
9000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_InputStream" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9001 }
9002 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9003 {
9004 PyThreadState* __tstate = wxPyBeginAllowThreads();
9005 delete arg1;
9006
9007 wxPyEndAllowThreads(__tstate);
9008 if (PyErr_Occurred()) SWIG_fail;
9009 }
9010 resultobj = SWIG_Py_Void();
9011 return resultobj;
9012 fail:
9013 return NULL;
9014 }
9015
9016
9017 SWIGINTERN PyObject *_wrap_InputStream_close(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9018 PyObject *resultobj = 0;
9019 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9020 void *argp1 = 0 ;
9021 int res1 = 0 ;
9022 PyObject *swig_obj[1] ;
9023
9024 if (!args) SWIG_fail;
9025 swig_obj[0] = args;
9026 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9027 if (!SWIG_IsOK(res1)) {
9028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_close" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9029 }
9030 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9031 {
9032 PyThreadState* __tstate = wxPyBeginAllowThreads();
9033 (arg1)->close();
9034 wxPyEndAllowThreads(__tstate);
9035 if (PyErr_Occurred()) SWIG_fail;
9036 }
9037 resultobj = SWIG_Py_Void();
9038 return resultobj;
9039 fail:
9040 return NULL;
9041 }
9042
9043
9044 SWIGINTERN PyObject *_wrap_InputStream_flush(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9045 PyObject *resultobj = 0;
9046 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9047 void *argp1 = 0 ;
9048 int res1 = 0 ;
9049 PyObject *swig_obj[1] ;
9050
9051 if (!args) SWIG_fail;
9052 swig_obj[0] = args;
9053 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9054 if (!SWIG_IsOK(res1)) {
9055 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_flush" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9056 }
9057 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9058 {
9059 PyThreadState* __tstate = wxPyBeginAllowThreads();
9060 (arg1)->flush();
9061 wxPyEndAllowThreads(__tstate);
9062 if (PyErr_Occurred()) SWIG_fail;
9063 }
9064 resultobj = SWIG_Py_Void();
9065 return resultobj;
9066 fail:
9067 return NULL;
9068 }
9069
9070
9071 SWIGINTERN PyObject *_wrap_InputStream_eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9072 PyObject *resultobj = 0;
9073 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9074 bool result;
9075 void *argp1 = 0 ;
9076 int res1 = 0 ;
9077 PyObject *swig_obj[1] ;
9078
9079 if (!args) SWIG_fail;
9080 swig_obj[0] = args;
9081 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9082 if (!SWIG_IsOK(res1)) {
9083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9084 }
9085 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9086 {
9087 PyThreadState* __tstate = wxPyBeginAllowThreads();
9088 result = (bool)(arg1)->eof();
9089 wxPyEndAllowThreads(__tstate);
9090 if (PyErr_Occurred()) SWIG_fail;
9091 }
9092 {
9093 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9094 }
9095 return resultobj;
9096 fail:
9097 return NULL;
9098 }
9099
9100
9101 SWIGINTERN PyObject *_wrap_InputStream_read(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9102 PyObject *resultobj = 0;
9103 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9104 int arg2 = (int) -1 ;
9105 PyObject *result = 0 ;
9106 void *argp1 = 0 ;
9107 int res1 = 0 ;
9108 int val2 ;
9109 int ecode2 = 0 ;
9110 PyObject * obj0 = 0 ;
9111 PyObject * obj1 = 0 ;
9112 char * kwnames[] = {
9113 (char *) "self",(char *) "size", NULL
9114 };
9115
9116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_read",kwnames,&obj0,&obj1)) SWIG_fail;
9117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9118 if (!SWIG_IsOK(res1)) {
9119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_read" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9120 }
9121 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9122 if (obj1) {
9123 ecode2 = SWIG_AsVal_int(obj1, &val2);
9124 if (!SWIG_IsOK(ecode2)) {
9125 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_read" "', expected argument " "2"" of type '" "int""'");
9126 }
9127 arg2 = static_cast< int >(val2);
9128 }
9129 {
9130 PyThreadState* __tstate = wxPyBeginAllowThreads();
9131 result = (PyObject *)(arg1)->read(arg2);
9132 wxPyEndAllowThreads(__tstate);
9133 if (PyErr_Occurred()) SWIG_fail;
9134 }
9135 resultobj = result;
9136 return resultobj;
9137 fail:
9138 return NULL;
9139 }
9140
9141
9142 SWIGINTERN PyObject *_wrap_InputStream_readline(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9143 PyObject *resultobj = 0;
9144 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9145 int arg2 = (int) -1 ;
9146 PyObject *result = 0 ;
9147 void *argp1 = 0 ;
9148 int res1 = 0 ;
9149 int val2 ;
9150 int ecode2 = 0 ;
9151 PyObject * obj0 = 0 ;
9152 PyObject * obj1 = 0 ;
9153 char * kwnames[] = {
9154 (char *) "self",(char *) "size", NULL
9155 };
9156
9157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readline",kwnames,&obj0,&obj1)) SWIG_fail;
9158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9159 if (!SWIG_IsOK(res1)) {
9160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readline" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9161 }
9162 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9163 if (obj1) {
9164 ecode2 = SWIG_AsVal_int(obj1, &val2);
9165 if (!SWIG_IsOK(ecode2)) {
9166 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readline" "', expected argument " "2"" of type '" "int""'");
9167 }
9168 arg2 = static_cast< int >(val2);
9169 }
9170 {
9171 PyThreadState* __tstate = wxPyBeginAllowThreads();
9172 result = (PyObject *)(arg1)->readline(arg2);
9173 wxPyEndAllowThreads(__tstate);
9174 if (PyErr_Occurred()) SWIG_fail;
9175 }
9176 resultobj = result;
9177 return resultobj;
9178 fail:
9179 return NULL;
9180 }
9181
9182
9183 SWIGINTERN PyObject *_wrap_InputStream_readlines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9184 PyObject *resultobj = 0;
9185 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9186 int arg2 = (int) -1 ;
9187 PyObject *result = 0 ;
9188 void *argp1 = 0 ;
9189 int res1 = 0 ;
9190 int val2 ;
9191 int ecode2 = 0 ;
9192 PyObject * obj0 = 0 ;
9193 PyObject * obj1 = 0 ;
9194 char * kwnames[] = {
9195 (char *) "self",(char *) "sizehint", NULL
9196 };
9197
9198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:InputStream_readlines",kwnames,&obj0,&obj1)) SWIG_fail;
9199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9200 if (!SWIG_IsOK(res1)) {
9201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_readlines" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9202 }
9203 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9204 if (obj1) {
9205 ecode2 = SWIG_AsVal_int(obj1, &val2);
9206 if (!SWIG_IsOK(ecode2)) {
9207 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_readlines" "', expected argument " "2"" of type '" "int""'");
9208 }
9209 arg2 = static_cast< int >(val2);
9210 }
9211 {
9212 PyThreadState* __tstate = wxPyBeginAllowThreads();
9213 result = (PyObject *)(arg1)->readlines(arg2);
9214 wxPyEndAllowThreads(__tstate);
9215 if (PyErr_Occurred()) SWIG_fail;
9216 }
9217 resultobj = result;
9218 return resultobj;
9219 fail:
9220 return NULL;
9221 }
9222
9223
9224 SWIGINTERN PyObject *_wrap_InputStream_seek(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9225 PyObject *resultobj = 0;
9226 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9227 int arg2 ;
9228 int arg3 = (int) 0 ;
9229 void *argp1 = 0 ;
9230 int res1 = 0 ;
9231 int val2 ;
9232 int ecode2 = 0 ;
9233 int val3 ;
9234 int ecode3 = 0 ;
9235 PyObject * obj0 = 0 ;
9236 PyObject * obj1 = 0 ;
9237 PyObject * obj2 = 0 ;
9238 char * kwnames[] = {
9239 (char *) "self",(char *) "offset",(char *) "whence", NULL
9240 };
9241
9242 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_seek",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9243 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9244 if (!SWIG_IsOK(res1)) {
9245 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_seek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9246 }
9247 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9248 ecode2 = SWIG_AsVal_int(obj1, &val2);
9249 if (!SWIG_IsOK(ecode2)) {
9250 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_seek" "', expected argument " "2"" of type '" "int""'");
9251 }
9252 arg2 = static_cast< int >(val2);
9253 if (obj2) {
9254 ecode3 = SWIG_AsVal_int(obj2, &val3);
9255 if (!SWIG_IsOK(ecode3)) {
9256 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_seek" "', expected argument " "3"" of type '" "int""'");
9257 }
9258 arg3 = static_cast< int >(val3);
9259 }
9260 {
9261 PyThreadState* __tstate = wxPyBeginAllowThreads();
9262 (arg1)->seek(arg2,arg3);
9263 wxPyEndAllowThreads(__tstate);
9264 if (PyErr_Occurred()) SWIG_fail;
9265 }
9266 resultobj = SWIG_Py_Void();
9267 return resultobj;
9268 fail:
9269 return NULL;
9270 }
9271
9272
9273 SWIGINTERN PyObject *_wrap_InputStream_tell(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9274 PyObject *resultobj = 0;
9275 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9276 int result;
9277 void *argp1 = 0 ;
9278 int res1 = 0 ;
9279 PyObject *swig_obj[1] ;
9280
9281 if (!args) SWIG_fail;
9282 swig_obj[0] = args;
9283 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9284 if (!SWIG_IsOK(res1)) {
9285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_tell" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9286 }
9287 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9288 {
9289 PyThreadState* __tstate = wxPyBeginAllowThreads();
9290 result = (int)(arg1)->tell();
9291 wxPyEndAllowThreads(__tstate);
9292 if (PyErr_Occurred()) SWIG_fail;
9293 }
9294 resultobj = SWIG_From_int(static_cast< int >(result));
9295 return resultobj;
9296 fail:
9297 return NULL;
9298 }
9299
9300
9301 SWIGINTERN PyObject *_wrap_InputStream_Peek(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9302 PyObject *resultobj = 0;
9303 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9304 char result;
9305 void *argp1 = 0 ;
9306 int res1 = 0 ;
9307 PyObject *swig_obj[1] ;
9308
9309 if (!args) SWIG_fail;
9310 swig_obj[0] = args;
9311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9312 if (!SWIG_IsOK(res1)) {
9313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Peek" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9314 }
9315 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9316 {
9317 PyThreadState* __tstate = wxPyBeginAllowThreads();
9318 result = (char)(arg1)->Peek();
9319 wxPyEndAllowThreads(__tstate);
9320 if (PyErr_Occurred()) SWIG_fail;
9321 }
9322 resultobj = SWIG_From_char(static_cast< char >(result));
9323 return resultobj;
9324 fail:
9325 return NULL;
9326 }
9327
9328
9329 SWIGINTERN PyObject *_wrap_InputStream_GetC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9330 PyObject *resultobj = 0;
9331 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9332 char result;
9333 void *argp1 = 0 ;
9334 int res1 = 0 ;
9335 PyObject *swig_obj[1] ;
9336
9337 if (!args) SWIG_fail;
9338 swig_obj[0] = args;
9339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9340 if (!SWIG_IsOK(res1)) {
9341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_GetC" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9342 }
9343 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9344 {
9345 PyThreadState* __tstate = wxPyBeginAllowThreads();
9346 result = (char)(arg1)->GetC();
9347 wxPyEndAllowThreads(__tstate);
9348 if (PyErr_Occurred()) SWIG_fail;
9349 }
9350 resultobj = SWIG_From_char(static_cast< char >(result));
9351 return resultobj;
9352 fail:
9353 return NULL;
9354 }
9355
9356
9357 SWIGINTERN PyObject *_wrap_InputStream_LastRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9358 PyObject *resultobj = 0;
9359 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9360 size_t result;
9361 void *argp1 = 0 ;
9362 int res1 = 0 ;
9363 PyObject *swig_obj[1] ;
9364
9365 if (!args) SWIG_fail;
9366 swig_obj[0] = args;
9367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9368 if (!SWIG_IsOK(res1)) {
9369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_LastRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9370 }
9371 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9372 {
9373 PyThreadState* __tstate = wxPyBeginAllowThreads();
9374 result = (size_t)(arg1)->LastRead();
9375 wxPyEndAllowThreads(__tstate);
9376 if (PyErr_Occurred()) SWIG_fail;
9377 }
9378 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9379 return resultobj;
9380 fail:
9381 return NULL;
9382 }
9383
9384
9385 SWIGINTERN PyObject *_wrap_InputStream_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9386 PyObject *resultobj = 0;
9387 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9388 bool result;
9389 void *argp1 = 0 ;
9390 int res1 = 0 ;
9391 PyObject *swig_obj[1] ;
9392
9393 if (!args) SWIG_fail;
9394 swig_obj[0] = args;
9395 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9396 if (!SWIG_IsOK(res1)) {
9397 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_CanRead" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9398 }
9399 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9400 {
9401 PyThreadState* __tstate = wxPyBeginAllowThreads();
9402 result = (bool)(arg1)->CanRead();
9403 wxPyEndAllowThreads(__tstate);
9404 if (PyErr_Occurred()) SWIG_fail;
9405 }
9406 {
9407 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9408 }
9409 return resultobj;
9410 fail:
9411 return NULL;
9412 }
9413
9414
9415 SWIGINTERN PyObject *_wrap_InputStream_Eof(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9416 PyObject *resultobj = 0;
9417 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9418 bool result;
9419 void *argp1 = 0 ;
9420 int res1 = 0 ;
9421 PyObject *swig_obj[1] ;
9422
9423 if (!args) SWIG_fail;
9424 swig_obj[0] = args;
9425 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9426 if (!SWIG_IsOK(res1)) {
9427 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Eof" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9428 }
9429 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9430 {
9431 PyThreadState* __tstate = wxPyBeginAllowThreads();
9432 result = (bool)(arg1)->Eof();
9433 wxPyEndAllowThreads(__tstate);
9434 if (PyErr_Occurred()) SWIG_fail;
9435 }
9436 {
9437 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9438 }
9439 return resultobj;
9440 fail:
9441 return NULL;
9442 }
9443
9444
9445 SWIGINTERN PyObject *_wrap_InputStream_Ungetch(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9446 PyObject *resultobj = 0;
9447 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9448 char arg2 ;
9449 bool result;
9450 void *argp1 = 0 ;
9451 int res1 = 0 ;
9452 char val2 ;
9453 int ecode2 = 0 ;
9454 PyObject * obj0 = 0 ;
9455 PyObject * obj1 = 0 ;
9456 char * kwnames[] = {
9457 (char *) "self",(char *) "c", NULL
9458 };
9459
9460 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InputStream_Ungetch",kwnames,&obj0,&obj1)) SWIG_fail;
9461 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9462 if (!SWIG_IsOK(res1)) {
9463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_Ungetch" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9464 }
9465 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9466 ecode2 = SWIG_AsVal_char(obj1, &val2);
9467 if (!SWIG_IsOK(ecode2)) {
9468 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_Ungetch" "', expected argument " "2"" of type '" "char""'");
9469 }
9470 arg2 = static_cast< char >(val2);
9471 {
9472 PyThreadState* __tstate = wxPyBeginAllowThreads();
9473 result = (bool)(arg1)->Ungetch(arg2);
9474 wxPyEndAllowThreads(__tstate);
9475 if (PyErr_Occurred()) SWIG_fail;
9476 }
9477 {
9478 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
9479 }
9480 return resultobj;
9481 fail:
9482 return NULL;
9483 }
9484
9485
9486 SWIGINTERN PyObject *_wrap_InputStream_SeekI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9487 PyObject *resultobj = 0;
9488 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9489 long arg2 ;
9490 wxSeekMode arg3 = (wxSeekMode) wxFromStart ;
9491 long result;
9492 void *argp1 = 0 ;
9493 int res1 = 0 ;
9494 long val2 ;
9495 int ecode2 = 0 ;
9496 int val3 ;
9497 int ecode3 = 0 ;
9498 PyObject * obj0 = 0 ;
9499 PyObject * obj1 = 0 ;
9500 PyObject * obj2 = 0 ;
9501 char * kwnames[] = {
9502 (char *) "self",(char *) "pos",(char *) "mode", NULL
9503 };
9504
9505 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:InputStream_SeekI",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
9506 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9507 if (!SWIG_IsOK(res1)) {
9508 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_SeekI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9509 }
9510 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9511 ecode2 = SWIG_AsVal_long(obj1, &val2);
9512 if (!SWIG_IsOK(ecode2)) {
9513 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "InputStream_SeekI" "', expected argument " "2"" of type '" "long""'");
9514 }
9515 arg2 = static_cast< long >(val2);
9516 if (obj2) {
9517 ecode3 = SWIG_AsVal_int(obj2, &val3);
9518 if (!SWIG_IsOK(ecode3)) {
9519 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "InputStream_SeekI" "', expected argument " "3"" of type '" "wxSeekMode""'");
9520 }
9521 arg3 = static_cast< wxSeekMode >(val3);
9522 }
9523 {
9524 PyThreadState* __tstate = wxPyBeginAllowThreads();
9525 result = (long)(arg1)->SeekI(arg2,arg3);
9526 wxPyEndAllowThreads(__tstate);
9527 if (PyErr_Occurred()) SWIG_fail;
9528 }
9529 resultobj = SWIG_From_long(static_cast< long >(result));
9530 return resultobj;
9531 fail:
9532 return NULL;
9533 }
9534
9535
9536 SWIGINTERN PyObject *_wrap_InputStream_TellI(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9537 PyObject *resultobj = 0;
9538 wxPyInputStream *arg1 = (wxPyInputStream *) 0 ;
9539 long result;
9540 void *argp1 = 0 ;
9541 int res1 = 0 ;
9542 PyObject *swig_obj[1] ;
9543
9544 if (!args) SWIG_fail;
9545 swig_obj[0] = args;
9546 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyInputStream, 0 | 0 );
9547 if (!SWIG_IsOK(res1)) {
9548 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InputStream_TellI" "', expected argument " "1"" of type '" "wxPyInputStream *""'");
9549 }
9550 arg1 = reinterpret_cast< wxPyInputStream * >(argp1);
9551 {
9552 PyThreadState* __tstate = wxPyBeginAllowThreads();
9553 result = (long)(arg1)->TellI();
9554 wxPyEndAllowThreads(__tstate);
9555 if (PyErr_Occurred()) SWIG_fail;
9556 }
9557 resultobj = SWIG_From_long(static_cast< long >(result));
9558 return resultobj;
9559 fail:
9560 return NULL;
9561 }
9562
9563
9564 SWIGINTERN PyObject *InputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9565 PyObject *obj;
9566 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9567 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyInputStream, SWIG_NewClientData(obj));
9568 return SWIG_Py_Void();
9569 }
9570
9571 SWIGINTERN PyObject *InputStream_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9572 return SWIG_Python_InitShadowInstance(args);
9573 }
9574
9575 SWIGINTERN PyObject *_wrap_OutputStream_write(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9576 PyObject *resultobj = 0;
9577 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9578 PyObject *arg2 = (PyObject *) 0 ;
9579 void *argp1 = 0 ;
9580 int res1 = 0 ;
9581 PyObject * obj0 = 0 ;
9582 PyObject * obj1 = 0 ;
9583 char * kwnames[] = {
9584 (char *) "self",(char *) "obj", NULL
9585 };
9586
9587 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:OutputStream_write",kwnames,&obj0,&obj1)) SWIG_fail;
9588 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9589 if (!SWIG_IsOK(res1)) {
9590 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_write" "', expected argument " "1"" of type '" "wxOutputStream *""'");
9591 }
9592 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9593 arg2 = obj1;
9594 {
9595 PyThreadState* __tstate = wxPyBeginAllowThreads();
9596 wxOutputStream_write(arg1,arg2);
9597 wxPyEndAllowThreads(__tstate);
9598 if (PyErr_Occurred()) SWIG_fail;
9599 }
9600 resultobj = SWIG_Py_Void();
9601 return resultobj;
9602 fail:
9603 return NULL;
9604 }
9605
9606
9607 SWIGINTERN PyObject *_wrap_OutputStream_LastWrite(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9608 PyObject *resultobj = 0;
9609 wxOutputStream *arg1 = (wxOutputStream *) 0 ;
9610 size_t result;
9611 void *argp1 = 0 ;
9612 int res1 = 0 ;
9613 PyObject *swig_obj[1] ;
9614
9615 if (!args) SWIG_fail;
9616 swig_obj[0] = args;
9617 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxOutputStream, 0 | 0 );
9618 if (!SWIG_IsOK(res1)) {
9619 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "OutputStream_LastWrite" "', expected argument " "1"" of type '" "wxOutputStream const *""'");
9620 }
9621 arg1 = reinterpret_cast< wxOutputStream * >(argp1);
9622 {
9623 PyThreadState* __tstate = wxPyBeginAllowThreads();
9624 result = (size_t)((wxOutputStream const *)arg1)->LastWrite();
9625 wxPyEndAllowThreads(__tstate);
9626 if (PyErr_Occurred()) SWIG_fail;
9627 }
9628 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
9629 return resultobj;
9630 fail:
9631 return NULL;
9632 }
9633
9634
9635 SWIGINTERN PyObject *OutputStream_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9636 PyObject *obj;
9637 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9638 SWIG_TypeNewClientData(SWIGTYPE_p_wxOutputStream, SWIG_NewClientData(obj));
9639 return SWIG_Py_Void();
9640 }
9641
9642 SWIGINTERN PyObject *_wrap_new_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
9643 PyObject *resultobj = 0;
9644 wxInputStream *arg1 = (wxInputStream *) 0 ;
9645 wxString *arg2 = 0 ;
9646 wxString *arg3 = 0 ;
9647 wxString *arg4 = 0 ;
9648 wxDateTime arg5 ;
9649 wxFSFile *result = 0 ;
9650 wxPyInputStream *temp1 ;
9651 bool temp2 = false ;
9652 bool temp3 = false ;
9653 bool temp4 = false ;
9654 void *argp5 ;
9655 int res5 = 0 ;
9656 PyObject * obj0 = 0 ;
9657 PyObject * obj1 = 0 ;
9658 PyObject * obj2 = 0 ;
9659 PyObject * obj3 = 0 ;
9660 PyObject * obj4 = 0 ;
9661 char * kwnames[] = {
9662 (char *) "stream",(char *) "loc",(char *) "mimetype",(char *) "anchor",(char *) "modif", NULL
9663 };
9664
9665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:new_FSFile",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
9666 {
9667 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
9668 arg1 = wxPyCBInputStream_copy((wxPyCBInputStream*)temp1->m_wxis);
9669 } else {
9670 PyErr_Clear(); // clear the failure of the wxPyConvert above
9671 arg1 = wxPyCBInputStream_create(obj0, true);
9672 if (arg1 == NULL) {
9673 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
9674 SWIG_fail;
9675 }
9676 }
9677 }
9678 {
9679 arg2 = wxString_in_helper(obj1);
9680 if (arg2 == NULL) SWIG_fail;
9681 temp2 = true;
9682 }
9683 {
9684 arg3 = wxString_in_helper(obj2);
9685 if (arg3 == NULL) SWIG_fail;
9686 temp3 = true;
9687 }
9688 {
9689 arg4 = wxString_in_helper(obj3);
9690 if (arg4 == NULL) SWIG_fail;
9691 temp4 = true;
9692 }
9693 {
9694 res5 = SWIG_ConvertPtr(obj4, &argp5, SWIGTYPE_p_wxDateTime, 0 | 0);
9695 if (!SWIG_IsOK(res5)) {
9696 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9697 }
9698 if (!argp5) {
9699 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_FSFile" "', expected argument " "5"" of type '" "wxDateTime""'");
9700 } else {
9701 wxDateTime * temp = reinterpret_cast< wxDateTime * >(argp5);
9702 arg5 = *temp;
9703 if (SWIG_IsNewObj(res5)) delete temp;
9704 }
9705 }
9706 {
9707 PyThreadState* __tstate = wxPyBeginAllowThreads();
9708 result = (wxFSFile *)new wxFSFile(arg1,(wxString const &)*arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
9709 wxPyEndAllowThreads(__tstate);
9710 if (PyErr_Occurred()) SWIG_fail;
9711 }
9712 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFSFile, SWIG_POINTER_NEW | 0 );
9713 {
9714 if (temp2)
9715 delete arg2;
9716 }
9717 {
9718 if (temp3)
9719 delete arg3;
9720 }
9721 {
9722 if (temp4)
9723 delete arg4;
9724 }
9725 return resultobj;
9726 fail:
9727 {
9728 if (temp2)
9729 delete arg2;
9730 }
9731 {
9732 if (temp3)
9733 delete arg3;
9734 }
9735 {
9736 if (temp4)
9737 delete arg4;
9738 }
9739 return NULL;
9740 }
9741
9742
9743 SWIGINTERN PyObject *_wrap_delete_FSFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9744 PyObject *resultobj = 0;
9745 wxFSFile *arg1 = (wxFSFile *) 0 ;
9746 void *argp1 = 0 ;
9747 int res1 = 0 ;
9748 PyObject *swig_obj[1] ;
9749
9750 if (!args) SWIG_fail;
9751 swig_obj[0] = args;
9752 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, SWIG_POINTER_DISOWN | 0 );
9753 if (!SWIG_IsOK(res1)) {
9754 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FSFile" "', expected argument " "1"" of type '" "wxFSFile *""'");
9755 }
9756 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9757 {
9758 PyThreadState* __tstate = wxPyBeginAllowThreads();
9759 delete arg1;
9760
9761 wxPyEndAllowThreads(__tstate);
9762 if (PyErr_Occurred()) SWIG_fail;
9763 }
9764 resultobj = SWIG_Py_Void();
9765 return resultobj;
9766 fail:
9767 return NULL;
9768 }
9769
9770
9771 SWIGINTERN PyObject *_wrap_FSFile_GetStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9772 PyObject *resultobj = 0;
9773 wxFSFile *arg1 = (wxFSFile *) 0 ;
9774 wxInputStream *result = 0 ;
9775 void *argp1 = 0 ;
9776 int res1 = 0 ;
9777 PyObject *swig_obj[1] ;
9778
9779 if (!args) SWIG_fail;
9780 swig_obj[0] = args;
9781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9782 if (!SWIG_IsOK(res1)) {
9783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetStream" "', expected argument " "1"" of type '" "wxFSFile *""'");
9784 }
9785 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9786 {
9787 PyThreadState* __tstate = wxPyBeginAllowThreads();
9788 result = (wxInputStream *)(arg1)->GetStream();
9789 wxPyEndAllowThreads(__tstate);
9790 if (PyErr_Occurred()) SWIG_fail;
9791 }
9792 {
9793 wxPyInputStream * _ptr = NULL;
9794
9795 if (result) {
9796 _ptr = new wxPyInputStream(result);
9797 }
9798 resultobj = wxPyConstructObject(_ptr, wxT("wxPyInputStream"), 0);
9799 }
9800 return resultobj;
9801 fail:
9802 return NULL;
9803 }
9804
9805
9806 SWIGINTERN PyObject *_wrap_FSFile_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9807 PyObject *resultobj = 0;
9808 wxFSFile *arg1 = (wxFSFile *) 0 ;
9809 wxString *result = 0 ;
9810 void *argp1 = 0 ;
9811 int res1 = 0 ;
9812 PyObject *swig_obj[1] ;
9813
9814 if (!args) SWIG_fail;
9815 swig_obj[0] = args;
9816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9817 if (!SWIG_IsOK(res1)) {
9818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetMimeType" "', expected argument " "1"" of type '" "wxFSFile *""'");
9819 }
9820 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9821 {
9822 PyThreadState* __tstate = wxPyBeginAllowThreads();
9823 {
9824 wxString const &_result_ref = (arg1)->GetMimeType();
9825 result = (wxString *) &_result_ref;
9826 }
9827 wxPyEndAllowThreads(__tstate);
9828 if (PyErr_Occurred()) SWIG_fail;
9829 }
9830 {
9831 #if wxUSE_UNICODE
9832 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9833 #else
9834 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9835 #endif
9836 }
9837 return resultobj;
9838 fail:
9839 return NULL;
9840 }
9841
9842
9843 SWIGINTERN PyObject *_wrap_FSFile_GetLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9844 PyObject *resultobj = 0;
9845 wxFSFile *arg1 = (wxFSFile *) 0 ;
9846 wxString *result = 0 ;
9847 void *argp1 = 0 ;
9848 int res1 = 0 ;
9849 PyObject *swig_obj[1] ;
9850
9851 if (!args) SWIG_fail;
9852 swig_obj[0] = args;
9853 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9854 if (!SWIG_IsOK(res1)) {
9855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetLocation" "', expected argument " "1"" of type '" "wxFSFile *""'");
9856 }
9857 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9858 {
9859 PyThreadState* __tstate = wxPyBeginAllowThreads();
9860 {
9861 wxString const &_result_ref = (arg1)->GetLocation();
9862 result = (wxString *) &_result_ref;
9863 }
9864 wxPyEndAllowThreads(__tstate);
9865 if (PyErr_Occurred()) SWIG_fail;
9866 }
9867 {
9868 #if wxUSE_UNICODE
9869 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9870 #else
9871 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9872 #endif
9873 }
9874 return resultobj;
9875 fail:
9876 return NULL;
9877 }
9878
9879
9880 SWIGINTERN PyObject *_wrap_FSFile_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9881 PyObject *resultobj = 0;
9882 wxFSFile *arg1 = (wxFSFile *) 0 ;
9883 wxString *result = 0 ;
9884 void *argp1 = 0 ;
9885 int res1 = 0 ;
9886 PyObject *swig_obj[1] ;
9887
9888 if (!args) SWIG_fail;
9889 swig_obj[0] = args;
9890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9891 if (!SWIG_IsOK(res1)) {
9892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetAnchor" "', expected argument " "1"" of type '" "wxFSFile *""'");
9893 }
9894 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9895 {
9896 PyThreadState* __tstate = wxPyBeginAllowThreads();
9897 {
9898 wxString const &_result_ref = (arg1)->GetAnchor();
9899 result = (wxString *) &_result_ref;
9900 }
9901 wxPyEndAllowThreads(__tstate);
9902 if (PyErr_Occurred()) SWIG_fail;
9903 }
9904 {
9905 #if wxUSE_UNICODE
9906 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
9907 #else
9908 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
9909 #endif
9910 }
9911 return resultobj;
9912 fail:
9913 return NULL;
9914 }
9915
9916
9917 SWIGINTERN PyObject *_wrap_FSFile_GetModificationTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9918 PyObject *resultobj = 0;
9919 wxFSFile *arg1 = (wxFSFile *) 0 ;
9920 wxDateTime result;
9921 void *argp1 = 0 ;
9922 int res1 = 0 ;
9923 PyObject *swig_obj[1] ;
9924
9925 if (!args) SWIG_fail;
9926 swig_obj[0] = args;
9927 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFSFile, 0 | 0 );
9928 if (!SWIG_IsOK(res1)) {
9929 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FSFile_GetModificationTime" "', expected argument " "1"" of type '" "wxFSFile *""'");
9930 }
9931 arg1 = reinterpret_cast< wxFSFile * >(argp1);
9932 {
9933 PyThreadState* __tstate = wxPyBeginAllowThreads();
9934 result = (arg1)->GetModificationTime();
9935 wxPyEndAllowThreads(__tstate);
9936 if (PyErr_Occurred()) SWIG_fail;
9937 }
9938 resultobj = SWIG_NewPointerObj((new wxDateTime(static_cast< const wxDateTime& >(result))), SWIGTYPE_p_wxDateTime, SWIG_POINTER_OWN | 0 );
9939 return resultobj;
9940 fail:
9941 return NULL;
9942 }
9943
9944
9945 SWIGINTERN PyObject *FSFile_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9946 PyObject *obj;
9947 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9948 SWIG_TypeNewClientData(SWIGTYPE_p_wxFSFile, SWIG_NewClientData(obj));
9949 return SWIG_Py_Void();
9950 }
9951
9952 SWIGINTERN PyObject *FSFile_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9953 return SWIG_Python_InitShadowInstance(args);
9954 }
9955
9956 SWIGINTERN PyObject *_wrap_delete_CPPFileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9957 PyObject *resultobj = 0;
9958 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
9959 void *argp1 = 0 ;
9960 int res1 = 0 ;
9961 PyObject *swig_obj[1] ;
9962
9963 if (!args) SWIG_fail;
9964 swig_obj[0] = args;
9965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
9966 if (!SWIG_IsOK(res1)) {
9967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_CPPFileSystemHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
9968 }
9969 arg1 = reinterpret_cast< wxFileSystemHandler * >(argp1);
9970 {
9971 PyThreadState* __tstate = wxPyBeginAllowThreads();
9972 delete arg1;
9973
9974 wxPyEndAllowThreads(__tstate);
9975 if (PyErr_Occurred()) SWIG_fail;
9976 }
9977 resultobj = SWIG_Py_Void();
9978 return resultobj;
9979 fail:
9980 return NULL;
9981 }
9982
9983
9984 SWIGINTERN PyObject *CPPFileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9985 PyObject *obj;
9986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
9987 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystemHandler, SWIG_NewClientData(obj));
9988 return SWIG_Py_Void();
9989 }
9990
9991 SWIGINTERN PyObject *_wrap_new_FileSystemHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
9992 PyObject *resultobj = 0;
9993 wxPyFileSystemHandler *result = 0 ;
9994
9995 if (!SWIG_Python_UnpackTuple(args,"new_FileSystemHandler",0,0,0)) SWIG_fail;
9996 {
9997 PyThreadState* __tstate = wxPyBeginAllowThreads();
9998 result = (wxPyFileSystemHandler *)new wxPyFileSystemHandler();
9999 wxPyEndAllowThreads(__tstate);
10000 if (PyErr_Occurred()) SWIG_fail;
10001 }
10002 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyFileSystemHandler, SWIG_POINTER_NEW | 0 );
10003 return resultobj;
10004 fail:
10005 return NULL;
10006 }
10007
10008
10009 SWIGINTERN PyObject *_wrap_FileSystemHandler__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10010 PyObject *resultobj = 0;
10011 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10012 PyObject *arg2 = (PyObject *) 0 ;
10013 PyObject *arg3 = (PyObject *) 0 ;
10014 void *argp1 = 0 ;
10015 int res1 = 0 ;
10016 PyObject * obj0 = 0 ;
10017 PyObject * obj1 = 0 ;
10018 PyObject * obj2 = 0 ;
10019 char * kwnames[] = {
10020 (char *) "self",(char *) "self",(char *) "_class", NULL
10021 };
10022
10023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10025 if (!SWIG_IsOK(res1)) {
10026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10027 }
10028 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10029 arg2 = obj1;
10030 arg3 = obj2;
10031 {
10032 PyThreadState* __tstate = wxPyBeginAllowThreads();
10033 (arg1)->_setCallbackInfo(arg2,arg3);
10034 wxPyEndAllowThreads(__tstate);
10035 if (PyErr_Occurred()) SWIG_fail;
10036 }
10037 resultobj = SWIG_Py_Void();
10038 return resultobj;
10039 fail:
10040 return NULL;
10041 }
10042
10043
10044 SWIGINTERN PyObject *_wrap_FileSystemHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10045 PyObject *resultobj = 0;
10046 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10047 wxString *arg2 = 0 ;
10048 bool result;
10049 void *argp1 = 0 ;
10050 int res1 = 0 ;
10051 bool temp2 = false ;
10052 PyObject * obj0 = 0 ;
10053 PyObject * obj1 = 0 ;
10054 char * kwnames[] = {
10055 (char *) "self",(char *) "location", NULL
10056 };
10057
10058 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10059 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10060 if (!SWIG_IsOK(res1)) {
10061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_CanOpen" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10062 }
10063 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10064 {
10065 arg2 = wxString_in_helper(obj1);
10066 if (arg2 == NULL) SWIG_fail;
10067 temp2 = true;
10068 }
10069 {
10070 PyThreadState* __tstate = wxPyBeginAllowThreads();
10071 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10072 wxPyEndAllowThreads(__tstate);
10073 if (PyErr_Occurred()) SWIG_fail;
10074 }
10075 {
10076 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10077 }
10078 {
10079 if (temp2)
10080 delete arg2;
10081 }
10082 return resultobj;
10083 fail:
10084 {
10085 if (temp2)
10086 delete arg2;
10087 }
10088 return NULL;
10089 }
10090
10091
10092 SWIGINTERN PyObject *_wrap_FileSystemHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10093 PyObject *resultobj = 0;
10094 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10095 wxFileSystem *arg2 = 0 ;
10096 wxString *arg3 = 0 ;
10097 wxFSFile *result = 0 ;
10098 void *argp1 = 0 ;
10099 int res1 = 0 ;
10100 void *argp2 = 0 ;
10101 int res2 = 0 ;
10102 bool temp3 = false ;
10103 PyObject * obj0 = 0 ;
10104 PyObject * obj1 = 0 ;
10105 PyObject * obj2 = 0 ;
10106 char * kwnames[] = {
10107 (char *) "self",(char *) "fs",(char *) "location", NULL
10108 };
10109
10110 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:FileSystemHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10111 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10112 if (!SWIG_IsOK(res1)) {
10113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10114 }
10115 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10116 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
10117 if (!SWIG_IsOK(res2)) {
10118 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10119 }
10120 if (!argp2) {
10121 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "FileSystemHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
10122 }
10123 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
10124 {
10125 arg3 = wxString_in_helper(obj2);
10126 if (arg3 == NULL) SWIG_fail;
10127 temp3 = true;
10128 }
10129 {
10130 PyThreadState* __tstate = wxPyBeginAllowThreads();
10131 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
10132 wxPyEndAllowThreads(__tstate);
10133 if (PyErr_Occurred()) SWIG_fail;
10134 }
10135 {
10136 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10137 }
10138 {
10139 if (temp3)
10140 delete arg3;
10141 }
10142 return resultobj;
10143 fail:
10144 {
10145 if (temp3)
10146 delete arg3;
10147 }
10148 return NULL;
10149 }
10150
10151
10152 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10153 PyObject *resultobj = 0;
10154 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10155 wxString *arg2 = 0 ;
10156 int arg3 = (int) 0 ;
10157 wxString result;
10158 void *argp1 = 0 ;
10159 int res1 = 0 ;
10160 bool temp2 = false ;
10161 int val3 ;
10162 int ecode3 = 0 ;
10163 PyObject * obj0 = 0 ;
10164 PyObject * obj1 = 0 ;
10165 PyObject * obj2 = 0 ;
10166 char * kwnames[] = {
10167 (char *) "self",(char *) "spec",(char *) "flags", NULL
10168 };
10169
10170 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystemHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10171 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10172 if (!SWIG_IsOK(res1)) {
10173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10174 }
10175 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10176 {
10177 arg2 = wxString_in_helper(obj1);
10178 if (arg2 == NULL) SWIG_fail;
10179 temp2 = true;
10180 }
10181 if (obj2) {
10182 ecode3 = SWIG_AsVal_int(obj2, &val3);
10183 if (!SWIG_IsOK(ecode3)) {
10184 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystemHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
10185 }
10186 arg3 = static_cast< int >(val3);
10187 }
10188 {
10189 PyThreadState* __tstate = wxPyBeginAllowThreads();
10190 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10191 wxPyEndAllowThreads(__tstate);
10192 if (PyErr_Occurred()) SWIG_fail;
10193 }
10194 {
10195 #if wxUSE_UNICODE
10196 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10197 #else
10198 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10199 #endif
10200 }
10201 {
10202 if (temp2)
10203 delete arg2;
10204 }
10205 return resultobj;
10206 fail:
10207 {
10208 if (temp2)
10209 delete arg2;
10210 }
10211 return NULL;
10212 }
10213
10214
10215 SWIGINTERN PyObject *_wrap_FileSystemHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10216 PyObject *resultobj = 0;
10217 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10218 wxString result;
10219 void *argp1 = 0 ;
10220 int res1 = 0 ;
10221 PyObject *swig_obj[1] ;
10222
10223 if (!args) SWIG_fail;
10224 swig_obj[0] = args;
10225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10226 if (!SWIG_IsOK(res1)) {
10227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_FindNext" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10228 }
10229 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10230 {
10231 PyThreadState* __tstate = wxPyBeginAllowThreads();
10232 result = (arg1)->FindNext();
10233 wxPyEndAllowThreads(__tstate);
10234 if (PyErr_Occurred()) SWIG_fail;
10235 }
10236 {
10237 #if wxUSE_UNICODE
10238 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10239 #else
10240 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10241 #endif
10242 }
10243 return resultobj;
10244 fail:
10245 return NULL;
10246 }
10247
10248
10249 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetProtocol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10250 PyObject *resultobj = 0;
10251 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10252 wxString *arg2 = 0 ;
10253 wxString result;
10254 void *argp1 = 0 ;
10255 int res1 = 0 ;
10256 bool temp2 = false ;
10257 PyObject * obj0 = 0 ;
10258 PyObject * obj1 = 0 ;
10259 char * kwnames[] = {
10260 (char *) "self",(char *) "location", NULL
10261 };
10262
10263 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetProtocol",kwnames,&obj0,&obj1)) SWIG_fail;
10264 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10265 if (!SWIG_IsOK(res1)) {
10266 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetProtocol" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10267 }
10268 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10269 {
10270 arg2 = wxString_in_helper(obj1);
10271 if (arg2 == NULL) SWIG_fail;
10272 temp2 = true;
10273 }
10274 {
10275 PyThreadState* __tstate = wxPyBeginAllowThreads();
10276 result = (arg1)->GetProtocol((wxString const &)*arg2);
10277 wxPyEndAllowThreads(__tstate);
10278 if (PyErr_Occurred()) SWIG_fail;
10279 }
10280 {
10281 #if wxUSE_UNICODE
10282 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10283 #else
10284 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10285 #endif
10286 }
10287 {
10288 if (temp2)
10289 delete arg2;
10290 }
10291 return resultobj;
10292 fail:
10293 {
10294 if (temp2)
10295 delete arg2;
10296 }
10297 return NULL;
10298 }
10299
10300
10301 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetLeftLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10302 PyObject *resultobj = 0;
10303 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10304 wxString *arg2 = 0 ;
10305 wxString result;
10306 void *argp1 = 0 ;
10307 int res1 = 0 ;
10308 bool temp2 = false ;
10309 PyObject * obj0 = 0 ;
10310 PyObject * obj1 = 0 ;
10311 char * kwnames[] = {
10312 (char *) "self",(char *) "location", NULL
10313 };
10314
10315 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetLeftLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10316 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10317 if (!SWIG_IsOK(res1)) {
10318 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetLeftLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10319 }
10320 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10321 {
10322 arg2 = wxString_in_helper(obj1);
10323 if (arg2 == NULL) SWIG_fail;
10324 temp2 = true;
10325 }
10326 {
10327 PyThreadState* __tstate = wxPyBeginAllowThreads();
10328 result = (arg1)->GetLeftLocation((wxString const &)*arg2);
10329 wxPyEndAllowThreads(__tstate);
10330 if (PyErr_Occurred()) SWIG_fail;
10331 }
10332 {
10333 #if wxUSE_UNICODE
10334 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10335 #else
10336 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10337 #endif
10338 }
10339 {
10340 if (temp2)
10341 delete arg2;
10342 }
10343 return resultobj;
10344 fail:
10345 {
10346 if (temp2)
10347 delete arg2;
10348 }
10349 return NULL;
10350 }
10351
10352
10353 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetAnchor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10354 PyObject *resultobj = 0;
10355 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10356 wxString *arg2 = 0 ;
10357 wxString result;
10358 void *argp1 = 0 ;
10359 int res1 = 0 ;
10360 bool temp2 = false ;
10361 PyObject * obj0 = 0 ;
10362 PyObject * obj1 = 0 ;
10363 char * kwnames[] = {
10364 (char *) "self",(char *) "location", NULL
10365 };
10366
10367 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetAnchor",kwnames,&obj0,&obj1)) SWIG_fail;
10368 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10369 if (!SWIG_IsOK(res1)) {
10370 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetAnchor" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10371 }
10372 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10373 {
10374 arg2 = wxString_in_helper(obj1);
10375 if (arg2 == NULL) SWIG_fail;
10376 temp2 = true;
10377 }
10378 {
10379 PyThreadState* __tstate = wxPyBeginAllowThreads();
10380 result = (arg1)->GetAnchor((wxString const &)*arg2);
10381 wxPyEndAllowThreads(__tstate);
10382 if (PyErr_Occurred()) SWIG_fail;
10383 }
10384 {
10385 #if wxUSE_UNICODE
10386 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10387 #else
10388 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10389 #endif
10390 }
10391 {
10392 if (temp2)
10393 delete arg2;
10394 }
10395 return resultobj;
10396 fail:
10397 {
10398 if (temp2)
10399 delete arg2;
10400 }
10401 return NULL;
10402 }
10403
10404
10405 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetRightLocation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10406 PyObject *resultobj = 0;
10407 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10408 wxString *arg2 = 0 ;
10409 wxString result;
10410 void *argp1 = 0 ;
10411 int res1 = 0 ;
10412 bool temp2 = false ;
10413 PyObject * obj0 = 0 ;
10414 PyObject * obj1 = 0 ;
10415 char * kwnames[] = {
10416 (char *) "self",(char *) "location", NULL
10417 };
10418
10419 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetRightLocation",kwnames,&obj0,&obj1)) SWIG_fail;
10420 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10421 if (!SWIG_IsOK(res1)) {
10422 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetRightLocation" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10423 }
10424 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10425 {
10426 arg2 = wxString_in_helper(obj1);
10427 if (arg2 == NULL) SWIG_fail;
10428 temp2 = true;
10429 }
10430 {
10431 PyThreadState* __tstate = wxPyBeginAllowThreads();
10432 result = (arg1)->GetRightLocation((wxString const &)*arg2);
10433 wxPyEndAllowThreads(__tstate);
10434 if (PyErr_Occurred()) SWIG_fail;
10435 }
10436 {
10437 #if wxUSE_UNICODE
10438 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10439 #else
10440 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10441 #endif
10442 }
10443 {
10444 if (temp2)
10445 delete arg2;
10446 }
10447 return resultobj;
10448 fail:
10449 {
10450 if (temp2)
10451 delete arg2;
10452 }
10453 return NULL;
10454 }
10455
10456
10457 SWIGINTERN PyObject *_wrap_FileSystemHandler_GetMimeTypeFromExt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10458 PyObject *resultobj = 0;
10459 wxPyFileSystemHandler *arg1 = (wxPyFileSystemHandler *) 0 ;
10460 wxString *arg2 = 0 ;
10461 wxString result;
10462 void *argp1 = 0 ;
10463 int res1 = 0 ;
10464 bool temp2 = false ;
10465 PyObject * obj0 = 0 ;
10466 PyObject * obj1 = 0 ;
10467 char * kwnames[] = {
10468 (char *) "self",(char *) "location", NULL
10469 };
10470
10471 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystemHandler_GetMimeTypeFromExt",kwnames,&obj0,&obj1)) SWIG_fail;
10472 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyFileSystemHandler, 0 | 0 );
10473 if (!SWIG_IsOK(res1)) {
10474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystemHandler_GetMimeTypeFromExt" "', expected argument " "1"" of type '" "wxPyFileSystemHandler *""'");
10475 }
10476 arg1 = reinterpret_cast< wxPyFileSystemHandler * >(argp1);
10477 {
10478 arg2 = wxString_in_helper(obj1);
10479 if (arg2 == NULL) SWIG_fail;
10480 temp2 = true;
10481 }
10482 {
10483 PyThreadState* __tstate = wxPyBeginAllowThreads();
10484 result = (arg1)->GetMimeTypeFromExt((wxString const &)*arg2);
10485 wxPyEndAllowThreads(__tstate);
10486 if (PyErr_Occurred()) SWIG_fail;
10487 }
10488 {
10489 #if wxUSE_UNICODE
10490 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10491 #else
10492 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10493 #endif
10494 }
10495 {
10496 if (temp2)
10497 delete arg2;
10498 }
10499 return resultobj;
10500 fail:
10501 {
10502 if (temp2)
10503 delete arg2;
10504 }
10505 return NULL;
10506 }
10507
10508
10509 SWIGINTERN PyObject *FileSystemHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10510 PyObject *obj;
10511 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10512 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyFileSystemHandler, SWIG_NewClientData(obj));
10513 return SWIG_Py_Void();
10514 }
10515
10516 SWIGINTERN PyObject *FileSystemHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10517 return SWIG_Python_InitShadowInstance(args);
10518 }
10519
10520 SWIGINTERN PyObject *_wrap_new_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10521 PyObject *resultobj = 0;
10522 wxFileSystem *result = 0 ;
10523
10524 if (!SWIG_Python_UnpackTuple(args,"new_FileSystem",0,0,0)) SWIG_fail;
10525 {
10526 PyThreadState* __tstate = wxPyBeginAllowThreads();
10527 result = (wxFileSystem *)new wxFileSystem();
10528 wxPyEndAllowThreads(__tstate);
10529 if (PyErr_Occurred()) SWIG_fail;
10530 }
10531 {
10532 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
10533 }
10534 return resultobj;
10535 fail:
10536 return NULL;
10537 }
10538
10539
10540 SWIGINTERN PyObject *_wrap_delete_FileSystem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10541 PyObject *resultobj = 0;
10542 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10543 void *argp1 = 0 ;
10544 int res1 = 0 ;
10545 PyObject *swig_obj[1] ;
10546
10547 if (!args) SWIG_fail;
10548 swig_obj[0] = args;
10549 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, SWIG_POINTER_DISOWN | 0 );
10550 if (!SWIG_IsOK(res1)) {
10551 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_FileSystem" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10552 }
10553 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10554 {
10555 PyThreadState* __tstate = wxPyBeginAllowThreads();
10556 delete arg1;
10557
10558 wxPyEndAllowThreads(__tstate);
10559 if (PyErr_Occurred()) SWIG_fail;
10560 }
10561 resultobj = SWIG_Py_Void();
10562 return resultobj;
10563 fail:
10564 return NULL;
10565 }
10566
10567
10568 SWIGINTERN PyObject *_wrap_FileSystem_ChangePathTo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10569 PyObject *resultobj = 0;
10570 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10571 wxString *arg2 = 0 ;
10572 bool arg3 = (bool) false ;
10573 void *argp1 = 0 ;
10574 int res1 = 0 ;
10575 bool temp2 = false ;
10576 bool val3 ;
10577 int ecode3 = 0 ;
10578 PyObject * obj0 = 0 ;
10579 PyObject * obj1 = 0 ;
10580 PyObject * obj2 = 0 ;
10581 char * kwnames[] = {
10582 (char *) "self",(char *) "location",(char *) "is_dir", NULL
10583 };
10584
10585 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_ChangePathTo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10586 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10587 if (!SWIG_IsOK(res1)) {
10588 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_ChangePathTo" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10589 }
10590 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10591 {
10592 arg2 = wxString_in_helper(obj1);
10593 if (arg2 == NULL) SWIG_fail;
10594 temp2 = true;
10595 }
10596 if (obj2) {
10597 ecode3 = SWIG_AsVal_bool(obj2, &val3);
10598 if (!SWIG_IsOK(ecode3)) {
10599 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_ChangePathTo" "', expected argument " "3"" of type '" "bool""'");
10600 }
10601 arg3 = static_cast< bool >(val3);
10602 }
10603 {
10604 PyThreadState* __tstate = wxPyBeginAllowThreads();
10605 (arg1)->ChangePathTo((wxString const &)*arg2,arg3);
10606 wxPyEndAllowThreads(__tstate);
10607 if (PyErr_Occurred()) SWIG_fail;
10608 }
10609 resultobj = SWIG_Py_Void();
10610 {
10611 if (temp2)
10612 delete arg2;
10613 }
10614 return resultobj;
10615 fail:
10616 {
10617 if (temp2)
10618 delete arg2;
10619 }
10620 return NULL;
10621 }
10622
10623
10624 SWIGINTERN PyObject *_wrap_FileSystem_GetPath(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10625 PyObject *resultobj = 0;
10626 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10627 wxString result;
10628 void *argp1 = 0 ;
10629 int res1 = 0 ;
10630 PyObject *swig_obj[1] ;
10631
10632 if (!args) SWIG_fail;
10633 swig_obj[0] = args;
10634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10635 if (!SWIG_IsOK(res1)) {
10636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_GetPath" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10637 }
10638 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10639 {
10640 PyThreadState* __tstate = wxPyBeginAllowThreads();
10641 result = (arg1)->GetPath();
10642 wxPyEndAllowThreads(__tstate);
10643 if (PyErr_Occurred()) SWIG_fail;
10644 }
10645 {
10646 #if wxUSE_UNICODE
10647 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10648 #else
10649 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10650 #endif
10651 }
10652 return resultobj;
10653 fail:
10654 return NULL;
10655 }
10656
10657
10658 SWIGINTERN PyObject *_wrap_FileSystem_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10659 PyObject *resultobj = 0;
10660 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10661 wxString *arg2 = 0 ;
10662 wxFSFile *result = 0 ;
10663 void *argp1 = 0 ;
10664 int res1 = 0 ;
10665 bool temp2 = false ;
10666 PyObject * obj0 = 0 ;
10667 PyObject * obj1 = 0 ;
10668 char * kwnames[] = {
10669 (char *) "self",(char *) "location", NULL
10670 };
10671
10672 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FileSystem_OpenFile",kwnames,&obj0,&obj1)) SWIG_fail;
10673 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10674 if (!SWIG_IsOK(res1)) {
10675 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_OpenFile" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10676 }
10677 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10678 {
10679 arg2 = wxString_in_helper(obj1);
10680 if (arg2 == NULL) SWIG_fail;
10681 temp2 = true;
10682 }
10683 {
10684 PyThreadState* __tstate = wxPyBeginAllowThreads();
10685 result = (wxFSFile *)(arg1)->OpenFile((wxString const &)*arg2);
10686 wxPyEndAllowThreads(__tstate);
10687 if (PyErr_Occurred()) SWIG_fail;
10688 }
10689 {
10690 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
10691 }
10692 {
10693 if (temp2)
10694 delete arg2;
10695 }
10696 return resultobj;
10697 fail:
10698 {
10699 if (temp2)
10700 delete arg2;
10701 }
10702 return NULL;
10703 }
10704
10705
10706 SWIGINTERN PyObject *_wrap_FileSystem_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10707 PyObject *resultobj = 0;
10708 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10709 wxString *arg2 = 0 ;
10710 int arg3 = (int) 0 ;
10711 wxString result;
10712 void *argp1 = 0 ;
10713 int res1 = 0 ;
10714 bool temp2 = false ;
10715 int val3 ;
10716 int ecode3 = 0 ;
10717 PyObject * obj0 = 0 ;
10718 PyObject * obj1 = 0 ;
10719 PyObject * obj2 = 0 ;
10720 char * kwnames[] = {
10721 (char *) "self",(char *) "spec",(char *) "flags", NULL
10722 };
10723
10724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FileSystem_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
10725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10726 if (!SWIG_IsOK(res1)) {
10727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindFirst" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10728 }
10729 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10730 {
10731 arg2 = wxString_in_helper(obj1);
10732 if (arg2 == NULL) SWIG_fail;
10733 temp2 = true;
10734 }
10735 if (obj2) {
10736 ecode3 = SWIG_AsVal_int(obj2, &val3);
10737 if (!SWIG_IsOK(ecode3)) {
10738 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FileSystem_FindFirst" "', expected argument " "3"" of type '" "int""'");
10739 }
10740 arg3 = static_cast< int >(val3);
10741 }
10742 {
10743 PyThreadState* __tstate = wxPyBeginAllowThreads();
10744 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
10745 wxPyEndAllowThreads(__tstate);
10746 if (PyErr_Occurred()) SWIG_fail;
10747 }
10748 {
10749 #if wxUSE_UNICODE
10750 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10751 #else
10752 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10753 #endif
10754 }
10755 {
10756 if (temp2)
10757 delete arg2;
10758 }
10759 return resultobj;
10760 fail:
10761 {
10762 if (temp2)
10763 delete arg2;
10764 }
10765 return NULL;
10766 }
10767
10768
10769 SWIGINTERN PyObject *_wrap_FileSystem_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10770 PyObject *resultobj = 0;
10771 wxFileSystem *arg1 = (wxFileSystem *) 0 ;
10772 wxString result;
10773 void *argp1 = 0 ;
10774 int res1 = 0 ;
10775 PyObject *swig_obj[1] ;
10776
10777 if (!args) SWIG_fail;
10778 swig_obj[0] = args;
10779 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFileSystem, 0 | 0 );
10780 if (!SWIG_IsOK(res1)) {
10781 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_FindNext" "', expected argument " "1"" of type '" "wxFileSystem *""'");
10782 }
10783 arg1 = reinterpret_cast< wxFileSystem * >(argp1);
10784 {
10785 PyThreadState* __tstate = wxPyBeginAllowThreads();
10786 result = (arg1)->FindNext();
10787 wxPyEndAllowThreads(__tstate);
10788 if (PyErr_Occurred()) SWIG_fail;
10789 }
10790 {
10791 #if wxUSE_UNICODE
10792 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10793 #else
10794 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10795 #endif
10796 }
10797 return resultobj;
10798 fail:
10799 return NULL;
10800 }
10801
10802
10803 SWIGINTERN PyObject *_wrap_FileSystem_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10804 PyObject *resultobj = 0;
10805 wxFileSystemHandler *arg1 = (wxFileSystemHandler *) 0 ;
10806 int res1 = 0 ;
10807 PyObject * obj0 = 0 ;
10808 char * kwnames[] = {
10809 (char *) "handler", NULL
10810 };
10811
10812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_AddHandler",kwnames,&obj0)) SWIG_fail;
10813 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxFileSystemHandler, SWIG_POINTER_DISOWN | 0 );
10814 if (!SWIG_IsOK(res1)) {
10815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FileSystem_AddHandler" "', expected argument " "1"" of type '" "wxFileSystemHandler *""'");
10816 }
10817 {
10818 PyThreadState* __tstate = wxPyBeginAllowThreads();
10819 wxFileSystem::AddHandler(arg1);
10820 wxPyEndAllowThreads(__tstate);
10821 if (PyErr_Occurred()) SWIG_fail;
10822 }
10823 resultobj = SWIG_Py_Void();
10824 return resultobj;
10825 fail:
10826 return NULL;
10827 }
10828
10829
10830 SWIGINTERN PyObject *_wrap_FileSystem_CleanUpHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10831 PyObject *resultobj = 0;
10832
10833 if (!SWIG_Python_UnpackTuple(args,"FileSystem_CleanUpHandlers",0,0,0)) SWIG_fail;
10834 {
10835 PyThreadState* __tstate = wxPyBeginAllowThreads();
10836 wxFileSystem::CleanUpHandlers();
10837 wxPyEndAllowThreads(__tstate);
10838 if (PyErr_Occurred()) SWIG_fail;
10839 }
10840 resultobj = SWIG_Py_Void();
10841 return resultobj;
10842 fail:
10843 return NULL;
10844 }
10845
10846
10847 SWIGINTERN PyObject *_wrap_FileSystem_FileNameToURL(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10848 PyObject *resultobj = 0;
10849 wxString *arg1 = 0 ;
10850 wxString result;
10851 bool temp1 = false ;
10852 PyObject * obj0 = 0 ;
10853 char * kwnames[] = {
10854 (char *) "filename", NULL
10855 };
10856
10857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_FileNameToURL",kwnames,&obj0)) SWIG_fail;
10858 {
10859 arg1 = wxString_in_helper(obj0);
10860 if (arg1 == NULL) SWIG_fail;
10861 temp1 = true;
10862 }
10863 {
10864 PyThreadState* __tstate = wxPyBeginAllowThreads();
10865 result = wxFileSystem::FileNameToURL((wxString const &)*arg1);
10866 wxPyEndAllowThreads(__tstate);
10867 if (PyErr_Occurred()) SWIG_fail;
10868 }
10869 {
10870 #if wxUSE_UNICODE
10871 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10872 #else
10873 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10874 #endif
10875 }
10876 {
10877 if (temp1)
10878 delete arg1;
10879 }
10880 return resultobj;
10881 fail:
10882 {
10883 if (temp1)
10884 delete arg1;
10885 }
10886 return NULL;
10887 }
10888
10889
10890 SWIGINTERN PyObject *_wrap_FileSystem_URLToFileName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10891 PyObject *resultobj = 0;
10892 wxString *arg1 = 0 ;
10893 wxString result;
10894 bool temp1 = false ;
10895 PyObject * obj0 = 0 ;
10896 char * kwnames[] = {
10897 (char *) "url", NULL
10898 };
10899
10900 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:FileSystem_URLToFileName",kwnames,&obj0)) SWIG_fail;
10901 {
10902 arg1 = wxString_in_helper(obj0);
10903 if (arg1 == NULL) SWIG_fail;
10904 temp1 = true;
10905 }
10906 {
10907 PyThreadState* __tstate = wxPyBeginAllowThreads();
10908 result = wxFileSystem_URLToFileName((wxString const &)*arg1);
10909 wxPyEndAllowThreads(__tstate);
10910 if (PyErr_Occurred()) SWIG_fail;
10911 }
10912 {
10913 #if wxUSE_UNICODE
10914 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
10915 #else
10916 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
10917 #endif
10918 }
10919 {
10920 if (temp1)
10921 delete arg1;
10922 }
10923 return resultobj;
10924 fail:
10925 {
10926 if (temp1)
10927 delete arg1;
10928 }
10929 return NULL;
10930 }
10931
10932
10933 SWIGINTERN PyObject *FileSystem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10934 PyObject *obj;
10935 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
10936 SWIG_TypeNewClientData(SWIGTYPE_p_wxFileSystem, SWIG_NewClientData(obj));
10937 return SWIG_Py_Void();
10938 }
10939
10940 SWIGINTERN PyObject *FileSystem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10941 return SWIG_Python_InitShadowInstance(args);
10942 }
10943
10944 SWIGINTERN PyObject *_wrap_new_InternetFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
10945 PyObject *resultobj = 0;
10946 wxInternetFSHandler *result = 0 ;
10947
10948 if (!SWIG_Python_UnpackTuple(args,"new_InternetFSHandler",0,0,0)) SWIG_fail;
10949 {
10950 PyThreadState* __tstate = wxPyBeginAllowThreads();
10951 result = (wxInternetFSHandler *)new wxInternetFSHandler();
10952 wxPyEndAllowThreads(__tstate);
10953 if (PyErr_Occurred()) SWIG_fail;
10954 }
10955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInternetFSHandler, SWIG_POINTER_NEW | 0 );
10956 return resultobj;
10957 fail:
10958 return NULL;
10959 }
10960
10961
10962 SWIGINTERN PyObject *_wrap_InternetFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
10963 PyObject *resultobj = 0;
10964 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
10965 wxString *arg2 = 0 ;
10966 bool result;
10967 void *argp1 = 0 ;
10968 int res1 = 0 ;
10969 bool temp2 = false ;
10970 PyObject * obj0 = 0 ;
10971 PyObject * obj1 = 0 ;
10972 char * kwnames[] = {
10973 (char *) "self",(char *) "location", NULL
10974 };
10975
10976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:InternetFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
10977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
10978 if (!SWIG_IsOK(res1)) {
10979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
10980 }
10981 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
10982 {
10983 arg2 = wxString_in_helper(obj1);
10984 if (arg2 == NULL) SWIG_fail;
10985 temp2 = true;
10986 }
10987 {
10988 PyThreadState* __tstate = wxPyBeginAllowThreads();
10989 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
10990 wxPyEndAllowThreads(__tstate);
10991 if (PyErr_Occurred()) SWIG_fail;
10992 }
10993 {
10994 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
10995 }
10996 {
10997 if (temp2)
10998 delete arg2;
10999 }
11000 return resultobj;
11001 fail:
11002 {
11003 if (temp2)
11004 delete arg2;
11005 }
11006 return NULL;
11007 }
11008
11009
11010 SWIGINTERN PyObject *_wrap_InternetFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11011 PyObject *resultobj = 0;
11012 wxInternetFSHandler *arg1 = (wxInternetFSHandler *) 0 ;
11013 wxFileSystem *arg2 = 0 ;
11014 wxString *arg3 = 0 ;
11015 wxFSFile *result = 0 ;
11016 void *argp1 = 0 ;
11017 int res1 = 0 ;
11018 void *argp2 = 0 ;
11019 int res2 = 0 ;
11020 bool temp3 = false ;
11021 PyObject * obj0 = 0 ;
11022 PyObject * obj1 = 0 ;
11023 PyObject * obj2 = 0 ;
11024 char * kwnames[] = {
11025 (char *) "self",(char *) "fs",(char *) "location", NULL
11026 };
11027
11028 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:InternetFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11029 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxInternetFSHandler, 0 | 0 );
11030 if (!SWIG_IsOK(res1)) {
11031 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxInternetFSHandler *""'");
11032 }
11033 arg1 = reinterpret_cast< wxInternetFSHandler * >(argp1);
11034 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11035 if (!SWIG_IsOK(res2)) {
11036 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11037 }
11038 if (!argp2) {
11039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "InternetFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11040 }
11041 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11042 {
11043 arg3 = wxString_in_helper(obj2);
11044 if (arg3 == NULL) SWIG_fail;
11045 temp3 = true;
11046 }
11047 {
11048 PyThreadState* __tstate = wxPyBeginAllowThreads();
11049 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11050 wxPyEndAllowThreads(__tstate);
11051 if (PyErr_Occurred()) SWIG_fail;
11052 }
11053 {
11054 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11055 }
11056 {
11057 if (temp3)
11058 delete arg3;
11059 }
11060 return resultobj;
11061 fail:
11062 {
11063 if (temp3)
11064 delete arg3;
11065 }
11066 return NULL;
11067 }
11068
11069
11070 SWIGINTERN PyObject *InternetFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11071 PyObject *obj;
11072 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11073 SWIG_TypeNewClientData(SWIGTYPE_p_wxInternetFSHandler, SWIG_NewClientData(obj));
11074 return SWIG_Py_Void();
11075 }
11076
11077 SWIGINTERN PyObject *InternetFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11078 return SWIG_Python_InitShadowInstance(args);
11079 }
11080
11081 SWIGINTERN PyObject *_wrap_new_ZipFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11082 PyObject *resultobj = 0;
11083 wxZipFSHandler *result = 0 ;
11084
11085 if (!SWIG_Python_UnpackTuple(args,"new_ZipFSHandler",0,0,0)) SWIG_fail;
11086 {
11087 PyThreadState* __tstate = wxPyBeginAllowThreads();
11088 result = (wxZipFSHandler *)new wxZipFSHandler();
11089 wxPyEndAllowThreads(__tstate);
11090 if (PyErr_Occurred()) SWIG_fail;
11091 }
11092 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxZipFSHandler, SWIG_POINTER_NEW | 0 );
11093 return resultobj;
11094 fail:
11095 return NULL;
11096 }
11097
11098
11099 SWIGINTERN PyObject *_wrap_ZipFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11100 PyObject *resultobj = 0;
11101 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11102 wxString *arg2 = 0 ;
11103 bool result;
11104 void *argp1 = 0 ;
11105 int res1 = 0 ;
11106 bool temp2 = false ;
11107 PyObject * obj0 = 0 ;
11108 PyObject * obj1 = 0 ;
11109 char * kwnames[] = {
11110 (char *) "self",(char *) "location", NULL
11111 };
11112
11113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ZipFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11115 if (!SWIG_IsOK(res1)) {
11116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11117 }
11118 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11119 {
11120 arg2 = wxString_in_helper(obj1);
11121 if (arg2 == NULL) SWIG_fail;
11122 temp2 = true;
11123 }
11124 {
11125 PyThreadState* __tstate = wxPyBeginAllowThreads();
11126 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11127 wxPyEndAllowThreads(__tstate);
11128 if (PyErr_Occurred()) SWIG_fail;
11129 }
11130 {
11131 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11132 }
11133 {
11134 if (temp2)
11135 delete arg2;
11136 }
11137 return resultobj;
11138 fail:
11139 {
11140 if (temp2)
11141 delete arg2;
11142 }
11143 return NULL;
11144 }
11145
11146
11147 SWIGINTERN PyObject *_wrap_ZipFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11148 PyObject *resultobj = 0;
11149 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11150 wxFileSystem *arg2 = 0 ;
11151 wxString *arg3 = 0 ;
11152 wxFSFile *result = 0 ;
11153 void *argp1 = 0 ;
11154 int res1 = 0 ;
11155 void *argp2 = 0 ;
11156 int res2 = 0 ;
11157 bool temp3 = false ;
11158 PyObject * obj0 = 0 ;
11159 PyObject * obj1 = 0 ;
11160 PyObject * obj2 = 0 ;
11161 char * kwnames[] = {
11162 (char *) "self",(char *) "fs",(char *) "location", NULL
11163 };
11164
11165 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ZipFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11166 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11167 if (!SWIG_IsOK(res1)) {
11168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11169 }
11170 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11171 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11172 if (!SWIG_IsOK(res2)) {
11173 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11174 }
11175 if (!argp2) {
11176 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "ZipFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11177 }
11178 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11179 {
11180 arg3 = wxString_in_helper(obj2);
11181 if (arg3 == NULL) SWIG_fail;
11182 temp3 = true;
11183 }
11184 {
11185 PyThreadState* __tstate = wxPyBeginAllowThreads();
11186 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11187 wxPyEndAllowThreads(__tstate);
11188 if (PyErr_Occurred()) SWIG_fail;
11189 }
11190 {
11191 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11192 }
11193 {
11194 if (temp3)
11195 delete arg3;
11196 }
11197 return resultobj;
11198 fail:
11199 {
11200 if (temp3)
11201 delete arg3;
11202 }
11203 return NULL;
11204 }
11205
11206
11207 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11208 PyObject *resultobj = 0;
11209 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11210 wxString *arg2 = 0 ;
11211 int arg3 = (int) 0 ;
11212 wxString result;
11213 void *argp1 = 0 ;
11214 int res1 = 0 ;
11215 bool temp2 = false ;
11216 int val3 ;
11217 int ecode3 = 0 ;
11218 PyObject * obj0 = 0 ;
11219 PyObject * obj1 = 0 ;
11220 PyObject * obj2 = 0 ;
11221 char * kwnames[] = {
11222 (char *) "self",(char *) "spec",(char *) "flags", NULL
11223 };
11224
11225 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ZipFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11226 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11227 if (!SWIG_IsOK(res1)) {
11228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11229 }
11230 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11231 {
11232 arg2 = wxString_in_helper(obj1);
11233 if (arg2 == NULL) SWIG_fail;
11234 temp2 = true;
11235 }
11236 if (obj2) {
11237 ecode3 = SWIG_AsVal_int(obj2, &val3);
11238 if (!SWIG_IsOK(ecode3)) {
11239 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ZipFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11240 }
11241 arg3 = static_cast< int >(val3);
11242 }
11243 {
11244 PyThreadState* __tstate = wxPyBeginAllowThreads();
11245 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11246 wxPyEndAllowThreads(__tstate);
11247 if (PyErr_Occurred()) SWIG_fail;
11248 }
11249 {
11250 #if wxUSE_UNICODE
11251 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11252 #else
11253 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11254 #endif
11255 }
11256 {
11257 if (temp2)
11258 delete arg2;
11259 }
11260 return resultobj;
11261 fail:
11262 {
11263 if (temp2)
11264 delete arg2;
11265 }
11266 return NULL;
11267 }
11268
11269
11270 SWIGINTERN PyObject *_wrap_ZipFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11271 PyObject *resultobj = 0;
11272 wxZipFSHandler *arg1 = (wxZipFSHandler *) 0 ;
11273 wxString result;
11274 void *argp1 = 0 ;
11275 int res1 = 0 ;
11276 PyObject *swig_obj[1] ;
11277
11278 if (!args) SWIG_fail;
11279 swig_obj[0] = args;
11280 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxZipFSHandler, 0 | 0 );
11281 if (!SWIG_IsOK(res1)) {
11282 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ZipFSHandler_FindNext" "', expected argument " "1"" of type '" "wxZipFSHandler *""'");
11283 }
11284 arg1 = reinterpret_cast< wxZipFSHandler * >(argp1);
11285 {
11286 PyThreadState* __tstate = wxPyBeginAllowThreads();
11287 result = (arg1)->FindNext();
11288 wxPyEndAllowThreads(__tstate);
11289 if (PyErr_Occurred()) SWIG_fail;
11290 }
11291 {
11292 #if wxUSE_UNICODE
11293 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11294 #else
11295 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11296 #endif
11297 }
11298 return resultobj;
11299 fail:
11300 return NULL;
11301 }
11302
11303
11304 SWIGINTERN PyObject *ZipFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11305 PyObject *obj;
11306 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11307 SWIG_TypeNewClientData(SWIGTYPE_p_wxZipFSHandler, SWIG_NewClientData(obj));
11308 return SWIG_Py_Void();
11309 }
11310
11311 SWIGINTERN PyObject *ZipFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11312 return SWIG_Python_InitShadowInstance(args);
11313 }
11314
11315 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11316 PyObject *resultobj = 0;
11317 wxString *arg1 = 0 ;
11318 wxImage *arg2 = 0 ;
11319 long arg3 ;
11320 bool temp1 = false ;
11321 void *argp2 = 0 ;
11322 int res2 = 0 ;
11323 long val3 ;
11324 int ecode3 = 0 ;
11325 PyObject * obj0 = 0 ;
11326 PyObject * obj1 = 0 ;
11327 PyObject * obj2 = 0 ;
11328 char * kwnames[] = {
11329 (char *) "filename",(char *) "image",(char *) "type", NULL
11330 };
11331
11332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11333 {
11334 arg1 = wxString_in_helper(obj0);
11335 if (arg1 == NULL) SWIG_fail;
11336 temp1 = true;
11337 }
11338 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
11339 if (!SWIG_IsOK(res2)) {
11340 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11341 }
11342 if (!argp2) {
11343 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "2"" of type '" "wxImage &""'");
11344 }
11345 arg2 = reinterpret_cast< wxImage * >(argp2);
11346 ecode3 = SWIG_AsVal_long(obj2, &val3);
11347 if (!SWIG_IsOK(ecode3)) {
11348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxImage" "', expected argument " "3"" of type '" "long""'");
11349 }
11350 arg3 = static_cast< long >(val3);
11351 {
11352 PyThreadState* __tstate = wxPyBeginAllowThreads();
11353 __wxMemoryFSHandler_AddFile_wxImage((wxString const &)*arg1,*arg2,arg3);
11354 wxPyEndAllowThreads(__tstate);
11355 if (PyErr_Occurred()) SWIG_fail;
11356 }
11357 resultobj = SWIG_Py_Void();
11358 {
11359 if (temp1)
11360 delete arg1;
11361 }
11362 return resultobj;
11363 fail:
11364 {
11365 if (temp1)
11366 delete arg1;
11367 }
11368 return NULL;
11369 }
11370
11371
11372 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_wxBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11373 PyObject *resultobj = 0;
11374 wxString *arg1 = 0 ;
11375 wxBitmap *arg2 = 0 ;
11376 long arg3 ;
11377 bool temp1 = false ;
11378 void *argp2 = 0 ;
11379 int res2 = 0 ;
11380 long val3 ;
11381 int ecode3 = 0 ;
11382 PyObject * obj0 = 0 ;
11383 PyObject * obj1 = 0 ;
11384 PyObject * obj2 = 0 ;
11385 char * kwnames[] = {
11386 (char *) "filename",(char *) "bitmap",(char *) "type", NULL
11387 };
11388
11389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:__wxMemoryFSHandler_AddFile_wxBitmap",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11390 {
11391 arg1 = wxString_in_helper(obj0);
11392 if (arg1 == NULL) SWIG_fail;
11393 temp1 = true;
11394 }
11395 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
11396 if (!SWIG_IsOK(res2)) {
11397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11398 }
11399 if (!argp2) {
11400 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
11401 }
11402 arg2 = reinterpret_cast< wxBitmap * >(argp2);
11403 ecode3 = SWIG_AsVal_long(obj2, &val3);
11404 if (!SWIG_IsOK(ecode3)) {
11405 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "__wxMemoryFSHandler_AddFile_wxBitmap" "', expected argument " "3"" of type '" "long""'");
11406 }
11407 arg3 = static_cast< long >(val3);
11408 {
11409 PyThreadState* __tstate = wxPyBeginAllowThreads();
11410 __wxMemoryFSHandler_AddFile_wxBitmap((wxString const &)*arg1,(wxBitmap const &)*arg2,arg3);
11411 wxPyEndAllowThreads(__tstate);
11412 if (PyErr_Occurred()) SWIG_fail;
11413 }
11414 resultobj = SWIG_Py_Void();
11415 {
11416 if (temp1)
11417 delete arg1;
11418 }
11419 return resultobj;
11420 fail:
11421 {
11422 if (temp1)
11423 delete arg1;
11424 }
11425 return NULL;
11426 }
11427
11428
11429 SWIGINTERN PyObject *_wrap___wxMemoryFSHandler_AddFile_Data(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11430 PyObject *resultobj = 0;
11431 wxString *arg1 = 0 ;
11432 PyObject *arg2 = (PyObject *) 0 ;
11433 bool temp1 = false ;
11434 PyObject * obj0 = 0 ;
11435 PyObject * obj1 = 0 ;
11436 char * kwnames[] = {
11437 (char *) "filename",(char *) "data", NULL
11438 };
11439
11440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:__wxMemoryFSHandler_AddFile_Data",kwnames,&obj0,&obj1)) SWIG_fail;
11441 {
11442 arg1 = wxString_in_helper(obj0);
11443 if (arg1 == NULL) SWIG_fail;
11444 temp1 = true;
11445 }
11446 arg2 = obj1;
11447 {
11448 PyThreadState* __tstate = wxPyBeginAllowThreads();
11449 __wxMemoryFSHandler_AddFile_Data((wxString const &)*arg1,arg2);
11450 wxPyEndAllowThreads(__tstate);
11451 if (PyErr_Occurred()) SWIG_fail;
11452 }
11453 resultobj = SWIG_Py_Void();
11454 {
11455 if (temp1)
11456 delete arg1;
11457 }
11458 return resultobj;
11459 fail:
11460 {
11461 if (temp1)
11462 delete arg1;
11463 }
11464 return NULL;
11465 }
11466
11467
11468 SWIGINTERN PyObject *_wrap_new_MemoryFSHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11469 PyObject *resultobj = 0;
11470 wxMemoryFSHandler *result = 0 ;
11471
11472 if (!SWIG_Python_UnpackTuple(args,"new_MemoryFSHandler",0,0,0)) SWIG_fail;
11473 {
11474 PyThreadState* __tstate = wxPyBeginAllowThreads();
11475 result = (wxMemoryFSHandler *)new wxMemoryFSHandler();
11476 wxPyEndAllowThreads(__tstate);
11477 if (PyErr_Occurred()) SWIG_fail;
11478 }
11479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMemoryFSHandler, SWIG_POINTER_NEW | 0 );
11480 return resultobj;
11481 fail:
11482 return NULL;
11483 }
11484
11485
11486 SWIGINTERN PyObject *_wrap_MemoryFSHandler_RemoveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11487 PyObject *resultobj = 0;
11488 wxString *arg1 = 0 ;
11489 bool temp1 = false ;
11490 PyObject * obj0 = 0 ;
11491 char * kwnames[] = {
11492 (char *) "filename", NULL
11493 };
11494
11495 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MemoryFSHandler_RemoveFile",kwnames,&obj0)) SWIG_fail;
11496 {
11497 arg1 = wxString_in_helper(obj0);
11498 if (arg1 == NULL) SWIG_fail;
11499 temp1 = true;
11500 }
11501 {
11502 PyThreadState* __tstate = wxPyBeginAllowThreads();
11503 wxMemoryFSHandler::RemoveFile((wxString const &)*arg1);
11504 wxPyEndAllowThreads(__tstate);
11505 if (PyErr_Occurred()) SWIG_fail;
11506 }
11507 resultobj = SWIG_Py_Void();
11508 {
11509 if (temp1)
11510 delete arg1;
11511 }
11512 return resultobj;
11513 fail:
11514 {
11515 if (temp1)
11516 delete arg1;
11517 }
11518 return NULL;
11519 }
11520
11521
11522 SWIGINTERN PyObject *_wrap_MemoryFSHandler_CanOpen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11523 PyObject *resultobj = 0;
11524 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11525 wxString *arg2 = 0 ;
11526 bool result;
11527 void *argp1 = 0 ;
11528 int res1 = 0 ;
11529 bool temp2 = false ;
11530 PyObject * obj0 = 0 ;
11531 PyObject * obj1 = 0 ;
11532 char * kwnames[] = {
11533 (char *) "self",(char *) "location", NULL
11534 };
11535
11536 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MemoryFSHandler_CanOpen",kwnames,&obj0,&obj1)) SWIG_fail;
11537 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11538 if (!SWIG_IsOK(res1)) {
11539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_CanOpen" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11540 }
11541 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11542 {
11543 arg2 = wxString_in_helper(obj1);
11544 if (arg2 == NULL) SWIG_fail;
11545 temp2 = true;
11546 }
11547 {
11548 PyThreadState* __tstate = wxPyBeginAllowThreads();
11549 result = (bool)(arg1)->CanOpen((wxString const &)*arg2);
11550 wxPyEndAllowThreads(__tstate);
11551 if (PyErr_Occurred()) SWIG_fail;
11552 }
11553 {
11554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11555 }
11556 {
11557 if (temp2)
11558 delete arg2;
11559 }
11560 return resultobj;
11561 fail:
11562 {
11563 if (temp2)
11564 delete arg2;
11565 }
11566 return NULL;
11567 }
11568
11569
11570 SWIGINTERN PyObject *_wrap_MemoryFSHandler_OpenFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11571 PyObject *resultobj = 0;
11572 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11573 wxFileSystem *arg2 = 0 ;
11574 wxString *arg3 = 0 ;
11575 wxFSFile *result = 0 ;
11576 void *argp1 = 0 ;
11577 int res1 = 0 ;
11578 void *argp2 = 0 ;
11579 int res2 = 0 ;
11580 bool temp3 = false ;
11581 PyObject * obj0 = 0 ;
11582 PyObject * obj1 = 0 ;
11583 PyObject * obj2 = 0 ;
11584 char * kwnames[] = {
11585 (char *) "self",(char *) "fs",(char *) "location", NULL
11586 };
11587
11588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MemoryFSHandler_OpenFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11590 if (!SWIG_IsOK(res1)) {
11591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11592 }
11593 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFileSystem, 0 );
11595 if (!SWIG_IsOK(res2)) {
11596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11597 }
11598 if (!argp2) {
11599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MemoryFSHandler_OpenFile" "', expected argument " "2"" of type '" "wxFileSystem &""'");
11600 }
11601 arg2 = reinterpret_cast< wxFileSystem * >(argp2);
11602 {
11603 arg3 = wxString_in_helper(obj2);
11604 if (arg3 == NULL) SWIG_fail;
11605 temp3 = true;
11606 }
11607 {
11608 PyThreadState* __tstate = wxPyBeginAllowThreads();
11609 result = (wxFSFile *)(arg1)->OpenFile(*arg2,(wxString const &)*arg3);
11610 wxPyEndAllowThreads(__tstate);
11611 if (PyErr_Occurred()) SWIG_fail;
11612 }
11613 {
11614 resultobj = wxPyMake_wxObject(result, SWIG_POINTER_OWN);
11615 }
11616 {
11617 if (temp3)
11618 delete arg3;
11619 }
11620 return resultobj;
11621 fail:
11622 {
11623 if (temp3)
11624 delete arg3;
11625 }
11626 return NULL;
11627 }
11628
11629
11630 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindFirst(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11631 PyObject *resultobj = 0;
11632 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11633 wxString *arg2 = 0 ;
11634 int arg3 = (int) 0 ;
11635 wxString result;
11636 void *argp1 = 0 ;
11637 int res1 = 0 ;
11638 bool temp2 = false ;
11639 int val3 ;
11640 int ecode3 = 0 ;
11641 PyObject * obj0 = 0 ;
11642 PyObject * obj1 = 0 ;
11643 PyObject * obj2 = 0 ;
11644 char * kwnames[] = {
11645 (char *) "self",(char *) "spec",(char *) "flags", NULL
11646 };
11647
11648 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MemoryFSHandler_FindFirst",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
11649 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11650 if (!SWIG_IsOK(res1)) {
11651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11652 }
11653 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11654 {
11655 arg2 = wxString_in_helper(obj1);
11656 if (arg2 == NULL) SWIG_fail;
11657 temp2 = true;
11658 }
11659 if (obj2) {
11660 ecode3 = SWIG_AsVal_int(obj2, &val3);
11661 if (!SWIG_IsOK(ecode3)) {
11662 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MemoryFSHandler_FindFirst" "', expected argument " "3"" of type '" "int""'");
11663 }
11664 arg3 = static_cast< int >(val3);
11665 }
11666 {
11667 PyThreadState* __tstate = wxPyBeginAllowThreads();
11668 result = (arg1)->FindFirst((wxString const &)*arg2,arg3);
11669 wxPyEndAllowThreads(__tstate);
11670 if (PyErr_Occurred()) SWIG_fail;
11671 }
11672 {
11673 #if wxUSE_UNICODE
11674 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11675 #else
11676 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11677 #endif
11678 }
11679 {
11680 if (temp2)
11681 delete arg2;
11682 }
11683 return resultobj;
11684 fail:
11685 {
11686 if (temp2)
11687 delete arg2;
11688 }
11689 return NULL;
11690 }
11691
11692
11693 SWIGINTERN PyObject *_wrap_MemoryFSHandler_FindNext(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11694 PyObject *resultobj = 0;
11695 wxMemoryFSHandler *arg1 = (wxMemoryFSHandler *) 0 ;
11696 wxString result;
11697 void *argp1 = 0 ;
11698 int res1 = 0 ;
11699 PyObject *swig_obj[1] ;
11700
11701 if (!args) SWIG_fail;
11702 swig_obj[0] = args;
11703 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMemoryFSHandler, 0 | 0 );
11704 if (!SWIG_IsOK(res1)) {
11705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MemoryFSHandler_FindNext" "', expected argument " "1"" of type '" "wxMemoryFSHandler *""'");
11706 }
11707 arg1 = reinterpret_cast< wxMemoryFSHandler * >(argp1);
11708 {
11709 PyThreadState* __tstate = wxPyBeginAllowThreads();
11710 result = (arg1)->FindNext();
11711 wxPyEndAllowThreads(__tstate);
11712 if (PyErr_Occurred()) SWIG_fail;
11713 }
11714 {
11715 #if wxUSE_UNICODE
11716 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11717 #else
11718 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11719 #endif
11720 }
11721 return resultobj;
11722 fail:
11723 return NULL;
11724 }
11725
11726
11727 SWIGINTERN PyObject *MemoryFSHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11728 PyObject *obj;
11729 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
11730 SWIG_TypeNewClientData(SWIGTYPE_p_wxMemoryFSHandler, SWIG_NewClientData(obj));
11731 return SWIG_Py_Void();
11732 }
11733
11734 SWIGINTERN PyObject *MemoryFSHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11735 return SWIG_Python_InitShadowInstance(args);
11736 }
11737
11738 SWIGINTERN PyObject *_wrap_ImageHandler_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11739 PyObject *resultobj = 0;
11740 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11741 wxString result;
11742 void *argp1 = 0 ;
11743 int res1 = 0 ;
11744 PyObject *swig_obj[1] ;
11745
11746 if (!args) SWIG_fail;
11747 swig_obj[0] = args;
11748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11749 if (!SWIG_IsOK(res1)) {
11750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11751 }
11752 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11753 {
11754 PyThreadState* __tstate = wxPyBeginAllowThreads();
11755 result = (arg1)->GetName();
11756 wxPyEndAllowThreads(__tstate);
11757 if (PyErr_Occurred()) SWIG_fail;
11758 }
11759 {
11760 #if wxUSE_UNICODE
11761 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11762 #else
11763 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11764 #endif
11765 }
11766 return resultobj;
11767 fail:
11768 return NULL;
11769 }
11770
11771
11772 SWIGINTERN PyObject *_wrap_ImageHandler_GetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11773 PyObject *resultobj = 0;
11774 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11775 wxString result;
11776 void *argp1 = 0 ;
11777 int res1 = 0 ;
11778 PyObject *swig_obj[1] ;
11779
11780 if (!args) SWIG_fail;
11781 swig_obj[0] = args;
11782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11783 if (!SWIG_IsOK(res1)) {
11784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11785 }
11786 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11787 {
11788 PyThreadState* __tstate = wxPyBeginAllowThreads();
11789 result = (arg1)->GetExtension();
11790 wxPyEndAllowThreads(__tstate);
11791 if (PyErr_Occurred()) SWIG_fail;
11792 }
11793 {
11794 #if wxUSE_UNICODE
11795 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11796 #else
11797 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11798 #endif
11799 }
11800 return resultobj;
11801 fail:
11802 return NULL;
11803 }
11804
11805
11806 SWIGINTERN PyObject *_wrap_ImageHandler_GetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11807 PyObject *resultobj = 0;
11808 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11809 long result;
11810 void *argp1 = 0 ;
11811 int res1 = 0 ;
11812 PyObject *swig_obj[1] ;
11813
11814 if (!args) SWIG_fail;
11815 swig_obj[0] = args;
11816 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11817 if (!SWIG_IsOK(res1)) {
11818 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11819 }
11820 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11821 {
11822 PyThreadState* __tstate = wxPyBeginAllowThreads();
11823 result = (long)(arg1)->GetType();
11824 wxPyEndAllowThreads(__tstate);
11825 if (PyErr_Occurred()) SWIG_fail;
11826 }
11827 resultobj = SWIG_From_long(static_cast< long >(result));
11828 return resultobj;
11829 fail:
11830 return NULL;
11831 }
11832
11833
11834 SWIGINTERN PyObject *_wrap_ImageHandler_GetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
11835 PyObject *resultobj = 0;
11836 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11837 wxString result;
11838 void *argp1 = 0 ;
11839 int res1 = 0 ;
11840 PyObject *swig_obj[1] ;
11841
11842 if (!args) SWIG_fail;
11843 swig_obj[0] = args;
11844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11845 if (!SWIG_IsOK(res1)) {
11846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_GetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11847 }
11848 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11849 {
11850 PyThreadState* __tstate = wxPyBeginAllowThreads();
11851 result = (arg1)->GetMimeType();
11852 wxPyEndAllowThreads(__tstate);
11853 if (PyErr_Occurred()) SWIG_fail;
11854 }
11855 {
11856 #if wxUSE_UNICODE
11857 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
11858 #else
11859 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
11860 #endif
11861 }
11862 return resultobj;
11863 fail:
11864 return NULL;
11865 }
11866
11867
11868 SWIGINTERN PyObject *_wrap_ImageHandler_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11869 PyObject *resultobj = 0;
11870 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11871 wxString *arg2 = 0 ;
11872 bool result;
11873 void *argp1 = 0 ;
11874 int res1 = 0 ;
11875 bool temp2 = false ;
11876 PyObject * obj0 = 0 ;
11877 PyObject * obj1 = 0 ;
11878 char * kwnames[] = {
11879 (char *) "self",(char *) "name", NULL
11880 };
11881
11882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanRead",kwnames,&obj0,&obj1)) SWIG_fail;
11883 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11884 if (!SWIG_IsOK(res1)) {
11885 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanRead" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11886 }
11887 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11888 {
11889 arg2 = wxString_in_helper(obj1);
11890 if (arg2 == NULL) SWIG_fail;
11891 temp2 = true;
11892 }
11893 {
11894 PyThreadState* __tstate = wxPyBeginAllowThreads();
11895 result = (bool)(arg1)->CanRead((wxString const &)*arg2);
11896 wxPyEndAllowThreads(__tstate);
11897 if (PyErr_Occurred()) SWIG_fail;
11898 }
11899 {
11900 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11901 }
11902 {
11903 if (temp2)
11904 delete arg2;
11905 }
11906 return resultobj;
11907 fail:
11908 {
11909 if (temp2)
11910 delete arg2;
11911 }
11912 return NULL;
11913 }
11914
11915
11916 SWIGINTERN PyObject *_wrap_ImageHandler_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11917 PyObject *resultobj = 0;
11918 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11919 wxInputStream *arg2 = 0 ;
11920 bool result;
11921 void *argp1 = 0 ;
11922 int res1 = 0 ;
11923 wxPyInputStream *temp2 ;
11924 bool created2 ;
11925 PyObject * obj0 = 0 ;
11926 PyObject * obj1 = 0 ;
11927 char * kwnames[] = {
11928 (char *) "self",(char *) "stream", NULL
11929 };
11930
11931 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_CanReadStream",kwnames,&obj0,&obj1)) SWIG_fail;
11932 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11933 if (!SWIG_IsOK(res1)) {
11934 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_CanReadStream" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11935 }
11936 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11937 {
11938 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
11939 arg2 = temp2->m_wxis;
11940 created2 = false;
11941 } else {
11942 PyErr_Clear(); // clear the failure of the wxPyConvert above
11943 arg2 = wxPyCBInputStream_create(obj1, false);
11944 if (arg2 == NULL) {
11945 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
11946 SWIG_fail;
11947 }
11948 created2 = true;
11949 }
11950 }
11951 {
11952 PyThreadState* __tstate = wxPyBeginAllowThreads();
11953 result = (bool)(arg1)->CanRead(*arg2);
11954 wxPyEndAllowThreads(__tstate);
11955 if (PyErr_Occurred()) SWIG_fail;
11956 }
11957 {
11958 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
11959 }
11960 {
11961 if (created2) delete arg2;
11962 }
11963 return resultobj;
11964 fail:
11965 {
11966 if (created2) delete arg2;
11967 }
11968 return NULL;
11969 }
11970
11971
11972 SWIGINTERN PyObject *_wrap_ImageHandler_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
11973 PyObject *resultobj = 0;
11974 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
11975 wxString *arg2 = 0 ;
11976 void *argp1 = 0 ;
11977 int res1 = 0 ;
11978 bool temp2 = false ;
11979 PyObject * obj0 = 0 ;
11980 PyObject * obj1 = 0 ;
11981 char * kwnames[] = {
11982 (char *) "self",(char *) "name", NULL
11983 };
11984
11985 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
11986 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
11987 if (!SWIG_IsOK(res1)) {
11988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetName" "', expected argument " "1"" of type '" "wxImageHandler *""'");
11989 }
11990 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
11991 {
11992 arg2 = wxString_in_helper(obj1);
11993 if (arg2 == NULL) SWIG_fail;
11994 temp2 = true;
11995 }
11996 {
11997 PyThreadState* __tstate = wxPyBeginAllowThreads();
11998 (arg1)->SetName((wxString const &)*arg2);
11999 wxPyEndAllowThreads(__tstate);
12000 if (PyErr_Occurred()) SWIG_fail;
12001 }
12002 resultobj = SWIG_Py_Void();
12003 {
12004 if (temp2)
12005 delete arg2;
12006 }
12007 return resultobj;
12008 fail:
12009 {
12010 if (temp2)
12011 delete arg2;
12012 }
12013 return NULL;
12014 }
12015
12016
12017 SWIGINTERN PyObject *_wrap_ImageHandler_SetExtension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12018 PyObject *resultobj = 0;
12019 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12020 wxString *arg2 = 0 ;
12021 void *argp1 = 0 ;
12022 int res1 = 0 ;
12023 bool temp2 = false ;
12024 PyObject * obj0 = 0 ;
12025 PyObject * obj1 = 0 ;
12026 char * kwnames[] = {
12027 (char *) "self",(char *) "extension", NULL
12028 };
12029
12030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetExtension",kwnames,&obj0,&obj1)) SWIG_fail;
12031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12032 if (!SWIG_IsOK(res1)) {
12033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetExtension" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12034 }
12035 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12036 {
12037 arg2 = wxString_in_helper(obj1);
12038 if (arg2 == NULL) SWIG_fail;
12039 temp2 = true;
12040 }
12041 {
12042 PyThreadState* __tstate = wxPyBeginAllowThreads();
12043 (arg1)->SetExtension((wxString const &)*arg2);
12044 wxPyEndAllowThreads(__tstate);
12045 if (PyErr_Occurred()) SWIG_fail;
12046 }
12047 resultobj = SWIG_Py_Void();
12048 {
12049 if (temp2)
12050 delete arg2;
12051 }
12052 return resultobj;
12053 fail:
12054 {
12055 if (temp2)
12056 delete arg2;
12057 }
12058 return NULL;
12059 }
12060
12061
12062 SWIGINTERN PyObject *_wrap_ImageHandler_SetType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12063 PyObject *resultobj = 0;
12064 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12065 long arg2 ;
12066 void *argp1 = 0 ;
12067 int res1 = 0 ;
12068 long val2 ;
12069 int ecode2 = 0 ;
12070 PyObject * obj0 = 0 ;
12071 PyObject * obj1 = 0 ;
12072 char * kwnames[] = {
12073 (char *) "self",(char *) "type", NULL
12074 };
12075
12076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetType",kwnames,&obj0,&obj1)) SWIG_fail;
12077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12078 if (!SWIG_IsOK(res1)) {
12079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12080 }
12081 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12082 ecode2 = SWIG_AsVal_long(obj1, &val2);
12083 if (!SWIG_IsOK(ecode2)) {
12084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHandler_SetType" "', expected argument " "2"" of type '" "long""'");
12085 }
12086 arg2 = static_cast< long >(val2);
12087 {
12088 PyThreadState* __tstate = wxPyBeginAllowThreads();
12089 (arg1)->SetType(arg2);
12090 wxPyEndAllowThreads(__tstate);
12091 if (PyErr_Occurred()) SWIG_fail;
12092 }
12093 resultobj = SWIG_Py_Void();
12094 return resultobj;
12095 fail:
12096 return NULL;
12097 }
12098
12099
12100 SWIGINTERN PyObject *_wrap_ImageHandler_SetMimeType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12101 PyObject *resultobj = 0;
12102 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
12103 wxString *arg2 = 0 ;
12104 void *argp1 = 0 ;
12105 int res1 = 0 ;
12106 bool temp2 = false ;
12107 PyObject * obj0 = 0 ;
12108 PyObject * obj1 = 0 ;
12109 char * kwnames[] = {
12110 (char *) "self",(char *) "mimetype", NULL
12111 };
12112
12113 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHandler_SetMimeType",kwnames,&obj0,&obj1)) SWIG_fail;
12114 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
12115 if (!SWIG_IsOK(res1)) {
12116 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHandler_SetMimeType" "', expected argument " "1"" of type '" "wxImageHandler *""'");
12117 }
12118 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
12119 {
12120 arg2 = wxString_in_helper(obj1);
12121 if (arg2 == NULL) SWIG_fail;
12122 temp2 = true;
12123 }
12124 {
12125 PyThreadState* __tstate = wxPyBeginAllowThreads();
12126 (arg1)->SetMimeType((wxString const &)*arg2);
12127 wxPyEndAllowThreads(__tstate);
12128 if (PyErr_Occurred()) SWIG_fail;
12129 }
12130 resultobj = SWIG_Py_Void();
12131 {
12132 if (temp2)
12133 delete arg2;
12134 }
12135 return resultobj;
12136 fail:
12137 {
12138 if (temp2)
12139 delete arg2;
12140 }
12141 return NULL;
12142 }
12143
12144
12145 SWIGINTERN PyObject *ImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12146 PyObject *obj;
12147 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12148 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHandler, SWIG_NewClientData(obj));
12149 return SWIG_Py_Void();
12150 }
12151
12152 SWIGINTERN PyObject *_wrap_new_PyImageHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12153 PyObject *resultobj = 0;
12154 wxPyImageHandler *result = 0 ;
12155
12156 if (!SWIG_Python_UnpackTuple(args,"new_PyImageHandler",0,0,0)) SWIG_fail;
12157 {
12158 PyThreadState* __tstate = wxPyBeginAllowThreads();
12159 result = (wxPyImageHandler *)new wxPyImageHandler();
12160 wxPyEndAllowThreads(__tstate);
12161 if (PyErr_Occurred()) SWIG_fail;
12162 }
12163 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyImageHandler, SWIG_POINTER_NEW | 0 );
12164 return resultobj;
12165 fail:
12166 return NULL;
12167 }
12168
12169
12170 SWIGINTERN PyObject *_wrap_PyImageHandler__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12171 PyObject *resultobj = 0;
12172 wxPyImageHandler *arg1 = (wxPyImageHandler *) 0 ;
12173 PyObject *arg2 = (PyObject *) 0 ;
12174 void *argp1 = 0 ;
12175 int res1 = 0 ;
12176 PyObject * obj0 = 0 ;
12177 PyObject * obj1 = 0 ;
12178 char * kwnames[] = {
12179 (char *) "self",(char *) "self", NULL
12180 };
12181
12182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyImageHandler__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
12183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyImageHandler, 0 | 0 );
12184 if (!SWIG_IsOK(res1)) {
12185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyImageHandler__SetSelf" "', expected argument " "1"" of type '" "wxPyImageHandler *""'");
12186 }
12187 arg1 = reinterpret_cast< wxPyImageHandler * >(argp1);
12188 arg2 = obj1;
12189 {
12190 PyThreadState* __tstate = wxPyBeginAllowThreads();
12191 (arg1)->_SetSelf(arg2);
12192 wxPyEndAllowThreads(__tstate);
12193 if (PyErr_Occurred()) SWIG_fail;
12194 }
12195 resultobj = SWIG_Py_Void();
12196 return resultobj;
12197 fail:
12198 return NULL;
12199 }
12200
12201
12202 SWIGINTERN PyObject *PyImageHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12203 PyObject *obj;
12204 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12205 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyImageHandler, SWIG_NewClientData(obj));
12206 return SWIG_Py_Void();
12207 }
12208
12209 SWIGINTERN PyObject *PyImageHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12210 return SWIG_Python_InitShadowInstance(args);
12211 }
12212
12213 SWIGINTERN PyObject *_wrap_new_ImageHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12214 PyObject *resultobj = 0;
12215 wxImageHistogram *result = 0 ;
12216
12217 if (!SWIG_Python_UnpackTuple(args,"new_ImageHistogram",0,0,0)) SWIG_fail;
12218 {
12219 PyThreadState* __tstate = wxPyBeginAllowThreads();
12220 result = (wxImageHistogram *)new wxImageHistogram();
12221 wxPyEndAllowThreads(__tstate);
12222 if (PyErr_Occurred()) SWIG_fail;
12223 }
12224 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImageHistogram, SWIG_POINTER_NEW | 0 );
12225 return resultobj;
12226 fail:
12227 return NULL;
12228 }
12229
12230
12231 SWIGINTERN PyObject *_wrap_ImageHistogram_MakeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12232 PyObject *resultobj = 0;
12233 byte arg1 ;
12234 byte arg2 ;
12235 byte arg3 ;
12236 unsigned long result;
12237 unsigned char val1 ;
12238 int ecode1 = 0 ;
12239 unsigned char val2 ;
12240 int ecode2 = 0 ;
12241 unsigned char val3 ;
12242 int ecode3 = 0 ;
12243 PyObject * obj0 = 0 ;
12244 PyObject * obj1 = 0 ;
12245 PyObject * obj2 = 0 ;
12246 char * kwnames[] = {
12247 (char *) "r",(char *) "g",(char *) "b", NULL
12248 };
12249
12250 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ImageHistogram_MakeKey",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12251 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12252 if (!SWIG_IsOK(ecode1)) {
12253 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "ImageHistogram_MakeKey" "', expected argument " "1"" of type '" "byte""'");
12254 }
12255 arg1 = static_cast< byte >(val1);
12256 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12257 if (!SWIG_IsOK(ecode2)) {
12258 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_MakeKey" "', expected argument " "2"" of type '" "byte""'");
12259 }
12260 arg2 = static_cast< byte >(val2);
12261 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12262 if (!SWIG_IsOK(ecode3)) {
12263 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_MakeKey" "', expected argument " "3"" of type '" "byte""'");
12264 }
12265 arg3 = static_cast< byte >(val3);
12266 {
12267 PyThreadState* __tstate = wxPyBeginAllowThreads();
12268 result = (unsigned long)wxImageHistogram::MakeKey(arg1,arg2,arg3);
12269 wxPyEndAllowThreads(__tstate);
12270 if (PyErr_Occurred()) SWIG_fail;
12271 }
12272 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12273 return resultobj;
12274 fail:
12275 return NULL;
12276 }
12277
12278
12279 SWIGINTERN PyObject *_wrap_ImageHistogram_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12280 PyObject *resultobj = 0;
12281 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12282 byte *arg2 = (byte *) 0 ;
12283 byte *arg3 = (byte *) 0 ;
12284 byte *arg4 = (byte *) 0 ;
12285 byte arg5 = (byte) 1 ;
12286 byte arg6 = (byte) 0 ;
12287 byte arg7 = (byte) 0 ;
12288 bool result;
12289 void *argp1 = 0 ;
12290 int res1 = 0 ;
12291 byte temp2 ;
12292 int res2 = SWIG_TMPOBJ ;
12293 byte temp3 ;
12294 int res3 = SWIG_TMPOBJ ;
12295 byte temp4 ;
12296 int res4 = SWIG_TMPOBJ ;
12297 unsigned char val5 ;
12298 int ecode5 = 0 ;
12299 unsigned char val6 ;
12300 int ecode6 = 0 ;
12301 unsigned char val7 ;
12302 int ecode7 = 0 ;
12303 PyObject * obj0 = 0 ;
12304 PyObject * obj1 = 0 ;
12305 PyObject * obj2 = 0 ;
12306 PyObject * obj3 = 0 ;
12307 char * kwnames[] = {
12308 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
12309 };
12310
12311 arg2 = &temp2;
12312 arg3 = &temp3;
12313 arg4 = &temp4;
12314 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:ImageHistogram_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12315 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12316 if (!SWIG_IsOK(res1)) {
12317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImageHistogram const *""'");
12318 }
12319 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12320 if (obj1) {
12321 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
12322 if (!SWIG_IsOK(ecode5)) {
12323 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
12324 }
12325 arg5 = static_cast< byte >(val5);
12326 }
12327 if (obj2) {
12328 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
12329 if (!SWIG_IsOK(ecode6)) {
12330 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
12331 }
12332 arg6 = static_cast< byte >(val6);
12333 }
12334 if (obj3) {
12335 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
12336 if (!SWIG_IsOK(ecode7)) {
12337 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "ImageHistogram_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
12338 }
12339 arg7 = static_cast< byte >(val7);
12340 }
12341 {
12342 PyThreadState* __tstate = wxPyBeginAllowThreads();
12343 result = (bool)((wxImageHistogram const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
12344 wxPyEndAllowThreads(__tstate);
12345 if (PyErr_Occurred()) SWIG_fail;
12346 }
12347 {
12348 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
12349 }
12350 if (SWIG_IsTmpObj(res2)) {
12351 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
12352 } else {
12353 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12354 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
12355 }
12356 if (SWIG_IsTmpObj(res3)) {
12357 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
12358 } else {
12359 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12360 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
12361 }
12362 if (SWIG_IsTmpObj(res4)) {
12363 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
12364 } else {
12365 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
12366 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
12367 }
12368 return resultobj;
12369 fail:
12370 return NULL;
12371 }
12372
12373
12374 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12375 PyObject *resultobj = 0;
12376 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12377 unsigned long arg2 ;
12378 unsigned long result;
12379 void *argp1 = 0 ;
12380 int res1 = 0 ;
12381 unsigned long val2 ;
12382 int ecode2 = 0 ;
12383 PyObject * obj0 = 0 ;
12384 PyObject * obj1 = 0 ;
12385 char * kwnames[] = {
12386 (char *) "self",(char *) "key", NULL
12387 };
12388
12389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCount",kwnames,&obj0,&obj1)) SWIG_fail;
12390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12391 if (!SWIG_IsOK(res1)) {
12392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCount" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12393 }
12394 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12395 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
12396 if (!SWIG_IsOK(ecode2)) {
12397 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCount" "', expected argument " "2"" of type '" "unsigned long""'");
12398 }
12399 arg2 = static_cast< unsigned long >(val2);
12400 {
12401 PyThreadState* __tstate = wxPyBeginAllowThreads();
12402 result = (unsigned long)wxImageHistogram_GetCount(arg1,arg2);
12403 wxPyEndAllowThreads(__tstate);
12404 if (PyErr_Occurred()) SWIG_fail;
12405 }
12406 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12407 return resultobj;
12408 fail:
12409 return NULL;
12410 }
12411
12412
12413 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12414 PyObject *resultobj = 0;
12415 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12416 byte arg2 ;
12417 byte arg3 ;
12418 byte arg4 ;
12419 unsigned long result;
12420 void *argp1 = 0 ;
12421 int res1 = 0 ;
12422 unsigned char val2 ;
12423 int ecode2 = 0 ;
12424 unsigned char val3 ;
12425 int ecode3 = 0 ;
12426 unsigned char val4 ;
12427 int ecode4 = 0 ;
12428 PyObject * obj0 = 0 ;
12429 PyObject * obj1 = 0 ;
12430 PyObject * obj2 = 0 ;
12431 PyObject * obj3 = 0 ;
12432 char * kwnames[] = {
12433 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
12434 };
12435
12436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:ImageHistogram_GetCountRGB",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
12437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12438 if (!SWIG_IsOK(res1)) {
12439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12440 }
12441 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12442 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12443 if (!SWIG_IsOK(ecode2)) {
12444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "2"" of type '" "byte""'");
12445 }
12446 arg2 = static_cast< byte >(val2);
12447 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12448 if (!SWIG_IsOK(ecode3)) {
12449 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "3"" of type '" "byte""'");
12450 }
12451 arg3 = static_cast< byte >(val3);
12452 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
12453 if (!SWIG_IsOK(ecode4)) {
12454 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "ImageHistogram_GetCountRGB" "', expected argument " "4"" of type '" "byte""'");
12455 }
12456 arg4 = static_cast< byte >(val4);
12457 {
12458 PyThreadState* __tstate = wxPyBeginAllowThreads();
12459 result = (unsigned long)wxImageHistogram_GetCountRGB(arg1,arg2,arg3,arg4);
12460 wxPyEndAllowThreads(__tstate);
12461 if (PyErr_Occurred()) SWIG_fail;
12462 }
12463 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12464 return resultobj;
12465 fail:
12466 return NULL;
12467 }
12468
12469
12470 SWIGINTERN PyObject *_wrap_ImageHistogram_GetCountColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12471 PyObject *resultobj = 0;
12472 wxImageHistogram *arg1 = (wxImageHistogram *) 0 ;
12473 wxColour *arg2 = 0 ;
12474 unsigned long result;
12475 void *argp1 = 0 ;
12476 int res1 = 0 ;
12477 wxColour temp2 ;
12478 PyObject * obj0 = 0 ;
12479 PyObject * obj1 = 0 ;
12480 char * kwnames[] = {
12481 (char *) "self",(char *) "colour", NULL
12482 };
12483
12484 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ImageHistogram_GetCountColour",kwnames,&obj0,&obj1)) SWIG_fail;
12485 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHistogram, 0 | 0 );
12486 if (!SWIG_IsOK(res1)) {
12487 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ImageHistogram_GetCountColour" "', expected argument " "1"" of type '" "wxImageHistogram *""'");
12488 }
12489 arg1 = reinterpret_cast< wxImageHistogram * >(argp1);
12490 {
12491 arg2 = &temp2;
12492 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
12493 }
12494 {
12495 PyThreadState* __tstate = wxPyBeginAllowThreads();
12496 result = (unsigned long)wxImageHistogram_GetCountColour(arg1,(wxColour const &)*arg2);
12497 wxPyEndAllowThreads(__tstate);
12498 if (PyErr_Occurred()) SWIG_fail;
12499 }
12500 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
12501 return resultobj;
12502 fail:
12503 return NULL;
12504 }
12505
12506
12507 SWIGINTERN PyObject *ImageHistogram_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12508 PyObject *obj;
12509 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12510 SWIG_TypeNewClientData(SWIGTYPE_p_wxImageHistogram, SWIG_NewClientData(obj));
12511 return SWIG_Py_Void();
12512 }
12513
12514 SWIGINTERN PyObject *ImageHistogram_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12515 return SWIG_Python_InitShadowInstance(args);
12516 }
12517
12518 SWIGINTERN PyObject *_wrap_new_Image_RGBValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12519 PyObject *resultobj = 0;
12520 byte arg1 = (byte) 0 ;
12521 byte arg2 = (byte) 0 ;
12522 byte arg3 = (byte) 0 ;
12523 wxImage_RGBValue *result = 0 ;
12524 unsigned char val1 ;
12525 int ecode1 = 0 ;
12526 unsigned char val2 ;
12527 int ecode2 = 0 ;
12528 unsigned char val3 ;
12529 int ecode3 = 0 ;
12530 PyObject * obj0 = 0 ;
12531 PyObject * obj1 = 0 ;
12532 PyObject * obj2 = 0 ;
12533 char * kwnames[] = {
12534 (char *) "r",(char *) "g",(char *) "b", NULL
12535 };
12536
12537 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_RGBValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12538 if (obj0) {
12539 ecode1 = SWIG_AsVal_unsigned_SS_char(obj0, &val1);
12540 if (!SWIG_IsOK(ecode1)) {
12541 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_RGBValue" "', expected argument " "1"" of type '" "byte""'");
12542 }
12543 arg1 = static_cast< byte >(val1);
12544 }
12545 if (obj1) {
12546 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
12547 if (!SWIG_IsOK(ecode2)) {
12548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_RGBValue" "', expected argument " "2"" of type '" "byte""'");
12549 }
12550 arg2 = static_cast< byte >(val2);
12551 }
12552 if (obj2) {
12553 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
12554 if (!SWIG_IsOK(ecode3)) {
12555 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_RGBValue" "', expected argument " "3"" of type '" "byte""'");
12556 }
12557 arg3 = static_cast< byte >(val3);
12558 }
12559 {
12560 PyThreadState* __tstate = wxPyBeginAllowThreads();
12561 result = (wxImage_RGBValue *)new wxImage_RGBValue(arg1,arg2,arg3);
12562 wxPyEndAllowThreads(__tstate);
12563 if (PyErr_Occurred()) SWIG_fail;
12564 }
12565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_NEW | 0 );
12566 return resultobj;
12567 fail:
12568 return NULL;
12569 }
12570
12571
12572 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12573 PyObject *resultobj = 0;
12574 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12575 byte arg2 ;
12576 void *argp1 = 0 ;
12577 int res1 = 0 ;
12578 unsigned char val2 ;
12579 int ecode2 = 0 ;
12580 PyObject *swig_obj[2] ;
12581
12582 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_red_set",2,2,swig_obj)) SWIG_fail;
12583 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12584 if (!SWIG_IsOK(res1)) {
12585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12586 }
12587 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12588 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12589 if (!SWIG_IsOK(ecode2)) {
12590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_red_set" "', expected argument " "2"" of type '" "byte""'");
12591 }
12592 arg2 = static_cast< byte >(val2);
12593 if (arg1) (arg1)->red = arg2;
12594
12595 resultobj = SWIG_Py_Void();
12596 return resultobj;
12597 fail:
12598 return NULL;
12599 }
12600
12601
12602 SWIGINTERN PyObject *_wrap_Image_RGBValue_red_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12603 PyObject *resultobj = 0;
12604 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12605 byte result;
12606 void *argp1 = 0 ;
12607 int res1 = 0 ;
12608 PyObject *swig_obj[1] ;
12609
12610 if (!args) SWIG_fail;
12611 swig_obj[0] = args;
12612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12613 if (!SWIG_IsOK(res1)) {
12614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_red_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12615 }
12616 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12617 result = (byte) ((arg1)->red);
12618 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12619 return resultobj;
12620 fail:
12621 return NULL;
12622 }
12623
12624
12625 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12626 PyObject *resultobj = 0;
12627 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12628 byte arg2 ;
12629 void *argp1 = 0 ;
12630 int res1 = 0 ;
12631 unsigned char val2 ;
12632 int ecode2 = 0 ;
12633 PyObject *swig_obj[2] ;
12634
12635 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_green_set",2,2,swig_obj)) SWIG_fail;
12636 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12637 if (!SWIG_IsOK(res1)) {
12638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12639 }
12640 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12641 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12642 if (!SWIG_IsOK(ecode2)) {
12643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_green_set" "', expected argument " "2"" of type '" "byte""'");
12644 }
12645 arg2 = static_cast< byte >(val2);
12646 if (arg1) (arg1)->green = arg2;
12647
12648 resultobj = SWIG_Py_Void();
12649 return resultobj;
12650 fail:
12651 return NULL;
12652 }
12653
12654
12655 SWIGINTERN PyObject *_wrap_Image_RGBValue_green_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12656 PyObject *resultobj = 0;
12657 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12658 byte result;
12659 void *argp1 = 0 ;
12660 int res1 = 0 ;
12661 PyObject *swig_obj[1] ;
12662
12663 if (!args) SWIG_fail;
12664 swig_obj[0] = args;
12665 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12666 if (!SWIG_IsOK(res1)) {
12667 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_green_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12668 }
12669 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12670 result = (byte) ((arg1)->green);
12671 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12672 return resultobj;
12673 fail:
12674 return NULL;
12675 }
12676
12677
12678 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12679 PyObject *resultobj = 0;
12680 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12681 byte arg2 ;
12682 void *argp1 = 0 ;
12683 int res1 = 0 ;
12684 unsigned char val2 ;
12685 int ecode2 = 0 ;
12686 PyObject *swig_obj[2] ;
12687
12688 if (!SWIG_Python_UnpackTuple(args,"Image_RGBValue_blue_set",2,2,swig_obj)) SWIG_fail;
12689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12690 if (!SWIG_IsOK(res1)) {
12691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_set" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12692 }
12693 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12694 ecode2 = SWIG_AsVal_unsigned_SS_char(swig_obj[1], &val2);
12695 if (!SWIG_IsOK(ecode2)) {
12696 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RGBValue_blue_set" "', expected argument " "2"" of type '" "byte""'");
12697 }
12698 arg2 = static_cast< byte >(val2);
12699 if (arg1) (arg1)->blue = arg2;
12700
12701 resultobj = SWIG_Py_Void();
12702 return resultobj;
12703 fail:
12704 return NULL;
12705 }
12706
12707
12708 SWIGINTERN PyObject *_wrap_Image_RGBValue_blue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12709 PyObject *resultobj = 0;
12710 wxImage_RGBValue *arg1 = (wxImage_RGBValue *) 0 ;
12711 byte result;
12712 void *argp1 = 0 ;
12713 int res1 = 0 ;
12714 PyObject *swig_obj[1] ;
12715
12716 if (!args) SWIG_fail;
12717 swig_obj[0] = args;
12718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_RGBValue, 0 | 0 );
12719 if (!SWIG_IsOK(res1)) {
12720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBValue_blue_get" "', expected argument " "1"" of type '" "wxImage_RGBValue *""'");
12721 }
12722 arg1 = reinterpret_cast< wxImage_RGBValue * >(argp1);
12723 result = (byte) ((arg1)->blue);
12724 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
12725 return resultobj;
12726 fail:
12727 return NULL;
12728 }
12729
12730
12731 SWIGINTERN PyObject *Image_RGBValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12732 PyObject *obj;
12733 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12734 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_RGBValue, SWIG_NewClientData(obj));
12735 return SWIG_Py_Void();
12736 }
12737
12738 SWIGINTERN PyObject *Image_RGBValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12739 return SWIG_Python_InitShadowInstance(args);
12740 }
12741
12742 SWIGINTERN PyObject *_wrap_new_Image_HSVValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12743 PyObject *resultobj = 0;
12744 double arg1 = (double) 0.0 ;
12745 double arg2 = (double) 0.0 ;
12746 double arg3 = (double) 0.0 ;
12747 wxImage_HSVValue *result = 0 ;
12748 double val1 ;
12749 int ecode1 = 0 ;
12750 double val2 ;
12751 int ecode2 = 0 ;
12752 double val3 ;
12753 int ecode3 = 0 ;
12754 PyObject * obj0 = 0 ;
12755 PyObject * obj1 = 0 ;
12756 PyObject * obj2 = 0 ;
12757 char * kwnames[] = {
12758 (char *) "h",(char *) "s",(char *) "v", NULL
12759 };
12760
12761 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_Image_HSVValue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12762 if (obj0) {
12763 ecode1 = SWIG_AsVal_double(obj0, &val1);
12764 if (!SWIG_IsOK(ecode1)) {
12765 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_Image_HSVValue" "', expected argument " "1"" of type '" "double""'");
12766 }
12767 arg1 = static_cast< double >(val1);
12768 }
12769 if (obj1) {
12770 ecode2 = SWIG_AsVal_double(obj1, &val2);
12771 if (!SWIG_IsOK(ecode2)) {
12772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image_HSVValue" "', expected argument " "2"" of type '" "double""'");
12773 }
12774 arg2 = static_cast< double >(val2);
12775 }
12776 if (obj2) {
12777 ecode3 = SWIG_AsVal_double(obj2, &val3);
12778 if (!SWIG_IsOK(ecode3)) {
12779 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image_HSVValue" "', expected argument " "3"" of type '" "double""'");
12780 }
12781 arg3 = static_cast< double >(val3);
12782 }
12783 {
12784 PyThreadState* __tstate = wxPyBeginAllowThreads();
12785 result = (wxImage_HSVValue *)new wxImage_HSVValue(arg1,arg2,arg3);
12786 wxPyEndAllowThreads(__tstate);
12787 if (PyErr_Occurred()) SWIG_fail;
12788 }
12789 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_NEW | 0 );
12790 return resultobj;
12791 fail:
12792 return NULL;
12793 }
12794
12795
12796 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12797 PyObject *resultobj = 0;
12798 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12799 double arg2 ;
12800 void *argp1 = 0 ;
12801 int res1 = 0 ;
12802 double val2 ;
12803 int ecode2 = 0 ;
12804 PyObject *swig_obj[2] ;
12805
12806 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_hue_set",2,2,swig_obj)) SWIG_fail;
12807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12808 if (!SWIG_IsOK(res1)) {
12809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12810 }
12811 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12812 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12813 if (!SWIG_IsOK(ecode2)) {
12814 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_hue_set" "', expected argument " "2"" of type '" "double""'");
12815 }
12816 arg2 = static_cast< double >(val2);
12817 if (arg1) (arg1)->hue = arg2;
12818
12819 resultobj = SWIG_Py_Void();
12820 return resultobj;
12821 fail:
12822 return NULL;
12823 }
12824
12825
12826 SWIGINTERN PyObject *_wrap_Image_HSVValue_hue_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12827 PyObject *resultobj = 0;
12828 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12829 double result;
12830 void *argp1 = 0 ;
12831 int res1 = 0 ;
12832 PyObject *swig_obj[1] ;
12833
12834 if (!args) SWIG_fail;
12835 swig_obj[0] = args;
12836 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12837 if (!SWIG_IsOK(res1)) {
12838 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_hue_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12839 }
12840 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12841 result = (double) ((arg1)->hue);
12842 resultobj = SWIG_From_double(static_cast< double >(result));
12843 return resultobj;
12844 fail:
12845 return NULL;
12846 }
12847
12848
12849 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12850 PyObject *resultobj = 0;
12851 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12852 double arg2 ;
12853 void *argp1 = 0 ;
12854 int res1 = 0 ;
12855 double val2 ;
12856 int ecode2 = 0 ;
12857 PyObject *swig_obj[2] ;
12858
12859 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_saturation_set",2,2,swig_obj)) SWIG_fail;
12860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12861 if (!SWIG_IsOK(res1)) {
12862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12863 }
12864 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12865 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12866 if (!SWIG_IsOK(ecode2)) {
12867 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_saturation_set" "', expected argument " "2"" of type '" "double""'");
12868 }
12869 arg2 = static_cast< double >(val2);
12870 if (arg1) (arg1)->saturation = arg2;
12871
12872 resultobj = SWIG_Py_Void();
12873 return resultobj;
12874 fail:
12875 return NULL;
12876 }
12877
12878
12879 SWIGINTERN PyObject *_wrap_Image_HSVValue_saturation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12880 PyObject *resultobj = 0;
12881 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12882 double result;
12883 void *argp1 = 0 ;
12884 int res1 = 0 ;
12885 PyObject *swig_obj[1] ;
12886
12887 if (!args) SWIG_fail;
12888 swig_obj[0] = args;
12889 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12890 if (!SWIG_IsOK(res1)) {
12891 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_saturation_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12892 }
12893 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12894 result = (double) ((arg1)->saturation);
12895 resultobj = SWIG_From_double(static_cast< double >(result));
12896 return resultobj;
12897 fail:
12898 return NULL;
12899 }
12900
12901
12902 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12903 PyObject *resultobj = 0;
12904 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12905 double arg2 ;
12906 void *argp1 = 0 ;
12907 int res1 = 0 ;
12908 double val2 ;
12909 int ecode2 = 0 ;
12910 PyObject *swig_obj[2] ;
12911
12912 if (!SWIG_Python_UnpackTuple(args,"Image_HSVValue_value_set",2,2,swig_obj)) SWIG_fail;
12913 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12914 if (!SWIG_IsOK(res1)) {
12915 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_set" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12916 }
12917 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12918 ecode2 = SWIG_AsVal_double(swig_obj[1], &val2);
12919 if (!SWIG_IsOK(ecode2)) {
12920 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_HSVValue_value_set" "', expected argument " "2"" of type '" "double""'");
12921 }
12922 arg2 = static_cast< double >(val2);
12923 if (arg1) (arg1)->value = arg2;
12924
12925 resultobj = SWIG_Py_Void();
12926 return resultobj;
12927 fail:
12928 return NULL;
12929 }
12930
12931
12932 SWIGINTERN PyObject *_wrap_Image_HSVValue_value_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12933 PyObject *resultobj = 0;
12934 wxImage_HSVValue *arg1 = (wxImage_HSVValue *) 0 ;
12935 double result;
12936 void *argp1 = 0 ;
12937 int res1 = 0 ;
12938 PyObject *swig_obj[1] ;
12939
12940 if (!args) SWIG_fail;
12941 swig_obj[0] = args;
12942 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage_HSVValue, 0 | 0 );
12943 if (!SWIG_IsOK(res1)) {
12944 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVValue_value_get" "', expected argument " "1"" of type '" "wxImage_HSVValue *""'");
12945 }
12946 arg1 = reinterpret_cast< wxImage_HSVValue * >(argp1);
12947 result = (double) ((arg1)->value);
12948 resultobj = SWIG_From_double(static_cast< double >(result));
12949 return resultobj;
12950 fail:
12951 return NULL;
12952 }
12953
12954
12955 SWIGINTERN PyObject *Image_HSVValue_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12956 PyObject *obj;
12957 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
12958 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage_HSVValue, SWIG_NewClientData(obj));
12959 return SWIG_Py_Void();
12960 }
12961
12962 SWIGINTERN PyObject *Image_HSVValue_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
12963 return SWIG_Python_InitShadowInstance(args);
12964 }
12965
12966 SWIGINTERN PyObject *_wrap_new_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
12967 PyObject *resultobj = 0;
12968 wxString *arg1 = 0 ;
12969 long arg2 = (long) wxBITMAP_TYPE_ANY ;
12970 int arg3 = (int) -1 ;
12971 wxImage *result = 0 ;
12972 bool temp1 = false ;
12973 long val2 ;
12974 int ecode2 = 0 ;
12975 int val3 ;
12976 int ecode3 = 0 ;
12977 PyObject * obj0 = 0 ;
12978 PyObject * obj1 = 0 ;
12979 PyObject * obj2 = 0 ;
12980 char * kwnames[] = {
12981 (char *) "name",(char *) "type",(char *) "index", NULL
12982 };
12983
12984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_Image",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
12985 {
12986 arg1 = wxString_in_helper(obj0);
12987 if (arg1 == NULL) SWIG_fail;
12988 temp1 = true;
12989 }
12990 if (obj1) {
12991 ecode2 = SWIG_AsVal_long(obj1, &val2);
12992 if (!SWIG_IsOK(ecode2)) {
12993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Image" "', expected argument " "2"" of type '" "long""'");
12994 }
12995 arg2 = static_cast< long >(val2);
12996 }
12997 if (obj2) {
12998 ecode3 = SWIG_AsVal_int(obj2, &val3);
12999 if (!SWIG_IsOK(ecode3)) {
13000 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_Image" "', expected argument " "3"" of type '" "int""'");
13001 }
13002 arg3 = static_cast< int >(val3);
13003 }
13004 {
13005 PyThreadState* __tstate = wxPyBeginAllowThreads();
13006 result = (wxImage *)new wxImage((wxString const &)*arg1,arg2,arg3);
13007 wxPyEndAllowThreads(__tstate);
13008 if (PyErr_Occurred()) SWIG_fail;
13009 }
13010 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_NEW | 0 );
13011 {
13012 if (temp1)
13013 delete arg1;
13014 }
13015 return resultobj;
13016 fail:
13017 {
13018 if (temp1)
13019 delete arg1;
13020 }
13021 return NULL;
13022 }
13023
13024
13025 SWIGINTERN PyObject *_wrap_delete_Image(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13026 PyObject *resultobj = 0;
13027 wxImage *arg1 = (wxImage *) 0 ;
13028 void *argp1 = 0 ;
13029 int res1 = 0 ;
13030 PyObject *swig_obj[1] ;
13031
13032 if (!args) SWIG_fail;
13033 swig_obj[0] = args;
13034 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, SWIG_POINTER_DISOWN | 0 );
13035 if (!SWIG_IsOK(res1)) {
13036 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Image" "', expected argument " "1"" of type '" "wxImage *""'");
13037 }
13038 arg1 = reinterpret_cast< wxImage * >(argp1);
13039 {
13040 PyThreadState* __tstate = wxPyBeginAllowThreads();
13041 delete arg1;
13042
13043 wxPyEndAllowThreads(__tstate);
13044 if (PyErr_Occurred()) SWIG_fail;
13045 }
13046 resultobj = SWIG_Py_Void();
13047 return resultobj;
13048 fail:
13049 return NULL;
13050 }
13051
13052
13053 SWIGINTERN PyObject *_wrap_new_ImageFromMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13054 PyObject *resultobj = 0;
13055 wxString *arg1 = 0 ;
13056 wxString *arg2 = 0 ;
13057 int arg3 = (int) -1 ;
13058 wxImage *result = 0 ;
13059 bool temp1 = false ;
13060 bool temp2 = false ;
13061 int val3 ;
13062 int ecode3 = 0 ;
13063 PyObject * obj0 = 0 ;
13064 PyObject * obj1 = 0 ;
13065 PyObject * obj2 = 0 ;
13066 char * kwnames[] = {
13067 (char *) "name",(char *) "mimetype",(char *) "index", NULL
13068 };
13069
13070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13071 {
13072 arg1 = wxString_in_helper(obj0);
13073 if (arg1 == NULL) SWIG_fail;
13074 temp1 = true;
13075 }
13076 {
13077 arg2 = wxString_in_helper(obj1);
13078 if (arg2 == NULL) SWIG_fail;
13079 temp2 = true;
13080 }
13081 if (obj2) {
13082 ecode3 = SWIG_AsVal_int(obj2, &val3);
13083 if (!SWIG_IsOK(ecode3)) {
13084 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromMime" "', expected argument " "3"" of type '" "int""'");
13085 }
13086 arg3 = static_cast< int >(val3);
13087 }
13088 {
13089 PyThreadState* __tstate = wxPyBeginAllowThreads();
13090 result = (wxImage *)new wxImage((wxString const &)*arg1,(wxString const &)*arg2,arg3);
13091 wxPyEndAllowThreads(__tstate);
13092 if (PyErr_Occurred()) SWIG_fail;
13093 }
13094 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13095 {
13096 if (temp1)
13097 delete arg1;
13098 }
13099 {
13100 if (temp2)
13101 delete arg2;
13102 }
13103 return resultobj;
13104 fail:
13105 {
13106 if (temp1)
13107 delete arg1;
13108 }
13109 {
13110 if (temp2)
13111 delete arg2;
13112 }
13113 return NULL;
13114 }
13115
13116
13117 SWIGINTERN PyObject *_wrap_new_ImageFromStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13118 PyObject *resultobj = 0;
13119 wxInputStream *arg1 = 0 ;
13120 long arg2 = (long) wxBITMAP_TYPE_ANY ;
13121 int arg3 = (int) -1 ;
13122 wxImage *result = 0 ;
13123 wxPyInputStream *temp1 ;
13124 bool created1 ;
13125 long val2 ;
13126 int ecode2 = 0 ;
13127 int val3 ;
13128 int ecode3 = 0 ;
13129 PyObject * obj0 = 0 ;
13130 PyObject * obj1 = 0 ;
13131 PyObject * obj2 = 0 ;
13132 char * kwnames[] = {
13133 (char *) "stream",(char *) "type",(char *) "index", NULL
13134 };
13135
13136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:new_ImageFromStream",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13137 {
13138 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13139 arg1 = temp1->m_wxis;
13140 created1 = false;
13141 } else {
13142 PyErr_Clear(); // clear the failure of the wxPyConvert above
13143 arg1 = wxPyCBInputStream_create(obj0, false);
13144 if (arg1 == NULL) {
13145 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13146 SWIG_fail;
13147 }
13148 created1 = true;
13149 }
13150 }
13151 if (obj1) {
13152 ecode2 = SWIG_AsVal_long(obj1, &val2);
13153 if (!SWIG_IsOK(ecode2)) {
13154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromStream" "', expected argument " "2"" of type '" "long""'");
13155 }
13156 arg2 = static_cast< long >(val2);
13157 }
13158 if (obj2) {
13159 ecode3 = SWIG_AsVal_int(obj2, &val3);
13160 if (!SWIG_IsOK(ecode3)) {
13161 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ImageFromStream" "', expected argument " "3"" of type '" "int""'");
13162 }
13163 arg3 = static_cast< int >(val3);
13164 }
13165 {
13166 PyThreadState* __tstate = wxPyBeginAllowThreads();
13167 result = (wxImage *)new wxImage(*arg1,arg2,arg3);
13168 wxPyEndAllowThreads(__tstate);
13169 if (PyErr_Occurred()) SWIG_fail;
13170 }
13171 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13172 {
13173 if (created1) delete arg1;
13174 }
13175 return resultobj;
13176 fail:
13177 {
13178 if (created1) delete arg1;
13179 }
13180 return NULL;
13181 }
13182
13183
13184 SWIGINTERN PyObject *_wrap_new_ImageFromStreamMime(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13185 PyObject *resultobj = 0;
13186 wxInputStream *arg1 = 0 ;
13187 wxString *arg2 = 0 ;
13188 int arg3 = (int) -1 ;
13189 wxImage *result = 0 ;
13190 wxPyInputStream *temp1 ;
13191 bool created1 ;
13192 bool temp2 = false ;
13193 int val3 ;
13194 int ecode3 = 0 ;
13195 PyObject * obj0 = 0 ;
13196 PyObject * obj1 = 0 ;
13197 PyObject * obj2 = 0 ;
13198 char * kwnames[] = {
13199 (char *) "stream",(char *) "mimetype",(char *) "index", NULL
13200 };
13201
13202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:new_ImageFromStreamMime",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13203 {
13204 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
13205 arg1 = temp1->m_wxis;
13206 created1 = false;
13207 } else {
13208 PyErr_Clear(); // clear the failure of the wxPyConvert above
13209 arg1 = wxPyCBInputStream_create(obj0, false);
13210 if (arg1 == NULL) {
13211 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
13212 SWIG_fail;
13213 }
13214 created1 = true;
13215 }
13216 }
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 '" "new_ImageFromStreamMime" "', expected argument " "3"" of type '" "int""'");
13226 }
13227 arg3 = static_cast< int >(val3);
13228 }
13229 {
13230 PyThreadState* __tstate = wxPyBeginAllowThreads();
13231 result = (wxImage *)new wxImage(*arg1,(wxString const &)*arg2,arg3);
13232 wxPyEndAllowThreads(__tstate);
13233 if (PyErr_Occurred()) SWIG_fail;
13234 }
13235 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13236 {
13237 if (created1) delete arg1;
13238 }
13239 {
13240 if (temp2)
13241 delete arg2;
13242 }
13243 return resultobj;
13244 fail:
13245 {
13246 if (created1) delete arg1;
13247 }
13248 {
13249 if (temp2)
13250 delete arg2;
13251 }
13252 return NULL;
13253 }
13254
13255
13256 SWIGINTERN PyObject *_wrap_new_EmptyImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13257 PyObject *resultobj = 0;
13258 int arg1 = (int) 0 ;
13259 int arg2 = (int) 0 ;
13260 bool arg3 = (bool) true ;
13261 wxImage *result = 0 ;
13262 int val1 ;
13263 int ecode1 = 0 ;
13264 int val2 ;
13265 int ecode2 = 0 ;
13266 bool val3 ;
13267 int ecode3 = 0 ;
13268 PyObject * obj0 = 0 ;
13269 PyObject * obj1 = 0 ;
13270 PyObject * obj2 = 0 ;
13271 char * kwnames[] = {
13272 (char *) "width",(char *) "height",(char *) "clear", NULL
13273 };
13274
13275 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_EmptyImage",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13276 if (obj0) {
13277 ecode1 = SWIG_AsVal_int(obj0, &val1);
13278 if (!SWIG_IsOK(ecode1)) {
13279 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EmptyImage" "', expected argument " "1"" of type '" "int""'");
13280 }
13281 arg1 = static_cast< int >(val1);
13282 }
13283 if (obj1) {
13284 ecode2 = SWIG_AsVal_int(obj1, &val2);
13285 if (!SWIG_IsOK(ecode2)) {
13286 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_EmptyImage" "', expected argument " "2"" of type '" "int""'");
13287 }
13288 arg2 = static_cast< int >(val2);
13289 }
13290 if (obj2) {
13291 ecode3 = SWIG_AsVal_bool(obj2, &val3);
13292 if (!SWIG_IsOK(ecode3)) {
13293 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_EmptyImage" "', expected argument " "3"" of type '" "bool""'");
13294 }
13295 arg3 = static_cast< bool >(val3);
13296 }
13297 {
13298 PyThreadState* __tstate = wxPyBeginAllowThreads();
13299 result = (wxImage *)new_wxImage(arg1,arg2,arg3);
13300 wxPyEndAllowThreads(__tstate);
13301 if (PyErr_Occurred()) SWIG_fail;
13302 }
13303 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13304 return resultobj;
13305 fail:
13306 return NULL;
13307 }
13308
13309
13310 SWIGINTERN PyObject *_wrap_new_ImageFromBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13311 PyObject *resultobj = 0;
13312 wxBitmap *arg1 = 0 ;
13313 wxImage *result = 0 ;
13314 void *argp1 = 0 ;
13315 int res1 = 0 ;
13316 PyObject * obj0 = 0 ;
13317 char * kwnames[] = {
13318 (char *) "bitmap", NULL
13319 };
13320
13321 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_ImageFromBitmap",kwnames,&obj0)) SWIG_fail;
13322 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxBitmap, 0 | 0);
13323 if (!SWIG_IsOK(res1)) {
13324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13325 }
13326 if (!argp1) {
13327 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_ImageFromBitmap" "', expected argument " "1"" of type '" "wxBitmap const &""'");
13328 }
13329 arg1 = reinterpret_cast< wxBitmap * >(argp1);
13330 {
13331 if (!wxPyCheckForApp()) SWIG_fail;
13332 PyThreadState* __tstate = wxPyBeginAllowThreads();
13333 result = (wxImage *)new_wxImage((wxBitmap const &)*arg1);
13334 wxPyEndAllowThreads(__tstate);
13335 if (PyErr_Occurred()) SWIG_fail;
13336 }
13337 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13338 return resultobj;
13339 fail:
13340 return NULL;
13341 }
13342
13343
13344 SWIGINTERN PyObject *_wrap_new_ImageFromData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13345 PyObject *resultobj = 0;
13346 int arg1 ;
13347 int arg2 ;
13348 buffer arg3 ;
13349 int arg4 ;
13350 wxImage *result = 0 ;
13351 int val1 ;
13352 int ecode1 = 0 ;
13353 int val2 ;
13354 int ecode2 = 0 ;
13355 PyObject * obj0 = 0 ;
13356 PyObject * obj1 = 0 ;
13357 PyObject * obj2 = 0 ;
13358 char * kwnames[] = {
13359 (char *) "width",(char *) "height",(char *) "data", NULL
13360 };
13361
13362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_ImageFromData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13363 ecode1 = SWIG_AsVal_int(obj0, &val1);
13364 if (!SWIG_IsOK(ecode1)) {
13365 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromData" "', expected argument " "1"" of type '" "int""'");
13366 }
13367 arg1 = static_cast< int >(val1);
13368 ecode2 = SWIG_AsVal_int(obj1, &val2);
13369 if (!SWIG_IsOK(ecode2)) {
13370 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromData" "', expected argument " "2"" of type '" "int""'");
13371 }
13372 arg2 = static_cast< int >(val2);
13373 {
13374 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13375 }
13376 {
13377 PyThreadState* __tstate = wxPyBeginAllowThreads();
13378 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4);
13379 wxPyEndAllowThreads(__tstate);
13380 if (PyErr_Occurred()) SWIG_fail;
13381 }
13382 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13383 return resultobj;
13384 fail:
13385 return NULL;
13386 }
13387
13388
13389 SWIGINTERN PyObject *_wrap_new_ImageFromDataWithAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13390 PyObject *resultobj = 0;
13391 int arg1 ;
13392 int arg2 ;
13393 buffer arg3 ;
13394 int arg4 ;
13395 buffer arg5 ;
13396 int arg6 ;
13397 wxImage *result = 0 ;
13398 int val1 ;
13399 int ecode1 = 0 ;
13400 int val2 ;
13401 int ecode2 = 0 ;
13402 PyObject * obj0 = 0 ;
13403 PyObject * obj1 = 0 ;
13404 PyObject * obj2 = 0 ;
13405 PyObject * obj3 = 0 ;
13406 char * kwnames[] = {
13407 (char *) "width",(char *) "height",(char *) "data",(char *) "alpha", NULL
13408 };
13409
13410 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:new_ImageFromDataWithAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13411 ecode1 = SWIG_AsVal_int(obj0, &val1);
13412 if (!SWIG_IsOK(ecode1)) {
13413 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "1"" of type '" "int""'");
13414 }
13415 arg1 = static_cast< int >(val1);
13416 ecode2 = SWIG_AsVal_int(obj1, &val2);
13417 if (!SWIG_IsOK(ecode2)) {
13418 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ImageFromDataWithAlpha" "', expected argument " "2"" of type '" "int""'");
13419 }
13420 arg2 = static_cast< int >(val2);
13421 {
13422 if (!PyArg_Parse(obj2, "t#", &arg3, &arg4)) SWIG_fail;
13423 }
13424 {
13425 if (!PyArg_Parse(obj3, "t#", &arg5, &arg6)) SWIG_fail;
13426 }
13427 {
13428 PyThreadState* __tstate = wxPyBeginAllowThreads();
13429 result = (wxImage *)new_wxImage(arg1,arg2,arg3,arg4,arg5,arg6);
13430 wxPyEndAllowThreads(__tstate);
13431 if (PyErr_Occurred()) SWIG_fail;
13432 }
13433 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13434 return resultobj;
13435 fail:
13436 return NULL;
13437 }
13438
13439
13440 SWIGINTERN PyObject *_wrap_Image_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13441 PyObject *resultobj = 0;
13442 wxImage *arg1 = (wxImage *) 0 ;
13443 int arg2 ;
13444 int arg3 ;
13445 bool arg4 = (bool) true ;
13446 void *argp1 = 0 ;
13447 int res1 = 0 ;
13448 int val2 ;
13449 int ecode2 = 0 ;
13450 int val3 ;
13451 int ecode3 = 0 ;
13452 bool val4 ;
13453 int ecode4 = 0 ;
13454 PyObject * obj0 = 0 ;
13455 PyObject * obj1 = 0 ;
13456 PyObject * obj2 = 0 ;
13457 PyObject * obj3 = 0 ;
13458 char * kwnames[] = {
13459 (char *) "self",(char *) "width",(char *) "height",(char *) "clear", NULL
13460 };
13461
13462 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_Create",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
13463 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13464 if (!SWIG_IsOK(res1)) {
13465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Create" "', expected argument " "1"" of type '" "wxImage *""'");
13466 }
13467 arg1 = reinterpret_cast< wxImage * >(argp1);
13468 ecode2 = SWIG_AsVal_int(obj1, &val2);
13469 if (!SWIG_IsOK(ecode2)) {
13470 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Create" "', expected argument " "2"" of type '" "int""'");
13471 }
13472 arg2 = static_cast< int >(val2);
13473 ecode3 = SWIG_AsVal_int(obj2, &val3);
13474 if (!SWIG_IsOK(ecode3)) {
13475 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Create" "', expected argument " "3"" of type '" "int""'");
13476 }
13477 arg3 = static_cast< int >(val3);
13478 if (obj3) {
13479 ecode4 = SWIG_AsVal_bool(obj3, &val4);
13480 if (!SWIG_IsOK(ecode4)) {
13481 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Create" "', expected argument " "4"" of type '" "bool""'");
13482 }
13483 arg4 = static_cast< bool >(val4);
13484 }
13485 {
13486 PyThreadState* __tstate = wxPyBeginAllowThreads();
13487 (arg1)->Create(arg2,arg3,arg4);
13488 wxPyEndAllowThreads(__tstate);
13489 if (PyErr_Occurred()) SWIG_fail;
13490 }
13491 resultobj = SWIG_Py_Void();
13492 return resultobj;
13493 fail:
13494 return NULL;
13495 }
13496
13497
13498 SWIGINTERN PyObject *_wrap_Image_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
13499 PyObject *resultobj = 0;
13500 wxImage *arg1 = (wxImage *) 0 ;
13501 void *argp1 = 0 ;
13502 int res1 = 0 ;
13503 PyObject *swig_obj[1] ;
13504
13505 if (!args) SWIG_fail;
13506 swig_obj[0] = args;
13507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13508 if (!SWIG_IsOK(res1)) {
13509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Destroy" "', expected argument " "1"" of type '" "wxImage *""'");
13510 }
13511 arg1 = reinterpret_cast< wxImage * >(argp1);
13512 {
13513 PyThreadState* __tstate = wxPyBeginAllowThreads();
13514 (arg1)->Destroy();
13515 wxPyEndAllowThreads(__tstate);
13516 if (PyErr_Occurred()) SWIG_fail;
13517 }
13518 resultobj = SWIG_Py_Void();
13519 return resultobj;
13520 fail:
13521 return NULL;
13522 }
13523
13524
13525 SWIGINTERN PyObject *_wrap_Image_Scale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13526 PyObject *resultobj = 0;
13527 wxImage *arg1 = (wxImage *) 0 ;
13528 int arg2 ;
13529 int arg3 ;
13530 SwigValueWrapper<wxImage > result;
13531 void *argp1 = 0 ;
13532 int res1 = 0 ;
13533 int val2 ;
13534 int ecode2 = 0 ;
13535 int val3 ;
13536 int ecode3 = 0 ;
13537 PyObject * obj0 = 0 ;
13538 PyObject * obj1 = 0 ;
13539 PyObject * obj2 = 0 ;
13540 char * kwnames[] = {
13541 (char *) "self",(char *) "width",(char *) "height", NULL
13542 };
13543
13544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Scale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13546 if (!SWIG_IsOK(res1)) {
13547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Scale" "', expected argument " "1"" of type '" "wxImage *""'");
13548 }
13549 arg1 = reinterpret_cast< wxImage * >(argp1);
13550 ecode2 = SWIG_AsVal_int(obj1, &val2);
13551 if (!SWIG_IsOK(ecode2)) {
13552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Scale" "', expected argument " "2"" of type '" "int""'");
13553 }
13554 arg2 = static_cast< int >(val2);
13555 ecode3 = SWIG_AsVal_int(obj2, &val3);
13556 if (!SWIG_IsOK(ecode3)) {
13557 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Scale" "', expected argument " "3"" of type '" "int""'");
13558 }
13559 arg3 = static_cast< int >(val3);
13560 {
13561 PyThreadState* __tstate = wxPyBeginAllowThreads();
13562 result = (arg1)->Scale(arg2,arg3);
13563 wxPyEndAllowThreads(__tstate);
13564 if (PyErr_Occurred()) SWIG_fail;
13565 }
13566 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13567 return resultobj;
13568 fail:
13569 return NULL;
13570 }
13571
13572
13573 SWIGINTERN PyObject *_wrap_Image_ShrinkBy(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13574 PyObject *resultobj = 0;
13575 wxImage *arg1 = (wxImage *) 0 ;
13576 int arg2 ;
13577 int arg3 ;
13578 SwigValueWrapper<wxImage > result;
13579 void *argp1 = 0 ;
13580 int res1 = 0 ;
13581 int val2 ;
13582 int ecode2 = 0 ;
13583 int val3 ;
13584 int ecode3 = 0 ;
13585 PyObject * obj0 = 0 ;
13586 PyObject * obj1 = 0 ;
13587 PyObject * obj2 = 0 ;
13588 char * kwnames[] = {
13589 (char *) "self",(char *) "xFactor",(char *) "yFactor", NULL
13590 };
13591
13592 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_ShrinkBy",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13593 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13594 if (!SWIG_IsOK(res1)) {
13595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ShrinkBy" "', expected argument " "1"" of type '" "wxImage const *""'");
13596 }
13597 arg1 = reinterpret_cast< wxImage * >(argp1);
13598 ecode2 = SWIG_AsVal_int(obj1, &val2);
13599 if (!SWIG_IsOK(ecode2)) {
13600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ShrinkBy" "', expected argument " "2"" of type '" "int""'");
13601 }
13602 arg2 = static_cast< int >(val2);
13603 ecode3 = SWIG_AsVal_int(obj2, &val3);
13604 if (!SWIG_IsOK(ecode3)) {
13605 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ShrinkBy" "', expected argument " "3"" of type '" "int""'");
13606 }
13607 arg3 = static_cast< int >(val3);
13608 {
13609 PyThreadState* __tstate = wxPyBeginAllowThreads();
13610 result = ((wxImage const *)arg1)->ShrinkBy(arg2,arg3);
13611 wxPyEndAllowThreads(__tstate);
13612 if (PyErr_Occurred()) SWIG_fail;
13613 }
13614 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
13615 return resultobj;
13616 fail:
13617 return NULL;
13618 }
13619
13620
13621 SWIGINTERN PyObject *_wrap_Image_Rescale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13622 PyObject *resultobj = 0;
13623 wxImage *arg1 = (wxImage *) 0 ;
13624 int arg2 ;
13625 int arg3 ;
13626 wxImage *result = 0 ;
13627 void *argp1 = 0 ;
13628 int res1 = 0 ;
13629 int val2 ;
13630 int ecode2 = 0 ;
13631 int val3 ;
13632 int ecode3 = 0 ;
13633 PyObject * obj0 = 0 ;
13634 PyObject * obj1 = 0 ;
13635 PyObject * obj2 = 0 ;
13636 char * kwnames[] = {
13637 (char *) "self",(char *) "width",(char *) "height", NULL
13638 };
13639
13640 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_Rescale",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13641 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13642 if (!SWIG_IsOK(res1)) {
13643 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rescale" "', expected argument " "1"" of type '" "wxImage *""'");
13644 }
13645 arg1 = reinterpret_cast< wxImage * >(argp1);
13646 ecode2 = SWIG_AsVal_int(obj1, &val2);
13647 if (!SWIG_IsOK(ecode2)) {
13648 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rescale" "', expected argument " "2"" of type '" "int""'");
13649 }
13650 arg2 = static_cast< int >(val2);
13651 ecode3 = SWIG_AsVal_int(obj2, &val3);
13652 if (!SWIG_IsOK(ecode3)) {
13653 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Rescale" "', expected argument " "3"" of type '" "int""'");
13654 }
13655 arg3 = static_cast< int >(val3);
13656 {
13657 PyThreadState* __tstate = wxPyBeginAllowThreads();
13658 {
13659 wxImage &_result_ref = (arg1)->Rescale(arg2,arg3);
13660 result = (wxImage *) &_result_ref;
13661 }
13662 wxPyEndAllowThreads(__tstate);
13663 if (PyErr_Occurred()) SWIG_fail;
13664 }
13665 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13666 return resultobj;
13667 fail:
13668 return NULL;
13669 }
13670
13671
13672 SWIGINTERN PyObject *_wrap_Image_Resize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13673 PyObject *resultobj = 0;
13674 wxImage *arg1 = (wxImage *) 0 ;
13675 wxSize *arg2 = 0 ;
13676 wxPoint *arg3 = 0 ;
13677 int arg4 = (int) -1 ;
13678 int arg5 = (int) -1 ;
13679 int arg6 = (int) -1 ;
13680 wxImage *result = 0 ;
13681 void *argp1 = 0 ;
13682 int res1 = 0 ;
13683 wxSize temp2 ;
13684 wxPoint temp3 ;
13685 int val4 ;
13686 int ecode4 = 0 ;
13687 int val5 ;
13688 int ecode5 = 0 ;
13689 int val6 ;
13690 int ecode6 = 0 ;
13691 PyObject * obj0 = 0 ;
13692 PyObject * obj1 = 0 ;
13693 PyObject * obj2 = 0 ;
13694 PyObject * obj3 = 0 ;
13695 PyObject * obj4 = 0 ;
13696 PyObject * obj5 = 0 ;
13697 char * kwnames[] = {
13698 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
13699 };
13700
13701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Resize",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13703 if (!SWIG_IsOK(res1)) {
13704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Resize" "', expected argument " "1"" of type '" "wxImage *""'");
13705 }
13706 arg1 = reinterpret_cast< wxImage * >(argp1);
13707 {
13708 arg2 = &temp2;
13709 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
13710 }
13711 {
13712 arg3 = &temp3;
13713 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
13714 }
13715 if (obj3) {
13716 ecode4 = SWIG_AsVal_int(obj3, &val4);
13717 if (!SWIG_IsOK(ecode4)) {
13718 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Resize" "', expected argument " "4"" of type '" "int""'");
13719 }
13720 arg4 = static_cast< int >(val4);
13721 }
13722 if (obj4) {
13723 ecode5 = SWIG_AsVal_int(obj4, &val5);
13724 if (!SWIG_IsOK(ecode5)) {
13725 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Resize" "', expected argument " "5"" of type '" "int""'");
13726 }
13727 arg5 = static_cast< int >(val5);
13728 }
13729 if (obj5) {
13730 ecode6 = SWIG_AsVal_int(obj5, &val6);
13731 if (!SWIG_IsOK(ecode6)) {
13732 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Resize" "', expected argument " "6"" of type '" "int""'");
13733 }
13734 arg6 = static_cast< int >(val6);
13735 }
13736 {
13737 PyThreadState* __tstate = wxPyBeginAllowThreads();
13738 {
13739 wxImage &_result_ref = (arg1)->Resize((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
13740 result = (wxImage *) &_result_ref;
13741 }
13742 wxPyEndAllowThreads(__tstate);
13743 if (PyErr_Occurred()) SWIG_fail;
13744 }
13745 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxImage, 0 | 0 );
13746 return resultobj;
13747 fail:
13748 return NULL;
13749 }
13750
13751
13752 SWIGINTERN PyObject *_wrap_Image_SetRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13753 PyObject *resultobj = 0;
13754 wxImage *arg1 = (wxImage *) 0 ;
13755 int arg2 ;
13756 int arg3 ;
13757 byte arg4 ;
13758 byte arg5 ;
13759 byte arg6 ;
13760 void *argp1 = 0 ;
13761 int res1 = 0 ;
13762 int val2 ;
13763 int ecode2 = 0 ;
13764 int val3 ;
13765 int ecode3 = 0 ;
13766 unsigned char val4 ;
13767 int ecode4 = 0 ;
13768 unsigned char val5 ;
13769 int ecode5 = 0 ;
13770 unsigned char val6 ;
13771 int ecode6 = 0 ;
13772 PyObject * obj0 = 0 ;
13773 PyObject * obj1 = 0 ;
13774 PyObject * obj2 = 0 ;
13775 PyObject * obj3 = 0 ;
13776 PyObject * obj4 = 0 ;
13777 PyObject * obj5 = 0 ;
13778 char * kwnames[] = {
13779 (char *) "self",(char *) "x",(char *) "y",(char *) "r",(char *) "g",(char *) "b", NULL
13780 };
13781
13782 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO:Image_SetRGB",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
13783 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13784 if (!SWIG_IsOK(res1)) {
13785 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGB" "', expected argument " "1"" of type '" "wxImage *""'");
13786 }
13787 arg1 = reinterpret_cast< wxImage * >(argp1);
13788 ecode2 = SWIG_AsVal_int(obj1, &val2);
13789 if (!SWIG_IsOK(ecode2)) {
13790 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetRGB" "', expected argument " "2"" of type '" "int""'");
13791 }
13792 arg2 = static_cast< int >(val2);
13793 ecode3 = SWIG_AsVal_int(obj2, &val3);
13794 if (!SWIG_IsOK(ecode3)) {
13795 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGB" "', expected argument " "3"" of type '" "int""'");
13796 }
13797 arg3 = static_cast< int >(val3);
13798 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13799 if (!SWIG_IsOK(ecode4)) {
13800 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGB" "', expected argument " "4"" of type '" "byte""'");
13801 }
13802 arg4 = static_cast< byte >(val4);
13803 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13804 if (!SWIG_IsOK(ecode5)) {
13805 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGB" "', expected argument " "5"" of type '" "byte""'");
13806 }
13807 arg5 = static_cast< byte >(val5);
13808 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
13809 if (!SWIG_IsOK(ecode6)) {
13810 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_SetRGB" "', expected argument " "6"" of type '" "byte""'");
13811 }
13812 arg6 = static_cast< byte >(val6);
13813 {
13814 PyThreadState* __tstate = wxPyBeginAllowThreads();
13815 (arg1)->SetRGB(arg2,arg3,arg4,arg5,arg6);
13816 wxPyEndAllowThreads(__tstate);
13817 if (PyErr_Occurred()) SWIG_fail;
13818 }
13819 resultobj = SWIG_Py_Void();
13820 return resultobj;
13821 fail:
13822 return NULL;
13823 }
13824
13825
13826 SWIGINTERN PyObject *_wrap_Image_SetRGBRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13827 PyObject *resultobj = 0;
13828 wxImage *arg1 = (wxImage *) 0 ;
13829 wxRect *arg2 = 0 ;
13830 byte arg3 ;
13831 byte arg4 ;
13832 byte arg5 ;
13833 void *argp1 = 0 ;
13834 int res1 = 0 ;
13835 wxRect temp2 ;
13836 unsigned char val3 ;
13837 int ecode3 = 0 ;
13838 unsigned char val4 ;
13839 int ecode4 = 0 ;
13840 unsigned char val5 ;
13841 int ecode5 = 0 ;
13842 PyObject * obj0 = 0 ;
13843 PyObject * obj1 = 0 ;
13844 PyObject * obj2 = 0 ;
13845 PyObject * obj3 = 0 ;
13846 PyObject * obj4 = 0 ;
13847 char * kwnames[] = {
13848 (char *) "self",(char *) "rect",(char *) "r",(char *) "g",(char *) "b", NULL
13849 };
13850
13851 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetRGBRect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
13852 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13853 if (!SWIG_IsOK(res1)) {
13854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetRGBRect" "', expected argument " "1"" of type '" "wxImage *""'");
13855 }
13856 arg1 = reinterpret_cast< wxImage * >(argp1);
13857 {
13858 arg2 = &temp2;
13859 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
13860 }
13861 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
13862 if (!SWIG_IsOK(ecode3)) {
13863 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetRGBRect" "', expected argument " "3"" of type '" "byte""'");
13864 }
13865 arg3 = static_cast< byte >(val3);
13866 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
13867 if (!SWIG_IsOK(ecode4)) {
13868 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetRGBRect" "', expected argument " "4"" of type '" "byte""'");
13869 }
13870 arg4 = static_cast< byte >(val4);
13871 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
13872 if (!SWIG_IsOK(ecode5)) {
13873 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetRGBRect" "', expected argument " "5"" of type '" "byte""'");
13874 }
13875 arg5 = static_cast< byte >(val5);
13876 {
13877 PyThreadState* __tstate = wxPyBeginAllowThreads();
13878 (arg1)->SetRGB((wxRect const &)*arg2,arg3,arg4,arg5);
13879 wxPyEndAllowThreads(__tstate);
13880 if (PyErr_Occurred()) SWIG_fail;
13881 }
13882 resultobj = SWIG_Py_Void();
13883 return resultobj;
13884 fail:
13885 return NULL;
13886 }
13887
13888
13889 SWIGINTERN PyObject *_wrap_Image_GetRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13890 PyObject *resultobj = 0;
13891 wxImage *arg1 = (wxImage *) 0 ;
13892 int arg2 ;
13893 int arg3 ;
13894 byte result;
13895 void *argp1 = 0 ;
13896 int res1 = 0 ;
13897 int val2 ;
13898 int ecode2 = 0 ;
13899 int val3 ;
13900 int ecode3 = 0 ;
13901 PyObject * obj0 = 0 ;
13902 PyObject * obj1 = 0 ;
13903 PyObject * obj2 = 0 ;
13904 char * kwnames[] = {
13905 (char *) "self",(char *) "x",(char *) "y", NULL
13906 };
13907
13908 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetRed",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13909 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13910 if (!SWIG_IsOK(res1)) {
13911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetRed" "', expected argument " "1"" of type '" "wxImage *""'");
13912 }
13913 arg1 = reinterpret_cast< wxImage * >(argp1);
13914 ecode2 = SWIG_AsVal_int(obj1, &val2);
13915 if (!SWIG_IsOK(ecode2)) {
13916 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetRed" "', expected argument " "2"" of type '" "int""'");
13917 }
13918 arg2 = static_cast< int >(val2);
13919 ecode3 = SWIG_AsVal_int(obj2, &val3);
13920 if (!SWIG_IsOK(ecode3)) {
13921 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetRed" "', expected argument " "3"" of type '" "int""'");
13922 }
13923 arg3 = static_cast< int >(val3);
13924 {
13925 PyThreadState* __tstate = wxPyBeginAllowThreads();
13926 result = (byte)(arg1)->GetRed(arg2,arg3);
13927 wxPyEndAllowThreads(__tstate);
13928 if (PyErr_Occurred()) SWIG_fail;
13929 }
13930 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13931 return resultobj;
13932 fail:
13933 return NULL;
13934 }
13935
13936
13937 SWIGINTERN PyObject *_wrap_Image_GetGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13938 PyObject *resultobj = 0;
13939 wxImage *arg1 = (wxImage *) 0 ;
13940 int arg2 ;
13941 int arg3 ;
13942 byte result;
13943 void *argp1 = 0 ;
13944 int res1 = 0 ;
13945 int val2 ;
13946 int ecode2 = 0 ;
13947 int val3 ;
13948 int ecode3 = 0 ;
13949 PyObject * obj0 = 0 ;
13950 PyObject * obj1 = 0 ;
13951 PyObject * obj2 = 0 ;
13952 char * kwnames[] = {
13953 (char *) "self",(char *) "x",(char *) "y", NULL
13954 };
13955
13956 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetGreen",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
13957 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
13958 if (!SWIG_IsOK(res1)) {
13959 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetGreen" "', expected argument " "1"" of type '" "wxImage *""'");
13960 }
13961 arg1 = reinterpret_cast< wxImage * >(argp1);
13962 ecode2 = SWIG_AsVal_int(obj1, &val2);
13963 if (!SWIG_IsOK(ecode2)) {
13964 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetGreen" "', expected argument " "2"" of type '" "int""'");
13965 }
13966 arg2 = static_cast< int >(val2);
13967 ecode3 = SWIG_AsVal_int(obj2, &val3);
13968 if (!SWIG_IsOK(ecode3)) {
13969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetGreen" "', expected argument " "3"" of type '" "int""'");
13970 }
13971 arg3 = static_cast< int >(val3);
13972 {
13973 PyThreadState* __tstate = wxPyBeginAllowThreads();
13974 result = (byte)(arg1)->GetGreen(arg2,arg3);
13975 wxPyEndAllowThreads(__tstate);
13976 if (PyErr_Occurred()) SWIG_fail;
13977 }
13978 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
13979 return resultobj;
13980 fail:
13981 return NULL;
13982 }
13983
13984
13985 SWIGINTERN PyObject *_wrap_Image_GetBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
13986 PyObject *resultobj = 0;
13987 wxImage *arg1 = (wxImage *) 0 ;
13988 int arg2 ;
13989 int arg3 ;
13990 byte result;
13991 void *argp1 = 0 ;
13992 int res1 = 0 ;
13993 int val2 ;
13994 int ecode2 = 0 ;
13995 int val3 ;
13996 int ecode3 = 0 ;
13997 PyObject * obj0 = 0 ;
13998 PyObject * obj1 = 0 ;
13999 PyObject * obj2 = 0 ;
14000 char * kwnames[] = {
14001 (char *) "self",(char *) "x",(char *) "y", NULL
14002 };
14003
14004 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetBlue",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14005 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14006 if (!SWIG_IsOK(res1)) {
14007 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetBlue" "', expected argument " "1"" of type '" "wxImage *""'");
14008 }
14009 arg1 = reinterpret_cast< wxImage * >(argp1);
14010 ecode2 = SWIG_AsVal_int(obj1, &val2);
14011 if (!SWIG_IsOK(ecode2)) {
14012 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetBlue" "', expected argument " "2"" of type '" "int""'");
14013 }
14014 arg2 = static_cast< int >(val2);
14015 ecode3 = SWIG_AsVal_int(obj2, &val3);
14016 if (!SWIG_IsOK(ecode3)) {
14017 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetBlue" "', expected argument " "3"" of type '" "int""'");
14018 }
14019 arg3 = static_cast< int >(val3);
14020 {
14021 PyThreadState* __tstate = wxPyBeginAllowThreads();
14022 result = (byte)(arg1)->GetBlue(arg2,arg3);
14023 wxPyEndAllowThreads(__tstate);
14024 if (PyErr_Occurred()) SWIG_fail;
14025 }
14026 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14027 return resultobj;
14028 fail:
14029 return NULL;
14030 }
14031
14032
14033 SWIGINTERN PyObject *_wrap_Image_SetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14034 PyObject *resultobj = 0;
14035 wxImage *arg1 = (wxImage *) 0 ;
14036 int arg2 ;
14037 int arg3 ;
14038 byte arg4 ;
14039 void *argp1 = 0 ;
14040 int res1 = 0 ;
14041 int val2 ;
14042 int ecode2 = 0 ;
14043 int val3 ;
14044 int ecode3 = 0 ;
14045 unsigned char val4 ;
14046 int ecode4 = 0 ;
14047 PyObject * obj0 = 0 ;
14048 PyObject * obj1 = 0 ;
14049 PyObject * obj2 = 0 ;
14050 PyObject * obj3 = 0 ;
14051 char * kwnames[] = {
14052 (char *) "self",(char *) "x",(char *) "y",(char *) "alpha", NULL
14053 };
14054
14055 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14056 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14057 if (!SWIG_IsOK(res1)) {
14058 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14059 }
14060 arg1 = reinterpret_cast< wxImage * >(argp1);
14061 ecode2 = SWIG_AsVal_int(obj1, &val2);
14062 if (!SWIG_IsOK(ecode2)) {
14063 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetAlpha" "', expected argument " "2"" of type '" "int""'");
14064 }
14065 arg2 = static_cast< int >(val2);
14066 ecode3 = SWIG_AsVal_int(obj2, &val3);
14067 if (!SWIG_IsOK(ecode3)) {
14068 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetAlpha" "', expected argument " "3"" of type '" "int""'");
14069 }
14070 arg3 = static_cast< int >(val3);
14071 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14072 if (!SWIG_IsOK(ecode4)) {
14073 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetAlpha" "', expected argument " "4"" of type '" "byte""'");
14074 }
14075 arg4 = static_cast< byte >(val4);
14076 {
14077 PyThreadState* __tstate = wxPyBeginAllowThreads();
14078 (arg1)->SetAlpha(arg2,arg3,arg4);
14079 wxPyEndAllowThreads(__tstate);
14080 if (PyErr_Occurred()) SWIG_fail;
14081 }
14082 resultobj = SWIG_Py_Void();
14083 return resultobj;
14084 fail:
14085 return NULL;
14086 }
14087
14088
14089 SWIGINTERN PyObject *_wrap_Image_GetAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14090 PyObject *resultobj = 0;
14091 wxImage *arg1 = (wxImage *) 0 ;
14092 int arg2 ;
14093 int arg3 ;
14094 byte result;
14095 void *argp1 = 0 ;
14096 int res1 = 0 ;
14097 int val2 ;
14098 int ecode2 = 0 ;
14099 int val3 ;
14100 int ecode3 = 0 ;
14101 PyObject * obj0 = 0 ;
14102 PyObject * obj1 = 0 ;
14103 PyObject * obj2 = 0 ;
14104 char * kwnames[] = {
14105 (char *) "self",(char *) "x",(char *) "y", NULL
14106 };
14107
14108 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_GetAlpha",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14109 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14110 if (!SWIG_IsOK(res1)) {
14111 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14112 }
14113 arg1 = reinterpret_cast< wxImage * >(argp1);
14114 ecode2 = SWIG_AsVal_int(obj1, &val2);
14115 if (!SWIG_IsOK(ecode2)) {
14116 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetAlpha" "', expected argument " "2"" of type '" "int""'");
14117 }
14118 arg2 = static_cast< int >(val2);
14119 ecode3 = SWIG_AsVal_int(obj2, &val3);
14120 if (!SWIG_IsOK(ecode3)) {
14121 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_GetAlpha" "', expected argument " "3"" of type '" "int""'");
14122 }
14123 arg3 = static_cast< int >(val3);
14124 {
14125 PyThreadState* __tstate = wxPyBeginAllowThreads();
14126 result = (byte)(arg1)->GetAlpha(arg2,arg3);
14127 wxPyEndAllowThreads(__tstate);
14128 if (PyErr_Occurred()) SWIG_fail;
14129 }
14130 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
14131 return resultobj;
14132 fail:
14133 return NULL;
14134 }
14135
14136
14137 SWIGINTERN PyObject *_wrap_Image_HasAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14138 PyObject *resultobj = 0;
14139 wxImage *arg1 = (wxImage *) 0 ;
14140 bool result;
14141 void *argp1 = 0 ;
14142 int res1 = 0 ;
14143 PyObject *swig_obj[1] ;
14144
14145 if (!args) SWIG_fail;
14146 swig_obj[0] = args;
14147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14148 if (!SWIG_IsOK(res1)) {
14149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14150 }
14151 arg1 = reinterpret_cast< wxImage * >(argp1);
14152 {
14153 PyThreadState* __tstate = wxPyBeginAllowThreads();
14154 result = (bool)(arg1)->HasAlpha();
14155 wxPyEndAllowThreads(__tstate);
14156 if (PyErr_Occurred()) SWIG_fail;
14157 }
14158 {
14159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14160 }
14161 return resultobj;
14162 fail:
14163 return NULL;
14164 }
14165
14166
14167 SWIGINTERN PyObject *_wrap_Image_InitAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
14168 PyObject *resultobj = 0;
14169 wxImage *arg1 = (wxImage *) 0 ;
14170 void *argp1 = 0 ;
14171 int res1 = 0 ;
14172 PyObject *swig_obj[1] ;
14173
14174 if (!args) SWIG_fail;
14175 swig_obj[0] = args;
14176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14177 if (!SWIG_IsOK(res1)) {
14178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InitAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14179 }
14180 arg1 = reinterpret_cast< wxImage * >(argp1);
14181 {
14182 PyThreadState* __tstate = wxPyBeginAllowThreads();
14183 (arg1)->InitAlpha();
14184 wxPyEndAllowThreads(__tstate);
14185 if (PyErr_Occurred()) SWIG_fail;
14186 }
14187 resultobj = SWIG_Py_Void();
14188 return resultobj;
14189 fail:
14190 return NULL;
14191 }
14192
14193
14194 SWIGINTERN PyObject *_wrap_Image_IsTransparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14195 PyObject *resultobj = 0;
14196 wxImage *arg1 = (wxImage *) 0 ;
14197 int arg2 ;
14198 int arg3 ;
14199 byte arg4 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14200 bool result;
14201 void *argp1 = 0 ;
14202 int res1 = 0 ;
14203 int val2 ;
14204 int ecode2 = 0 ;
14205 int val3 ;
14206 int ecode3 = 0 ;
14207 unsigned char val4 ;
14208 int ecode4 = 0 ;
14209 PyObject * obj0 = 0 ;
14210 PyObject * obj1 = 0 ;
14211 PyObject * obj2 = 0 ;
14212 PyObject * obj3 = 0 ;
14213 char * kwnames[] = {
14214 (char *) "self",(char *) "x",(char *) "y",(char *) "threshold", NULL
14215 };
14216
14217 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_IsTransparent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14218 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14219 if (!SWIG_IsOK(res1)) {
14220 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_IsTransparent" "', expected argument " "1"" of type '" "wxImage const *""'");
14221 }
14222 arg1 = reinterpret_cast< wxImage * >(argp1);
14223 ecode2 = SWIG_AsVal_int(obj1, &val2);
14224 if (!SWIG_IsOK(ecode2)) {
14225 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_IsTransparent" "', expected argument " "2"" of type '" "int""'");
14226 }
14227 arg2 = static_cast< int >(val2);
14228 ecode3 = SWIG_AsVal_int(obj2, &val3);
14229 if (!SWIG_IsOK(ecode3)) {
14230 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_IsTransparent" "', expected argument " "3"" of type '" "int""'");
14231 }
14232 arg3 = static_cast< int >(val3);
14233 if (obj3) {
14234 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14235 if (!SWIG_IsOK(ecode4)) {
14236 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_IsTransparent" "', expected argument " "4"" of type '" "byte""'");
14237 }
14238 arg4 = static_cast< byte >(val4);
14239 }
14240 {
14241 PyThreadState* __tstate = wxPyBeginAllowThreads();
14242 result = (bool)((wxImage const *)arg1)->IsTransparent(arg2,arg3,arg4);
14243 wxPyEndAllowThreads(__tstate);
14244 if (PyErr_Occurred()) SWIG_fail;
14245 }
14246 {
14247 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14248 }
14249 return resultobj;
14250 fail:
14251 return NULL;
14252 }
14253
14254
14255 SWIGINTERN PyObject *_wrap_Image_FindFirstUnusedColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14256 PyObject *resultobj = 0;
14257 wxImage *arg1 = (wxImage *) 0 ;
14258 byte *arg2 = (byte *) 0 ;
14259 byte *arg3 = (byte *) 0 ;
14260 byte *arg4 = (byte *) 0 ;
14261 byte arg5 = (byte) 0 ;
14262 byte arg6 = (byte) 0 ;
14263 byte arg7 = (byte) 0 ;
14264 bool result;
14265 void *argp1 = 0 ;
14266 int res1 = 0 ;
14267 byte temp2 ;
14268 int res2 = SWIG_TMPOBJ ;
14269 byte temp3 ;
14270 int res3 = SWIG_TMPOBJ ;
14271 byte temp4 ;
14272 int res4 = SWIG_TMPOBJ ;
14273 unsigned char val5 ;
14274 int ecode5 = 0 ;
14275 unsigned char val6 ;
14276 int ecode6 = 0 ;
14277 unsigned char val7 ;
14278 int ecode7 = 0 ;
14279 PyObject * obj0 = 0 ;
14280 PyObject * obj1 = 0 ;
14281 PyObject * obj2 = 0 ;
14282 PyObject * obj3 = 0 ;
14283 char * kwnames[] = {
14284 (char *) "self",(char *) "startR",(char *) "startG",(char *) "startB", NULL
14285 };
14286
14287 arg2 = &temp2;
14288 arg3 = &temp3;
14289 arg4 = &temp4;
14290 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_FindFirstUnusedColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14291 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14292 if (!SWIG_IsOK(res1)) {
14293 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "1"" of type '" "wxImage const *""'");
14294 }
14295 arg1 = reinterpret_cast< wxImage * >(argp1);
14296 if (obj1) {
14297 ecode5 = SWIG_AsVal_unsigned_SS_char(obj1, &val5);
14298 if (!SWIG_IsOK(ecode5)) {
14299 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "5"" of type '" "byte""'");
14300 }
14301 arg5 = static_cast< byte >(val5);
14302 }
14303 if (obj2) {
14304 ecode6 = SWIG_AsVal_unsigned_SS_char(obj2, &val6);
14305 if (!SWIG_IsOK(ecode6)) {
14306 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "6"" of type '" "byte""'");
14307 }
14308 arg6 = static_cast< byte >(val6);
14309 }
14310 if (obj3) {
14311 ecode7 = SWIG_AsVal_unsigned_SS_char(obj3, &val7);
14312 if (!SWIG_IsOK(ecode7)) {
14313 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_FindFirstUnusedColour" "', expected argument " "7"" of type '" "byte""'");
14314 }
14315 arg7 = static_cast< byte >(val7);
14316 }
14317 {
14318 PyThreadState* __tstate = wxPyBeginAllowThreads();
14319 result = (bool)((wxImage const *)arg1)->FindFirstUnusedColour(arg2,arg3,arg4,arg5,arg6,arg7);
14320 wxPyEndAllowThreads(__tstate);
14321 if (PyErr_Occurred()) SWIG_fail;
14322 }
14323 {
14324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14325 }
14326 if (SWIG_IsTmpObj(res2)) {
14327 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
14328 } else {
14329 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14330 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
14331 }
14332 if (SWIG_IsTmpObj(res3)) {
14333 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
14334 } else {
14335 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14336 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
14337 }
14338 if (SWIG_IsTmpObj(res4)) {
14339 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
14340 } else {
14341 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
14342 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
14343 }
14344 return resultobj;
14345 fail:
14346 return NULL;
14347 }
14348
14349
14350 SWIGINTERN PyObject *_wrap_Image_ConvertAlphaToMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14351 PyObject *resultobj = 0;
14352 wxImage *arg1 = (wxImage *) 0 ;
14353 byte arg2 = (byte) wxIMAGE_ALPHA_THRESHOLD ;
14354 bool result;
14355 void *argp1 = 0 ;
14356 int res1 = 0 ;
14357 unsigned char val2 ;
14358 int ecode2 = 0 ;
14359 PyObject * obj0 = 0 ;
14360 PyObject * obj1 = 0 ;
14361 char * kwnames[] = {
14362 (char *) "self",(char *) "threshold", NULL
14363 };
14364
14365 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertAlphaToMask",kwnames,&obj0,&obj1)) SWIG_fail;
14366 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14367 if (!SWIG_IsOK(res1)) {
14368 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "1"" of type '" "wxImage *""'");
14369 }
14370 arg1 = reinterpret_cast< wxImage * >(argp1);
14371 if (obj1) {
14372 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14373 if (!SWIG_IsOK(ecode2)) {
14374 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertAlphaToMask" "', expected argument " "2"" of type '" "byte""'");
14375 }
14376 arg2 = static_cast< byte >(val2);
14377 }
14378 {
14379 PyThreadState* __tstate = wxPyBeginAllowThreads();
14380 result = (bool)(arg1)->ConvertAlphaToMask(arg2);
14381 wxPyEndAllowThreads(__tstate);
14382 if (PyErr_Occurred()) SWIG_fail;
14383 }
14384 {
14385 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14386 }
14387 return resultobj;
14388 fail:
14389 return NULL;
14390 }
14391
14392
14393 SWIGINTERN PyObject *_wrap_Image_ConvertColourToAlpha(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14394 PyObject *resultobj = 0;
14395 wxImage *arg1 = (wxImage *) 0 ;
14396 byte arg2 ;
14397 byte arg3 ;
14398 byte arg4 ;
14399 bool result;
14400 void *argp1 = 0 ;
14401 int res1 = 0 ;
14402 unsigned char val2 ;
14403 int ecode2 = 0 ;
14404 unsigned char val3 ;
14405 int ecode3 = 0 ;
14406 unsigned char val4 ;
14407 int ecode4 = 0 ;
14408 PyObject * obj0 = 0 ;
14409 PyObject * obj1 = 0 ;
14410 PyObject * obj2 = 0 ;
14411 PyObject * obj3 = 0 ;
14412 char * kwnames[] = {
14413 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
14414 };
14415
14416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertColourToAlpha",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14418 if (!SWIG_IsOK(res1)) {
14419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "1"" of type '" "wxImage *""'");
14420 }
14421 arg1 = reinterpret_cast< wxImage * >(argp1);
14422 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
14423 if (!SWIG_IsOK(ecode2)) {
14424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "2"" of type '" "byte""'");
14425 }
14426 arg2 = static_cast< byte >(val2);
14427 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14428 if (!SWIG_IsOK(ecode3)) {
14429 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "3"" of type '" "byte""'");
14430 }
14431 arg3 = static_cast< byte >(val3);
14432 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14433 if (!SWIG_IsOK(ecode4)) {
14434 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertColourToAlpha" "', expected argument " "4"" of type '" "byte""'");
14435 }
14436 arg4 = static_cast< byte >(val4);
14437 {
14438 PyThreadState* __tstate = wxPyBeginAllowThreads();
14439 result = (bool)(arg1)->ConvertColourToAlpha(arg2,arg3,arg4);
14440 wxPyEndAllowThreads(__tstate);
14441 if (PyErr_Occurred()) SWIG_fail;
14442 }
14443 {
14444 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14445 }
14446 return resultobj;
14447 fail:
14448 return NULL;
14449 }
14450
14451
14452 SWIGINTERN PyObject *_wrap_Image_SetMaskFromImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14453 PyObject *resultobj = 0;
14454 wxImage *arg1 = (wxImage *) 0 ;
14455 wxImage *arg2 = 0 ;
14456 byte arg3 ;
14457 byte arg4 ;
14458 byte arg5 ;
14459 bool result;
14460 void *argp1 = 0 ;
14461 int res1 = 0 ;
14462 void *argp2 = 0 ;
14463 int res2 = 0 ;
14464 unsigned char val3 ;
14465 int ecode3 = 0 ;
14466 unsigned char val4 ;
14467 int ecode4 = 0 ;
14468 unsigned char val5 ;
14469 int ecode5 = 0 ;
14470 PyObject * obj0 = 0 ;
14471 PyObject * obj1 = 0 ;
14472 PyObject * obj2 = 0 ;
14473 PyObject * obj3 = 0 ;
14474 PyObject * obj4 = 0 ;
14475 char * kwnames[] = {
14476 (char *) "self",(char *) "mask",(char *) "mr",(char *) "mg",(char *) "mb", NULL
14477 };
14478
14479 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Image_SetMaskFromImage",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
14480 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14481 if (!SWIG_IsOK(res1)) {
14482 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskFromImage" "', expected argument " "1"" of type '" "wxImage *""'");
14483 }
14484 arg1 = reinterpret_cast< wxImage * >(argp1);
14485 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
14486 if (!SWIG_IsOK(res2)) {
14487 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14488 }
14489 if (!argp2) {
14490 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_SetMaskFromImage" "', expected argument " "2"" of type '" "wxImage const &""'");
14491 }
14492 arg2 = reinterpret_cast< wxImage * >(argp2);
14493 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
14494 if (!SWIG_IsOK(ecode3)) {
14495 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskFromImage" "', expected argument " "3"" of type '" "byte""'");
14496 }
14497 arg3 = static_cast< byte >(val3);
14498 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
14499 if (!SWIG_IsOK(ecode4)) {
14500 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskFromImage" "', expected argument " "4"" of type '" "byte""'");
14501 }
14502 arg4 = static_cast< byte >(val4);
14503 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
14504 if (!SWIG_IsOK(ecode5)) {
14505 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_SetMaskFromImage" "', expected argument " "5"" of type '" "byte""'");
14506 }
14507 arg5 = static_cast< byte >(val5);
14508 {
14509 PyThreadState* __tstate = wxPyBeginAllowThreads();
14510 result = (bool)(arg1)->SetMaskFromImage((wxImage const &)*arg2,arg3,arg4,arg5);
14511 wxPyEndAllowThreads(__tstate);
14512 if (PyErr_Occurred()) SWIG_fail;
14513 }
14514 {
14515 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14516 }
14517 return resultobj;
14518 fail:
14519 return NULL;
14520 }
14521
14522
14523 SWIGINTERN PyObject *_wrap_Image_CanRead(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14524 PyObject *resultobj = 0;
14525 wxString *arg1 = 0 ;
14526 bool result;
14527 bool temp1 = false ;
14528 PyObject * obj0 = 0 ;
14529 char * kwnames[] = {
14530 (char *) "filename", NULL
14531 };
14532
14533 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanRead",kwnames,&obj0)) SWIG_fail;
14534 {
14535 arg1 = wxString_in_helper(obj0);
14536 if (arg1 == NULL) SWIG_fail;
14537 temp1 = true;
14538 }
14539 {
14540 PyThreadState* __tstate = wxPyBeginAllowThreads();
14541 result = (bool)wxImage::CanRead((wxString const &)*arg1);
14542 wxPyEndAllowThreads(__tstate);
14543 if (PyErr_Occurred()) SWIG_fail;
14544 }
14545 {
14546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14547 }
14548 {
14549 if (temp1)
14550 delete arg1;
14551 }
14552 return resultobj;
14553 fail:
14554 {
14555 if (temp1)
14556 delete arg1;
14557 }
14558 return NULL;
14559 }
14560
14561
14562 SWIGINTERN PyObject *_wrap_Image_GetImageCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14563 PyObject *resultobj = 0;
14564 wxString *arg1 = 0 ;
14565 long arg2 = (long) wxBITMAP_TYPE_ANY ;
14566 int result;
14567 bool temp1 = false ;
14568 long val2 ;
14569 int ecode2 = 0 ;
14570 PyObject * obj0 = 0 ;
14571 PyObject * obj1 = 0 ;
14572 char * kwnames[] = {
14573 (char *) "filename",(char *) "type", NULL
14574 };
14575
14576 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_GetImageCount",kwnames,&obj0,&obj1)) SWIG_fail;
14577 {
14578 arg1 = wxString_in_helper(obj0);
14579 if (arg1 == NULL) SWIG_fail;
14580 temp1 = true;
14581 }
14582 if (obj1) {
14583 ecode2 = SWIG_AsVal_long(obj1, &val2);
14584 if (!SWIG_IsOK(ecode2)) {
14585 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_GetImageCount" "', expected argument " "2"" of type '" "long""'");
14586 }
14587 arg2 = static_cast< long >(val2);
14588 }
14589 {
14590 PyThreadState* __tstate = wxPyBeginAllowThreads();
14591 result = (int)wxImage::GetImageCount((wxString const &)*arg1,arg2);
14592 wxPyEndAllowThreads(__tstate);
14593 if (PyErr_Occurred()) SWIG_fail;
14594 }
14595 resultobj = SWIG_From_int(static_cast< int >(result));
14596 {
14597 if (temp1)
14598 delete arg1;
14599 }
14600 return resultobj;
14601 fail:
14602 {
14603 if (temp1)
14604 delete arg1;
14605 }
14606 return NULL;
14607 }
14608
14609
14610 SWIGINTERN PyObject *_wrap_Image_LoadFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14611 PyObject *resultobj = 0;
14612 wxImage *arg1 = (wxImage *) 0 ;
14613 wxString *arg2 = 0 ;
14614 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14615 int arg4 = (int) -1 ;
14616 bool result;
14617 void *argp1 = 0 ;
14618 int res1 = 0 ;
14619 bool temp2 = false ;
14620 long val3 ;
14621 int ecode3 = 0 ;
14622 int val4 ;
14623 int ecode4 = 0 ;
14624 PyObject * obj0 = 0 ;
14625 PyObject * obj1 = 0 ;
14626 PyObject * obj2 = 0 ;
14627 PyObject * obj3 = 0 ;
14628 char * kwnames[] = {
14629 (char *) "self",(char *) "name",(char *) "type",(char *) "index", NULL
14630 };
14631
14632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14634 if (!SWIG_IsOK(res1)) {
14635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadFile" "', expected argument " "1"" of type '" "wxImage *""'");
14636 }
14637 arg1 = reinterpret_cast< wxImage * >(argp1);
14638 {
14639 arg2 = wxString_in_helper(obj1);
14640 if (arg2 == NULL) SWIG_fail;
14641 temp2 = true;
14642 }
14643 if (obj2) {
14644 ecode3 = SWIG_AsVal_long(obj2, &val3);
14645 if (!SWIG_IsOK(ecode3)) {
14646 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadFile" "', expected argument " "3"" of type '" "long""'");
14647 }
14648 arg3 = static_cast< long >(val3);
14649 }
14650 if (obj3) {
14651 ecode4 = SWIG_AsVal_int(obj3, &val4);
14652 if (!SWIG_IsOK(ecode4)) {
14653 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadFile" "', expected argument " "4"" of type '" "int""'");
14654 }
14655 arg4 = static_cast< int >(val4);
14656 }
14657 {
14658 PyThreadState* __tstate = wxPyBeginAllowThreads();
14659 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,arg3,arg4);
14660 wxPyEndAllowThreads(__tstate);
14661 if (PyErr_Occurred()) SWIG_fail;
14662 }
14663 {
14664 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14665 }
14666 {
14667 if (temp2)
14668 delete arg2;
14669 }
14670 return resultobj;
14671 fail:
14672 {
14673 if (temp2)
14674 delete arg2;
14675 }
14676 return NULL;
14677 }
14678
14679
14680 SWIGINTERN PyObject *_wrap_Image_LoadMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14681 PyObject *resultobj = 0;
14682 wxImage *arg1 = (wxImage *) 0 ;
14683 wxString *arg2 = 0 ;
14684 wxString *arg3 = 0 ;
14685 int arg4 = (int) -1 ;
14686 bool result;
14687 void *argp1 = 0 ;
14688 int res1 = 0 ;
14689 bool temp2 = false ;
14690 bool temp3 = false ;
14691 int val4 ;
14692 int ecode4 = 0 ;
14693 PyObject * obj0 = 0 ;
14694 PyObject * obj1 = 0 ;
14695 PyObject * obj2 = 0 ;
14696 PyObject * obj3 = 0 ;
14697 char * kwnames[] = {
14698 (char *) "self",(char *) "name",(char *) "mimetype",(char *) "index", NULL
14699 };
14700
14701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeFile",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14703 if (!SWIG_IsOK(res1)) {
14704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14705 }
14706 arg1 = reinterpret_cast< wxImage * >(argp1);
14707 {
14708 arg2 = wxString_in_helper(obj1);
14709 if (arg2 == NULL) SWIG_fail;
14710 temp2 = true;
14711 }
14712 {
14713 arg3 = wxString_in_helper(obj2);
14714 if (arg3 == NULL) SWIG_fail;
14715 temp3 = true;
14716 }
14717 if (obj3) {
14718 ecode4 = SWIG_AsVal_int(obj3, &val4);
14719 if (!SWIG_IsOK(ecode4)) {
14720 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeFile" "', expected argument " "4"" of type '" "int""'");
14721 }
14722 arg4 = static_cast< int >(val4);
14723 }
14724 {
14725 PyThreadState* __tstate = wxPyBeginAllowThreads();
14726 result = (bool)(arg1)->LoadFile((wxString const &)*arg2,(wxString const &)*arg3,arg4);
14727 wxPyEndAllowThreads(__tstate);
14728 if (PyErr_Occurred()) SWIG_fail;
14729 }
14730 {
14731 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14732 }
14733 {
14734 if (temp2)
14735 delete arg2;
14736 }
14737 {
14738 if (temp3)
14739 delete arg3;
14740 }
14741 return resultobj;
14742 fail:
14743 {
14744 if (temp2)
14745 delete arg2;
14746 }
14747 {
14748 if (temp3)
14749 delete arg3;
14750 }
14751 return NULL;
14752 }
14753
14754
14755 SWIGINTERN PyObject *_wrap_Image_SaveFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14756 PyObject *resultobj = 0;
14757 wxImage *arg1 = (wxImage *) 0 ;
14758 wxString *arg2 = 0 ;
14759 int arg3 ;
14760 bool result;
14761 void *argp1 = 0 ;
14762 int res1 = 0 ;
14763 bool temp2 = false ;
14764 int val3 ;
14765 int ecode3 = 0 ;
14766 PyObject * obj0 = 0 ;
14767 PyObject * obj1 = 0 ;
14768 PyObject * obj2 = 0 ;
14769 char * kwnames[] = {
14770 (char *) "self",(char *) "name",(char *) "type", NULL
14771 };
14772
14773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14775 if (!SWIG_IsOK(res1)) {
14776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveFile" "', expected argument " "1"" of type '" "wxImage *""'");
14777 }
14778 arg1 = reinterpret_cast< wxImage * >(argp1);
14779 {
14780 arg2 = wxString_in_helper(obj1);
14781 if (arg2 == NULL) SWIG_fail;
14782 temp2 = true;
14783 }
14784 ecode3 = SWIG_AsVal_int(obj2, &val3);
14785 if (!SWIG_IsOK(ecode3)) {
14786 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SaveFile" "', expected argument " "3"" of type '" "int""'");
14787 }
14788 arg3 = static_cast< int >(val3);
14789 {
14790 PyThreadState* __tstate = wxPyBeginAllowThreads();
14791 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,arg3);
14792 wxPyEndAllowThreads(__tstate);
14793 if (PyErr_Occurred()) SWIG_fail;
14794 }
14795 {
14796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14797 }
14798 {
14799 if (temp2)
14800 delete arg2;
14801 }
14802 return resultobj;
14803 fail:
14804 {
14805 if (temp2)
14806 delete arg2;
14807 }
14808 return NULL;
14809 }
14810
14811
14812 SWIGINTERN PyObject *_wrap_Image_SaveMimeFile(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14813 PyObject *resultobj = 0;
14814 wxImage *arg1 = (wxImage *) 0 ;
14815 wxString *arg2 = 0 ;
14816 wxString *arg3 = 0 ;
14817 bool result;
14818 void *argp1 = 0 ;
14819 int res1 = 0 ;
14820 bool temp2 = false ;
14821 bool temp3 = false ;
14822 PyObject * obj0 = 0 ;
14823 PyObject * obj1 = 0 ;
14824 PyObject * obj2 = 0 ;
14825 char * kwnames[] = {
14826 (char *) "self",(char *) "name",(char *) "mimetype", NULL
14827 };
14828
14829 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SaveMimeFile",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
14830 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14831 if (!SWIG_IsOK(res1)) {
14832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SaveMimeFile" "', expected argument " "1"" of type '" "wxImage *""'");
14833 }
14834 arg1 = reinterpret_cast< wxImage * >(argp1);
14835 {
14836 arg2 = wxString_in_helper(obj1);
14837 if (arg2 == NULL) SWIG_fail;
14838 temp2 = true;
14839 }
14840 {
14841 arg3 = wxString_in_helper(obj2);
14842 if (arg3 == NULL) SWIG_fail;
14843 temp3 = true;
14844 }
14845 {
14846 PyThreadState* __tstate = wxPyBeginAllowThreads();
14847 result = (bool)(arg1)->SaveFile((wxString const &)*arg2,(wxString const &)*arg3);
14848 wxPyEndAllowThreads(__tstate);
14849 if (PyErr_Occurred()) SWIG_fail;
14850 }
14851 {
14852 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14853 }
14854 {
14855 if (temp2)
14856 delete arg2;
14857 }
14858 {
14859 if (temp3)
14860 delete arg3;
14861 }
14862 return resultobj;
14863 fail:
14864 {
14865 if (temp2)
14866 delete arg2;
14867 }
14868 {
14869 if (temp3)
14870 delete arg3;
14871 }
14872 return NULL;
14873 }
14874
14875
14876 SWIGINTERN PyObject *_wrap_Image_CanReadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14877 PyObject *resultobj = 0;
14878 wxInputStream *arg1 = 0 ;
14879 bool result;
14880 wxPyInputStream *temp1 ;
14881 bool created1 ;
14882 PyObject * obj0 = 0 ;
14883 char * kwnames[] = {
14884 (char *) "stream", NULL
14885 };
14886
14887 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_CanReadStream",kwnames,&obj0)) SWIG_fail;
14888 {
14889 if (wxPyConvertSwigPtr(obj0, (void **)&temp1, wxT("wxPyInputStream"))) {
14890 arg1 = temp1->m_wxis;
14891 created1 = false;
14892 } else {
14893 PyErr_Clear(); // clear the failure of the wxPyConvert above
14894 arg1 = wxPyCBInputStream_create(obj0, false);
14895 if (arg1 == NULL) {
14896 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14897 SWIG_fail;
14898 }
14899 created1 = true;
14900 }
14901 }
14902 {
14903 PyThreadState* __tstate = wxPyBeginAllowThreads();
14904 result = (bool)wxImage::CanRead(*arg1);
14905 wxPyEndAllowThreads(__tstate);
14906 if (PyErr_Occurred()) SWIG_fail;
14907 }
14908 {
14909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14910 }
14911 {
14912 if (created1) delete arg1;
14913 }
14914 return resultobj;
14915 fail:
14916 {
14917 if (created1) delete arg1;
14918 }
14919 return NULL;
14920 }
14921
14922
14923 SWIGINTERN PyObject *_wrap_Image_LoadStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
14924 PyObject *resultobj = 0;
14925 wxImage *arg1 = (wxImage *) 0 ;
14926 wxInputStream *arg2 = 0 ;
14927 long arg3 = (long) wxBITMAP_TYPE_ANY ;
14928 int arg4 = (int) -1 ;
14929 bool result;
14930 void *argp1 = 0 ;
14931 int res1 = 0 ;
14932 wxPyInputStream *temp2 ;
14933 bool created2 ;
14934 long val3 ;
14935 int ecode3 = 0 ;
14936 int val4 ;
14937 int ecode4 = 0 ;
14938 PyObject * obj0 = 0 ;
14939 PyObject * obj1 = 0 ;
14940 PyObject * obj2 = 0 ;
14941 PyObject * obj3 = 0 ;
14942 char * kwnames[] = {
14943 (char *) "self",(char *) "stream",(char *) "type",(char *) "index", NULL
14944 };
14945
14946 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Image_LoadStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
14947 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
14948 if (!SWIG_IsOK(res1)) {
14949 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadStream" "', expected argument " "1"" of type '" "wxImage *""'");
14950 }
14951 arg1 = reinterpret_cast< wxImage * >(argp1);
14952 {
14953 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
14954 arg2 = temp2->m_wxis;
14955 created2 = false;
14956 } else {
14957 PyErr_Clear(); // clear the failure of the wxPyConvert above
14958 arg2 = wxPyCBInputStream_create(obj1, false);
14959 if (arg2 == NULL) {
14960 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
14961 SWIG_fail;
14962 }
14963 created2 = true;
14964 }
14965 }
14966 if (obj2) {
14967 ecode3 = SWIG_AsVal_long(obj2, &val3);
14968 if (!SWIG_IsOK(ecode3)) {
14969 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_LoadStream" "', expected argument " "3"" of type '" "long""'");
14970 }
14971 arg3 = static_cast< long >(val3);
14972 }
14973 if (obj3) {
14974 ecode4 = SWIG_AsVal_int(obj3, &val4);
14975 if (!SWIG_IsOK(ecode4)) {
14976 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadStream" "', expected argument " "4"" of type '" "int""'");
14977 }
14978 arg4 = static_cast< int >(val4);
14979 }
14980 {
14981 PyThreadState* __tstate = wxPyBeginAllowThreads();
14982 result = (bool)(arg1)->LoadFile(*arg2,arg3,arg4);
14983 wxPyEndAllowThreads(__tstate);
14984 if (PyErr_Occurred()) SWIG_fail;
14985 }
14986 {
14987 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
14988 }
14989 {
14990 if (created2) delete arg2;
14991 }
14992 return resultobj;
14993 fail:
14994 {
14995 if (created2) delete arg2;
14996 }
14997 return NULL;
14998 }
14999
15000
15001 SWIGINTERN PyObject *_wrap_Image_LoadMimeStream(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15002 PyObject *resultobj = 0;
15003 wxImage *arg1 = (wxImage *) 0 ;
15004 wxInputStream *arg2 = 0 ;
15005 wxString *arg3 = 0 ;
15006 int arg4 = (int) -1 ;
15007 bool result;
15008 void *argp1 = 0 ;
15009 int res1 = 0 ;
15010 wxPyInputStream *temp2 ;
15011 bool created2 ;
15012 bool temp3 = false ;
15013 int val4 ;
15014 int ecode4 = 0 ;
15015 PyObject * obj0 = 0 ;
15016 PyObject * obj1 = 0 ;
15017 PyObject * obj2 = 0 ;
15018 PyObject * obj3 = 0 ;
15019 char * kwnames[] = {
15020 (char *) "self",(char *) "stream",(char *) "mimetype",(char *) "index", NULL
15021 };
15022
15023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Image_LoadMimeStream",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15025 if (!SWIG_IsOK(res1)) {
15026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_LoadMimeStream" "', expected argument " "1"" of type '" "wxImage *""'");
15027 }
15028 arg1 = reinterpret_cast< wxImage * >(argp1);
15029 {
15030 if (wxPyConvertSwigPtr(obj1, (void **)&temp2, wxT("wxPyInputStream"))) {
15031 arg2 = temp2->m_wxis;
15032 created2 = false;
15033 } else {
15034 PyErr_Clear(); // clear the failure of the wxPyConvert above
15035 arg2 = wxPyCBInputStream_create(obj1, false);
15036 if (arg2 == NULL) {
15037 PyErr_SetString(PyExc_TypeError, "Expected wx.InputStream or Python file-like object.");
15038 SWIG_fail;
15039 }
15040 created2 = true;
15041 }
15042 }
15043 {
15044 arg3 = wxString_in_helper(obj2);
15045 if (arg3 == NULL) SWIG_fail;
15046 temp3 = true;
15047 }
15048 if (obj3) {
15049 ecode4 = SWIG_AsVal_int(obj3, &val4);
15050 if (!SWIG_IsOK(ecode4)) {
15051 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_LoadMimeStream" "', expected argument " "4"" of type '" "int""'");
15052 }
15053 arg4 = static_cast< int >(val4);
15054 }
15055 {
15056 PyThreadState* __tstate = wxPyBeginAllowThreads();
15057 result = (bool)(arg1)->LoadFile(*arg2,(wxString const &)*arg3,arg4);
15058 wxPyEndAllowThreads(__tstate);
15059 if (PyErr_Occurred()) SWIG_fail;
15060 }
15061 {
15062 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15063 }
15064 {
15065 if (created2) delete arg2;
15066 }
15067 {
15068 if (temp3)
15069 delete arg3;
15070 }
15071 return resultobj;
15072 fail:
15073 {
15074 if (created2) delete arg2;
15075 }
15076 {
15077 if (temp3)
15078 delete arg3;
15079 }
15080 return NULL;
15081 }
15082
15083
15084 SWIGINTERN PyObject *_wrap_Image_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15085 PyObject *resultobj = 0;
15086 wxImage *arg1 = (wxImage *) 0 ;
15087 bool result;
15088 void *argp1 = 0 ;
15089 int res1 = 0 ;
15090 PyObject *swig_obj[1] ;
15091
15092 if (!args) SWIG_fail;
15093 swig_obj[0] = args;
15094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15095 if (!SWIG_IsOK(res1)) {
15096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Ok" "', expected argument " "1"" of type '" "wxImage *""'");
15097 }
15098 arg1 = reinterpret_cast< wxImage * >(argp1);
15099 {
15100 PyThreadState* __tstate = wxPyBeginAllowThreads();
15101 result = (bool)(arg1)->Ok();
15102 wxPyEndAllowThreads(__tstate);
15103 if (PyErr_Occurred()) SWIG_fail;
15104 }
15105 {
15106 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15107 }
15108 return resultobj;
15109 fail:
15110 return NULL;
15111 }
15112
15113
15114 SWIGINTERN PyObject *_wrap_Image_GetWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15115 PyObject *resultobj = 0;
15116 wxImage *arg1 = (wxImage *) 0 ;
15117 int result;
15118 void *argp1 = 0 ;
15119 int res1 = 0 ;
15120 PyObject *swig_obj[1] ;
15121
15122 if (!args) SWIG_fail;
15123 swig_obj[0] = args;
15124 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15125 if (!SWIG_IsOK(res1)) {
15126 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetWidth" "', expected argument " "1"" of type '" "wxImage *""'");
15127 }
15128 arg1 = reinterpret_cast< wxImage * >(argp1);
15129 {
15130 PyThreadState* __tstate = wxPyBeginAllowThreads();
15131 result = (int)(arg1)->GetWidth();
15132 wxPyEndAllowThreads(__tstate);
15133 if (PyErr_Occurred()) SWIG_fail;
15134 }
15135 resultobj = SWIG_From_int(static_cast< int >(result));
15136 return resultobj;
15137 fail:
15138 return NULL;
15139 }
15140
15141
15142 SWIGINTERN PyObject *_wrap_Image_GetHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15143 PyObject *resultobj = 0;
15144 wxImage *arg1 = (wxImage *) 0 ;
15145 int result;
15146 void *argp1 = 0 ;
15147 int res1 = 0 ;
15148 PyObject *swig_obj[1] ;
15149
15150 if (!args) SWIG_fail;
15151 swig_obj[0] = args;
15152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15153 if (!SWIG_IsOK(res1)) {
15154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetHeight" "', expected argument " "1"" of type '" "wxImage *""'");
15155 }
15156 arg1 = reinterpret_cast< wxImage * >(argp1);
15157 {
15158 PyThreadState* __tstate = wxPyBeginAllowThreads();
15159 result = (int)(arg1)->GetHeight();
15160 wxPyEndAllowThreads(__tstate);
15161 if (PyErr_Occurred()) SWIG_fail;
15162 }
15163 resultobj = SWIG_From_int(static_cast< int >(result));
15164 return resultobj;
15165 fail:
15166 return NULL;
15167 }
15168
15169
15170 SWIGINTERN PyObject *_wrap_Image_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15171 PyObject *resultobj = 0;
15172 wxImage *arg1 = (wxImage *) 0 ;
15173 wxSize result;
15174 void *argp1 = 0 ;
15175 int res1 = 0 ;
15176 PyObject *swig_obj[1] ;
15177
15178 if (!args) SWIG_fail;
15179 swig_obj[0] = args;
15180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15181 if (!SWIG_IsOK(res1)) {
15182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSize" "', expected argument " "1"" of type '" "wxImage *""'");
15183 }
15184 arg1 = reinterpret_cast< wxImage * >(argp1);
15185 {
15186 PyThreadState* __tstate = wxPyBeginAllowThreads();
15187 result = wxImage_GetSize(arg1);
15188 wxPyEndAllowThreads(__tstate);
15189 if (PyErr_Occurred()) SWIG_fail;
15190 }
15191 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
15192 return resultobj;
15193 fail:
15194 return NULL;
15195 }
15196
15197
15198 SWIGINTERN PyObject *_wrap_Image_GetSubImage(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15199 PyObject *resultobj = 0;
15200 wxImage *arg1 = (wxImage *) 0 ;
15201 wxRect *arg2 = 0 ;
15202 SwigValueWrapper<wxImage > result;
15203 void *argp1 = 0 ;
15204 int res1 = 0 ;
15205 wxRect temp2 ;
15206 PyObject * obj0 = 0 ;
15207 PyObject * obj1 = 0 ;
15208 char * kwnames[] = {
15209 (char *) "self",(char *) "rect", NULL
15210 };
15211
15212 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetSubImage",kwnames,&obj0,&obj1)) SWIG_fail;
15213 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15214 if (!SWIG_IsOK(res1)) {
15215 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetSubImage" "', expected argument " "1"" of type '" "wxImage *""'");
15216 }
15217 arg1 = reinterpret_cast< wxImage * >(argp1);
15218 {
15219 arg2 = &temp2;
15220 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
15221 }
15222 {
15223 PyThreadState* __tstate = wxPyBeginAllowThreads();
15224 result = (arg1)->GetSubImage((wxRect const &)*arg2);
15225 wxPyEndAllowThreads(__tstate);
15226 if (PyErr_Occurred()) SWIG_fail;
15227 }
15228 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15229 return resultobj;
15230 fail:
15231 return NULL;
15232 }
15233
15234
15235 SWIGINTERN PyObject *_wrap_Image_Size(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15236 PyObject *resultobj = 0;
15237 wxImage *arg1 = (wxImage *) 0 ;
15238 wxSize *arg2 = 0 ;
15239 wxPoint *arg3 = 0 ;
15240 int arg4 = (int) -1 ;
15241 int arg5 = (int) -1 ;
15242 int arg6 = (int) -1 ;
15243 SwigValueWrapper<wxImage > result;
15244 void *argp1 = 0 ;
15245 int res1 = 0 ;
15246 wxSize temp2 ;
15247 wxPoint temp3 ;
15248 int val4 ;
15249 int ecode4 = 0 ;
15250 int val5 ;
15251 int ecode5 = 0 ;
15252 int val6 ;
15253 int ecode6 = 0 ;
15254 PyObject * obj0 = 0 ;
15255 PyObject * obj1 = 0 ;
15256 PyObject * obj2 = 0 ;
15257 PyObject * obj3 = 0 ;
15258 PyObject * obj4 = 0 ;
15259 PyObject * obj5 = 0 ;
15260 char * kwnames[] = {
15261 (char *) "self",(char *) "size",(char *) "pos",(char *) "r",(char *) "g",(char *) "b", NULL
15262 };
15263
15264 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOO:Image_Size",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
15265 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15266 if (!SWIG_IsOK(res1)) {
15267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Size" "', expected argument " "1"" of type '" "wxImage const *""'");
15268 }
15269 arg1 = reinterpret_cast< wxImage * >(argp1);
15270 {
15271 arg2 = &temp2;
15272 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
15273 }
15274 {
15275 arg3 = &temp3;
15276 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15277 }
15278 if (obj3) {
15279 ecode4 = SWIG_AsVal_int(obj3, &val4);
15280 if (!SWIG_IsOK(ecode4)) {
15281 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Size" "', expected argument " "4"" of type '" "int""'");
15282 }
15283 arg4 = static_cast< int >(val4);
15284 }
15285 if (obj4) {
15286 ecode5 = SWIG_AsVal_int(obj4, &val5);
15287 if (!SWIG_IsOK(ecode5)) {
15288 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Size" "', expected argument " "5"" of type '" "int""'");
15289 }
15290 arg5 = static_cast< int >(val5);
15291 }
15292 if (obj5) {
15293 ecode6 = SWIG_AsVal_int(obj5, &val6);
15294 if (!SWIG_IsOK(ecode6)) {
15295 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Size" "', expected argument " "6"" of type '" "int""'");
15296 }
15297 arg6 = static_cast< int >(val6);
15298 }
15299 {
15300 PyThreadState* __tstate = wxPyBeginAllowThreads();
15301 result = ((wxImage const *)arg1)->Size((wxSize const &)*arg2,(wxPoint const &)*arg3,arg4,arg5,arg6);
15302 wxPyEndAllowThreads(__tstate);
15303 if (PyErr_Occurred()) SWIG_fail;
15304 }
15305 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15306 return resultobj;
15307 fail:
15308 return NULL;
15309 }
15310
15311
15312 SWIGINTERN PyObject *_wrap_Image_Copy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15313 PyObject *resultobj = 0;
15314 wxImage *arg1 = (wxImage *) 0 ;
15315 SwigValueWrapper<wxImage > result;
15316 void *argp1 = 0 ;
15317 int res1 = 0 ;
15318 PyObject *swig_obj[1] ;
15319
15320 if (!args) SWIG_fail;
15321 swig_obj[0] = args;
15322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15323 if (!SWIG_IsOK(res1)) {
15324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Copy" "', expected argument " "1"" of type '" "wxImage *""'");
15325 }
15326 arg1 = reinterpret_cast< wxImage * >(argp1);
15327 {
15328 PyThreadState* __tstate = wxPyBeginAllowThreads();
15329 result = (arg1)->Copy();
15330 wxPyEndAllowThreads(__tstate);
15331 if (PyErr_Occurred()) SWIG_fail;
15332 }
15333 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15334 return resultobj;
15335 fail:
15336 return NULL;
15337 }
15338
15339
15340 SWIGINTERN PyObject *_wrap_Image_Paste(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15341 PyObject *resultobj = 0;
15342 wxImage *arg1 = (wxImage *) 0 ;
15343 wxImage *arg2 = 0 ;
15344 int arg3 ;
15345 int arg4 ;
15346 void *argp1 = 0 ;
15347 int res1 = 0 ;
15348 void *argp2 = 0 ;
15349 int res2 = 0 ;
15350 int val3 ;
15351 int ecode3 = 0 ;
15352 int val4 ;
15353 int ecode4 = 0 ;
15354 PyObject * obj0 = 0 ;
15355 PyObject * obj1 = 0 ;
15356 PyObject * obj2 = 0 ;
15357 PyObject * obj3 = 0 ;
15358 char * kwnames[] = {
15359 (char *) "self",(char *) "image",(char *) "x",(char *) "y", NULL
15360 };
15361
15362 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_Paste",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15363 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15364 if (!SWIG_IsOK(res1)) {
15365 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Paste" "', expected argument " "1"" of type '" "wxImage *""'");
15366 }
15367 arg1 = reinterpret_cast< wxImage * >(argp1);
15368 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 | 0);
15369 if (!SWIG_IsOK(res2)) {
15370 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15371 }
15372 if (!argp2) {
15373 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_Paste" "', expected argument " "2"" of type '" "wxImage const &""'");
15374 }
15375 arg2 = reinterpret_cast< wxImage * >(argp2);
15376 ecode3 = SWIG_AsVal_int(obj2, &val3);
15377 if (!SWIG_IsOK(ecode3)) {
15378 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Paste" "', expected argument " "3"" of type '" "int""'");
15379 }
15380 arg3 = static_cast< int >(val3);
15381 ecode4 = SWIG_AsVal_int(obj3, &val4);
15382 if (!SWIG_IsOK(ecode4)) {
15383 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Paste" "', expected argument " "4"" of type '" "int""'");
15384 }
15385 arg4 = static_cast< int >(val4);
15386 {
15387 PyThreadState* __tstate = wxPyBeginAllowThreads();
15388 (arg1)->Paste((wxImage const &)*arg2,arg3,arg4);
15389 wxPyEndAllowThreads(__tstate);
15390 if (PyErr_Occurred()) SWIG_fail;
15391 }
15392 resultobj = SWIG_Py_Void();
15393 return resultobj;
15394 fail:
15395 return NULL;
15396 }
15397
15398
15399 SWIGINTERN PyObject *_wrap_Image_GetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15400 PyObject *resultobj = 0;
15401 wxImage *arg1 = (wxImage *) 0 ;
15402 PyObject *result = 0 ;
15403 void *argp1 = 0 ;
15404 int res1 = 0 ;
15405 PyObject *swig_obj[1] ;
15406
15407 if (!args) SWIG_fail;
15408 swig_obj[0] = args;
15409 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15410 if (!SWIG_IsOK(res1)) {
15411 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetData" "', expected argument " "1"" of type '" "wxImage *""'");
15412 }
15413 arg1 = reinterpret_cast< wxImage * >(argp1);
15414 {
15415 PyThreadState* __tstate = wxPyBeginAllowThreads();
15416 result = (PyObject *)wxImage_GetData(arg1);
15417 wxPyEndAllowThreads(__tstate);
15418 if (PyErr_Occurred()) SWIG_fail;
15419 }
15420 resultobj = result;
15421 return resultobj;
15422 fail:
15423 return NULL;
15424 }
15425
15426
15427 SWIGINTERN PyObject *_wrap_Image_SetData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15428 PyObject *resultobj = 0;
15429 wxImage *arg1 = (wxImage *) 0 ;
15430 buffer arg2 ;
15431 int arg3 ;
15432 void *argp1 = 0 ;
15433 int res1 = 0 ;
15434 PyObject * obj0 = 0 ;
15435 PyObject * obj1 = 0 ;
15436 char * kwnames[] = {
15437 (char *) "self",(char *) "data", NULL
15438 };
15439
15440 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetData",kwnames,&obj0,&obj1)) SWIG_fail;
15441 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15442 if (!SWIG_IsOK(res1)) {
15443 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetData" "', expected argument " "1"" of type '" "wxImage *""'");
15444 }
15445 arg1 = reinterpret_cast< wxImage * >(argp1);
15446 {
15447 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15448 }
15449 {
15450 PyThreadState* __tstate = wxPyBeginAllowThreads();
15451 wxImage_SetData(arg1,arg2,arg3);
15452 wxPyEndAllowThreads(__tstate);
15453 if (PyErr_Occurred()) SWIG_fail;
15454 }
15455 resultobj = SWIG_Py_Void();
15456 return resultobj;
15457 fail:
15458 return NULL;
15459 }
15460
15461
15462 SWIGINTERN PyObject *_wrap_Image_GetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15463 PyObject *resultobj = 0;
15464 wxImage *arg1 = (wxImage *) 0 ;
15465 PyObject *result = 0 ;
15466 void *argp1 = 0 ;
15467 int res1 = 0 ;
15468 PyObject *swig_obj[1] ;
15469
15470 if (!args) SWIG_fail;
15471 swig_obj[0] = args;
15472 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15473 if (!SWIG_IsOK(res1)) {
15474 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15475 }
15476 arg1 = reinterpret_cast< wxImage * >(argp1);
15477 {
15478 PyThreadState* __tstate = wxPyBeginAllowThreads();
15479 result = (PyObject *)wxImage_GetDataBuffer(arg1);
15480 wxPyEndAllowThreads(__tstate);
15481 if (PyErr_Occurred()) SWIG_fail;
15482 }
15483 resultobj = result;
15484 return resultobj;
15485 fail:
15486 return NULL;
15487 }
15488
15489
15490 SWIGINTERN PyObject *_wrap_Image_SetDataBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15491 PyObject *resultobj = 0;
15492 wxImage *arg1 = (wxImage *) 0 ;
15493 buffer arg2 ;
15494 int arg3 ;
15495 void *argp1 = 0 ;
15496 int res1 = 0 ;
15497 PyObject * obj0 = 0 ;
15498 PyObject * obj1 = 0 ;
15499 char * kwnames[] = {
15500 (char *) "self",(char *) "data", NULL
15501 };
15502
15503 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetDataBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15504 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15505 if (!SWIG_IsOK(res1)) {
15506 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetDataBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15507 }
15508 arg1 = reinterpret_cast< wxImage * >(argp1);
15509 {
15510 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15511 }
15512 {
15513 PyThreadState* __tstate = wxPyBeginAllowThreads();
15514 wxImage_SetDataBuffer(arg1,arg2,arg3);
15515 wxPyEndAllowThreads(__tstate);
15516 if (PyErr_Occurred()) SWIG_fail;
15517 }
15518 resultobj = SWIG_Py_Void();
15519 return resultobj;
15520 fail:
15521 return NULL;
15522 }
15523
15524
15525 SWIGINTERN PyObject *_wrap_Image_GetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15526 PyObject *resultobj = 0;
15527 wxImage *arg1 = (wxImage *) 0 ;
15528 PyObject *result = 0 ;
15529 void *argp1 = 0 ;
15530 int res1 = 0 ;
15531 PyObject *swig_obj[1] ;
15532
15533 if (!args) SWIG_fail;
15534 swig_obj[0] = args;
15535 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15536 if (!SWIG_IsOK(res1)) {
15537 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15538 }
15539 arg1 = reinterpret_cast< wxImage * >(argp1);
15540 {
15541 PyThreadState* __tstate = wxPyBeginAllowThreads();
15542 result = (PyObject *)wxImage_GetAlphaData(arg1);
15543 wxPyEndAllowThreads(__tstate);
15544 if (PyErr_Occurred()) SWIG_fail;
15545 }
15546 resultobj = result;
15547 return resultobj;
15548 fail:
15549 return NULL;
15550 }
15551
15552
15553 SWIGINTERN PyObject *_wrap_Image_SetAlphaData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15554 PyObject *resultobj = 0;
15555 wxImage *arg1 = (wxImage *) 0 ;
15556 buffer arg2 ;
15557 int arg3 ;
15558 void *argp1 = 0 ;
15559 int res1 = 0 ;
15560 PyObject * obj0 = 0 ;
15561 PyObject * obj1 = 0 ;
15562 char * kwnames[] = {
15563 (char *) "self",(char *) "alpha", NULL
15564 };
15565
15566 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaData",kwnames,&obj0,&obj1)) SWIG_fail;
15567 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15568 if (!SWIG_IsOK(res1)) {
15569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaData" "', expected argument " "1"" of type '" "wxImage *""'");
15570 }
15571 arg1 = reinterpret_cast< wxImage * >(argp1);
15572 {
15573 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15574 }
15575 {
15576 PyThreadState* __tstate = wxPyBeginAllowThreads();
15577 wxImage_SetAlphaData(arg1,arg2,arg3);
15578 wxPyEndAllowThreads(__tstate);
15579 if (PyErr_Occurred()) SWIG_fail;
15580 }
15581 resultobj = SWIG_Py_Void();
15582 return resultobj;
15583 fail:
15584 return NULL;
15585 }
15586
15587
15588 SWIGINTERN PyObject *_wrap_Image_GetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15589 PyObject *resultobj = 0;
15590 wxImage *arg1 = (wxImage *) 0 ;
15591 PyObject *result = 0 ;
15592 void *argp1 = 0 ;
15593 int res1 = 0 ;
15594 PyObject *swig_obj[1] ;
15595
15596 if (!args) SWIG_fail;
15597 swig_obj[0] = args;
15598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15599 if (!SWIG_IsOK(res1)) {
15600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15601 }
15602 arg1 = reinterpret_cast< wxImage * >(argp1);
15603 {
15604 PyThreadState* __tstate = wxPyBeginAllowThreads();
15605 result = (PyObject *)wxImage_GetAlphaBuffer(arg1);
15606 wxPyEndAllowThreads(__tstate);
15607 if (PyErr_Occurred()) SWIG_fail;
15608 }
15609 resultobj = result;
15610 return resultobj;
15611 fail:
15612 return NULL;
15613 }
15614
15615
15616 SWIGINTERN PyObject *_wrap_Image_SetAlphaBuffer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15617 PyObject *resultobj = 0;
15618 wxImage *arg1 = (wxImage *) 0 ;
15619 buffer arg2 ;
15620 int arg3 ;
15621 void *argp1 = 0 ;
15622 int res1 = 0 ;
15623 PyObject * obj0 = 0 ;
15624 PyObject * obj1 = 0 ;
15625 char * kwnames[] = {
15626 (char *) "self",(char *) "alpha", NULL
15627 };
15628
15629 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_SetAlphaBuffer",kwnames,&obj0,&obj1)) SWIG_fail;
15630 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15631 if (!SWIG_IsOK(res1)) {
15632 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetAlphaBuffer" "', expected argument " "1"" of type '" "wxImage *""'");
15633 }
15634 arg1 = reinterpret_cast< wxImage * >(argp1);
15635 {
15636 if (!PyArg_Parse(obj1, "t#", &arg2, &arg3)) SWIG_fail;
15637 }
15638 {
15639 PyThreadState* __tstate = wxPyBeginAllowThreads();
15640 wxImage_SetAlphaBuffer(arg1,arg2,arg3);
15641 wxPyEndAllowThreads(__tstate);
15642 if (PyErr_Occurred()) SWIG_fail;
15643 }
15644 resultobj = SWIG_Py_Void();
15645 return resultobj;
15646 fail:
15647 return NULL;
15648 }
15649
15650
15651 SWIGINTERN PyObject *_wrap_Image_SetMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15652 PyObject *resultobj = 0;
15653 wxImage *arg1 = (wxImage *) 0 ;
15654 byte arg2 ;
15655 byte arg3 ;
15656 byte arg4 ;
15657 void *argp1 = 0 ;
15658 int res1 = 0 ;
15659 unsigned char val2 ;
15660 int ecode2 = 0 ;
15661 unsigned char val3 ;
15662 int ecode3 = 0 ;
15663 unsigned char val4 ;
15664 int ecode4 = 0 ;
15665 PyObject * obj0 = 0 ;
15666 PyObject * obj1 = 0 ;
15667 PyObject * obj2 = 0 ;
15668 PyObject * obj3 = 0 ;
15669 char * kwnames[] = {
15670 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
15671 };
15672
15673 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_SetMaskColour",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
15674 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15675 if (!SWIG_IsOK(res1)) {
15676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMaskColour" "', expected argument " "1"" of type '" "wxImage *""'");
15677 }
15678 arg1 = reinterpret_cast< wxImage * >(argp1);
15679 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
15680 if (!SWIG_IsOK(ecode2)) {
15681 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMaskColour" "', expected argument " "2"" of type '" "byte""'");
15682 }
15683 arg2 = static_cast< byte >(val2);
15684 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
15685 if (!SWIG_IsOK(ecode3)) {
15686 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetMaskColour" "', expected argument " "3"" of type '" "byte""'");
15687 }
15688 arg3 = static_cast< byte >(val3);
15689 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
15690 if (!SWIG_IsOK(ecode4)) {
15691 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_SetMaskColour" "', expected argument " "4"" of type '" "byte""'");
15692 }
15693 arg4 = static_cast< byte >(val4);
15694 {
15695 PyThreadState* __tstate = wxPyBeginAllowThreads();
15696 (arg1)->SetMaskColour(arg2,arg3,arg4);
15697 wxPyEndAllowThreads(__tstate);
15698 if (PyErr_Occurred()) SWIG_fail;
15699 }
15700 resultobj = SWIG_Py_Void();
15701 return resultobj;
15702 fail:
15703 return NULL;
15704 }
15705
15706
15707 SWIGINTERN PyObject *_wrap_Image_GetOrFindMaskColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15708 PyObject *resultobj = 0;
15709 wxImage *arg1 = (wxImage *) 0 ;
15710 byte *arg2 = (byte *) 0 ;
15711 byte *arg3 = (byte *) 0 ;
15712 byte *arg4 = (byte *) 0 ;
15713 void *argp1 = 0 ;
15714 int res1 = 0 ;
15715 byte temp2 ;
15716 int res2 = SWIG_TMPOBJ ;
15717 byte temp3 ;
15718 int res3 = SWIG_TMPOBJ ;
15719 byte temp4 ;
15720 int res4 = SWIG_TMPOBJ ;
15721 PyObject *swig_obj[1] ;
15722
15723 arg2 = &temp2;
15724 arg3 = &temp3;
15725 arg4 = &temp4;
15726 if (!args) SWIG_fail;
15727 swig_obj[0] = args;
15728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15729 if (!SWIG_IsOK(res1)) {
15730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOrFindMaskColour" "', expected argument " "1"" of type '" "wxImage const *""'");
15731 }
15732 arg1 = reinterpret_cast< wxImage * >(argp1);
15733 {
15734 PyThreadState* __tstate = wxPyBeginAllowThreads();
15735 ((wxImage const *)arg1)->GetOrFindMaskColour(arg2,arg3,arg4);
15736 wxPyEndAllowThreads(__tstate);
15737 if (PyErr_Occurred()) SWIG_fail;
15738 }
15739 resultobj = SWIG_Py_Void();
15740 if (SWIG_IsTmpObj(res2)) {
15741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg2)));
15742 } else {
15743 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15744 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_unsigned_char, new_flags));
15745 }
15746 if (SWIG_IsTmpObj(res3)) {
15747 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg3)));
15748 } else {
15749 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15750 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_unsigned_char, new_flags));
15751 }
15752 if (SWIG_IsTmpObj(res4)) {
15753 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_unsigned_SS_char((*arg4)));
15754 } else {
15755 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
15756 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_unsigned_char, new_flags));
15757 }
15758 return resultobj;
15759 fail:
15760 return NULL;
15761 }
15762
15763
15764 SWIGINTERN PyObject *_wrap_Image_GetMaskRed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15765 PyObject *resultobj = 0;
15766 wxImage *arg1 = (wxImage *) 0 ;
15767 byte result;
15768 void *argp1 = 0 ;
15769 int res1 = 0 ;
15770 PyObject *swig_obj[1] ;
15771
15772 if (!args) SWIG_fail;
15773 swig_obj[0] = args;
15774 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15775 if (!SWIG_IsOK(res1)) {
15776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskRed" "', expected argument " "1"" of type '" "wxImage *""'");
15777 }
15778 arg1 = reinterpret_cast< wxImage * >(argp1);
15779 {
15780 PyThreadState* __tstate = wxPyBeginAllowThreads();
15781 result = (byte)(arg1)->GetMaskRed();
15782 wxPyEndAllowThreads(__tstate);
15783 if (PyErr_Occurred()) SWIG_fail;
15784 }
15785 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15786 return resultobj;
15787 fail:
15788 return NULL;
15789 }
15790
15791
15792 SWIGINTERN PyObject *_wrap_Image_GetMaskGreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15793 PyObject *resultobj = 0;
15794 wxImage *arg1 = (wxImage *) 0 ;
15795 byte result;
15796 void *argp1 = 0 ;
15797 int res1 = 0 ;
15798 PyObject *swig_obj[1] ;
15799
15800 if (!args) SWIG_fail;
15801 swig_obj[0] = args;
15802 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15803 if (!SWIG_IsOK(res1)) {
15804 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskGreen" "', expected argument " "1"" of type '" "wxImage *""'");
15805 }
15806 arg1 = reinterpret_cast< wxImage * >(argp1);
15807 {
15808 PyThreadState* __tstate = wxPyBeginAllowThreads();
15809 result = (byte)(arg1)->GetMaskGreen();
15810 wxPyEndAllowThreads(__tstate);
15811 if (PyErr_Occurred()) SWIG_fail;
15812 }
15813 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15814 return resultobj;
15815 fail:
15816 return NULL;
15817 }
15818
15819
15820 SWIGINTERN PyObject *_wrap_Image_GetMaskBlue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15821 PyObject *resultobj = 0;
15822 wxImage *arg1 = (wxImage *) 0 ;
15823 byte result;
15824 void *argp1 = 0 ;
15825 int res1 = 0 ;
15826 PyObject *swig_obj[1] ;
15827
15828 if (!args) SWIG_fail;
15829 swig_obj[0] = args;
15830 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15831 if (!SWIG_IsOK(res1)) {
15832 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetMaskBlue" "', expected argument " "1"" of type '" "wxImage *""'");
15833 }
15834 arg1 = reinterpret_cast< wxImage * >(argp1);
15835 {
15836 PyThreadState* __tstate = wxPyBeginAllowThreads();
15837 result = (byte)(arg1)->GetMaskBlue();
15838 wxPyEndAllowThreads(__tstate);
15839 if (PyErr_Occurred()) SWIG_fail;
15840 }
15841 resultobj = SWIG_From_unsigned_SS_char(static_cast< unsigned char >(result));
15842 return resultobj;
15843 fail:
15844 return NULL;
15845 }
15846
15847
15848 SWIGINTERN PyObject *_wrap_Image_SetMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15849 PyObject *resultobj = 0;
15850 wxImage *arg1 = (wxImage *) 0 ;
15851 bool arg2 = (bool) true ;
15852 void *argp1 = 0 ;
15853 int res1 = 0 ;
15854 bool val2 ;
15855 int ecode2 = 0 ;
15856 PyObject * obj0 = 0 ;
15857 PyObject * obj1 = 0 ;
15858 char * kwnames[] = {
15859 (char *) "self",(char *) "mask", NULL
15860 };
15861
15862 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_SetMask",kwnames,&obj0,&obj1)) SWIG_fail;
15863 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15864 if (!SWIG_IsOK(res1)) {
15865 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetMask" "', expected argument " "1"" of type '" "wxImage *""'");
15866 }
15867 arg1 = reinterpret_cast< wxImage * >(argp1);
15868 if (obj1) {
15869 ecode2 = SWIG_AsVal_bool(obj1, &val2);
15870 if (!SWIG_IsOK(ecode2)) {
15871 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_SetMask" "', expected argument " "2"" of type '" "bool""'");
15872 }
15873 arg2 = static_cast< bool >(val2);
15874 }
15875 {
15876 PyThreadState* __tstate = wxPyBeginAllowThreads();
15877 (arg1)->SetMask(arg2);
15878 wxPyEndAllowThreads(__tstate);
15879 if (PyErr_Occurred()) SWIG_fail;
15880 }
15881 resultobj = SWIG_Py_Void();
15882 return resultobj;
15883 fail:
15884 return NULL;
15885 }
15886
15887
15888 SWIGINTERN PyObject *_wrap_Image_HasMask(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
15889 PyObject *resultobj = 0;
15890 wxImage *arg1 = (wxImage *) 0 ;
15891 bool result;
15892 void *argp1 = 0 ;
15893 int res1 = 0 ;
15894 PyObject *swig_obj[1] ;
15895
15896 if (!args) SWIG_fail;
15897 swig_obj[0] = args;
15898 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15899 if (!SWIG_IsOK(res1)) {
15900 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasMask" "', expected argument " "1"" of type '" "wxImage *""'");
15901 }
15902 arg1 = reinterpret_cast< wxImage * >(argp1);
15903 {
15904 PyThreadState* __tstate = wxPyBeginAllowThreads();
15905 result = (bool)(arg1)->HasMask();
15906 wxPyEndAllowThreads(__tstate);
15907 if (PyErr_Occurred()) SWIG_fail;
15908 }
15909 {
15910 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
15911 }
15912 return resultobj;
15913 fail:
15914 return NULL;
15915 }
15916
15917
15918 SWIGINTERN PyObject *_wrap_Image_Rotate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15919 PyObject *resultobj = 0;
15920 wxImage *arg1 = (wxImage *) 0 ;
15921 double arg2 ;
15922 wxPoint *arg3 = 0 ;
15923 bool arg4 = (bool) true ;
15924 wxPoint *arg5 = (wxPoint *) NULL ;
15925 SwigValueWrapper<wxImage > result;
15926 void *argp1 = 0 ;
15927 int res1 = 0 ;
15928 double val2 ;
15929 int ecode2 = 0 ;
15930 wxPoint temp3 ;
15931 bool val4 ;
15932 int ecode4 = 0 ;
15933 void *argp5 = 0 ;
15934 int res5 = 0 ;
15935 PyObject * obj0 = 0 ;
15936 PyObject * obj1 = 0 ;
15937 PyObject * obj2 = 0 ;
15938 PyObject * obj3 = 0 ;
15939 PyObject * obj4 = 0 ;
15940 char * kwnames[] = {
15941 (char *) "self",(char *) "angle",(char *) "centre_of_rotation",(char *) "interpolating",(char *) "offset_after_rotation", NULL
15942 };
15943
15944 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Image_Rotate",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
15945 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
15946 if (!SWIG_IsOK(res1)) {
15947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate" "', expected argument " "1"" of type '" "wxImage const *""'");
15948 }
15949 arg1 = reinterpret_cast< wxImage * >(argp1);
15950 ecode2 = SWIG_AsVal_double(obj1, &val2);
15951 if (!SWIG_IsOK(ecode2)) {
15952 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate" "', expected argument " "2"" of type '" "double""'");
15953 }
15954 arg2 = static_cast< double >(val2);
15955 {
15956 arg3 = &temp3;
15957 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
15958 }
15959 if (obj3) {
15960 ecode4 = SWIG_AsVal_bool(obj3, &val4);
15961 if (!SWIG_IsOK(ecode4)) {
15962 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Rotate" "', expected argument " "4"" of type '" "bool""'");
15963 }
15964 arg4 = static_cast< bool >(val4);
15965 }
15966 if (obj4) {
15967 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxPoint, 0 | 0 );
15968 if (!SWIG_IsOK(res5)) {
15969 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Image_Rotate" "', expected argument " "5"" of type '" "wxPoint *""'");
15970 }
15971 arg5 = reinterpret_cast< wxPoint * >(argp5);
15972 }
15973 {
15974 PyThreadState* __tstate = wxPyBeginAllowThreads();
15975 result = ((wxImage const *)arg1)->Rotate(arg2,(wxPoint const &)*arg3,arg4,arg5);
15976 wxPyEndAllowThreads(__tstate);
15977 if (PyErr_Occurred()) SWIG_fail;
15978 }
15979 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
15980 return resultobj;
15981 fail:
15982 return NULL;
15983 }
15984
15985
15986 SWIGINTERN PyObject *_wrap_Image_Rotate90(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
15987 PyObject *resultobj = 0;
15988 wxImage *arg1 = (wxImage *) 0 ;
15989 bool arg2 = (bool) true ;
15990 SwigValueWrapper<wxImage > result;
15991 void *argp1 = 0 ;
15992 int res1 = 0 ;
15993 bool val2 ;
15994 int ecode2 = 0 ;
15995 PyObject * obj0 = 0 ;
15996 PyObject * obj1 = 0 ;
15997 char * kwnames[] = {
15998 (char *) "self",(char *) "clockwise", NULL
15999 };
16000
16001 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Rotate90",kwnames,&obj0,&obj1)) SWIG_fail;
16002 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16003 if (!SWIG_IsOK(res1)) {
16004 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Rotate90" "', expected argument " "1"" of type '" "wxImage *""'");
16005 }
16006 arg1 = reinterpret_cast< wxImage * >(argp1);
16007 if (obj1) {
16008 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16009 if (!SWIG_IsOK(ecode2)) {
16010 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Rotate90" "', expected argument " "2"" of type '" "bool""'");
16011 }
16012 arg2 = static_cast< bool >(val2);
16013 }
16014 {
16015 PyThreadState* __tstate = wxPyBeginAllowThreads();
16016 result = (arg1)->Rotate90(arg2);
16017 wxPyEndAllowThreads(__tstate);
16018 if (PyErr_Occurred()) SWIG_fail;
16019 }
16020 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16021 return resultobj;
16022 fail:
16023 return NULL;
16024 }
16025
16026
16027 SWIGINTERN PyObject *_wrap_Image_Mirror(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16028 PyObject *resultobj = 0;
16029 wxImage *arg1 = (wxImage *) 0 ;
16030 bool arg2 = (bool) true ;
16031 SwigValueWrapper<wxImage > result;
16032 void *argp1 = 0 ;
16033 int res1 = 0 ;
16034 bool val2 ;
16035 int ecode2 = 0 ;
16036 PyObject * obj0 = 0 ;
16037 PyObject * obj1 = 0 ;
16038 char * kwnames[] = {
16039 (char *) "self",(char *) "horizontally", NULL
16040 };
16041
16042 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_Mirror",kwnames,&obj0,&obj1)) SWIG_fail;
16043 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16044 if (!SWIG_IsOK(res1)) {
16045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Mirror" "', expected argument " "1"" of type '" "wxImage *""'");
16046 }
16047 arg1 = reinterpret_cast< wxImage * >(argp1);
16048 if (obj1) {
16049 ecode2 = SWIG_AsVal_bool(obj1, &val2);
16050 if (!SWIG_IsOK(ecode2)) {
16051 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Mirror" "', expected argument " "2"" of type '" "bool""'");
16052 }
16053 arg2 = static_cast< bool >(val2);
16054 }
16055 {
16056 PyThreadState* __tstate = wxPyBeginAllowThreads();
16057 result = (arg1)->Mirror(arg2);
16058 wxPyEndAllowThreads(__tstate);
16059 if (PyErr_Occurred()) SWIG_fail;
16060 }
16061 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16062 return resultobj;
16063 fail:
16064 return NULL;
16065 }
16066
16067
16068 SWIGINTERN PyObject *_wrap_Image_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16069 PyObject *resultobj = 0;
16070 wxImage *arg1 = (wxImage *) 0 ;
16071 byte arg2 ;
16072 byte arg3 ;
16073 byte arg4 ;
16074 byte arg5 ;
16075 byte arg6 ;
16076 byte arg7 ;
16077 void *argp1 = 0 ;
16078 int res1 = 0 ;
16079 unsigned char val2 ;
16080 int ecode2 = 0 ;
16081 unsigned char val3 ;
16082 int ecode3 = 0 ;
16083 unsigned char val4 ;
16084 int ecode4 = 0 ;
16085 unsigned char val5 ;
16086 int ecode5 = 0 ;
16087 unsigned char val6 ;
16088 int ecode6 = 0 ;
16089 unsigned char val7 ;
16090 int ecode7 = 0 ;
16091 PyObject * obj0 = 0 ;
16092 PyObject * obj1 = 0 ;
16093 PyObject * obj2 = 0 ;
16094 PyObject * obj3 = 0 ;
16095 PyObject * obj4 = 0 ;
16096 PyObject * obj5 = 0 ;
16097 PyObject * obj6 = 0 ;
16098 char * kwnames[] = {
16099 (char *) "self",(char *) "r1",(char *) "g1",(char *) "b1",(char *) "r2",(char *) "g2",(char *) "b2", NULL
16100 };
16101
16102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOOO:Image_Replace",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
16103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16104 if (!SWIG_IsOK(res1)) {
16105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_Replace" "', expected argument " "1"" of type '" "wxImage *""'");
16106 }
16107 arg1 = reinterpret_cast< wxImage * >(argp1);
16108 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16109 if (!SWIG_IsOK(ecode2)) {
16110 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_Replace" "', expected argument " "2"" of type '" "byte""'");
16111 }
16112 arg2 = static_cast< byte >(val2);
16113 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16114 if (!SWIG_IsOK(ecode3)) {
16115 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_Replace" "', expected argument " "3"" of type '" "byte""'");
16116 }
16117 arg3 = static_cast< byte >(val3);
16118 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16119 if (!SWIG_IsOK(ecode4)) {
16120 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_Replace" "', expected argument " "4"" of type '" "byte""'");
16121 }
16122 arg4 = static_cast< byte >(val4);
16123 ecode5 = SWIG_AsVal_unsigned_SS_char(obj4, &val5);
16124 if (!SWIG_IsOK(ecode5)) {
16125 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Image_Replace" "', expected argument " "5"" of type '" "byte""'");
16126 }
16127 arg5 = static_cast< byte >(val5);
16128 ecode6 = SWIG_AsVal_unsigned_SS_char(obj5, &val6);
16129 if (!SWIG_IsOK(ecode6)) {
16130 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Image_Replace" "', expected argument " "6"" of type '" "byte""'");
16131 }
16132 arg6 = static_cast< byte >(val6);
16133 ecode7 = SWIG_AsVal_unsigned_SS_char(obj6, &val7);
16134 if (!SWIG_IsOK(ecode7)) {
16135 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Image_Replace" "', expected argument " "7"" of type '" "byte""'");
16136 }
16137 arg7 = static_cast< byte >(val7);
16138 {
16139 PyThreadState* __tstate = wxPyBeginAllowThreads();
16140 (arg1)->Replace(arg2,arg3,arg4,arg5,arg6,arg7);
16141 wxPyEndAllowThreads(__tstate);
16142 if (PyErr_Occurred()) SWIG_fail;
16143 }
16144 resultobj = SWIG_Py_Void();
16145 return resultobj;
16146 fail:
16147 return NULL;
16148 }
16149
16150
16151 SWIGINTERN PyObject *_wrap_Image_ConvertToGreyscale(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16152 PyObject *resultobj = 0;
16153 wxImage *arg1 = (wxImage *) 0 ;
16154 double arg2 = (double) 0.299 ;
16155 double arg3 = (double) 0.587 ;
16156 double arg4 = (double) 0.114 ;
16157 SwigValueWrapper<wxImage > result;
16158 void *argp1 = 0 ;
16159 int res1 = 0 ;
16160 double val2 ;
16161 int ecode2 = 0 ;
16162 double val3 ;
16163 int ecode3 = 0 ;
16164 double val4 ;
16165 int ecode4 = 0 ;
16166 PyObject * obj0 = 0 ;
16167 PyObject * obj1 = 0 ;
16168 PyObject * obj2 = 0 ;
16169 PyObject * obj3 = 0 ;
16170 char * kwnames[] = {
16171 (char *) "self",(char *) "lr",(char *) "lg",(char *) "lb", NULL
16172 };
16173
16174 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOO:Image_ConvertToGreyscale",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16175 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16176 if (!SWIG_IsOK(res1)) {
16177 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToGreyscale" "', expected argument " "1"" of type '" "wxImage const *""'");
16178 }
16179 arg1 = reinterpret_cast< wxImage * >(argp1);
16180 if (obj1) {
16181 ecode2 = SWIG_AsVal_double(obj1, &val2);
16182 if (!SWIG_IsOK(ecode2)) {
16183 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToGreyscale" "', expected argument " "2"" of type '" "double""'");
16184 }
16185 arg2 = static_cast< double >(val2);
16186 }
16187 if (obj2) {
16188 ecode3 = SWIG_AsVal_double(obj2, &val3);
16189 if (!SWIG_IsOK(ecode3)) {
16190 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToGreyscale" "', expected argument " "3"" of type '" "double""'");
16191 }
16192 arg3 = static_cast< double >(val3);
16193 }
16194 if (obj3) {
16195 ecode4 = SWIG_AsVal_double(obj3, &val4);
16196 if (!SWIG_IsOK(ecode4)) {
16197 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToGreyscale" "', expected argument " "4"" of type '" "double""'");
16198 }
16199 arg4 = static_cast< double >(val4);
16200 }
16201 {
16202 PyThreadState* __tstate = wxPyBeginAllowThreads();
16203 result = ((wxImage const *)arg1)->ConvertToGreyscale(arg2,arg3,arg4);
16204 wxPyEndAllowThreads(__tstate);
16205 if (PyErr_Occurred()) SWIG_fail;
16206 }
16207 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16208 return resultobj;
16209 fail:
16210 return NULL;
16211 }
16212
16213
16214 SWIGINTERN PyObject *_wrap_Image_ConvertToMono(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16215 PyObject *resultobj = 0;
16216 wxImage *arg1 = (wxImage *) 0 ;
16217 byte arg2 ;
16218 byte arg3 ;
16219 byte arg4 ;
16220 SwigValueWrapper<wxImage > result;
16221 void *argp1 = 0 ;
16222 int res1 = 0 ;
16223 unsigned char val2 ;
16224 int ecode2 = 0 ;
16225 unsigned char val3 ;
16226 int ecode3 = 0 ;
16227 unsigned char val4 ;
16228 int ecode4 = 0 ;
16229 PyObject * obj0 = 0 ;
16230 PyObject * obj1 = 0 ;
16231 PyObject * obj2 = 0 ;
16232 PyObject * obj3 = 0 ;
16233 char * kwnames[] = {
16234 (char *) "self",(char *) "r",(char *) "g",(char *) "b", NULL
16235 };
16236
16237 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMono",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16238 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16239 if (!SWIG_IsOK(res1)) {
16240 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMono" "', expected argument " "1"" of type '" "wxImage const *""'");
16241 }
16242 arg1 = reinterpret_cast< wxImage * >(argp1);
16243 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16244 if (!SWIG_IsOK(ecode2)) {
16245 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMono" "', expected argument " "2"" of type '" "byte""'");
16246 }
16247 arg2 = static_cast< byte >(val2);
16248 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16249 if (!SWIG_IsOK(ecode3)) {
16250 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMono" "', expected argument " "3"" of type '" "byte""'");
16251 }
16252 arg3 = static_cast< byte >(val3);
16253 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16254 if (!SWIG_IsOK(ecode4)) {
16255 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMono" "', expected argument " "4"" of type '" "byte""'");
16256 }
16257 arg4 = static_cast< byte >(val4);
16258 {
16259 PyThreadState* __tstate = wxPyBeginAllowThreads();
16260 result = ((wxImage const *)arg1)->ConvertToMono(arg2,arg3,arg4);
16261 wxPyEndAllowThreads(__tstate);
16262 if (PyErr_Occurred()) SWIG_fail;
16263 }
16264 resultobj = SWIG_NewPointerObj((new wxImage(static_cast< const wxImage& >(result))), SWIGTYPE_p_wxImage, SWIG_POINTER_OWN | 0 );
16265 return resultobj;
16266 fail:
16267 return NULL;
16268 }
16269
16270
16271 SWIGINTERN PyObject *_wrap_Image_SetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16272 PyObject *resultobj = 0;
16273 wxImage *arg1 = (wxImage *) 0 ;
16274 wxString *arg2 = 0 ;
16275 wxString *arg3 = 0 ;
16276 void *argp1 = 0 ;
16277 int res1 = 0 ;
16278 bool temp2 = false ;
16279 bool temp3 = false ;
16280 PyObject * obj0 = 0 ;
16281 PyObject * obj1 = 0 ;
16282 PyObject * obj2 = 0 ;
16283 char * kwnames[] = {
16284 (char *) "self",(char *) "name",(char *) "value", NULL
16285 };
16286
16287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOption",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16289 if (!SWIG_IsOK(res1)) {
16290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOption" "', expected argument " "1"" of type '" "wxImage *""'");
16291 }
16292 arg1 = reinterpret_cast< wxImage * >(argp1);
16293 {
16294 arg2 = wxString_in_helper(obj1);
16295 if (arg2 == NULL) SWIG_fail;
16296 temp2 = true;
16297 }
16298 {
16299 arg3 = wxString_in_helper(obj2);
16300 if (arg3 == NULL) SWIG_fail;
16301 temp3 = true;
16302 }
16303 {
16304 PyThreadState* __tstate = wxPyBeginAllowThreads();
16305 (arg1)->SetOption((wxString const &)*arg2,(wxString const &)*arg3);
16306 wxPyEndAllowThreads(__tstate);
16307 if (PyErr_Occurred()) SWIG_fail;
16308 }
16309 resultobj = SWIG_Py_Void();
16310 {
16311 if (temp2)
16312 delete arg2;
16313 }
16314 {
16315 if (temp3)
16316 delete arg3;
16317 }
16318 return resultobj;
16319 fail:
16320 {
16321 if (temp2)
16322 delete arg2;
16323 }
16324 {
16325 if (temp3)
16326 delete arg3;
16327 }
16328 return NULL;
16329 }
16330
16331
16332 SWIGINTERN PyObject *_wrap_Image_SetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16333 PyObject *resultobj = 0;
16334 wxImage *arg1 = (wxImage *) 0 ;
16335 wxString *arg2 = 0 ;
16336 int arg3 ;
16337 void *argp1 = 0 ;
16338 int res1 = 0 ;
16339 bool temp2 = false ;
16340 int val3 ;
16341 int ecode3 = 0 ;
16342 PyObject * obj0 = 0 ;
16343 PyObject * obj1 = 0 ;
16344 PyObject * obj2 = 0 ;
16345 char * kwnames[] = {
16346 (char *) "self",(char *) "name",(char *) "value", NULL
16347 };
16348
16349 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Image_SetOptionInt",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
16350 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16351 if (!SWIG_IsOK(res1)) {
16352 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_SetOptionInt" "', expected argument " "1"" of type '" "wxImage *""'");
16353 }
16354 arg1 = reinterpret_cast< wxImage * >(argp1);
16355 {
16356 arg2 = wxString_in_helper(obj1);
16357 if (arg2 == NULL) SWIG_fail;
16358 temp2 = true;
16359 }
16360 ecode3 = SWIG_AsVal_int(obj2, &val3);
16361 if (!SWIG_IsOK(ecode3)) {
16362 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_SetOptionInt" "', expected argument " "3"" of type '" "int""'");
16363 }
16364 arg3 = static_cast< int >(val3);
16365 {
16366 PyThreadState* __tstate = wxPyBeginAllowThreads();
16367 (arg1)->SetOption((wxString const &)*arg2,arg3);
16368 wxPyEndAllowThreads(__tstate);
16369 if (PyErr_Occurred()) SWIG_fail;
16370 }
16371 resultobj = SWIG_Py_Void();
16372 {
16373 if (temp2)
16374 delete arg2;
16375 }
16376 return resultobj;
16377 fail:
16378 {
16379 if (temp2)
16380 delete arg2;
16381 }
16382 return NULL;
16383 }
16384
16385
16386 SWIGINTERN PyObject *_wrap_Image_GetOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16387 PyObject *resultobj = 0;
16388 wxImage *arg1 = (wxImage *) 0 ;
16389 wxString *arg2 = 0 ;
16390 wxString result;
16391 void *argp1 = 0 ;
16392 int res1 = 0 ;
16393 bool temp2 = false ;
16394 PyObject * obj0 = 0 ;
16395 PyObject * obj1 = 0 ;
16396 char * kwnames[] = {
16397 (char *) "self",(char *) "name", NULL
16398 };
16399
16400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOption",kwnames,&obj0,&obj1)) SWIG_fail;
16401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16402 if (!SWIG_IsOK(res1)) {
16403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16404 }
16405 arg1 = reinterpret_cast< wxImage * >(argp1);
16406 {
16407 arg2 = wxString_in_helper(obj1);
16408 if (arg2 == NULL) SWIG_fail;
16409 temp2 = true;
16410 }
16411 {
16412 PyThreadState* __tstate = wxPyBeginAllowThreads();
16413 result = ((wxImage const *)arg1)->GetOption((wxString const &)*arg2);
16414 wxPyEndAllowThreads(__tstate);
16415 if (PyErr_Occurred()) SWIG_fail;
16416 }
16417 {
16418 #if wxUSE_UNICODE
16419 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16420 #else
16421 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16422 #endif
16423 }
16424 {
16425 if (temp2)
16426 delete arg2;
16427 }
16428 return resultobj;
16429 fail:
16430 {
16431 if (temp2)
16432 delete arg2;
16433 }
16434 return NULL;
16435 }
16436
16437
16438 SWIGINTERN PyObject *_wrap_Image_GetOptionInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16439 PyObject *resultobj = 0;
16440 wxImage *arg1 = (wxImage *) 0 ;
16441 wxString *arg2 = 0 ;
16442 int result;
16443 void *argp1 = 0 ;
16444 int res1 = 0 ;
16445 bool temp2 = false ;
16446 PyObject * obj0 = 0 ;
16447 PyObject * obj1 = 0 ;
16448 char * kwnames[] = {
16449 (char *) "self",(char *) "name", NULL
16450 };
16451
16452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_GetOptionInt",kwnames,&obj0,&obj1)) SWIG_fail;
16453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16454 if (!SWIG_IsOK(res1)) {
16455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_GetOptionInt" "', expected argument " "1"" of type '" "wxImage const *""'");
16456 }
16457 arg1 = reinterpret_cast< wxImage * >(argp1);
16458 {
16459 arg2 = wxString_in_helper(obj1);
16460 if (arg2 == NULL) SWIG_fail;
16461 temp2 = true;
16462 }
16463 {
16464 PyThreadState* __tstate = wxPyBeginAllowThreads();
16465 result = (int)((wxImage const *)arg1)->GetOptionInt((wxString const &)*arg2);
16466 wxPyEndAllowThreads(__tstate);
16467 if (PyErr_Occurred()) SWIG_fail;
16468 }
16469 resultobj = SWIG_From_int(static_cast< int >(result));
16470 {
16471 if (temp2)
16472 delete arg2;
16473 }
16474 return resultobj;
16475 fail:
16476 {
16477 if (temp2)
16478 delete arg2;
16479 }
16480 return NULL;
16481 }
16482
16483
16484 SWIGINTERN PyObject *_wrap_Image_HasOption(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16485 PyObject *resultobj = 0;
16486 wxImage *arg1 = (wxImage *) 0 ;
16487 wxString *arg2 = 0 ;
16488 bool result;
16489 void *argp1 = 0 ;
16490 int res1 = 0 ;
16491 bool temp2 = false ;
16492 PyObject * obj0 = 0 ;
16493 PyObject * obj1 = 0 ;
16494 char * kwnames[] = {
16495 (char *) "self",(char *) "name", NULL
16496 };
16497
16498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_HasOption",kwnames,&obj0,&obj1)) SWIG_fail;
16499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16500 if (!SWIG_IsOK(res1)) {
16501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HasOption" "', expected argument " "1"" of type '" "wxImage const *""'");
16502 }
16503 arg1 = reinterpret_cast< wxImage * >(argp1);
16504 {
16505 arg2 = wxString_in_helper(obj1);
16506 if (arg2 == NULL) SWIG_fail;
16507 temp2 = true;
16508 }
16509 {
16510 PyThreadState* __tstate = wxPyBeginAllowThreads();
16511 result = (bool)((wxImage const *)arg1)->HasOption((wxString const &)*arg2);
16512 wxPyEndAllowThreads(__tstate);
16513 if (PyErr_Occurred()) SWIG_fail;
16514 }
16515 {
16516 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16517 }
16518 {
16519 if (temp2)
16520 delete arg2;
16521 }
16522 return resultobj;
16523 fail:
16524 {
16525 if (temp2)
16526 delete arg2;
16527 }
16528 return NULL;
16529 }
16530
16531
16532 SWIGINTERN PyObject *_wrap_Image_CountColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16533 PyObject *resultobj = 0;
16534 wxImage *arg1 = (wxImage *) 0 ;
16535 unsigned long arg2 = (unsigned long) (unsigned long) -1 ;
16536 unsigned long result;
16537 void *argp1 = 0 ;
16538 int res1 = 0 ;
16539 unsigned long val2 ;
16540 int ecode2 = 0 ;
16541 PyObject * obj0 = 0 ;
16542 PyObject * obj1 = 0 ;
16543 char * kwnames[] = {
16544 (char *) "self",(char *) "stopafter", NULL
16545 };
16546
16547 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_CountColours",kwnames,&obj0,&obj1)) SWIG_fail;
16548 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16549 if (!SWIG_IsOK(res1)) {
16550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_CountColours" "', expected argument " "1"" of type '" "wxImage *""'");
16551 }
16552 arg1 = reinterpret_cast< wxImage * >(argp1);
16553 if (obj1) {
16554 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
16555 if (!SWIG_IsOK(ecode2)) {
16556 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_CountColours" "', expected argument " "2"" of type '" "unsigned long""'");
16557 }
16558 arg2 = static_cast< unsigned long >(val2);
16559 }
16560 {
16561 PyThreadState* __tstate = wxPyBeginAllowThreads();
16562 result = (unsigned long)(arg1)->CountColours(arg2);
16563 wxPyEndAllowThreads(__tstate);
16564 if (PyErr_Occurred()) SWIG_fail;
16565 }
16566 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16567 return resultobj;
16568 fail:
16569 return NULL;
16570 }
16571
16572
16573 SWIGINTERN PyObject *_wrap_Image_ComputeHistogram(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16574 PyObject *resultobj = 0;
16575 wxImage *arg1 = (wxImage *) 0 ;
16576 wxImageHistogram *arg2 = 0 ;
16577 unsigned long result;
16578 void *argp1 = 0 ;
16579 int res1 = 0 ;
16580 void *argp2 = 0 ;
16581 int res2 = 0 ;
16582 PyObject * obj0 = 0 ;
16583 PyObject * obj1 = 0 ;
16584 char * kwnames[] = {
16585 (char *) "self",(char *) "h", NULL
16586 };
16587
16588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_ComputeHistogram",kwnames,&obj0,&obj1)) SWIG_fail;
16589 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16590 if (!SWIG_IsOK(res1)) {
16591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ComputeHistogram" "', expected argument " "1"" of type '" "wxImage *""'");
16592 }
16593 arg1 = reinterpret_cast< wxImage * >(argp1);
16594 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImageHistogram, 0 );
16595 if (!SWIG_IsOK(res2)) {
16596 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16597 }
16598 if (!argp2) {
16599 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_ComputeHistogram" "', expected argument " "2"" of type '" "wxImageHistogram &""'");
16600 }
16601 arg2 = reinterpret_cast< wxImageHistogram * >(argp2);
16602 {
16603 PyThreadState* __tstate = wxPyBeginAllowThreads();
16604 result = (unsigned long)(arg1)->ComputeHistogram(*arg2);
16605 wxPyEndAllowThreads(__tstate);
16606 if (PyErr_Occurred()) SWIG_fail;
16607 }
16608 resultobj = SWIG_From_unsigned_SS_long(static_cast< unsigned long >(result));
16609 return resultobj;
16610 fail:
16611 return NULL;
16612 }
16613
16614
16615 SWIGINTERN PyObject *_wrap_Image_AddHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16616 PyObject *resultobj = 0;
16617 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16618 void *argp1 = 0 ;
16619 int res1 = 0 ;
16620 PyObject * obj0 = 0 ;
16621 char * kwnames[] = {
16622 (char *) "handler", NULL
16623 };
16624
16625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_AddHandler",kwnames,&obj0)) SWIG_fail;
16626 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16627 if (!SWIG_IsOK(res1)) {
16628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_AddHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16629 }
16630 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16631 {
16632 PyThreadState* __tstate = wxPyBeginAllowThreads();
16633 wxImage::AddHandler(arg1);
16634 wxPyEndAllowThreads(__tstate);
16635 if (PyErr_Occurred()) SWIG_fail;
16636 }
16637 resultobj = SWIG_Py_Void();
16638 return resultobj;
16639 fail:
16640 return NULL;
16641 }
16642
16643
16644 SWIGINTERN PyObject *_wrap_Image_InsertHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16645 PyObject *resultobj = 0;
16646 wxImageHandler *arg1 = (wxImageHandler *) 0 ;
16647 void *argp1 = 0 ;
16648 int res1 = 0 ;
16649 PyObject * obj0 = 0 ;
16650 char * kwnames[] = {
16651 (char *) "handler", NULL
16652 };
16653
16654 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_InsertHandler",kwnames,&obj0)) SWIG_fail;
16655 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImageHandler, 0 | 0 );
16656 if (!SWIG_IsOK(res1)) {
16657 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_InsertHandler" "', expected argument " "1"" of type '" "wxImageHandler *""'");
16658 }
16659 arg1 = reinterpret_cast< wxImageHandler * >(argp1);
16660 {
16661 PyThreadState* __tstate = wxPyBeginAllowThreads();
16662 wxImage::InsertHandler(arg1);
16663 wxPyEndAllowThreads(__tstate);
16664 if (PyErr_Occurred()) SWIG_fail;
16665 }
16666 resultobj = SWIG_Py_Void();
16667 return resultobj;
16668 fail:
16669 return NULL;
16670 }
16671
16672
16673 SWIGINTERN PyObject *_wrap_Image_RemoveHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16674 PyObject *resultobj = 0;
16675 wxString *arg1 = 0 ;
16676 bool result;
16677 bool temp1 = false ;
16678 PyObject * obj0 = 0 ;
16679 char * kwnames[] = {
16680 (char *) "name", NULL
16681 };
16682
16683 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RemoveHandler",kwnames,&obj0)) SWIG_fail;
16684 {
16685 arg1 = wxString_in_helper(obj0);
16686 if (arg1 == NULL) SWIG_fail;
16687 temp1 = true;
16688 }
16689 {
16690 PyThreadState* __tstate = wxPyBeginAllowThreads();
16691 result = (bool)wxImage::RemoveHandler((wxString const &)*arg1);
16692 wxPyEndAllowThreads(__tstate);
16693 if (PyErr_Occurred()) SWIG_fail;
16694 }
16695 {
16696 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
16697 }
16698 {
16699 if (temp1)
16700 delete arg1;
16701 }
16702 return resultobj;
16703 fail:
16704 {
16705 if (temp1)
16706 delete arg1;
16707 }
16708 return NULL;
16709 }
16710
16711
16712 SWIGINTERN PyObject *_wrap_Image_GetHandlers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16713 PyObject *resultobj = 0;
16714 PyObject *result = 0 ;
16715
16716 if (!SWIG_Python_UnpackTuple(args,"Image_GetHandlers",0,0,0)) SWIG_fail;
16717 {
16718 PyThreadState* __tstate = wxPyBeginAllowThreads();
16719 result = (PyObject *)wxImage_GetHandlers();
16720 wxPyEndAllowThreads(__tstate);
16721 if (PyErr_Occurred()) SWIG_fail;
16722 }
16723 resultobj = result;
16724 return resultobj;
16725 fail:
16726 return NULL;
16727 }
16728
16729
16730 SWIGINTERN PyObject *_wrap_Image_GetImageExtWildcard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16731 PyObject *resultobj = 0;
16732 wxString result;
16733
16734 if (!SWIG_Python_UnpackTuple(args,"Image_GetImageExtWildcard",0,0,0)) SWIG_fail;
16735 {
16736 PyThreadState* __tstate = wxPyBeginAllowThreads();
16737 result = wxImage::GetImageExtWildcard();
16738 wxPyEndAllowThreads(__tstate);
16739 if (PyErr_Occurred()) SWIG_fail;
16740 }
16741 {
16742 #if wxUSE_UNICODE
16743 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
16744 #else
16745 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
16746 #endif
16747 }
16748 return resultobj;
16749 fail:
16750 return NULL;
16751 }
16752
16753
16754 SWIGINTERN PyObject *_wrap_Image_ConvertToBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16755 PyObject *resultobj = 0;
16756 wxImage *arg1 = (wxImage *) 0 ;
16757 int arg2 = (int) -1 ;
16758 wxBitmap result;
16759 void *argp1 = 0 ;
16760 int res1 = 0 ;
16761 int val2 ;
16762 int ecode2 = 0 ;
16763 PyObject * obj0 = 0 ;
16764 PyObject * obj1 = 0 ;
16765 char * kwnames[] = {
16766 (char *) "self",(char *) "depth", NULL
16767 };
16768
16769 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Image_ConvertToBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
16770 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16771 if (!SWIG_IsOK(res1)) {
16772 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16773 }
16774 arg1 = reinterpret_cast< wxImage * >(argp1);
16775 if (obj1) {
16776 ecode2 = SWIG_AsVal_int(obj1, &val2);
16777 if (!SWIG_IsOK(ecode2)) {
16778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToBitmap" "', expected argument " "2"" of type '" "int""'");
16779 }
16780 arg2 = static_cast< int >(val2);
16781 }
16782 {
16783 if (!wxPyCheckForApp()) SWIG_fail;
16784 PyThreadState* __tstate = wxPyBeginAllowThreads();
16785 result = wxImage_ConvertToBitmap(arg1,arg2);
16786 wxPyEndAllowThreads(__tstate);
16787 if (PyErr_Occurred()) SWIG_fail;
16788 }
16789 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16790 return resultobj;
16791 fail:
16792 return NULL;
16793 }
16794
16795
16796 SWIGINTERN PyObject *_wrap_Image_ConvertToMonoBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16797 PyObject *resultobj = 0;
16798 wxImage *arg1 = (wxImage *) 0 ;
16799 byte arg2 ;
16800 byte arg3 ;
16801 byte arg4 ;
16802 wxBitmap result;
16803 void *argp1 = 0 ;
16804 int res1 = 0 ;
16805 unsigned char val2 ;
16806 int ecode2 = 0 ;
16807 unsigned char val3 ;
16808 int ecode3 = 0 ;
16809 unsigned char val4 ;
16810 int ecode4 = 0 ;
16811 PyObject * obj0 = 0 ;
16812 PyObject * obj1 = 0 ;
16813 PyObject * obj2 = 0 ;
16814 PyObject * obj3 = 0 ;
16815 char * kwnames[] = {
16816 (char *) "self",(char *) "red",(char *) "green",(char *) "blue", NULL
16817 };
16818
16819 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Image_ConvertToMonoBitmap",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
16820 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxImage, 0 | 0 );
16821 if (!SWIG_IsOK(res1)) {
16822 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "1"" of type '" "wxImage *""'");
16823 }
16824 arg1 = reinterpret_cast< wxImage * >(argp1);
16825 ecode2 = SWIG_AsVal_unsigned_SS_char(obj1, &val2);
16826 if (!SWIG_IsOK(ecode2)) {
16827 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "2"" of type '" "byte""'");
16828 }
16829 arg2 = static_cast< byte >(val2);
16830 ecode3 = SWIG_AsVal_unsigned_SS_char(obj2, &val3);
16831 if (!SWIG_IsOK(ecode3)) {
16832 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "3"" of type '" "byte""'");
16833 }
16834 arg3 = static_cast< byte >(val3);
16835 ecode4 = SWIG_AsVal_unsigned_SS_char(obj3, &val4);
16836 if (!SWIG_IsOK(ecode4)) {
16837 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Image_ConvertToMonoBitmap" "', expected argument " "4"" of type '" "byte""'");
16838 }
16839 arg4 = static_cast< byte >(val4);
16840 {
16841 if (!wxPyCheckForApp()) SWIG_fail;
16842 PyThreadState* __tstate = wxPyBeginAllowThreads();
16843 result = wxImage_ConvertToMonoBitmap(arg1,arg2,arg3,arg4);
16844 wxPyEndAllowThreads(__tstate);
16845 if (PyErr_Occurred()) SWIG_fail;
16846 }
16847 resultobj = SWIG_NewPointerObj((new wxBitmap(static_cast< const wxBitmap& >(result))), SWIGTYPE_p_wxBitmap, SWIG_POINTER_OWN | 0 );
16848 return resultobj;
16849 fail:
16850 return NULL;
16851 }
16852
16853
16854 SWIGINTERN PyObject *_wrap_Image_RotateHue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16855 PyObject *resultobj = 0;
16856 wxImage *arg1 = (wxImage *) 0 ;
16857 double arg2 ;
16858 void *argp1 = 0 ;
16859 int res1 = 0 ;
16860 double val2 ;
16861 int ecode2 = 0 ;
16862 PyObject * obj0 = 0 ;
16863 PyObject * obj1 = 0 ;
16864 char * kwnames[] = {
16865 (char *) "self",(char *) "angle", NULL
16866 };
16867
16868 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Image_RotateHue",kwnames,&obj0,&obj1)) 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_RotateHue" "', expected argument " "1"" of type '" "wxImage *""'");
16872 }
16873 arg1 = reinterpret_cast< wxImage * >(argp1);
16874 ecode2 = SWIG_AsVal_double(obj1, &val2);
16875 if (!SWIG_IsOK(ecode2)) {
16876 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Image_RotateHue" "', expected argument " "2"" of type '" "double""'");
16877 }
16878 arg2 = static_cast< double >(val2);
16879 {
16880 PyThreadState* __tstate = wxPyBeginAllowThreads();
16881 (arg1)->RotateHue(arg2);
16882 wxPyEndAllowThreads(__tstate);
16883 if (PyErr_Occurred()) SWIG_fail;
16884 }
16885 resultobj = SWIG_Py_Void();
16886 return resultobj;
16887 fail:
16888 return NULL;
16889 }
16890
16891
16892 SWIGINTERN PyObject *_wrap_Image_RGBtoHSV(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16893 PyObject *resultobj = 0;
16894 wxImage_RGBValue arg1 ;
16895 wxImage_HSVValue result;
16896 void *argp1 ;
16897 int res1 = 0 ;
16898 PyObject * obj0 = 0 ;
16899 char * kwnames[] = {
16900 (char *) "rgb", NULL
16901 };
16902
16903 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_RGBtoHSV",kwnames,&obj0)) SWIG_fail;
16904 {
16905 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_RGBValue, 0 | 0);
16906 if (!SWIG_IsOK(res1)) {
16907 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16908 }
16909 if (!argp1) {
16910 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_RGBtoHSV" "', expected argument " "1"" of type '" "wxImage_RGBValue""'");
16911 } else {
16912 wxImage_RGBValue * temp = reinterpret_cast< wxImage_RGBValue * >(argp1);
16913 arg1 = *temp;
16914 if (SWIG_IsNewObj(res1)) delete temp;
16915 }
16916 }
16917 {
16918 PyThreadState* __tstate = wxPyBeginAllowThreads();
16919 result = wxImage::RGBtoHSV(arg1);
16920 wxPyEndAllowThreads(__tstate);
16921 if (PyErr_Occurred()) SWIG_fail;
16922 }
16923 resultobj = SWIG_NewPointerObj((new wxImage_HSVValue(static_cast< const wxImage_HSVValue& >(result))), SWIGTYPE_p_wxImage_HSVValue, SWIG_POINTER_OWN | 0 );
16924 return resultobj;
16925 fail:
16926 return NULL;
16927 }
16928
16929
16930 SWIGINTERN PyObject *_wrap_Image_HSVtoRGB(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
16931 PyObject *resultobj = 0;
16932 wxImage_HSVValue arg1 ;
16933 wxImage_RGBValue result;
16934 void *argp1 ;
16935 int res1 = 0 ;
16936 PyObject * obj0 = 0 ;
16937 char * kwnames[] = {
16938 (char *) "hsv", NULL
16939 };
16940
16941 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Image_HSVtoRGB",kwnames,&obj0)) SWIG_fail;
16942 {
16943 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage_HSVValue, 0 | 0);
16944 if (!SWIG_IsOK(res1)) {
16945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16946 }
16947 if (!argp1) {
16948 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Image_HSVtoRGB" "', expected argument " "1"" of type '" "wxImage_HSVValue""'");
16949 } else {
16950 wxImage_HSVValue * temp = reinterpret_cast< wxImage_HSVValue * >(argp1);
16951 arg1 = *temp;
16952 if (SWIG_IsNewObj(res1)) delete temp;
16953 }
16954 }
16955 {
16956 PyThreadState* __tstate = wxPyBeginAllowThreads();
16957 result = wxImage::HSVtoRGB(arg1);
16958 wxPyEndAllowThreads(__tstate);
16959 if (PyErr_Occurred()) SWIG_fail;
16960 }
16961 resultobj = SWIG_NewPointerObj((new wxImage_RGBValue(static_cast< const wxImage_RGBValue& >(result))), SWIGTYPE_p_wxImage_RGBValue, SWIG_POINTER_OWN | 0 );
16962 return resultobj;
16963 fail:
16964 return NULL;
16965 }
16966
16967
16968 SWIGINTERN PyObject *Image_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16969 PyObject *obj;
16970 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
16971 SWIG_TypeNewClientData(SWIGTYPE_p_wxImage, SWIG_NewClientData(obj));
16972 return SWIG_Py_Void();
16973 }
16974
16975 SWIGINTERN PyObject *Image_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
16976 return SWIG_Python_InitShadowInstance(args);
16977 }
16978
16979 SWIGINTERN int NullImage_set(PyObject *) {
16980 SWIG_Error(SWIG_AttributeError,"Variable NullImage is read-only.");
16981 return 1;
16982 }
16983
16984
16985 SWIGINTERN PyObject *NullImage_get(void) {
16986 PyObject *pyobj = 0;
16987
16988 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullImage), SWIGTYPE_p_wxImage, 0 );
16989 return pyobj;
16990 }
16991
16992
16993 SWIGINTERN int IMAGE_OPTION_FILENAME_set(PyObject *) {
16994 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_FILENAME is read-only.");
16995 return 1;
16996 }
16997
16998
16999 SWIGINTERN PyObject *IMAGE_OPTION_FILENAME_get(void) {
17000 PyObject *pyobj = 0;
17001
17002 {
17003 #if wxUSE_UNICODE
17004 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17005 #else
17006 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_FILENAME)->c_str(), (&wxPyIMAGE_OPTION_FILENAME)->Len());
17007 #endif
17008 }
17009 return pyobj;
17010 }
17011
17012
17013 SWIGINTERN int IMAGE_OPTION_BMP_FORMAT_set(PyObject *) {
17014 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BMP_FORMAT is read-only.");
17015 return 1;
17016 }
17017
17018
17019 SWIGINTERN PyObject *IMAGE_OPTION_BMP_FORMAT_get(void) {
17020 PyObject *pyobj = 0;
17021
17022 {
17023 #if wxUSE_UNICODE
17024 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17025 #else
17026 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BMP_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_BMP_FORMAT)->Len());
17027 #endif
17028 }
17029 return pyobj;
17030 }
17031
17032
17033 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_X_set(PyObject *) {
17034 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_X is read-only.");
17035 return 1;
17036 }
17037
17038
17039 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_X_get(void) {
17040 PyObject *pyobj = 0;
17041
17042 {
17043 #if wxUSE_UNICODE
17044 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17045 #else
17046 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_X)->Len());
17047 #endif
17048 }
17049 return pyobj;
17050 }
17051
17052
17053 SWIGINTERN int IMAGE_OPTION_CUR_HOTSPOT_Y_set(PyObject *) {
17054 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_CUR_HOTSPOT_Y is read-only.");
17055 return 1;
17056 }
17057
17058
17059 SWIGINTERN PyObject *IMAGE_OPTION_CUR_HOTSPOT_Y_get(void) {
17060 PyObject *pyobj = 0;
17061
17062 {
17063 #if wxUSE_UNICODE
17064 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17065 #else
17066 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->c_str(), (&wxPyIMAGE_OPTION_CUR_HOTSPOT_Y)->Len());
17067 #endif
17068 }
17069 return pyobj;
17070 }
17071
17072
17073 SWIGINTERN int IMAGE_OPTION_RESOLUTION_set(PyObject *) {
17074 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTION is read-only.");
17075 return 1;
17076 }
17077
17078
17079 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTION_get(void) {
17080 PyObject *pyobj = 0;
17081
17082 {
17083 #if wxUSE_UNICODE
17084 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17085 #else
17086 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTION)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTION)->Len());
17087 #endif
17088 }
17089 return pyobj;
17090 }
17091
17092
17093 SWIGINTERN int IMAGE_OPTION_RESOLUTIONX_set(PyObject *) {
17094 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONX is read-only.");
17095 return 1;
17096 }
17097
17098
17099 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONX_get(void) {
17100 PyObject *pyobj = 0;
17101
17102 {
17103 #if wxUSE_UNICODE
17104 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17105 #else
17106 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONX)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONX)->Len());
17107 #endif
17108 }
17109 return pyobj;
17110 }
17111
17112
17113 SWIGINTERN int IMAGE_OPTION_RESOLUTIONY_set(PyObject *) {
17114 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONY is read-only.");
17115 return 1;
17116 }
17117
17118
17119 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONY_get(void) {
17120 PyObject *pyobj = 0;
17121
17122 {
17123 #if wxUSE_UNICODE
17124 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17125 #else
17126 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONY)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONY)->Len());
17127 #endif
17128 }
17129 return pyobj;
17130 }
17131
17132
17133 SWIGINTERN int IMAGE_OPTION_RESOLUTIONUNIT_set(PyObject *) {
17134 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_RESOLUTIONUNIT is read-only.");
17135 return 1;
17136 }
17137
17138
17139 SWIGINTERN PyObject *IMAGE_OPTION_RESOLUTIONUNIT_get(void) {
17140 PyObject *pyobj = 0;
17141
17142 {
17143 #if wxUSE_UNICODE
17144 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17145 #else
17146 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->c_str(), (&wxPyIMAGE_OPTION_RESOLUTIONUNIT)->Len());
17147 #endif
17148 }
17149 return pyobj;
17150 }
17151
17152
17153 SWIGINTERN int IMAGE_OPTION_QUALITY_set(PyObject *) {
17154 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_QUALITY is read-only.");
17155 return 1;
17156 }
17157
17158
17159 SWIGINTERN PyObject *IMAGE_OPTION_QUALITY_get(void) {
17160 PyObject *pyobj = 0;
17161
17162 {
17163 #if wxUSE_UNICODE
17164 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17165 #else
17166 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_QUALITY)->c_str(), (&wxPyIMAGE_OPTION_QUALITY)->Len());
17167 #endif
17168 }
17169 return pyobj;
17170 }
17171
17172
17173 SWIGINTERN int IMAGE_OPTION_BITSPERSAMPLE_set(PyObject *) {
17174 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_BITSPERSAMPLE is read-only.");
17175 return 1;
17176 }
17177
17178
17179 SWIGINTERN PyObject *IMAGE_OPTION_BITSPERSAMPLE_get(void) {
17180 PyObject *pyobj = 0;
17181
17182 {
17183 #if wxUSE_UNICODE
17184 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17185 #else
17186 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_BITSPERSAMPLE)->c_str(), (&wxPyIMAGE_OPTION_BITSPERSAMPLE)->Len());
17187 #endif
17188 }
17189 return pyobj;
17190 }
17191
17192
17193 SWIGINTERN int IMAGE_OPTION_SAMPLESPERPIXEL_set(PyObject *) {
17194 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_SAMPLESPERPIXEL is read-only.");
17195 return 1;
17196 }
17197
17198
17199 SWIGINTERN PyObject *IMAGE_OPTION_SAMPLESPERPIXEL_get(void) {
17200 PyObject *pyobj = 0;
17201
17202 {
17203 #if wxUSE_UNICODE
17204 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17205 #else
17206 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->c_str(), (&wxPyIMAGE_OPTION_SAMPLESPERPIXEL)->Len());
17207 #endif
17208 }
17209 return pyobj;
17210 }
17211
17212
17213 SWIGINTERN int IMAGE_OPTION_COMPRESSION_set(PyObject *) {
17214 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_COMPRESSION is read-only.");
17215 return 1;
17216 }
17217
17218
17219 SWIGINTERN PyObject *IMAGE_OPTION_COMPRESSION_get(void) {
17220 PyObject *pyobj = 0;
17221
17222 {
17223 #if wxUSE_UNICODE
17224 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17225 #else
17226 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_COMPRESSION)->c_str(), (&wxPyIMAGE_OPTION_COMPRESSION)->Len());
17227 #endif
17228 }
17229 return pyobj;
17230 }
17231
17232
17233 SWIGINTERN int IMAGE_OPTION_IMAGEDESCRIPTOR_set(PyObject *) {
17234 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_IMAGEDESCRIPTOR is read-only.");
17235 return 1;
17236 }
17237
17238
17239 SWIGINTERN PyObject *IMAGE_OPTION_IMAGEDESCRIPTOR_get(void) {
17240 PyObject *pyobj = 0;
17241
17242 {
17243 #if wxUSE_UNICODE
17244 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17245 #else
17246 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->c_str(), (&wxPyIMAGE_OPTION_IMAGEDESCRIPTOR)->Len());
17247 #endif
17248 }
17249 return pyobj;
17250 }
17251
17252
17253 SWIGINTERN int IMAGE_OPTION_PNG_FORMAT_set(PyObject *) {
17254 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_FORMAT is read-only.");
17255 return 1;
17256 }
17257
17258
17259 SWIGINTERN PyObject *IMAGE_OPTION_PNG_FORMAT_get(void) {
17260 PyObject *pyobj = 0;
17261
17262 {
17263 #if wxUSE_UNICODE
17264 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17265 #else
17266 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_FORMAT)->c_str(), (&wxPyIMAGE_OPTION_PNG_FORMAT)->Len());
17267 #endif
17268 }
17269 return pyobj;
17270 }
17271
17272
17273 SWIGINTERN int IMAGE_OPTION_PNG_BITDEPTH_set(PyObject *) {
17274 SWIG_Error(SWIG_AttributeError,"Variable IMAGE_OPTION_PNG_BITDEPTH is read-only.");
17275 return 1;
17276 }
17277
17278
17279 SWIGINTERN PyObject *IMAGE_OPTION_PNG_BITDEPTH_get(void) {
17280 PyObject *pyobj = 0;
17281
17282 {
17283 #if wxUSE_UNICODE
17284 pyobj = PyUnicode_FromWideChar((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17285 #else
17286 pyobj = PyString_FromStringAndSize((&wxPyIMAGE_OPTION_PNG_BITDEPTH)->c_str(), (&wxPyIMAGE_OPTION_PNG_BITDEPTH)->Len());
17287 #endif
17288 }
17289 return pyobj;
17290 }
17291
17292
17293 SWIGINTERN PyObject *_wrap_new_BMPHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17294 PyObject *resultobj = 0;
17295 wxBMPHandler *result = 0 ;
17296
17297 if (!SWIG_Python_UnpackTuple(args,"new_BMPHandler",0,0,0)) SWIG_fail;
17298 {
17299 PyThreadState* __tstate = wxPyBeginAllowThreads();
17300 result = (wxBMPHandler *)new wxBMPHandler();
17301 wxPyEndAllowThreads(__tstate);
17302 if (PyErr_Occurred()) SWIG_fail;
17303 }
17304 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBMPHandler, SWIG_POINTER_NEW | 0 );
17305 return resultobj;
17306 fail:
17307 return NULL;
17308 }
17309
17310
17311 SWIGINTERN PyObject *BMPHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17312 PyObject *obj;
17313 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17314 SWIG_TypeNewClientData(SWIGTYPE_p_wxBMPHandler, SWIG_NewClientData(obj));
17315 return SWIG_Py_Void();
17316 }
17317
17318 SWIGINTERN PyObject *BMPHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17319 return SWIG_Python_InitShadowInstance(args);
17320 }
17321
17322 SWIGINTERN PyObject *_wrap_new_ICOHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17323 PyObject *resultobj = 0;
17324 wxICOHandler *result = 0 ;
17325
17326 if (!SWIG_Python_UnpackTuple(args,"new_ICOHandler",0,0,0)) SWIG_fail;
17327 {
17328 PyThreadState* __tstate = wxPyBeginAllowThreads();
17329 result = (wxICOHandler *)new wxICOHandler();
17330 wxPyEndAllowThreads(__tstate);
17331 if (PyErr_Occurred()) SWIG_fail;
17332 }
17333 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxICOHandler, SWIG_POINTER_NEW | 0 );
17334 return resultobj;
17335 fail:
17336 return NULL;
17337 }
17338
17339
17340 SWIGINTERN PyObject *ICOHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17341 PyObject *obj;
17342 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17343 SWIG_TypeNewClientData(SWIGTYPE_p_wxICOHandler, SWIG_NewClientData(obj));
17344 return SWIG_Py_Void();
17345 }
17346
17347 SWIGINTERN PyObject *ICOHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17348 return SWIG_Python_InitShadowInstance(args);
17349 }
17350
17351 SWIGINTERN PyObject *_wrap_new_CURHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17352 PyObject *resultobj = 0;
17353 wxCURHandler *result = 0 ;
17354
17355 if (!SWIG_Python_UnpackTuple(args,"new_CURHandler",0,0,0)) SWIG_fail;
17356 {
17357 PyThreadState* __tstate = wxPyBeginAllowThreads();
17358 result = (wxCURHandler *)new wxCURHandler();
17359 wxPyEndAllowThreads(__tstate);
17360 if (PyErr_Occurred()) SWIG_fail;
17361 }
17362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCURHandler, SWIG_POINTER_NEW | 0 );
17363 return resultobj;
17364 fail:
17365 return NULL;
17366 }
17367
17368
17369 SWIGINTERN PyObject *CURHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17370 PyObject *obj;
17371 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17372 SWIG_TypeNewClientData(SWIGTYPE_p_wxCURHandler, SWIG_NewClientData(obj));
17373 return SWIG_Py_Void();
17374 }
17375
17376 SWIGINTERN PyObject *CURHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17377 return SWIG_Python_InitShadowInstance(args);
17378 }
17379
17380 SWIGINTERN PyObject *_wrap_new_ANIHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17381 PyObject *resultobj = 0;
17382 wxANIHandler *result = 0 ;
17383
17384 if (!SWIG_Python_UnpackTuple(args,"new_ANIHandler",0,0,0)) SWIG_fail;
17385 {
17386 PyThreadState* __tstate = wxPyBeginAllowThreads();
17387 result = (wxANIHandler *)new wxANIHandler();
17388 wxPyEndAllowThreads(__tstate);
17389 if (PyErr_Occurred()) SWIG_fail;
17390 }
17391 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxANIHandler, SWIG_POINTER_NEW | 0 );
17392 return resultobj;
17393 fail:
17394 return NULL;
17395 }
17396
17397
17398 SWIGINTERN PyObject *ANIHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17399 PyObject *obj;
17400 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17401 SWIG_TypeNewClientData(SWIGTYPE_p_wxANIHandler, SWIG_NewClientData(obj));
17402 return SWIG_Py_Void();
17403 }
17404
17405 SWIGINTERN PyObject *ANIHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17406 return SWIG_Python_InitShadowInstance(args);
17407 }
17408
17409 SWIGINTERN PyObject *_wrap_new_PNGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17410 PyObject *resultobj = 0;
17411 wxPNGHandler *result = 0 ;
17412
17413 if (!SWIG_Python_UnpackTuple(args,"new_PNGHandler",0,0,0)) SWIG_fail;
17414 {
17415 PyThreadState* __tstate = wxPyBeginAllowThreads();
17416 result = (wxPNGHandler *)new wxPNGHandler();
17417 wxPyEndAllowThreads(__tstate);
17418 if (PyErr_Occurred()) SWIG_fail;
17419 }
17420 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNGHandler, SWIG_POINTER_NEW | 0 );
17421 return resultobj;
17422 fail:
17423 return NULL;
17424 }
17425
17426
17427 SWIGINTERN PyObject *PNGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17428 PyObject *obj;
17429 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17430 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNGHandler, SWIG_NewClientData(obj));
17431 return SWIG_Py_Void();
17432 }
17433
17434 SWIGINTERN PyObject *PNGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17435 return SWIG_Python_InitShadowInstance(args);
17436 }
17437
17438 SWIGINTERN PyObject *_wrap_new_GIFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17439 PyObject *resultobj = 0;
17440 wxGIFHandler *result = 0 ;
17441
17442 if (!SWIG_Python_UnpackTuple(args,"new_GIFHandler",0,0,0)) SWIG_fail;
17443 {
17444 PyThreadState* __tstate = wxPyBeginAllowThreads();
17445 result = (wxGIFHandler *)new wxGIFHandler();
17446 wxPyEndAllowThreads(__tstate);
17447 if (PyErr_Occurred()) SWIG_fail;
17448 }
17449 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGIFHandler, SWIG_POINTER_NEW | 0 );
17450 return resultobj;
17451 fail:
17452 return NULL;
17453 }
17454
17455
17456 SWIGINTERN PyObject *GIFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17457 PyObject *obj;
17458 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17459 SWIG_TypeNewClientData(SWIGTYPE_p_wxGIFHandler, SWIG_NewClientData(obj));
17460 return SWIG_Py_Void();
17461 }
17462
17463 SWIGINTERN PyObject *GIFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17464 return SWIG_Python_InitShadowInstance(args);
17465 }
17466
17467 SWIGINTERN PyObject *_wrap_new_PCXHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17468 PyObject *resultobj = 0;
17469 wxPCXHandler *result = 0 ;
17470
17471 if (!SWIG_Python_UnpackTuple(args,"new_PCXHandler",0,0,0)) SWIG_fail;
17472 {
17473 PyThreadState* __tstate = wxPyBeginAllowThreads();
17474 result = (wxPCXHandler *)new wxPCXHandler();
17475 wxPyEndAllowThreads(__tstate);
17476 if (PyErr_Occurred()) SWIG_fail;
17477 }
17478 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPCXHandler, SWIG_POINTER_NEW | 0 );
17479 return resultobj;
17480 fail:
17481 return NULL;
17482 }
17483
17484
17485 SWIGINTERN PyObject *PCXHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17486 PyObject *obj;
17487 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17488 SWIG_TypeNewClientData(SWIGTYPE_p_wxPCXHandler, SWIG_NewClientData(obj));
17489 return SWIG_Py_Void();
17490 }
17491
17492 SWIGINTERN PyObject *PCXHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17493 return SWIG_Python_InitShadowInstance(args);
17494 }
17495
17496 SWIGINTERN PyObject *_wrap_new_JPEGHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17497 PyObject *resultobj = 0;
17498 wxJPEGHandler *result = 0 ;
17499
17500 if (!SWIG_Python_UnpackTuple(args,"new_JPEGHandler",0,0,0)) SWIG_fail;
17501 {
17502 PyThreadState* __tstate = wxPyBeginAllowThreads();
17503 result = (wxJPEGHandler *)new wxJPEGHandler();
17504 wxPyEndAllowThreads(__tstate);
17505 if (PyErr_Occurred()) SWIG_fail;
17506 }
17507 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxJPEGHandler, SWIG_POINTER_NEW | 0 );
17508 return resultobj;
17509 fail:
17510 return NULL;
17511 }
17512
17513
17514 SWIGINTERN PyObject *JPEGHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17515 PyObject *obj;
17516 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17517 SWIG_TypeNewClientData(SWIGTYPE_p_wxJPEGHandler, SWIG_NewClientData(obj));
17518 return SWIG_Py_Void();
17519 }
17520
17521 SWIGINTERN PyObject *JPEGHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17522 return SWIG_Python_InitShadowInstance(args);
17523 }
17524
17525 SWIGINTERN PyObject *_wrap_new_PNMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17526 PyObject *resultobj = 0;
17527 wxPNMHandler *result = 0 ;
17528
17529 if (!SWIG_Python_UnpackTuple(args,"new_PNMHandler",0,0,0)) SWIG_fail;
17530 {
17531 PyThreadState* __tstate = wxPyBeginAllowThreads();
17532 result = (wxPNMHandler *)new wxPNMHandler();
17533 wxPyEndAllowThreads(__tstate);
17534 if (PyErr_Occurred()) SWIG_fail;
17535 }
17536 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPNMHandler, SWIG_POINTER_NEW | 0 );
17537 return resultobj;
17538 fail:
17539 return NULL;
17540 }
17541
17542
17543 SWIGINTERN PyObject *PNMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17544 PyObject *obj;
17545 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17546 SWIG_TypeNewClientData(SWIGTYPE_p_wxPNMHandler, SWIG_NewClientData(obj));
17547 return SWIG_Py_Void();
17548 }
17549
17550 SWIGINTERN PyObject *PNMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17551 return SWIG_Python_InitShadowInstance(args);
17552 }
17553
17554 SWIGINTERN PyObject *_wrap_new_XPMHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17555 PyObject *resultobj = 0;
17556 wxXPMHandler *result = 0 ;
17557
17558 if (!SWIG_Python_UnpackTuple(args,"new_XPMHandler",0,0,0)) SWIG_fail;
17559 {
17560 PyThreadState* __tstate = wxPyBeginAllowThreads();
17561 result = (wxXPMHandler *)new wxXPMHandler();
17562 wxPyEndAllowThreads(__tstate);
17563 if (PyErr_Occurred()) SWIG_fail;
17564 }
17565 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxXPMHandler, SWIG_POINTER_NEW | 0 );
17566 return resultobj;
17567 fail:
17568 return NULL;
17569 }
17570
17571
17572 SWIGINTERN PyObject *XPMHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17573 PyObject *obj;
17574 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17575 SWIG_TypeNewClientData(SWIGTYPE_p_wxXPMHandler, SWIG_NewClientData(obj));
17576 return SWIG_Py_Void();
17577 }
17578
17579 SWIGINTERN PyObject *XPMHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17580 return SWIG_Python_InitShadowInstance(args);
17581 }
17582
17583 SWIGINTERN PyObject *_wrap_new_TIFFHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17584 PyObject *resultobj = 0;
17585 wxTIFFHandler *result = 0 ;
17586
17587 if (!SWIG_Python_UnpackTuple(args,"new_TIFFHandler",0,0,0)) SWIG_fail;
17588 {
17589 PyThreadState* __tstate = wxPyBeginAllowThreads();
17590 result = (wxTIFFHandler *)new wxTIFFHandler();
17591 wxPyEndAllowThreads(__tstate);
17592 if (PyErr_Occurred()) SWIG_fail;
17593 }
17594 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxTIFFHandler, SWIG_POINTER_NEW | 0 );
17595 return resultobj;
17596 fail:
17597 return NULL;
17598 }
17599
17600
17601 SWIGINTERN PyObject *TIFFHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17602 PyObject *obj;
17603 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17604 SWIG_TypeNewClientData(SWIGTYPE_p_wxTIFFHandler, SWIG_NewClientData(obj));
17605 return SWIG_Py_Void();
17606 }
17607
17608 SWIGINTERN PyObject *TIFFHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17609 return SWIG_Python_InitShadowInstance(args);
17610 }
17611
17612 SWIGINTERN PyObject *_wrap_Quantize_Quantize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17613 PyObject *resultobj = 0;
17614 wxImage *arg1 = 0 ;
17615 wxImage *arg2 = 0 ;
17616 int arg3 = (int) 236 ;
17617 int arg4 = (int) wxQUANTIZE_INCLUDE_WINDOWS_COLOURS|wxQUANTIZE_FILL_DESTINATION_IMAGE ;
17618 bool result;
17619 void *argp1 = 0 ;
17620 int res1 = 0 ;
17621 void *argp2 = 0 ;
17622 int res2 = 0 ;
17623 int val3 ;
17624 int ecode3 = 0 ;
17625 int val4 ;
17626 int ecode4 = 0 ;
17627 PyObject * obj0 = 0 ;
17628 PyObject * obj1 = 0 ;
17629 PyObject * obj2 = 0 ;
17630 PyObject * obj3 = 0 ;
17631 char * kwnames[] = {
17632 (char *) "src",(char *) "dest",(char *) "desiredNoColours",(char *) "flags", NULL
17633 };
17634
17635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Quantize_Quantize",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
17636 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxImage, 0 | 0);
17637 if (!SWIG_IsOK(res1)) {
17638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17639 }
17640 if (!argp1) {
17641 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "1"" of type '" "wxImage const &""'");
17642 }
17643 arg1 = reinterpret_cast< wxImage * >(argp1);
17644 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxImage, 0 );
17645 if (!SWIG_IsOK(res2)) {
17646 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17647 }
17648 if (!argp2) {
17649 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Quantize_Quantize" "', expected argument " "2"" of type '" "wxImage &""'");
17650 }
17651 arg2 = reinterpret_cast< wxImage * >(argp2);
17652 if (obj2) {
17653 ecode3 = SWIG_AsVal_int(obj2, &val3);
17654 if (!SWIG_IsOK(ecode3)) {
17655 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Quantize_Quantize" "', expected argument " "3"" of type '" "int""'");
17656 }
17657 arg3 = static_cast< int >(val3);
17658 }
17659 if (obj3) {
17660 ecode4 = SWIG_AsVal_int(obj3, &val4);
17661 if (!SWIG_IsOK(ecode4)) {
17662 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Quantize_Quantize" "', expected argument " "4"" of type '" "int""'");
17663 }
17664 arg4 = static_cast< int >(val4);
17665 }
17666 {
17667 PyThreadState* __tstate = wxPyBeginAllowThreads();
17668 result = (bool)wxQuantize_Quantize((wxImage const &)*arg1,*arg2,arg3,arg4);
17669 wxPyEndAllowThreads(__tstate);
17670 if (PyErr_Occurred()) SWIG_fail;
17671 }
17672 {
17673 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17674 }
17675 return resultobj;
17676 fail:
17677 return NULL;
17678 }
17679
17680
17681 SWIGINTERN PyObject *Quantize_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17682 PyObject *obj;
17683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
17684 SWIG_TypeNewClientData(SWIGTYPE_p_wxQuantize, SWIG_NewClientData(obj));
17685 return SWIG_Py_Void();
17686 }
17687
17688 SWIGINTERN PyObject *_wrap_new_EvtHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17689 PyObject *resultobj = 0;
17690 wxEvtHandler *result = 0 ;
17691
17692 if (!SWIG_Python_UnpackTuple(args,"new_EvtHandler",0,0,0)) SWIG_fail;
17693 {
17694 PyThreadState* __tstate = wxPyBeginAllowThreads();
17695 result = (wxEvtHandler *)new wxEvtHandler();
17696 wxPyEndAllowThreads(__tstate);
17697 if (PyErr_Occurred()) SWIG_fail;
17698 }
17699 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvtHandler, SWIG_POINTER_NEW | 0 );
17700 return resultobj;
17701 fail:
17702 return NULL;
17703 }
17704
17705
17706 SWIGINTERN PyObject *_wrap_EvtHandler_GetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17707 PyObject *resultobj = 0;
17708 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17709 wxEvtHandler *result = 0 ;
17710 void *argp1 = 0 ;
17711 int res1 = 0 ;
17712 PyObject *swig_obj[1] ;
17713
17714 if (!args) SWIG_fail;
17715 swig_obj[0] = args;
17716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17717 if (!SWIG_IsOK(res1)) {
17718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17719 }
17720 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17721 {
17722 PyThreadState* __tstate = wxPyBeginAllowThreads();
17723 result = (wxEvtHandler *)(arg1)->GetNextHandler();
17724 wxPyEndAllowThreads(__tstate);
17725 if (PyErr_Occurred()) SWIG_fail;
17726 }
17727 {
17728 resultobj = wxPyMake_wxObject(result, 0);
17729 }
17730 return resultobj;
17731 fail:
17732 return NULL;
17733 }
17734
17735
17736 SWIGINTERN PyObject *_wrap_EvtHandler_GetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17737 PyObject *resultobj = 0;
17738 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17739 wxEvtHandler *result = 0 ;
17740 void *argp1 = 0 ;
17741 int res1 = 0 ;
17742 PyObject *swig_obj[1] ;
17743
17744 if (!args) SWIG_fail;
17745 swig_obj[0] = args;
17746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17747 if (!SWIG_IsOK(res1)) {
17748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17749 }
17750 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17751 {
17752 PyThreadState* __tstate = wxPyBeginAllowThreads();
17753 result = (wxEvtHandler *)(arg1)->GetPreviousHandler();
17754 wxPyEndAllowThreads(__tstate);
17755 if (PyErr_Occurred()) SWIG_fail;
17756 }
17757 {
17758 resultobj = wxPyMake_wxObject(result, 0);
17759 }
17760 return resultobj;
17761 fail:
17762 return NULL;
17763 }
17764
17765
17766 SWIGINTERN PyObject *_wrap_EvtHandler_SetNextHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17767 PyObject *resultobj = 0;
17768 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17769 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17770 void *argp1 = 0 ;
17771 int res1 = 0 ;
17772 void *argp2 = 0 ;
17773 int res2 = 0 ;
17774 PyObject * obj0 = 0 ;
17775 PyObject * obj1 = 0 ;
17776 char * kwnames[] = {
17777 (char *) "self",(char *) "handler", NULL
17778 };
17779
17780 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetNextHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17781 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17782 if (!SWIG_IsOK(res1)) {
17783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17784 }
17785 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17786 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17787 if (!SWIG_IsOK(res2)) {
17788 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetNextHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17789 }
17790 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17791 {
17792 PyThreadState* __tstate = wxPyBeginAllowThreads();
17793 (arg1)->SetNextHandler(arg2);
17794 wxPyEndAllowThreads(__tstate);
17795 if (PyErr_Occurred()) SWIG_fail;
17796 }
17797 resultobj = SWIG_Py_Void();
17798 return resultobj;
17799 fail:
17800 return NULL;
17801 }
17802
17803
17804 SWIGINTERN PyObject *_wrap_EvtHandler_SetPreviousHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17805 PyObject *resultobj = 0;
17806 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17807 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
17808 void *argp1 = 0 ;
17809 int res1 = 0 ;
17810 void *argp2 = 0 ;
17811 int res2 = 0 ;
17812 PyObject * obj0 = 0 ;
17813 PyObject * obj1 = 0 ;
17814 char * kwnames[] = {
17815 (char *) "self",(char *) "handler", NULL
17816 };
17817
17818 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetPreviousHandler",kwnames,&obj0,&obj1)) SWIG_fail;
17819 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17820 if (!SWIG_IsOK(res1)) {
17821 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17822 }
17823 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17824 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17825 if (!SWIG_IsOK(res2)) {
17826 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_SetPreviousHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
17827 }
17828 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
17829 {
17830 PyThreadState* __tstate = wxPyBeginAllowThreads();
17831 (arg1)->SetPreviousHandler(arg2);
17832 wxPyEndAllowThreads(__tstate);
17833 if (PyErr_Occurred()) SWIG_fail;
17834 }
17835 resultobj = SWIG_Py_Void();
17836 return resultobj;
17837 fail:
17838 return NULL;
17839 }
17840
17841
17842 SWIGINTERN PyObject *_wrap_EvtHandler_GetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17843 PyObject *resultobj = 0;
17844 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17845 bool result;
17846 void *argp1 = 0 ;
17847 int res1 = 0 ;
17848 PyObject *swig_obj[1] ;
17849
17850 if (!args) SWIG_fail;
17851 swig_obj[0] = args;
17852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17853 if (!SWIG_IsOK(res1)) {
17854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_GetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17855 }
17856 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17857 {
17858 PyThreadState* __tstate = wxPyBeginAllowThreads();
17859 result = (bool)(arg1)->GetEvtHandlerEnabled();
17860 wxPyEndAllowThreads(__tstate);
17861 if (PyErr_Occurred()) SWIG_fail;
17862 }
17863 {
17864 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17865 }
17866 return resultobj;
17867 fail:
17868 return NULL;
17869 }
17870
17871
17872 SWIGINTERN PyObject *_wrap_EvtHandler_SetEvtHandlerEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17873 PyObject *resultobj = 0;
17874 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17875 bool arg2 ;
17876 void *argp1 = 0 ;
17877 int res1 = 0 ;
17878 bool val2 ;
17879 int ecode2 = 0 ;
17880 PyObject * obj0 = 0 ;
17881 PyObject * obj1 = 0 ;
17882 char * kwnames[] = {
17883 (char *) "self",(char *) "enabled", NULL
17884 };
17885
17886 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_SetEvtHandlerEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
17887 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17888 if (!SWIG_IsOK(res1)) {
17889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17890 }
17891 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17892 ecode2 = SWIG_AsVal_bool(obj1, &val2);
17893 if (!SWIG_IsOK(ecode2)) {
17894 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_SetEvtHandlerEnabled" "', expected argument " "2"" of type '" "bool""'");
17895 }
17896 arg2 = static_cast< bool >(val2);
17897 {
17898 PyThreadState* __tstate = wxPyBeginAllowThreads();
17899 (arg1)->SetEvtHandlerEnabled(arg2);
17900 wxPyEndAllowThreads(__tstate);
17901 if (PyErr_Occurred()) SWIG_fail;
17902 }
17903 resultobj = SWIG_Py_Void();
17904 return resultobj;
17905 fail:
17906 return NULL;
17907 }
17908
17909
17910 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17911 PyObject *resultobj = 0;
17912 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17913 wxEvent *arg2 = 0 ;
17914 bool result;
17915 void *argp1 = 0 ;
17916 int res1 = 0 ;
17917 void *argp2 = 0 ;
17918 int res2 = 0 ;
17919 PyObject * obj0 = 0 ;
17920 PyObject * obj1 = 0 ;
17921 char * kwnames[] = {
17922 (char *) "self",(char *) "event", NULL
17923 };
17924
17925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_ProcessEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17927 if (!SWIG_IsOK(res1)) {
17928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17929 }
17930 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17931 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17932 if (!SWIG_IsOK(res2)) {
17933 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17934 }
17935 if (!argp2) {
17936 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_ProcessEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17937 }
17938 arg2 = reinterpret_cast< wxEvent * >(argp2);
17939 {
17940 PyThreadState* __tstate = wxPyBeginAllowThreads();
17941 result = (bool)(arg1)->ProcessEvent(*arg2);
17942 wxPyEndAllowThreads(__tstate);
17943 if (PyErr_Occurred()) SWIG_fail;
17944 }
17945 {
17946 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
17947 }
17948 return resultobj;
17949 fail:
17950 return NULL;
17951 }
17952
17953
17954 SWIGINTERN PyObject *_wrap_EvtHandler_AddPendingEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
17955 PyObject *resultobj = 0;
17956 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17957 wxEvent *arg2 = 0 ;
17958 void *argp1 = 0 ;
17959 int res1 = 0 ;
17960 void *argp2 = 0 ;
17961 int res2 = 0 ;
17962 PyObject * obj0 = 0 ;
17963 PyObject * obj1 = 0 ;
17964 char * kwnames[] = {
17965 (char *) "self",(char *) "event", NULL
17966 };
17967
17968 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:EvtHandler_AddPendingEvent",kwnames,&obj0,&obj1)) SWIG_fail;
17969 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
17970 if (!SWIG_IsOK(res1)) {
17971 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
17972 }
17973 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
17974 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
17975 if (!SWIG_IsOK(res2)) {
17976 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17977 }
17978 if (!argp2) {
17979 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "EvtHandler_AddPendingEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
17980 }
17981 arg2 = reinterpret_cast< wxEvent * >(argp2);
17982 {
17983 PyThreadState* __tstate = wxPyBeginAllowThreads();
17984 (arg1)->AddPendingEvent(*arg2);
17985 wxPyEndAllowThreads(__tstate);
17986 if (PyErr_Occurred()) SWIG_fail;
17987 }
17988 resultobj = SWIG_Py_Void();
17989 return resultobj;
17990 fail:
17991 return NULL;
17992 }
17993
17994
17995 SWIGINTERN PyObject *_wrap_EvtHandler_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
17996 PyObject *resultobj = 0;
17997 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
17998 void *argp1 = 0 ;
17999 int res1 = 0 ;
18000 PyObject *swig_obj[1] ;
18001
18002 if (!args) SWIG_fail;
18003 swig_obj[0] = args;
18004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18005 if (!SWIG_IsOK(res1)) {
18006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18007 }
18008 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18009 {
18010 PyThreadState* __tstate = wxPyBeginAllowThreads();
18011 (arg1)->ProcessPendingEvents();
18012 wxPyEndAllowThreads(__tstate);
18013 if (PyErr_Occurred()) SWIG_fail;
18014 }
18015 resultobj = SWIG_Py_Void();
18016 return resultobj;
18017 fail:
18018 return NULL;
18019 }
18020
18021
18022 SWIGINTERN PyObject *_wrap_EvtHandler_Connect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18023 PyObject *resultobj = 0;
18024 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18025 int arg2 ;
18026 int arg3 ;
18027 int arg4 ;
18028 PyObject *arg5 = (PyObject *) 0 ;
18029 void *argp1 = 0 ;
18030 int res1 = 0 ;
18031 int val2 ;
18032 int ecode2 = 0 ;
18033 int val3 ;
18034 int ecode3 = 0 ;
18035 int val4 ;
18036 int ecode4 = 0 ;
18037 PyObject * obj0 = 0 ;
18038 PyObject * obj1 = 0 ;
18039 PyObject * obj2 = 0 ;
18040 PyObject * obj3 = 0 ;
18041 PyObject * obj4 = 0 ;
18042 char * kwnames[] = {
18043 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType",(char *) "func", NULL
18044 };
18045
18046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:EvtHandler_Connect",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
18047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18048 if (!SWIG_IsOK(res1)) {
18049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Connect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18050 }
18051 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18052 ecode2 = SWIG_AsVal_int(obj1, &val2);
18053 if (!SWIG_IsOK(ecode2)) {
18054 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Connect" "', expected argument " "2"" of type '" "int""'");
18055 }
18056 arg2 = static_cast< int >(val2);
18057 ecode3 = SWIG_AsVal_int(obj2, &val3);
18058 if (!SWIG_IsOK(ecode3)) {
18059 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Connect" "', expected argument " "3"" of type '" "int""'");
18060 }
18061 arg3 = static_cast< int >(val3);
18062 ecode4 = SWIG_AsVal_int(obj3, &val4);
18063 if (!SWIG_IsOK(ecode4)) {
18064 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Connect" "', expected argument " "4"" of type '" "int""'");
18065 }
18066 arg4 = static_cast< int >(val4);
18067 arg5 = obj4;
18068 {
18069 PyThreadState* __tstate = wxPyBeginAllowThreads();
18070 wxEvtHandler_Connect(arg1,arg2,arg3,arg4,arg5);
18071 wxPyEndAllowThreads(__tstate);
18072 if (PyErr_Occurred()) SWIG_fail;
18073 }
18074 resultobj = SWIG_Py_Void();
18075 return resultobj;
18076 fail:
18077 return NULL;
18078 }
18079
18080
18081 SWIGINTERN PyObject *_wrap_EvtHandler_Disconnect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18082 PyObject *resultobj = 0;
18083 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18084 int arg2 ;
18085 int arg3 = (int) -1 ;
18086 wxEventType arg4 = (wxEventType) wxEVT_NULL ;
18087 bool result;
18088 void *argp1 = 0 ;
18089 int res1 = 0 ;
18090 int val2 ;
18091 int ecode2 = 0 ;
18092 int val3 ;
18093 int ecode3 = 0 ;
18094 int val4 ;
18095 int ecode4 = 0 ;
18096 PyObject * obj0 = 0 ;
18097 PyObject * obj1 = 0 ;
18098 PyObject * obj2 = 0 ;
18099 PyObject * obj3 = 0 ;
18100 char * kwnames[] = {
18101 (char *) "self",(char *) "id",(char *) "lastId",(char *) "eventType", NULL
18102 };
18103
18104 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:EvtHandler_Disconnect",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
18105 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18106 if (!SWIG_IsOK(res1)) {
18107 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler_Disconnect" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18108 }
18109 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18110 ecode2 = SWIG_AsVal_int(obj1, &val2);
18111 if (!SWIG_IsOK(ecode2)) {
18112 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EvtHandler_Disconnect" "', expected argument " "2"" of type '" "int""'");
18113 }
18114 arg2 = static_cast< int >(val2);
18115 if (obj2) {
18116 ecode3 = SWIG_AsVal_int(obj2, &val3);
18117 if (!SWIG_IsOK(ecode3)) {
18118 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler_Disconnect" "', expected argument " "3"" of type '" "int""'");
18119 }
18120 arg3 = static_cast< int >(val3);
18121 }
18122 if (obj3) {
18123 ecode4 = SWIG_AsVal_int(obj3, &val4);
18124 if (!SWIG_IsOK(ecode4)) {
18125 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "EvtHandler_Disconnect" "', expected argument " "4"" of type '" "wxEventType""'");
18126 }
18127 arg4 = static_cast< wxEventType >(val4);
18128 }
18129 {
18130 PyThreadState* __tstate = wxPyBeginAllowThreads();
18131 result = (bool)wxEvtHandler_Disconnect(arg1,arg2,arg3,arg4);
18132 wxPyEndAllowThreads(__tstate);
18133 if (PyErr_Occurred()) SWIG_fail;
18134 }
18135 {
18136 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18137 }
18138 return resultobj;
18139 fail:
18140 return NULL;
18141 }
18142
18143
18144 SWIGINTERN PyObject *_wrap_EvtHandler__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18145 PyObject *resultobj = 0;
18146 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
18147 PyObject *arg2 = (PyObject *) 0 ;
18148 bool arg3 = (bool) true ;
18149 void *argp1 = 0 ;
18150 int res1 = 0 ;
18151 bool val3 ;
18152 int ecode3 = 0 ;
18153 PyObject * obj0 = 0 ;
18154 PyObject * obj1 = 0 ;
18155 PyObject * obj2 = 0 ;
18156 char * kwnames[] = {
18157 (char *) "self",(char *) "_self",(char *) "incref", NULL
18158 };
18159
18160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:EvtHandler__setOORInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
18161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
18162 if (!SWIG_IsOK(res1)) {
18163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EvtHandler__setOORInfo" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
18164 }
18165 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
18166 arg2 = obj1;
18167 if (obj2) {
18168 ecode3 = SWIG_AsVal_bool(obj2, &val3);
18169 if (!SWIG_IsOK(ecode3)) {
18170 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "EvtHandler__setOORInfo" "', expected argument " "3"" of type '" "bool""'");
18171 }
18172 arg3 = static_cast< bool >(val3);
18173 }
18174 {
18175 PyThreadState* __tstate = wxPyBeginAllowThreads();
18176 wxEvtHandler__setOORInfo(arg1,arg2,arg3);
18177 wxPyEndAllowThreads(__tstate);
18178 if (PyErr_Occurred()) SWIG_fail;
18179 }
18180 resultobj = SWIG_Py_Void();
18181 return resultobj;
18182 fail:
18183 return NULL;
18184 }
18185
18186
18187 SWIGINTERN PyObject *EvtHandler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18188 PyObject *obj;
18189 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18190 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvtHandler, SWIG_NewClientData(obj));
18191 return SWIG_Py_Void();
18192 }
18193
18194 SWIGINTERN PyObject *EvtHandler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18195 return SWIG_Python_InitShadowInstance(args);
18196 }
18197
18198 SWIGINTERN PyObject *_wrap_NewEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18199 PyObject *resultobj = 0;
18200 wxEventType result;
18201
18202 if (!SWIG_Python_UnpackTuple(args,"NewEventType",0,0,0)) SWIG_fail;
18203 {
18204 PyThreadState* __tstate = wxPyBeginAllowThreads();
18205 result = (wxEventType)wxNewEventType();
18206 wxPyEndAllowThreads(__tstate);
18207 if (PyErr_Occurred()) SWIG_fail;
18208 }
18209 resultobj = SWIG_From_int(static_cast< int >(result));
18210 return resultobj;
18211 fail:
18212 return NULL;
18213 }
18214
18215
18216 SWIGINTERN PyObject *_wrap_delete_Event(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18217 PyObject *resultobj = 0;
18218 wxEvent *arg1 = (wxEvent *) 0 ;
18219 void *argp1 = 0 ;
18220 int res1 = 0 ;
18221 PyObject *swig_obj[1] ;
18222
18223 if (!args) SWIG_fail;
18224 swig_obj[0] = args;
18225 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, SWIG_POINTER_DISOWN | 0 );
18226 if (!SWIG_IsOK(res1)) {
18227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Event" "', expected argument " "1"" of type '" "wxEvent *""'");
18228 }
18229 arg1 = reinterpret_cast< wxEvent * >(argp1);
18230 {
18231 PyThreadState* __tstate = wxPyBeginAllowThreads();
18232 delete arg1;
18233
18234 wxPyEndAllowThreads(__tstate);
18235 if (PyErr_Occurred()) SWIG_fail;
18236 }
18237 resultobj = SWIG_Py_Void();
18238 return resultobj;
18239 fail:
18240 return NULL;
18241 }
18242
18243
18244 SWIGINTERN PyObject *_wrap_Event_SetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18245 PyObject *resultobj = 0;
18246 wxEvent *arg1 = (wxEvent *) 0 ;
18247 wxEventType arg2 ;
18248 void *argp1 = 0 ;
18249 int res1 = 0 ;
18250 int val2 ;
18251 int ecode2 = 0 ;
18252 PyObject * obj0 = 0 ;
18253 PyObject * obj1 = 0 ;
18254 char * kwnames[] = {
18255 (char *) "self",(char *) "typ", NULL
18256 };
18257
18258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventType",kwnames,&obj0,&obj1)) SWIG_fail;
18259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18260 if (!SWIG_IsOK(res1)) {
18261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventType" "', expected argument " "1"" of type '" "wxEvent *""'");
18262 }
18263 arg1 = reinterpret_cast< wxEvent * >(argp1);
18264 ecode2 = SWIG_AsVal_int(obj1, &val2);
18265 if (!SWIG_IsOK(ecode2)) {
18266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetEventType" "', expected argument " "2"" of type '" "wxEventType""'");
18267 }
18268 arg2 = static_cast< wxEventType >(val2);
18269 {
18270 PyThreadState* __tstate = wxPyBeginAllowThreads();
18271 (arg1)->SetEventType(arg2);
18272 wxPyEndAllowThreads(__tstate);
18273 if (PyErr_Occurred()) SWIG_fail;
18274 }
18275 resultobj = SWIG_Py_Void();
18276 return resultobj;
18277 fail:
18278 return NULL;
18279 }
18280
18281
18282 SWIGINTERN PyObject *_wrap_Event_GetEventType(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18283 PyObject *resultobj = 0;
18284 wxEvent *arg1 = (wxEvent *) 0 ;
18285 wxEventType result;
18286 void *argp1 = 0 ;
18287 int res1 = 0 ;
18288 PyObject *swig_obj[1] ;
18289
18290 if (!args) SWIG_fail;
18291 swig_obj[0] = args;
18292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18293 if (!SWIG_IsOK(res1)) {
18294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventType" "', expected argument " "1"" of type '" "wxEvent const *""'");
18295 }
18296 arg1 = reinterpret_cast< wxEvent * >(argp1);
18297 {
18298 PyThreadState* __tstate = wxPyBeginAllowThreads();
18299 result = (wxEventType)((wxEvent const *)arg1)->GetEventType();
18300 wxPyEndAllowThreads(__tstate);
18301 if (PyErr_Occurred()) SWIG_fail;
18302 }
18303 resultobj = SWIG_From_int(static_cast< int >(result));
18304 return resultobj;
18305 fail:
18306 return NULL;
18307 }
18308
18309
18310 SWIGINTERN PyObject *_wrap_Event_GetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18311 PyObject *resultobj = 0;
18312 wxEvent *arg1 = (wxEvent *) 0 ;
18313 wxObject *result = 0 ;
18314 void *argp1 = 0 ;
18315 int res1 = 0 ;
18316 PyObject *swig_obj[1] ;
18317
18318 if (!args) SWIG_fail;
18319 swig_obj[0] = args;
18320 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18321 if (!SWIG_IsOK(res1)) {
18322 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetEventObject" "', expected argument " "1"" of type '" "wxEvent const *""'");
18323 }
18324 arg1 = reinterpret_cast< wxEvent * >(argp1);
18325 {
18326 PyThreadState* __tstate = wxPyBeginAllowThreads();
18327 result = (wxObject *)((wxEvent const *)arg1)->GetEventObject();
18328 wxPyEndAllowThreads(__tstate);
18329 if (PyErr_Occurred()) SWIG_fail;
18330 }
18331 {
18332 resultobj = wxPyMake_wxObject(result, (bool)0);
18333 }
18334 return resultobj;
18335 fail:
18336 return NULL;
18337 }
18338
18339
18340 SWIGINTERN PyObject *_wrap_Event_SetEventObject(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18341 PyObject *resultobj = 0;
18342 wxEvent *arg1 = (wxEvent *) 0 ;
18343 wxObject *arg2 = (wxObject *) 0 ;
18344 void *argp1 = 0 ;
18345 int res1 = 0 ;
18346 void *argp2 = 0 ;
18347 int res2 = 0 ;
18348 PyObject * obj0 = 0 ;
18349 PyObject * obj1 = 0 ;
18350 char * kwnames[] = {
18351 (char *) "self",(char *) "obj", NULL
18352 };
18353
18354 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetEventObject",kwnames,&obj0,&obj1)) SWIG_fail;
18355 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18356 if (!SWIG_IsOK(res1)) {
18357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetEventObject" "', expected argument " "1"" of type '" "wxEvent *""'");
18358 }
18359 arg1 = reinterpret_cast< wxEvent * >(argp1);
18360 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxObject, 0 | 0 );
18361 if (!SWIG_IsOK(res2)) {
18362 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Event_SetEventObject" "', expected argument " "2"" of type '" "wxObject *""'");
18363 }
18364 arg2 = reinterpret_cast< wxObject * >(argp2);
18365 {
18366 PyThreadState* __tstate = wxPyBeginAllowThreads();
18367 (arg1)->SetEventObject(arg2);
18368 wxPyEndAllowThreads(__tstate);
18369 if (PyErr_Occurred()) SWIG_fail;
18370 }
18371 resultobj = SWIG_Py_Void();
18372 return resultobj;
18373 fail:
18374 return NULL;
18375 }
18376
18377
18378 SWIGINTERN PyObject *_wrap_Event_GetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18379 PyObject *resultobj = 0;
18380 wxEvent *arg1 = (wxEvent *) 0 ;
18381 long result;
18382 void *argp1 = 0 ;
18383 int res1 = 0 ;
18384 PyObject *swig_obj[1] ;
18385
18386 if (!args) SWIG_fail;
18387 swig_obj[0] = args;
18388 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18389 if (!SWIG_IsOK(res1)) {
18390 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetTimestamp" "', expected argument " "1"" of type '" "wxEvent const *""'");
18391 }
18392 arg1 = reinterpret_cast< wxEvent * >(argp1);
18393 {
18394 PyThreadState* __tstate = wxPyBeginAllowThreads();
18395 result = (long)((wxEvent const *)arg1)->GetTimestamp();
18396 wxPyEndAllowThreads(__tstate);
18397 if (PyErr_Occurred()) SWIG_fail;
18398 }
18399 resultobj = SWIG_From_long(static_cast< long >(result));
18400 return resultobj;
18401 fail:
18402 return NULL;
18403 }
18404
18405
18406 SWIGINTERN PyObject *_wrap_Event_SetTimestamp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18407 PyObject *resultobj = 0;
18408 wxEvent *arg1 = (wxEvent *) 0 ;
18409 long arg2 = (long) 0 ;
18410 void *argp1 = 0 ;
18411 int res1 = 0 ;
18412 long val2 ;
18413 int ecode2 = 0 ;
18414 PyObject * obj0 = 0 ;
18415 PyObject * obj1 = 0 ;
18416 char * kwnames[] = {
18417 (char *) "self",(char *) "ts", NULL
18418 };
18419
18420 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_SetTimestamp",kwnames,&obj0,&obj1)) SWIG_fail;
18421 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18422 if (!SWIG_IsOK(res1)) {
18423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetTimestamp" "', expected argument " "1"" of type '" "wxEvent *""'");
18424 }
18425 arg1 = reinterpret_cast< wxEvent * >(argp1);
18426 if (obj1) {
18427 ecode2 = SWIG_AsVal_long(obj1, &val2);
18428 if (!SWIG_IsOK(ecode2)) {
18429 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetTimestamp" "', expected argument " "2"" of type '" "long""'");
18430 }
18431 arg2 = static_cast< long >(val2);
18432 }
18433 {
18434 PyThreadState* __tstate = wxPyBeginAllowThreads();
18435 (arg1)->SetTimestamp(arg2);
18436 wxPyEndAllowThreads(__tstate);
18437 if (PyErr_Occurred()) SWIG_fail;
18438 }
18439 resultobj = SWIG_Py_Void();
18440 return resultobj;
18441 fail:
18442 return NULL;
18443 }
18444
18445
18446 SWIGINTERN PyObject *_wrap_Event_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18447 PyObject *resultobj = 0;
18448 wxEvent *arg1 = (wxEvent *) 0 ;
18449 int result;
18450 void *argp1 = 0 ;
18451 int res1 = 0 ;
18452 PyObject *swig_obj[1] ;
18453
18454 if (!args) SWIG_fail;
18455 swig_obj[0] = args;
18456 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18457 if (!SWIG_IsOK(res1)) {
18458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetId" "', expected argument " "1"" of type '" "wxEvent const *""'");
18459 }
18460 arg1 = reinterpret_cast< wxEvent * >(argp1);
18461 {
18462 PyThreadState* __tstate = wxPyBeginAllowThreads();
18463 result = (int)((wxEvent const *)arg1)->GetId();
18464 wxPyEndAllowThreads(__tstate);
18465 if (PyErr_Occurred()) SWIG_fail;
18466 }
18467 resultobj = SWIG_From_int(static_cast< int >(result));
18468 return resultobj;
18469 fail:
18470 return NULL;
18471 }
18472
18473
18474 SWIGINTERN PyObject *_wrap_Event_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18475 PyObject *resultobj = 0;
18476 wxEvent *arg1 = (wxEvent *) 0 ;
18477 int arg2 ;
18478 void *argp1 = 0 ;
18479 int res1 = 0 ;
18480 int val2 ;
18481 int ecode2 = 0 ;
18482 PyObject * obj0 = 0 ;
18483 PyObject * obj1 = 0 ;
18484 char * kwnames[] = {
18485 (char *) "self",(char *) "Id", NULL
18486 };
18487
18488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
18489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18490 if (!SWIG_IsOK(res1)) {
18491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_SetId" "', expected argument " "1"" of type '" "wxEvent *""'");
18492 }
18493 arg1 = reinterpret_cast< wxEvent * >(argp1);
18494 ecode2 = SWIG_AsVal_int(obj1, &val2);
18495 if (!SWIG_IsOK(ecode2)) {
18496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_SetId" "', expected argument " "2"" of type '" "int""'");
18497 }
18498 arg2 = static_cast< int >(val2);
18499 {
18500 PyThreadState* __tstate = wxPyBeginAllowThreads();
18501 (arg1)->SetId(arg2);
18502 wxPyEndAllowThreads(__tstate);
18503 if (PyErr_Occurred()) SWIG_fail;
18504 }
18505 resultobj = SWIG_Py_Void();
18506 return resultobj;
18507 fail:
18508 return NULL;
18509 }
18510
18511
18512 SWIGINTERN PyObject *_wrap_Event_IsCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18513 PyObject *resultobj = 0;
18514 wxEvent *arg1 = (wxEvent *) 0 ;
18515 bool result;
18516 void *argp1 = 0 ;
18517 int res1 = 0 ;
18518 PyObject *swig_obj[1] ;
18519
18520 if (!args) SWIG_fail;
18521 swig_obj[0] = args;
18522 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18523 if (!SWIG_IsOK(res1)) {
18524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_IsCommandEvent" "', expected argument " "1"" of type '" "wxEvent const *""'");
18525 }
18526 arg1 = reinterpret_cast< wxEvent * >(argp1);
18527 {
18528 PyThreadState* __tstate = wxPyBeginAllowThreads();
18529 result = (bool)((wxEvent const *)arg1)->IsCommandEvent();
18530 wxPyEndAllowThreads(__tstate);
18531 if (PyErr_Occurred()) SWIG_fail;
18532 }
18533 {
18534 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18535 }
18536 return resultobj;
18537 fail:
18538 return NULL;
18539 }
18540
18541
18542 SWIGINTERN PyObject *_wrap_Event_Skip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18543 PyObject *resultobj = 0;
18544 wxEvent *arg1 = (wxEvent *) 0 ;
18545 bool arg2 = (bool) true ;
18546 void *argp1 = 0 ;
18547 int res1 = 0 ;
18548 bool val2 ;
18549 int ecode2 = 0 ;
18550 PyObject * obj0 = 0 ;
18551 PyObject * obj1 = 0 ;
18552 char * kwnames[] = {
18553 (char *) "self",(char *) "skip", NULL
18554 };
18555
18556 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Event_Skip",kwnames,&obj0,&obj1)) SWIG_fail;
18557 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18558 if (!SWIG_IsOK(res1)) {
18559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Skip" "', expected argument " "1"" of type '" "wxEvent *""'");
18560 }
18561 arg1 = reinterpret_cast< wxEvent * >(argp1);
18562 if (obj1) {
18563 ecode2 = SWIG_AsVal_bool(obj1, &val2);
18564 if (!SWIG_IsOK(ecode2)) {
18565 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_Skip" "', expected argument " "2"" of type '" "bool""'");
18566 }
18567 arg2 = static_cast< bool >(val2);
18568 }
18569 {
18570 PyThreadState* __tstate = wxPyBeginAllowThreads();
18571 (arg1)->Skip(arg2);
18572 wxPyEndAllowThreads(__tstate);
18573 if (PyErr_Occurred()) SWIG_fail;
18574 }
18575 resultobj = SWIG_Py_Void();
18576 return resultobj;
18577 fail:
18578 return NULL;
18579 }
18580
18581
18582 SWIGINTERN PyObject *_wrap_Event_GetSkipped(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18583 PyObject *resultobj = 0;
18584 wxEvent *arg1 = (wxEvent *) 0 ;
18585 bool result;
18586 void *argp1 = 0 ;
18587 int res1 = 0 ;
18588 PyObject *swig_obj[1] ;
18589
18590 if (!args) SWIG_fail;
18591 swig_obj[0] = args;
18592 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18593 if (!SWIG_IsOK(res1)) {
18594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_GetSkipped" "', expected argument " "1"" of type '" "wxEvent const *""'");
18595 }
18596 arg1 = reinterpret_cast< wxEvent * >(argp1);
18597 {
18598 PyThreadState* __tstate = wxPyBeginAllowThreads();
18599 result = (bool)((wxEvent const *)arg1)->GetSkipped();
18600 wxPyEndAllowThreads(__tstate);
18601 if (PyErr_Occurred()) SWIG_fail;
18602 }
18603 {
18604 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18605 }
18606 return resultobj;
18607 fail:
18608 return NULL;
18609 }
18610
18611
18612 SWIGINTERN PyObject *_wrap_Event_ShouldPropagate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18613 PyObject *resultobj = 0;
18614 wxEvent *arg1 = (wxEvent *) 0 ;
18615 bool result;
18616 void *argp1 = 0 ;
18617 int res1 = 0 ;
18618 PyObject *swig_obj[1] ;
18619
18620 if (!args) SWIG_fail;
18621 swig_obj[0] = args;
18622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18623 if (!SWIG_IsOK(res1)) {
18624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ShouldPropagate" "', expected argument " "1"" of type '" "wxEvent const *""'");
18625 }
18626 arg1 = reinterpret_cast< wxEvent * >(argp1);
18627 {
18628 PyThreadState* __tstate = wxPyBeginAllowThreads();
18629 result = (bool)((wxEvent const *)arg1)->ShouldPropagate();
18630 wxPyEndAllowThreads(__tstate);
18631 if (PyErr_Occurred()) SWIG_fail;
18632 }
18633 {
18634 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
18635 }
18636 return resultobj;
18637 fail:
18638 return NULL;
18639 }
18640
18641
18642 SWIGINTERN PyObject *_wrap_Event_StopPropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18643 PyObject *resultobj = 0;
18644 wxEvent *arg1 = (wxEvent *) 0 ;
18645 int result;
18646 void *argp1 = 0 ;
18647 int res1 = 0 ;
18648 PyObject *swig_obj[1] ;
18649
18650 if (!args) SWIG_fail;
18651 swig_obj[0] = args;
18652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18653 if (!SWIG_IsOK(res1)) {
18654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_StopPropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18655 }
18656 arg1 = reinterpret_cast< wxEvent * >(argp1);
18657 {
18658 PyThreadState* __tstate = wxPyBeginAllowThreads();
18659 result = (int)(arg1)->StopPropagation();
18660 wxPyEndAllowThreads(__tstate);
18661 if (PyErr_Occurred()) SWIG_fail;
18662 }
18663 resultobj = SWIG_From_int(static_cast< int >(result));
18664 return resultobj;
18665 fail:
18666 return NULL;
18667 }
18668
18669
18670 SWIGINTERN PyObject *_wrap_Event_ResumePropagation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18671 PyObject *resultobj = 0;
18672 wxEvent *arg1 = (wxEvent *) 0 ;
18673 int arg2 ;
18674 void *argp1 = 0 ;
18675 int res1 = 0 ;
18676 int val2 ;
18677 int ecode2 = 0 ;
18678 PyObject * obj0 = 0 ;
18679 PyObject * obj1 = 0 ;
18680 char * kwnames[] = {
18681 (char *) "self",(char *) "propagationLevel", NULL
18682 };
18683
18684 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Event_ResumePropagation",kwnames,&obj0,&obj1)) SWIG_fail;
18685 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18686 if (!SWIG_IsOK(res1)) {
18687 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_ResumePropagation" "', expected argument " "1"" of type '" "wxEvent *""'");
18688 }
18689 arg1 = reinterpret_cast< wxEvent * >(argp1);
18690 ecode2 = SWIG_AsVal_int(obj1, &val2);
18691 if (!SWIG_IsOK(ecode2)) {
18692 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Event_ResumePropagation" "', expected argument " "2"" of type '" "int""'");
18693 }
18694 arg2 = static_cast< int >(val2);
18695 {
18696 PyThreadState* __tstate = wxPyBeginAllowThreads();
18697 (arg1)->ResumePropagation(arg2);
18698 wxPyEndAllowThreads(__tstate);
18699 if (PyErr_Occurred()) SWIG_fail;
18700 }
18701 resultobj = SWIG_Py_Void();
18702 return resultobj;
18703 fail:
18704 return NULL;
18705 }
18706
18707
18708 SWIGINTERN PyObject *_wrap_Event_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18709 PyObject *resultobj = 0;
18710 wxEvent *arg1 = (wxEvent *) 0 ;
18711 wxEvent *result = 0 ;
18712 void *argp1 = 0 ;
18713 int res1 = 0 ;
18714 PyObject *swig_obj[1] ;
18715
18716 if (!args) SWIG_fail;
18717 swig_obj[0] = args;
18718 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEvent, 0 | 0 );
18719 if (!SWIG_IsOK(res1)) {
18720 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Event_Clone" "', expected argument " "1"" of type '" "wxEvent *""'");
18721 }
18722 arg1 = reinterpret_cast< wxEvent * >(argp1);
18723 {
18724 PyThreadState* __tstate = wxPyBeginAllowThreads();
18725 result = (wxEvent *)(arg1)->Clone();
18726 wxPyEndAllowThreads(__tstate);
18727 if (PyErr_Occurred()) SWIG_fail;
18728 }
18729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
18730 return resultobj;
18731 fail:
18732 return NULL;
18733 }
18734
18735
18736 SWIGINTERN PyObject *Event_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18737 PyObject *obj;
18738 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18739 SWIG_TypeNewClientData(SWIGTYPE_p_wxEvent, SWIG_NewClientData(obj));
18740 return SWIG_Py_Void();
18741 }
18742
18743 SWIGINTERN PyObject *_wrap_new_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18744 PyObject *resultobj = 0;
18745 wxEvent *arg1 = 0 ;
18746 wxPropagationDisabler *result = 0 ;
18747 void *argp1 = 0 ;
18748 int res1 = 0 ;
18749 PyObject * obj0 = 0 ;
18750 char * kwnames[] = {
18751 (char *) "event", NULL
18752 };
18753
18754 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagationDisabler",kwnames,&obj0)) SWIG_fail;
18755 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18756 if (!SWIG_IsOK(res1)) {
18757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18758 }
18759 if (!argp1) {
18760 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagationDisabler" "', expected argument " "1"" of type '" "wxEvent &""'");
18761 }
18762 arg1 = reinterpret_cast< wxEvent * >(argp1);
18763 {
18764 PyThreadState* __tstate = wxPyBeginAllowThreads();
18765 result = (wxPropagationDisabler *)new wxPropagationDisabler(*arg1);
18766 wxPyEndAllowThreads(__tstate);
18767 if (PyErr_Occurred()) SWIG_fail;
18768 }
18769 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_NEW | 0 );
18770 return resultobj;
18771 fail:
18772 return NULL;
18773 }
18774
18775
18776 SWIGINTERN PyObject *_wrap_delete_PropagationDisabler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18777 PyObject *resultobj = 0;
18778 wxPropagationDisabler *arg1 = (wxPropagationDisabler *) 0 ;
18779 void *argp1 = 0 ;
18780 int res1 = 0 ;
18781 PyObject *swig_obj[1] ;
18782
18783 if (!args) SWIG_fail;
18784 swig_obj[0] = args;
18785 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagationDisabler, SWIG_POINTER_DISOWN | 0 );
18786 if (!SWIG_IsOK(res1)) {
18787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagationDisabler" "', expected argument " "1"" of type '" "wxPropagationDisabler *""'");
18788 }
18789 arg1 = reinterpret_cast< wxPropagationDisabler * >(argp1);
18790 {
18791 PyThreadState* __tstate = wxPyBeginAllowThreads();
18792 delete arg1;
18793
18794 wxPyEndAllowThreads(__tstate);
18795 if (PyErr_Occurred()) SWIG_fail;
18796 }
18797 resultobj = SWIG_Py_Void();
18798 return resultobj;
18799 fail:
18800 return NULL;
18801 }
18802
18803
18804 SWIGINTERN PyObject *PropagationDisabler_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18805 PyObject *obj;
18806 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18807 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagationDisabler, SWIG_NewClientData(obj));
18808 return SWIG_Py_Void();
18809 }
18810
18811 SWIGINTERN PyObject *PropagationDisabler_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18812 return SWIG_Python_InitShadowInstance(args);
18813 }
18814
18815 SWIGINTERN PyObject *_wrap_new_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18816 PyObject *resultobj = 0;
18817 wxEvent *arg1 = 0 ;
18818 wxPropagateOnce *result = 0 ;
18819 void *argp1 = 0 ;
18820 int res1 = 0 ;
18821 PyObject * obj0 = 0 ;
18822 char * kwnames[] = {
18823 (char *) "event", NULL
18824 };
18825
18826 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_PropagateOnce",kwnames,&obj0)) SWIG_fail;
18827 res1 = SWIG_ConvertPtr(obj0, &argp1, SWIGTYPE_p_wxEvent, 0 );
18828 if (!SWIG_IsOK(res1)) {
18829 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18830 }
18831 if (!argp1) {
18832 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_PropagateOnce" "', expected argument " "1"" of type '" "wxEvent &""'");
18833 }
18834 arg1 = reinterpret_cast< wxEvent * >(argp1);
18835 {
18836 PyThreadState* __tstate = wxPyBeginAllowThreads();
18837 result = (wxPropagateOnce *)new wxPropagateOnce(*arg1);
18838 wxPyEndAllowThreads(__tstate);
18839 if (PyErr_Occurred()) SWIG_fail;
18840 }
18841 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_NEW | 0 );
18842 return resultobj;
18843 fail:
18844 return NULL;
18845 }
18846
18847
18848 SWIGINTERN PyObject *_wrap_delete_PropagateOnce(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18849 PyObject *resultobj = 0;
18850 wxPropagateOnce *arg1 = (wxPropagateOnce *) 0 ;
18851 void *argp1 = 0 ;
18852 int res1 = 0 ;
18853 PyObject *swig_obj[1] ;
18854
18855 if (!args) SWIG_fail;
18856 swig_obj[0] = args;
18857 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPropagateOnce, SWIG_POINTER_DISOWN | 0 );
18858 if (!SWIG_IsOK(res1)) {
18859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PropagateOnce" "', expected argument " "1"" of type '" "wxPropagateOnce *""'");
18860 }
18861 arg1 = reinterpret_cast< wxPropagateOnce * >(argp1);
18862 {
18863 PyThreadState* __tstate = wxPyBeginAllowThreads();
18864 delete arg1;
18865
18866 wxPyEndAllowThreads(__tstate);
18867 if (PyErr_Occurred()) SWIG_fail;
18868 }
18869 resultobj = SWIG_Py_Void();
18870 return resultobj;
18871 fail:
18872 return NULL;
18873 }
18874
18875
18876 SWIGINTERN PyObject *PropagateOnce_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18877 PyObject *obj;
18878 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
18879 SWIG_TypeNewClientData(SWIGTYPE_p_wxPropagateOnce, SWIG_NewClientData(obj));
18880 return SWIG_Py_Void();
18881 }
18882
18883 SWIGINTERN PyObject *PropagateOnce_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18884 return SWIG_Python_InitShadowInstance(args);
18885 }
18886
18887 SWIGINTERN PyObject *_wrap_new_CommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18888 PyObject *resultobj = 0;
18889 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
18890 int arg2 = (int) 0 ;
18891 wxCommandEvent *result = 0 ;
18892 int val1 ;
18893 int ecode1 = 0 ;
18894 int val2 ;
18895 int ecode2 = 0 ;
18896 PyObject * obj0 = 0 ;
18897 PyObject * obj1 = 0 ;
18898 char * kwnames[] = {
18899 (char *) "commandType",(char *) "winid", NULL
18900 };
18901
18902 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
18903 if (obj0) {
18904 ecode1 = SWIG_AsVal_int(obj0, &val1);
18905 if (!SWIG_IsOK(ecode1)) {
18906 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
18907 }
18908 arg1 = static_cast< wxEventType >(val1);
18909 }
18910 if (obj1) {
18911 ecode2 = SWIG_AsVal_int(obj1, &val2);
18912 if (!SWIG_IsOK(ecode2)) {
18913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CommandEvent" "', expected argument " "2"" of type '" "int""'");
18914 }
18915 arg2 = static_cast< int >(val2);
18916 }
18917 {
18918 PyThreadState* __tstate = wxPyBeginAllowThreads();
18919 result = (wxCommandEvent *)new wxCommandEvent(arg1,arg2);
18920 wxPyEndAllowThreads(__tstate);
18921 if (PyErr_Occurred()) SWIG_fail;
18922 }
18923 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCommandEvent, SWIG_POINTER_NEW | 0 );
18924 return resultobj;
18925 fail:
18926 return NULL;
18927 }
18928
18929
18930 SWIGINTERN PyObject *_wrap_CommandEvent_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
18931 PyObject *resultobj = 0;
18932 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18933 int result;
18934 void *argp1 = 0 ;
18935 int res1 = 0 ;
18936 PyObject *swig_obj[1] ;
18937
18938 if (!args) SWIG_fail;
18939 swig_obj[0] = args;
18940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18941 if (!SWIG_IsOK(res1)) {
18942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
18943 }
18944 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18945 {
18946 PyThreadState* __tstate = wxPyBeginAllowThreads();
18947 result = (int)((wxCommandEvent const *)arg1)->GetSelection();
18948 wxPyEndAllowThreads(__tstate);
18949 if (PyErr_Occurred()) SWIG_fail;
18950 }
18951 resultobj = SWIG_From_int(static_cast< int >(result));
18952 return resultobj;
18953 fail:
18954 return NULL;
18955 }
18956
18957
18958 SWIGINTERN PyObject *_wrap_CommandEvent_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
18959 PyObject *resultobj = 0;
18960 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
18961 wxString *arg2 = 0 ;
18962 void *argp1 = 0 ;
18963 int res1 = 0 ;
18964 bool temp2 = false ;
18965 PyObject * obj0 = 0 ;
18966 PyObject * obj1 = 0 ;
18967 char * kwnames[] = {
18968 (char *) "self",(char *) "s", NULL
18969 };
18970
18971 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetString",kwnames,&obj0,&obj1)) SWIG_fail;
18972 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
18973 if (!SWIG_IsOK(res1)) {
18974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetString" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
18975 }
18976 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
18977 {
18978 arg2 = wxString_in_helper(obj1);
18979 if (arg2 == NULL) SWIG_fail;
18980 temp2 = true;
18981 }
18982 {
18983 PyThreadState* __tstate = wxPyBeginAllowThreads();
18984 (arg1)->SetString((wxString const &)*arg2);
18985 wxPyEndAllowThreads(__tstate);
18986 if (PyErr_Occurred()) SWIG_fail;
18987 }
18988 resultobj = SWIG_Py_Void();
18989 {
18990 if (temp2)
18991 delete arg2;
18992 }
18993 return resultobj;
18994 fail:
18995 {
18996 if (temp2)
18997 delete arg2;
18998 }
18999 return NULL;
19000 }
19001
19002
19003 SWIGINTERN PyObject *_wrap_CommandEvent_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19004 PyObject *resultobj = 0;
19005 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19006 wxString result;
19007 void *argp1 = 0 ;
19008 int res1 = 0 ;
19009 PyObject *swig_obj[1] ;
19010
19011 if (!args) SWIG_fail;
19012 swig_obj[0] = args;
19013 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19014 if (!SWIG_IsOK(res1)) {
19015 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetString" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19016 }
19017 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19018 {
19019 PyThreadState* __tstate = wxPyBeginAllowThreads();
19020 result = ((wxCommandEvent const *)arg1)->GetString();
19021 wxPyEndAllowThreads(__tstate);
19022 if (PyErr_Occurred()) SWIG_fail;
19023 }
19024 {
19025 #if wxUSE_UNICODE
19026 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
19027 #else
19028 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
19029 #endif
19030 }
19031 return resultobj;
19032 fail:
19033 return NULL;
19034 }
19035
19036
19037 SWIGINTERN PyObject *_wrap_CommandEvent_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19038 PyObject *resultobj = 0;
19039 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19040 bool result;
19041 void *argp1 = 0 ;
19042 int res1 = 0 ;
19043 PyObject *swig_obj[1] ;
19044
19045 if (!args) SWIG_fail;
19046 swig_obj[0] = args;
19047 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19048 if (!SWIG_IsOK(res1)) {
19049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsChecked" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19050 }
19051 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19052 {
19053 PyThreadState* __tstate = wxPyBeginAllowThreads();
19054 result = (bool)((wxCommandEvent const *)arg1)->IsChecked();
19055 wxPyEndAllowThreads(__tstate);
19056 if (PyErr_Occurred()) SWIG_fail;
19057 }
19058 {
19059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19060 }
19061 return resultobj;
19062 fail:
19063 return NULL;
19064 }
19065
19066
19067 SWIGINTERN PyObject *_wrap_CommandEvent_IsSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19068 PyObject *resultobj = 0;
19069 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19070 bool result;
19071 void *argp1 = 0 ;
19072 int res1 = 0 ;
19073 PyObject *swig_obj[1] ;
19074
19075 if (!args) SWIG_fail;
19076 swig_obj[0] = args;
19077 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19078 if (!SWIG_IsOK(res1)) {
19079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_IsSelection" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19080 }
19081 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19082 {
19083 PyThreadState* __tstate = wxPyBeginAllowThreads();
19084 result = (bool)((wxCommandEvent const *)arg1)->IsSelection();
19085 wxPyEndAllowThreads(__tstate);
19086 if (PyErr_Occurred()) SWIG_fail;
19087 }
19088 {
19089 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19090 }
19091 return resultobj;
19092 fail:
19093 return NULL;
19094 }
19095
19096
19097 SWIGINTERN PyObject *_wrap_CommandEvent_SetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19098 PyObject *resultobj = 0;
19099 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19100 long arg2 ;
19101 void *argp1 = 0 ;
19102 int res1 = 0 ;
19103 long val2 ;
19104 int ecode2 = 0 ;
19105 PyObject * obj0 = 0 ;
19106 PyObject * obj1 = 0 ;
19107 char * kwnames[] = {
19108 (char *) "self",(char *) "extraLong", NULL
19109 };
19110
19111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetExtraLong",kwnames,&obj0,&obj1)) SWIG_fail;
19112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19113 if (!SWIG_IsOK(res1)) {
19114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19115 }
19116 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19117 ecode2 = SWIG_AsVal_long(obj1, &val2);
19118 if (!SWIG_IsOK(ecode2)) {
19119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetExtraLong" "', expected argument " "2"" of type '" "long""'");
19120 }
19121 arg2 = static_cast< long >(val2);
19122 {
19123 PyThreadState* __tstate = wxPyBeginAllowThreads();
19124 (arg1)->SetExtraLong(arg2);
19125 wxPyEndAllowThreads(__tstate);
19126 if (PyErr_Occurred()) SWIG_fail;
19127 }
19128 resultobj = SWIG_Py_Void();
19129 return resultobj;
19130 fail:
19131 return NULL;
19132 }
19133
19134
19135 SWIGINTERN PyObject *_wrap_CommandEvent_GetExtraLong(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19136 PyObject *resultobj = 0;
19137 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19138 long result;
19139 void *argp1 = 0 ;
19140 int res1 = 0 ;
19141 PyObject *swig_obj[1] ;
19142
19143 if (!args) SWIG_fail;
19144 swig_obj[0] = args;
19145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19146 if (!SWIG_IsOK(res1)) {
19147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetExtraLong" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19148 }
19149 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19150 {
19151 PyThreadState* __tstate = wxPyBeginAllowThreads();
19152 result = (long)((wxCommandEvent const *)arg1)->GetExtraLong();
19153 wxPyEndAllowThreads(__tstate);
19154 if (PyErr_Occurred()) SWIG_fail;
19155 }
19156 resultobj = SWIG_From_long(static_cast< long >(result));
19157 return resultobj;
19158 fail:
19159 return NULL;
19160 }
19161
19162
19163 SWIGINTERN PyObject *_wrap_CommandEvent_SetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19164 PyObject *resultobj = 0;
19165 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19166 int arg2 ;
19167 void *argp1 = 0 ;
19168 int res1 = 0 ;
19169 int val2 ;
19170 int ecode2 = 0 ;
19171 PyObject * obj0 = 0 ;
19172 PyObject * obj1 = 0 ;
19173 char * kwnames[] = {
19174 (char *) "self",(char *) "i", NULL
19175 };
19176
19177 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetInt",kwnames,&obj0,&obj1)) SWIG_fail;
19178 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19179 if (!SWIG_IsOK(res1)) {
19180 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetInt" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19181 }
19182 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19183 ecode2 = SWIG_AsVal_int(obj1, &val2);
19184 if (!SWIG_IsOK(ecode2)) {
19185 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CommandEvent_SetInt" "', expected argument " "2"" of type '" "int""'");
19186 }
19187 arg2 = static_cast< int >(val2);
19188 {
19189 PyThreadState* __tstate = wxPyBeginAllowThreads();
19190 (arg1)->SetInt(arg2);
19191 wxPyEndAllowThreads(__tstate);
19192 if (PyErr_Occurred()) SWIG_fail;
19193 }
19194 resultobj = SWIG_Py_Void();
19195 return resultobj;
19196 fail:
19197 return NULL;
19198 }
19199
19200
19201 SWIGINTERN PyObject *_wrap_CommandEvent_GetInt(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19202 PyObject *resultobj = 0;
19203 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19204 int result;
19205 void *argp1 = 0 ;
19206 int res1 = 0 ;
19207 PyObject *swig_obj[1] ;
19208
19209 if (!args) SWIG_fail;
19210 swig_obj[0] = args;
19211 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19212 if (!SWIG_IsOK(res1)) {
19213 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetInt" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19214 }
19215 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19216 {
19217 PyThreadState* __tstate = wxPyBeginAllowThreads();
19218 result = (int)((wxCommandEvent const *)arg1)->GetInt();
19219 wxPyEndAllowThreads(__tstate);
19220 if (PyErr_Occurred()) SWIG_fail;
19221 }
19222 resultobj = SWIG_From_int(static_cast< int >(result));
19223 return resultobj;
19224 fail:
19225 return NULL;
19226 }
19227
19228
19229 SWIGINTERN PyObject *_wrap_CommandEvent_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19230 PyObject *resultobj = 0;
19231 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19232 PyObject *result = 0 ;
19233 void *argp1 = 0 ;
19234 int res1 = 0 ;
19235 PyObject *swig_obj[1] ;
19236
19237 if (!args) SWIG_fail;
19238 swig_obj[0] = args;
19239 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19240 if (!SWIG_IsOK(res1)) {
19241 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_GetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19242 }
19243 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19244 {
19245 PyThreadState* __tstate = wxPyBeginAllowThreads();
19246 result = (PyObject *)wxCommandEvent_GetClientData(arg1);
19247 wxPyEndAllowThreads(__tstate);
19248 if (PyErr_Occurred()) SWIG_fail;
19249 }
19250 resultobj = result;
19251 return resultobj;
19252 fail:
19253 return NULL;
19254 }
19255
19256
19257 SWIGINTERN PyObject *_wrap_CommandEvent_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19258 PyObject *resultobj = 0;
19259 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19260 PyObject *arg2 = (PyObject *) 0 ;
19261 void *argp1 = 0 ;
19262 int res1 = 0 ;
19263 PyObject * obj0 = 0 ;
19264 PyObject * obj1 = 0 ;
19265 char * kwnames[] = {
19266 (char *) "self",(char *) "clientData", NULL
19267 };
19268
19269 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CommandEvent_SetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
19270 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19271 if (!SWIG_IsOK(res1)) {
19272 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_SetClientData" "', expected argument " "1"" of type '" "wxCommandEvent *""'");
19273 }
19274 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19275 arg2 = obj1;
19276 {
19277 PyThreadState* __tstate = wxPyBeginAllowThreads();
19278 wxCommandEvent_SetClientData(arg1,arg2);
19279 wxPyEndAllowThreads(__tstate);
19280 if (PyErr_Occurred()) SWIG_fail;
19281 }
19282 resultobj = SWIG_Py_Void();
19283 return resultobj;
19284 fail:
19285 return NULL;
19286 }
19287
19288
19289 SWIGINTERN PyObject *_wrap_CommandEvent_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19290 PyObject *resultobj = 0;
19291 wxCommandEvent *arg1 = (wxCommandEvent *) 0 ;
19292 wxEvent *result = 0 ;
19293 void *argp1 = 0 ;
19294 int res1 = 0 ;
19295 PyObject *swig_obj[1] ;
19296
19297 if (!args) SWIG_fail;
19298 swig_obj[0] = args;
19299 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCommandEvent, 0 | 0 );
19300 if (!SWIG_IsOK(res1)) {
19301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CommandEvent_Clone" "', expected argument " "1"" of type '" "wxCommandEvent const *""'");
19302 }
19303 arg1 = reinterpret_cast< wxCommandEvent * >(argp1);
19304 {
19305 PyThreadState* __tstate = wxPyBeginAllowThreads();
19306 result = (wxEvent *)((wxCommandEvent const *)arg1)->Clone();
19307 wxPyEndAllowThreads(__tstate);
19308 if (PyErr_Occurred()) SWIG_fail;
19309 }
19310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEvent, 0 | 0 );
19311 return resultobj;
19312 fail:
19313 return NULL;
19314 }
19315
19316
19317 SWIGINTERN PyObject *CommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19318 PyObject *obj;
19319 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19320 SWIG_TypeNewClientData(SWIGTYPE_p_wxCommandEvent, SWIG_NewClientData(obj));
19321 return SWIG_Py_Void();
19322 }
19323
19324 SWIGINTERN PyObject *CommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19325 return SWIG_Python_InitShadowInstance(args);
19326 }
19327
19328 SWIGINTERN PyObject *_wrap_new_NotifyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19329 PyObject *resultobj = 0;
19330 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19331 int arg2 = (int) 0 ;
19332 wxNotifyEvent *result = 0 ;
19333 int val1 ;
19334 int ecode1 = 0 ;
19335 int val2 ;
19336 int ecode2 = 0 ;
19337 PyObject * obj0 = 0 ;
19338 PyObject * obj1 = 0 ;
19339 char * kwnames[] = {
19340 (char *) "commandType",(char *) "winid", NULL
19341 };
19342
19343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_NotifyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
19344 if (obj0) {
19345 ecode1 = SWIG_AsVal_int(obj0, &val1);
19346 if (!SWIG_IsOK(ecode1)) {
19347 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NotifyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19348 }
19349 arg1 = static_cast< wxEventType >(val1);
19350 }
19351 if (obj1) {
19352 ecode2 = SWIG_AsVal_int(obj1, &val2);
19353 if (!SWIG_IsOK(ecode2)) {
19354 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_NotifyEvent" "', expected argument " "2"" of type '" "int""'");
19355 }
19356 arg2 = static_cast< int >(val2);
19357 }
19358 {
19359 PyThreadState* __tstate = wxPyBeginAllowThreads();
19360 result = (wxNotifyEvent *)new wxNotifyEvent(arg1,arg2);
19361 wxPyEndAllowThreads(__tstate);
19362 if (PyErr_Occurred()) SWIG_fail;
19363 }
19364 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNotifyEvent, SWIG_POINTER_NEW | 0 );
19365 return resultobj;
19366 fail:
19367 return NULL;
19368 }
19369
19370
19371 SWIGINTERN PyObject *_wrap_NotifyEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19372 PyObject *resultobj = 0;
19373 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19374 void *argp1 = 0 ;
19375 int res1 = 0 ;
19376 PyObject *swig_obj[1] ;
19377
19378 if (!args) SWIG_fail;
19379 swig_obj[0] = args;
19380 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19381 if (!SWIG_IsOK(res1)) {
19382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Veto" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19383 }
19384 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19385 {
19386 PyThreadState* __tstate = wxPyBeginAllowThreads();
19387 (arg1)->Veto();
19388 wxPyEndAllowThreads(__tstate);
19389 if (PyErr_Occurred()) SWIG_fail;
19390 }
19391 resultobj = SWIG_Py_Void();
19392 return resultobj;
19393 fail:
19394 return NULL;
19395 }
19396
19397
19398 SWIGINTERN PyObject *_wrap_NotifyEvent_Allow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19399 PyObject *resultobj = 0;
19400 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19401 void *argp1 = 0 ;
19402 int res1 = 0 ;
19403 PyObject *swig_obj[1] ;
19404
19405 if (!args) SWIG_fail;
19406 swig_obj[0] = args;
19407 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19408 if (!SWIG_IsOK(res1)) {
19409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_Allow" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19410 }
19411 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19412 {
19413 PyThreadState* __tstate = wxPyBeginAllowThreads();
19414 (arg1)->Allow();
19415 wxPyEndAllowThreads(__tstate);
19416 if (PyErr_Occurred()) SWIG_fail;
19417 }
19418 resultobj = SWIG_Py_Void();
19419 return resultobj;
19420 fail:
19421 return NULL;
19422 }
19423
19424
19425 SWIGINTERN PyObject *_wrap_NotifyEvent_IsAllowed(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19426 PyObject *resultobj = 0;
19427 wxNotifyEvent *arg1 = (wxNotifyEvent *) 0 ;
19428 bool result;
19429 void *argp1 = 0 ;
19430 int res1 = 0 ;
19431 PyObject *swig_obj[1] ;
19432
19433 if (!args) SWIG_fail;
19434 swig_obj[0] = args;
19435 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNotifyEvent, 0 | 0 );
19436 if (!SWIG_IsOK(res1)) {
19437 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NotifyEvent_IsAllowed" "', expected argument " "1"" of type '" "wxNotifyEvent *""'");
19438 }
19439 arg1 = reinterpret_cast< wxNotifyEvent * >(argp1);
19440 {
19441 PyThreadState* __tstate = wxPyBeginAllowThreads();
19442 result = (bool)(arg1)->IsAllowed();
19443 wxPyEndAllowThreads(__tstate);
19444 if (PyErr_Occurred()) SWIG_fail;
19445 }
19446 {
19447 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19448 }
19449 return resultobj;
19450 fail:
19451 return NULL;
19452 }
19453
19454
19455 SWIGINTERN PyObject *NotifyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19456 PyObject *obj;
19457 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19458 SWIG_TypeNewClientData(SWIGTYPE_p_wxNotifyEvent, SWIG_NewClientData(obj));
19459 return SWIG_Py_Void();
19460 }
19461
19462 SWIGINTERN PyObject *NotifyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19463 return SWIG_Python_InitShadowInstance(args);
19464 }
19465
19466 SWIGINTERN PyObject *_wrap_new_ScrollEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19467 PyObject *resultobj = 0;
19468 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19469 int arg2 = (int) 0 ;
19470 int arg3 = (int) 0 ;
19471 int arg4 = (int) 0 ;
19472 wxScrollEvent *result = 0 ;
19473 int val1 ;
19474 int ecode1 = 0 ;
19475 int val2 ;
19476 int ecode2 = 0 ;
19477 int val3 ;
19478 int ecode3 = 0 ;
19479 int val4 ;
19480 int ecode4 = 0 ;
19481 PyObject * obj0 = 0 ;
19482 PyObject * obj1 = 0 ;
19483 PyObject * obj2 = 0 ;
19484 PyObject * obj3 = 0 ;
19485 char * kwnames[] = {
19486 (char *) "commandType",(char *) "winid",(char *) "pos",(char *) "orient", NULL
19487 };
19488
19489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_ScrollEvent",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
19490 if (obj0) {
19491 ecode1 = SWIG_AsVal_int(obj0, &val1);
19492 if (!SWIG_IsOK(ecode1)) {
19493 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19494 }
19495 arg1 = static_cast< wxEventType >(val1);
19496 }
19497 if (obj1) {
19498 ecode2 = SWIG_AsVal_int(obj1, &val2);
19499 if (!SWIG_IsOK(ecode2)) {
19500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollEvent" "', expected argument " "2"" of type '" "int""'");
19501 }
19502 arg2 = static_cast< int >(val2);
19503 }
19504 if (obj2) {
19505 ecode3 = SWIG_AsVal_int(obj2, &val3);
19506 if (!SWIG_IsOK(ecode3)) {
19507 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollEvent" "', expected argument " "3"" of type '" "int""'");
19508 }
19509 arg3 = static_cast< int >(val3);
19510 }
19511 if (obj3) {
19512 ecode4 = SWIG_AsVal_int(obj3, &val4);
19513 if (!SWIG_IsOK(ecode4)) {
19514 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_ScrollEvent" "', expected argument " "4"" of type '" "int""'");
19515 }
19516 arg4 = static_cast< int >(val4);
19517 }
19518 {
19519 PyThreadState* __tstate = wxPyBeginAllowThreads();
19520 result = (wxScrollEvent *)new wxScrollEvent(arg1,arg2,arg3,arg4);
19521 wxPyEndAllowThreads(__tstate);
19522 if (PyErr_Occurred()) SWIG_fail;
19523 }
19524 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollEvent, SWIG_POINTER_NEW | 0 );
19525 return resultobj;
19526 fail:
19527 return NULL;
19528 }
19529
19530
19531 SWIGINTERN PyObject *_wrap_ScrollEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19532 PyObject *resultobj = 0;
19533 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19534 int result;
19535 void *argp1 = 0 ;
19536 int res1 = 0 ;
19537 PyObject *swig_obj[1] ;
19538
19539 if (!args) SWIG_fail;
19540 swig_obj[0] = args;
19541 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19542 if (!SWIG_IsOK(res1)) {
19543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19544 }
19545 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19546 {
19547 PyThreadState* __tstate = wxPyBeginAllowThreads();
19548 result = (int)((wxScrollEvent const *)arg1)->GetOrientation();
19549 wxPyEndAllowThreads(__tstate);
19550 if (PyErr_Occurred()) SWIG_fail;
19551 }
19552 resultobj = SWIG_From_int(static_cast< int >(result));
19553 return resultobj;
19554 fail:
19555 return NULL;
19556 }
19557
19558
19559 SWIGINTERN PyObject *_wrap_ScrollEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19560 PyObject *resultobj = 0;
19561 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19562 int result;
19563 void *argp1 = 0 ;
19564 int res1 = 0 ;
19565 PyObject *swig_obj[1] ;
19566
19567 if (!args) SWIG_fail;
19568 swig_obj[0] = args;
19569 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19570 if (!SWIG_IsOK(res1)) {
19571 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollEvent const *""'");
19572 }
19573 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19574 {
19575 PyThreadState* __tstate = wxPyBeginAllowThreads();
19576 result = (int)((wxScrollEvent const *)arg1)->GetPosition();
19577 wxPyEndAllowThreads(__tstate);
19578 if (PyErr_Occurred()) SWIG_fail;
19579 }
19580 resultobj = SWIG_From_int(static_cast< int >(result));
19581 return resultobj;
19582 fail:
19583 return NULL;
19584 }
19585
19586
19587 SWIGINTERN PyObject *_wrap_ScrollEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19588 PyObject *resultobj = 0;
19589 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19590 int arg2 ;
19591 void *argp1 = 0 ;
19592 int res1 = 0 ;
19593 int val2 ;
19594 int ecode2 = 0 ;
19595 PyObject * obj0 = 0 ;
19596 PyObject * obj1 = 0 ;
19597 char * kwnames[] = {
19598 (char *) "self",(char *) "orient", NULL
19599 };
19600
19601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19603 if (!SWIG_IsOK(res1)) {
19604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19605 }
19606 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19607 ecode2 = SWIG_AsVal_int(obj1, &val2);
19608 if (!SWIG_IsOK(ecode2)) {
19609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19610 }
19611 arg2 = static_cast< int >(val2);
19612 {
19613 PyThreadState* __tstate = wxPyBeginAllowThreads();
19614 (arg1)->SetOrientation(arg2);
19615 wxPyEndAllowThreads(__tstate);
19616 if (PyErr_Occurred()) SWIG_fail;
19617 }
19618 resultobj = SWIG_Py_Void();
19619 return resultobj;
19620 fail:
19621 return NULL;
19622 }
19623
19624
19625 SWIGINTERN PyObject *_wrap_ScrollEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19626 PyObject *resultobj = 0;
19627 wxScrollEvent *arg1 = (wxScrollEvent *) 0 ;
19628 int arg2 ;
19629 void *argp1 = 0 ;
19630 int res1 = 0 ;
19631 int val2 ;
19632 int ecode2 = 0 ;
19633 PyObject * obj0 = 0 ;
19634 PyObject * obj1 = 0 ;
19635 char * kwnames[] = {
19636 (char *) "self",(char *) "pos", NULL
19637 };
19638
19639 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19640 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollEvent, 0 | 0 );
19641 if (!SWIG_IsOK(res1)) {
19642 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollEvent *""'");
19643 }
19644 arg1 = reinterpret_cast< wxScrollEvent * >(argp1);
19645 ecode2 = SWIG_AsVal_int(obj1, &val2);
19646 if (!SWIG_IsOK(ecode2)) {
19647 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19648 }
19649 arg2 = static_cast< int >(val2);
19650 {
19651 PyThreadState* __tstate = wxPyBeginAllowThreads();
19652 (arg1)->SetPosition(arg2);
19653 wxPyEndAllowThreads(__tstate);
19654 if (PyErr_Occurred()) SWIG_fail;
19655 }
19656 resultobj = SWIG_Py_Void();
19657 return resultobj;
19658 fail:
19659 return NULL;
19660 }
19661
19662
19663 SWIGINTERN PyObject *ScrollEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19664 PyObject *obj;
19665 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19666 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollEvent, SWIG_NewClientData(obj));
19667 return SWIG_Py_Void();
19668 }
19669
19670 SWIGINTERN PyObject *ScrollEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19671 return SWIG_Python_InitShadowInstance(args);
19672 }
19673
19674 SWIGINTERN PyObject *_wrap_new_ScrollWinEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19675 PyObject *resultobj = 0;
19676 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19677 int arg2 = (int) 0 ;
19678 int arg3 = (int) 0 ;
19679 wxScrollWinEvent *result = 0 ;
19680 int val1 ;
19681 int ecode1 = 0 ;
19682 int val2 ;
19683 int ecode2 = 0 ;
19684 int val3 ;
19685 int ecode3 = 0 ;
19686 PyObject * obj0 = 0 ;
19687 PyObject * obj1 = 0 ;
19688 PyObject * obj2 = 0 ;
19689 char * kwnames[] = {
19690 (char *) "commandType",(char *) "pos",(char *) "orient", NULL
19691 };
19692
19693 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ScrollWinEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
19694 if (obj0) {
19695 ecode1 = SWIG_AsVal_int(obj0, &val1);
19696 if (!SWIG_IsOK(ecode1)) {
19697 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ScrollWinEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19698 }
19699 arg1 = static_cast< wxEventType >(val1);
19700 }
19701 if (obj1) {
19702 ecode2 = SWIG_AsVal_int(obj1, &val2);
19703 if (!SWIG_IsOK(ecode2)) {
19704 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ScrollWinEvent" "', expected argument " "2"" of type '" "int""'");
19705 }
19706 arg2 = static_cast< int >(val2);
19707 }
19708 if (obj2) {
19709 ecode3 = SWIG_AsVal_int(obj2, &val3);
19710 if (!SWIG_IsOK(ecode3)) {
19711 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ScrollWinEvent" "', expected argument " "3"" of type '" "int""'");
19712 }
19713 arg3 = static_cast< int >(val3);
19714 }
19715 {
19716 PyThreadState* __tstate = wxPyBeginAllowThreads();
19717 result = (wxScrollWinEvent *)new wxScrollWinEvent(arg1,arg2,arg3);
19718 wxPyEndAllowThreads(__tstate);
19719 if (PyErr_Occurred()) SWIG_fail;
19720 }
19721 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxScrollWinEvent, SWIG_POINTER_NEW | 0 );
19722 return resultobj;
19723 fail:
19724 return NULL;
19725 }
19726
19727
19728 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19729 PyObject *resultobj = 0;
19730 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19731 int result;
19732 void *argp1 = 0 ;
19733 int res1 = 0 ;
19734 PyObject *swig_obj[1] ;
19735
19736 if (!args) SWIG_fail;
19737 swig_obj[0] = args;
19738 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19739 if (!SWIG_IsOK(res1)) {
19740 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19741 }
19742 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19743 {
19744 PyThreadState* __tstate = wxPyBeginAllowThreads();
19745 result = (int)((wxScrollWinEvent const *)arg1)->GetOrientation();
19746 wxPyEndAllowThreads(__tstate);
19747 if (PyErr_Occurred()) SWIG_fail;
19748 }
19749 resultobj = SWIG_From_int(static_cast< int >(result));
19750 return resultobj;
19751 fail:
19752 return NULL;
19753 }
19754
19755
19756 SWIGINTERN PyObject *_wrap_ScrollWinEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19757 PyObject *resultobj = 0;
19758 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19759 int result;
19760 void *argp1 = 0 ;
19761 int res1 = 0 ;
19762 PyObject *swig_obj[1] ;
19763
19764 if (!args) SWIG_fail;
19765 swig_obj[0] = args;
19766 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19767 if (!SWIG_IsOK(res1)) {
19768 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_GetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent const *""'");
19769 }
19770 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19771 {
19772 PyThreadState* __tstate = wxPyBeginAllowThreads();
19773 result = (int)((wxScrollWinEvent const *)arg1)->GetPosition();
19774 wxPyEndAllowThreads(__tstate);
19775 if (PyErr_Occurred()) SWIG_fail;
19776 }
19777 resultobj = SWIG_From_int(static_cast< int >(result));
19778 return resultobj;
19779 fail:
19780 return NULL;
19781 }
19782
19783
19784 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19785 PyObject *resultobj = 0;
19786 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19787 int arg2 ;
19788 void *argp1 = 0 ;
19789 int res1 = 0 ;
19790 int val2 ;
19791 int ecode2 = 0 ;
19792 PyObject * obj0 = 0 ;
19793 PyObject * obj1 = 0 ;
19794 char * kwnames[] = {
19795 (char *) "self",(char *) "orient", NULL
19796 };
19797
19798 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
19799 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19800 if (!SWIG_IsOK(res1)) {
19801 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19802 }
19803 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19804 ecode2 = SWIG_AsVal_int(obj1, &val2);
19805 if (!SWIG_IsOK(ecode2)) {
19806 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetOrientation" "', expected argument " "2"" of type '" "int""'");
19807 }
19808 arg2 = static_cast< int >(val2);
19809 {
19810 PyThreadState* __tstate = wxPyBeginAllowThreads();
19811 (arg1)->SetOrientation(arg2);
19812 wxPyEndAllowThreads(__tstate);
19813 if (PyErr_Occurred()) SWIG_fail;
19814 }
19815 resultobj = SWIG_Py_Void();
19816 return resultobj;
19817 fail:
19818 return NULL;
19819 }
19820
19821
19822 SWIGINTERN PyObject *_wrap_ScrollWinEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19823 PyObject *resultobj = 0;
19824 wxScrollWinEvent *arg1 = (wxScrollWinEvent *) 0 ;
19825 int arg2 ;
19826 void *argp1 = 0 ;
19827 int res1 = 0 ;
19828 int val2 ;
19829 int ecode2 = 0 ;
19830 PyObject * obj0 = 0 ;
19831 PyObject * obj1 = 0 ;
19832 char * kwnames[] = {
19833 (char *) "self",(char *) "pos", NULL
19834 };
19835
19836 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ScrollWinEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
19837 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxScrollWinEvent, 0 | 0 );
19838 if (!SWIG_IsOK(res1)) {
19839 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "1"" of type '" "wxScrollWinEvent *""'");
19840 }
19841 arg1 = reinterpret_cast< wxScrollWinEvent * >(argp1);
19842 ecode2 = SWIG_AsVal_int(obj1, &val2);
19843 if (!SWIG_IsOK(ecode2)) {
19844 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ScrollWinEvent_SetPosition" "', expected argument " "2"" of type '" "int""'");
19845 }
19846 arg2 = static_cast< int >(val2);
19847 {
19848 PyThreadState* __tstate = wxPyBeginAllowThreads();
19849 (arg1)->SetPosition(arg2);
19850 wxPyEndAllowThreads(__tstate);
19851 if (PyErr_Occurred()) SWIG_fail;
19852 }
19853 resultobj = SWIG_Py_Void();
19854 return resultobj;
19855 fail:
19856 return NULL;
19857 }
19858
19859
19860 SWIGINTERN PyObject *ScrollWinEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19861 PyObject *obj;
19862 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
19863 SWIG_TypeNewClientData(SWIGTYPE_p_wxScrollWinEvent, SWIG_NewClientData(obj));
19864 return SWIG_Py_Void();
19865 }
19866
19867 SWIGINTERN PyObject *ScrollWinEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19868 return SWIG_Python_InitShadowInstance(args);
19869 }
19870
19871 SWIGINTERN PyObject *_wrap_new_MouseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19872 PyObject *resultobj = 0;
19873 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
19874 wxMouseEvent *result = 0 ;
19875 int val1 ;
19876 int ecode1 = 0 ;
19877 PyObject * obj0 = 0 ;
19878 char * kwnames[] = {
19879 (char *) "mouseType", NULL
19880 };
19881
19882 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseEvent",kwnames,&obj0)) SWIG_fail;
19883 if (obj0) {
19884 ecode1 = SWIG_AsVal_int(obj0, &val1);
19885 if (!SWIG_IsOK(ecode1)) {
19886 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
19887 }
19888 arg1 = static_cast< wxEventType >(val1);
19889 }
19890 {
19891 PyThreadState* __tstate = wxPyBeginAllowThreads();
19892 result = (wxMouseEvent *)new wxMouseEvent(arg1);
19893 wxPyEndAllowThreads(__tstate);
19894 if (PyErr_Occurred()) SWIG_fail;
19895 }
19896 {
19897 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
19898 }
19899 return resultobj;
19900 fail:
19901 return NULL;
19902 }
19903
19904
19905 SWIGINTERN PyObject *_wrap_MouseEvent_IsButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
19906 PyObject *resultobj = 0;
19907 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19908 bool result;
19909 void *argp1 = 0 ;
19910 int res1 = 0 ;
19911 PyObject *swig_obj[1] ;
19912
19913 if (!args) SWIG_fail;
19914 swig_obj[0] = args;
19915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19916 if (!SWIG_IsOK(res1)) {
19917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19918 }
19919 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19920 {
19921 PyThreadState* __tstate = wxPyBeginAllowThreads();
19922 result = (bool)((wxMouseEvent const *)arg1)->IsButton();
19923 wxPyEndAllowThreads(__tstate);
19924 if (PyErr_Occurred()) SWIG_fail;
19925 }
19926 {
19927 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19928 }
19929 return resultobj;
19930 fail:
19931 return NULL;
19932 }
19933
19934
19935 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19936 PyObject *resultobj = 0;
19937 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19938 int arg2 = (int) wxMOUSE_BTN_ANY ;
19939 bool result;
19940 void *argp1 = 0 ;
19941 int res1 = 0 ;
19942 int val2 ;
19943 int ecode2 = 0 ;
19944 PyObject * obj0 = 0 ;
19945 PyObject * obj1 = 0 ;
19946 char * kwnames[] = {
19947 (char *) "self",(char *) "but", NULL
19948 };
19949
19950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDown",kwnames,&obj0,&obj1)) SWIG_fail;
19951 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19952 if (!SWIG_IsOK(res1)) {
19953 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19954 }
19955 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19956 if (obj1) {
19957 ecode2 = SWIG_AsVal_int(obj1, &val2);
19958 if (!SWIG_IsOK(ecode2)) {
19959 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDown" "', expected argument " "2"" of type '" "int""'");
19960 }
19961 arg2 = static_cast< int >(val2);
19962 }
19963 {
19964 PyThreadState* __tstate = wxPyBeginAllowThreads();
19965 result = (bool)((wxMouseEvent const *)arg1)->ButtonDown(arg2);
19966 wxPyEndAllowThreads(__tstate);
19967 if (PyErr_Occurred()) SWIG_fail;
19968 }
19969 {
19970 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
19971 }
19972 return resultobj;
19973 fail:
19974 return NULL;
19975 }
19976
19977
19978 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
19979 PyObject *resultobj = 0;
19980 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
19981 int arg2 = (int) wxMOUSE_BTN_ANY ;
19982 bool result;
19983 void *argp1 = 0 ;
19984 int res1 = 0 ;
19985 int val2 ;
19986 int ecode2 = 0 ;
19987 PyObject * obj0 = 0 ;
19988 PyObject * obj1 = 0 ;
19989 char * kwnames[] = {
19990 (char *) "self",(char *) "but", NULL
19991 };
19992
19993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonDClick",kwnames,&obj0,&obj1)) SWIG_fail;
19994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
19995 if (!SWIG_IsOK(res1)) {
19996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
19997 }
19998 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
19999 if (obj1) {
20000 ecode2 = SWIG_AsVal_int(obj1, &val2);
20001 if (!SWIG_IsOK(ecode2)) {
20002 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonDClick" "', expected argument " "2"" of type '" "int""'");
20003 }
20004 arg2 = static_cast< int >(val2);
20005 }
20006 {
20007 PyThreadState* __tstate = wxPyBeginAllowThreads();
20008 result = (bool)((wxMouseEvent const *)arg1)->ButtonDClick(arg2);
20009 wxPyEndAllowThreads(__tstate);
20010 if (PyErr_Occurred()) SWIG_fail;
20011 }
20012 {
20013 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20014 }
20015 return resultobj;
20016 fail:
20017 return NULL;
20018 }
20019
20020
20021 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20022 PyObject *resultobj = 0;
20023 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20024 int arg2 = (int) wxMOUSE_BTN_ANY ;
20025 bool result;
20026 void *argp1 = 0 ;
20027 int res1 = 0 ;
20028 int val2 ;
20029 int ecode2 = 0 ;
20030 PyObject * obj0 = 0 ;
20031 PyObject * obj1 = 0 ;
20032 char * kwnames[] = {
20033 (char *) "self",(char *) "but", NULL
20034 };
20035
20036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MouseEvent_ButtonUp",kwnames,&obj0,&obj1)) SWIG_fail;
20037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20038 if (!SWIG_IsOK(res1)) {
20039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20040 }
20041 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20042 if (obj1) {
20043 ecode2 = SWIG_AsVal_int(obj1, &val2);
20044 if (!SWIG_IsOK(ecode2)) {
20045 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonUp" "', expected argument " "2"" of type '" "int""'");
20046 }
20047 arg2 = static_cast< int >(val2);
20048 }
20049 {
20050 PyThreadState* __tstate = wxPyBeginAllowThreads();
20051 result = (bool)((wxMouseEvent const *)arg1)->ButtonUp(arg2);
20052 wxPyEndAllowThreads(__tstate);
20053 if (PyErr_Occurred()) SWIG_fail;
20054 }
20055 {
20056 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20057 }
20058 return resultobj;
20059 fail:
20060 return NULL;
20061 }
20062
20063
20064 SWIGINTERN PyObject *_wrap_MouseEvent_Button(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20065 PyObject *resultobj = 0;
20066 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20067 int arg2 ;
20068 bool result;
20069 void *argp1 = 0 ;
20070 int res1 = 0 ;
20071 int val2 ;
20072 int ecode2 = 0 ;
20073 PyObject * obj0 = 0 ;
20074 PyObject * obj1 = 0 ;
20075 char * kwnames[] = {
20076 (char *) "self",(char *) "button", NULL
20077 };
20078
20079 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_Button",kwnames,&obj0,&obj1)) SWIG_fail;
20080 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20081 if (!SWIG_IsOK(res1)) {
20082 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Button" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20083 }
20084 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20085 ecode2 = SWIG_AsVal_int(obj1, &val2);
20086 if (!SWIG_IsOK(ecode2)) {
20087 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_Button" "', expected argument " "2"" of type '" "int""'");
20088 }
20089 arg2 = static_cast< int >(val2);
20090 {
20091 PyThreadState* __tstate = wxPyBeginAllowThreads();
20092 result = (bool)((wxMouseEvent const *)arg1)->Button(arg2);
20093 wxPyEndAllowThreads(__tstate);
20094 if (PyErr_Occurred()) SWIG_fail;
20095 }
20096 {
20097 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20098 }
20099 return resultobj;
20100 fail:
20101 return NULL;
20102 }
20103
20104
20105 SWIGINTERN PyObject *_wrap_MouseEvent_ButtonIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20106 PyObject *resultobj = 0;
20107 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20108 int arg2 ;
20109 bool result;
20110 void *argp1 = 0 ;
20111 int res1 = 0 ;
20112 int val2 ;
20113 int ecode2 = 0 ;
20114 PyObject * obj0 = 0 ;
20115 PyObject * obj1 = 0 ;
20116 char * kwnames[] = {
20117 (char *) "self",(char *) "but", NULL
20118 };
20119
20120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_ButtonIsDown",kwnames,&obj0,&obj1)) SWIG_fail;
20121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20122 if (!SWIG_IsOK(res1)) {
20123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20124 }
20125 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20126 ecode2 = SWIG_AsVal_int(obj1, &val2);
20127 if (!SWIG_IsOK(ecode2)) {
20128 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_ButtonIsDown" "', expected argument " "2"" of type '" "int""'");
20129 }
20130 arg2 = static_cast< int >(val2);
20131 {
20132 PyThreadState* __tstate = wxPyBeginAllowThreads();
20133 result = (bool)((wxMouseEvent const *)arg1)->ButtonIsDown(arg2);
20134 wxPyEndAllowThreads(__tstate);
20135 if (PyErr_Occurred()) SWIG_fail;
20136 }
20137 {
20138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20139 }
20140 return resultobj;
20141 fail:
20142 return NULL;
20143 }
20144
20145
20146 SWIGINTERN PyObject *_wrap_MouseEvent_GetButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20147 PyObject *resultobj = 0;
20148 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20149 int result;
20150 void *argp1 = 0 ;
20151 int res1 = 0 ;
20152 PyObject *swig_obj[1] ;
20153
20154 if (!args) SWIG_fail;
20155 swig_obj[0] = args;
20156 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20157 if (!SWIG_IsOK(res1)) {
20158 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetButton" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20159 }
20160 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20161 {
20162 PyThreadState* __tstate = wxPyBeginAllowThreads();
20163 result = (int)((wxMouseEvent const *)arg1)->GetButton();
20164 wxPyEndAllowThreads(__tstate);
20165 if (PyErr_Occurred()) SWIG_fail;
20166 }
20167 resultobj = SWIG_From_int(static_cast< int >(result));
20168 return resultobj;
20169 fail:
20170 return NULL;
20171 }
20172
20173
20174 SWIGINTERN PyObject *_wrap_MouseEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20175 PyObject *resultobj = 0;
20176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20177 bool result;
20178 void *argp1 = 0 ;
20179 int res1 = 0 ;
20180 PyObject *swig_obj[1] ;
20181
20182 if (!args) SWIG_fail;
20183 swig_obj[0] = args;
20184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20185 if (!SWIG_IsOK(res1)) {
20186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ControlDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20187 }
20188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20189 {
20190 PyThreadState* __tstate = wxPyBeginAllowThreads();
20191 result = (bool)((wxMouseEvent const *)arg1)->ControlDown();
20192 wxPyEndAllowThreads(__tstate);
20193 if (PyErr_Occurred()) SWIG_fail;
20194 }
20195 {
20196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20197 }
20198 return resultobj;
20199 fail:
20200 return NULL;
20201 }
20202
20203
20204 SWIGINTERN PyObject *_wrap_MouseEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20205 PyObject *resultobj = 0;
20206 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20207 bool result;
20208 void *argp1 = 0 ;
20209 int res1 = 0 ;
20210 PyObject *swig_obj[1] ;
20211
20212 if (!args) SWIG_fail;
20213 swig_obj[0] = args;
20214 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20215 if (!SWIG_IsOK(res1)) {
20216 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MetaDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20217 }
20218 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20219 {
20220 PyThreadState* __tstate = wxPyBeginAllowThreads();
20221 result = (bool)((wxMouseEvent const *)arg1)->MetaDown();
20222 wxPyEndAllowThreads(__tstate);
20223 if (PyErr_Occurred()) SWIG_fail;
20224 }
20225 {
20226 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20227 }
20228 return resultobj;
20229 fail:
20230 return NULL;
20231 }
20232
20233
20234 SWIGINTERN PyObject *_wrap_MouseEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20235 PyObject *resultobj = 0;
20236 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20237 bool result;
20238 void *argp1 = 0 ;
20239 int res1 = 0 ;
20240 PyObject *swig_obj[1] ;
20241
20242 if (!args) SWIG_fail;
20243 swig_obj[0] = args;
20244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20245 if (!SWIG_IsOK(res1)) {
20246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_AltDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20247 }
20248 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20249 {
20250 PyThreadState* __tstate = wxPyBeginAllowThreads();
20251 result = (bool)((wxMouseEvent const *)arg1)->AltDown();
20252 wxPyEndAllowThreads(__tstate);
20253 if (PyErr_Occurred()) SWIG_fail;
20254 }
20255 {
20256 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20257 }
20258 return resultobj;
20259 fail:
20260 return NULL;
20261 }
20262
20263
20264 SWIGINTERN PyObject *_wrap_MouseEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20265 PyObject *resultobj = 0;
20266 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20267 bool result;
20268 void *argp1 = 0 ;
20269 int res1 = 0 ;
20270 PyObject *swig_obj[1] ;
20271
20272 if (!args) SWIG_fail;
20273 swig_obj[0] = args;
20274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20275 if (!SWIG_IsOK(res1)) {
20276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_ShiftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20277 }
20278 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20279 {
20280 PyThreadState* __tstate = wxPyBeginAllowThreads();
20281 result = (bool)((wxMouseEvent const *)arg1)->ShiftDown();
20282 wxPyEndAllowThreads(__tstate);
20283 if (PyErr_Occurred()) SWIG_fail;
20284 }
20285 {
20286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20287 }
20288 return resultobj;
20289 fail:
20290 return NULL;
20291 }
20292
20293
20294 SWIGINTERN PyObject *_wrap_MouseEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20295 PyObject *resultobj = 0;
20296 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20297 bool result;
20298 void *argp1 = 0 ;
20299 int res1 = 0 ;
20300 PyObject *swig_obj[1] ;
20301
20302 if (!args) SWIG_fail;
20303 swig_obj[0] = args;
20304 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20305 if (!SWIG_IsOK(res1)) {
20306 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_CmdDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20307 }
20308 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20309 {
20310 PyThreadState* __tstate = wxPyBeginAllowThreads();
20311 result = (bool)((wxMouseEvent const *)arg1)->CmdDown();
20312 wxPyEndAllowThreads(__tstate);
20313 if (PyErr_Occurred()) SWIG_fail;
20314 }
20315 {
20316 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20317 }
20318 return resultobj;
20319 fail:
20320 return NULL;
20321 }
20322
20323
20324 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20325 PyObject *resultobj = 0;
20326 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20327 bool result;
20328 void *argp1 = 0 ;
20329 int res1 = 0 ;
20330 PyObject *swig_obj[1] ;
20331
20332 if (!args) SWIG_fail;
20333 swig_obj[0] = args;
20334 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20335 if (!SWIG_IsOK(res1)) {
20336 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20337 }
20338 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20339 {
20340 PyThreadState* __tstate = wxPyBeginAllowThreads();
20341 result = (bool)((wxMouseEvent const *)arg1)->LeftDown();
20342 wxPyEndAllowThreads(__tstate);
20343 if (PyErr_Occurred()) SWIG_fail;
20344 }
20345 {
20346 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20347 }
20348 return resultobj;
20349 fail:
20350 return NULL;
20351 }
20352
20353
20354 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20355 PyObject *resultobj = 0;
20356 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20357 bool result;
20358 void *argp1 = 0 ;
20359 int res1 = 0 ;
20360 PyObject *swig_obj[1] ;
20361
20362 if (!args) SWIG_fail;
20363 swig_obj[0] = args;
20364 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20365 if (!SWIG_IsOK(res1)) {
20366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20367 }
20368 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20369 {
20370 PyThreadState* __tstate = wxPyBeginAllowThreads();
20371 result = (bool)((wxMouseEvent const *)arg1)->MiddleDown();
20372 wxPyEndAllowThreads(__tstate);
20373 if (PyErr_Occurred()) SWIG_fail;
20374 }
20375 {
20376 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20377 }
20378 return resultobj;
20379 fail:
20380 return NULL;
20381 }
20382
20383
20384 SWIGINTERN PyObject *_wrap_MouseEvent_RightDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20385 PyObject *resultobj = 0;
20386 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20387 bool result;
20388 void *argp1 = 0 ;
20389 int res1 = 0 ;
20390 PyObject *swig_obj[1] ;
20391
20392 if (!args) SWIG_fail;
20393 swig_obj[0] = args;
20394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20395 if (!SWIG_IsOK(res1)) {
20396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDown" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20397 }
20398 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20399 {
20400 PyThreadState* __tstate = wxPyBeginAllowThreads();
20401 result = (bool)((wxMouseEvent const *)arg1)->RightDown();
20402 wxPyEndAllowThreads(__tstate);
20403 if (PyErr_Occurred()) SWIG_fail;
20404 }
20405 {
20406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20407 }
20408 return resultobj;
20409 fail:
20410 return NULL;
20411 }
20412
20413
20414 SWIGINTERN PyObject *_wrap_MouseEvent_LeftUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20415 PyObject *resultobj = 0;
20416 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20417 bool result;
20418 void *argp1 = 0 ;
20419 int res1 = 0 ;
20420 PyObject *swig_obj[1] ;
20421
20422 if (!args) SWIG_fail;
20423 swig_obj[0] = args;
20424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20425 if (!SWIG_IsOK(res1)) {
20426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20427 }
20428 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20429 {
20430 PyThreadState* __tstate = wxPyBeginAllowThreads();
20431 result = (bool)((wxMouseEvent const *)arg1)->LeftUp();
20432 wxPyEndAllowThreads(__tstate);
20433 if (PyErr_Occurred()) SWIG_fail;
20434 }
20435 {
20436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20437 }
20438 return resultobj;
20439 fail:
20440 return NULL;
20441 }
20442
20443
20444 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20445 PyObject *resultobj = 0;
20446 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20447 bool result;
20448 void *argp1 = 0 ;
20449 int res1 = 0 ;
20450 PyObject *swig_obj[1] ;
20451
20452 if (!args) SWIG_fail;
20453 swig_obj[0] = args;
20454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20455 if (!SWIG_IsOK(res1)) {
20456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20457 }
20458 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20459 {
20460 PyThreadState* __tstate = wxPyBeginAllowThreads();
20461 result = (bool)((wxMouseEvent const *)arg1)->MiddleUp();
20462 wxPyEndAllowThreads(__tstate);
20463 if (PyErr_Occurred()) SWIG_fail;
20464 }
20465 {
20466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20467 }
20468 return resultobj;
20469 fail:
20470 return NULL;
20471 }
20472
20473
20474 SWIGINTERN PyObject *_wrap_MouseEvent_RightUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20475 PyObject *resultobj = 0;
20476 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20477 bool result;
20478 void *argp1 = 0 ;
20479 int res1 = 0 ;
20480 PyObject *swig_obj[1] ;
20481
20482 if (!args) SWIG_fail;
20483 swig_obj[0] = args;
20484 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20485 if (!SWIG_IsOK(res1)) {
20486 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightUp" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20487 }
20488 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20489 {
20490 PyThreadState* __tstate = wxPyBeginAllowThreads();
20491 result = (bool)((wxMouseEvent const *)arg1)->RightUp();
20492 wxPyEndAllowThreads(__tstate);
20493 if (PyErr_Occurred()) SWIG_fail;
20494 }
20495 {
20496 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20497 }
20498 return resultobj;
20499 fail:
20500 return NULL;
20501 }
20502
20503
20504 SWIGINTERN PyObject *_wrap_MouseEvent_LeftDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20505 PyObject *resultobj = 0;
20506 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20507 bool result;
20508 void *argp1 = 0 ;
20509 int res1 = 0 ;
20510 PyObject *swig_obj[1] ;
20511
20512 if (!args) SWIG_fail;
20513 swig_obj[0] = args;
20514 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20515 if (!SWIG_IsOK(res1)) {
20516 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20517 }
20518 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20519 {
20520 PyThreadState* __tstate = wxPyBeginAllowThreads();
20521 result = (bool)((wxMouseEvent const *)arg1)->LeftDClick();
20522 wxPyEndAllowThreads(__tstate);
20523 if (PyErr_Occurred()) SWIG_fail;
20524 }
20525 {
20526 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20527 }
20528 return resultobj;
20529 fail:
20530 return NULL;
20531 }
20532
20533
20534 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20535 PyObject *resultobj = 0;
20536 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20537 bool result;
20538 void *argp1 = 0 ;
20539 int res1 = 0 ;
20540 PyObject *swig_obj[1] ;
20541
20542 if (!args) SWIG_fail;
20543 swig_obj[0] = args;
20544 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20545 if (!SWIG_IsOK(res1)) {
20546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20547 }
20548 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20549 {
20550 PyThreadState* __tstate = wxPyBeginAllowThreads();
20551 result = (bool)((wxMouseEvent const *)arg1)->MiddleDClick();
20552 wxPyEndAllowThreads(__tstate);
20553 if (PyErr_Occurred()) SWIG_fail;
20554 }
20555 {
20556 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20557 }
20558 return resultobj;
20559 fail:
20560 return NULL;
20561 }
20562
20563
20564 SWIGINTERN PyObject *_wrap_MouseEvent_RightDClick(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20565 PyObject *resultobj = 0;
20566 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20567 bool result;
20568 void *argp1 = 0 ;
20569 int res1 = 0 ;
20570 PyObject *swig_obj[1] ;
20571
20572 if (!args) SWIG_fail;
20573 swig_obj[0] = args;
20574 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20575 if (!SWIG_IsOK(res1)) {
20576 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightDClick" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20577 }
20578 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20579 {
20580 PyThreadState* __tstate = wxPyBeginAllowThreads();
20581 result = (bool)((wxMouseEvent const *)arg1)->RightDClick();
20582 wxPyEndAllowThreads(__tstate);
20583 if (PyErr_Occurred()) SWIG_fail;
20584 }
20585 {
20586 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20587 }
20588 return resultobj;
20589 fail:
20590 return NULL;
20591 }
20592
20593
20594 SWIGINTERN PyObject *_wrap_MouseEvent_LeftIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20595 PyObject *resultobj = 0;
20596 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20597 bool result;
20598 void *argp1 = 0 ;
20599 int res1 = 0 ;
20600 PyObject *swig_obj[1] ;
20601
20602 if (!args) SWIG_fail;
20603 swig_obj[0] = args;
20604 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20605 if (!SWIG_IsOK(res1)) {
20606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_LeftIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20607 }
20608 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20609 {
20610 PyThreadState* __tstate = wxPyBeginAllowThreads();
20611 result = (bool)(arg1)->LeftIsDown();
20612 wxPyEndAllowThreads(__tstate);
20613 if (PyErr_Occurred()) SWIG_fail;
20614 }
20615 {
20616 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20617 }
20618 return resultobj;
20619 fail:
20620 return NULL;
20621 }
20622
20623
20624 SWIGINTERN PyObject *_wrap_MouseEvent_MiddleIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20625 PyObject *resultobj = 0;
20626 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20627 bool result;
20628 void *argp1 = 0 ;
20629 int res1 = 0 ;
20630 PyObject *swig_obj[1] ;
20631
20632 if (!args) SWIG_fail;
20633 swig_obj[0] = args;
20634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20635 if (!SWIG_IsOK(res1)) {
20636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_MiddleIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20637 }
20638 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20639 {
20640 PyThreadState* __tstate = wxPyBeginAllowThreads();
20641 result = (bool)(arg1)->MiddleIsDown();
20642 wxPyEndAllowThreads(__tstate);
20643 if (PyErr_Occurred()) SWIG_fail;
20644 }
20645 {
20646 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20647 }
20648 return resultobj;
20649 fail:
20650 return NULL;
20651 }
20652
20653
20654 SWIGINTERN PyObject *_wrap_MouseEvent_RightIsDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20655 PyObject *resultobj = 0;
20656 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20657 bool result;
20658 void *argp1 = 0 ;
20659 int res1 = 0 ;
20660 PyObject *swig_obj[1] ;
20661
20662 if (!args) SWIG_fail;
20663 swig_obj[0] = args;
20664 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20665 if (!SWIG_IsOK(res1)) {
20666 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_RightIsDown" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20667 }
20668 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20669 {
20670 PyThreadState* __tstate = wxPyBeginAllowThreads();
20671 result = (bool)(arg1)->RightIsDown();
20672 wxPyEndAllowThreads(__tstate);
20673 if (PyErr_Occurred()) SWIG_fail;
20674 }
20675 {
20676 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20677 }
20678 return resultobj;
20679 fail:
20680 return NULL;
20681 }
20682
20683
20684 SWIGINTERN PyObject *_wrap_MouseEvent_Dragging(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20685 PyObject *resultobj = 0;
20686 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20687 bool result;
20688 void *argp1 = 0 ;
20689 int res1 = 0 ;
20690 PyObject *swig_obj[1] ;
20691
20692 if (!args) SWIG_fail;
20693 swig_obj[0] = args;
20694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20695 if (!SWIG_IsOK(res1)) {
20696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Dragging" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20697 }
20698 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20699 {
20700 PyThreadState* __tstate = wxPyBeginAllowThreads();
20701 result = (bool)((wxMouseEvent const *)arg1)->Dragging();
20702 wxPyEndAllowThreads(__tstate);
20703 if (PyErr_Occurred()) SWIG_fail;
20704 }
20705 {
20706 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20707 }
20708 return resultobj;
20709 fail:
20710 return NULL;
20711 }
20712
20713
20714 SWIGINTERN PyObject *_wrap_MouseEvent_Moving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20715 PyObject *resultobj = 0;
20716 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20717 bool result;
20718 void *argp1 = 0 ;
20719 int res1 = 0 ;
20720 PyObject *swig_obj[1] ;
20721
20722 if (!args) SWIG_fail;
20723 swig_obj[0] = args;
20724 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20725 if (!SWIG_IsOK(res1)) {
20726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Moving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20727 }
20728 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20729 {
20730 PyThreadState* __tstate = wxPyBeginAllowThreads();
20731 result = (bool)((wxMouseEvent const *)arg1)->Moving();
20732 wxPyEndAllowThreads(__tstate);
20733 if (PyErr_Occurred()) SWIG_fail;
20734 }
20735 {
20736 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20737 }
20738 return resultobj;
20739 fail:
20740 return NULL;
20741 }
20742
20743
20744 SWIGINTERN PyObject *_wrap_MouseEvent_Entering(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20745 PyObject *resultobj = 0;
20746 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20747 bool result;
20748 void *argp1 = 0 ;
20749 int res1 = 0 ;
20750 PyObject *swig_obj[1] ;
20751
20752 if (!args) SWIG_fail;
20753 swig_obj[0] = args;
20754 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20755 if (!SWIG_IsOK(res1)) {
20756 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Entering" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20757 }
20758 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20759 {
20760 PyThreadState* __tstate = wxPyBeginAllowThreads();
20761 result = (bool)((wxMouseEvent const *)arg1)->Entering();
20762 wxPyEndAllowThreads(__tstate);
20763 if (PyErr_Occurred()) SWIG_fail;
20764 }
20765 {
20766 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20767 }
20768 return resultobj;
20769 fail:
20770 return NULL;
20771 }
20772
20773
20774 SWIGINTERN PyObject *_wrap_MouseEvent_Leaving(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20775 PyObject *resultobj = 0;
20776 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20777 bool result;
20778 void *argp1 = 0 ;
20779 int res1 = 0 ;
20780 PyObject *swig_obj[1] ;
20781
20782 if (!args) SWIG_fail;
20783 swig_obj[0] = args;
20784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20785 if (!SWIG_IsOK(res1)) {
20786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_Leaving" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20787 }
20788 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20789 {
20790 PyThreadState* __tstate = wxPyBeginAllowThreads();
20791 result = (bool)((wxMouseEvent const *)arg1)->Leaving();
20792 wxPyEndAllowThreads(__tstate);
20793 if (PyErr_Occurred()) SWIG_fail;
20794 }
20795 {
20796 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
20797 }
20798 return resultobj;
20799 fail:
20800 return NULL;
20801 }
20802
20803
20804 SWIGINTERN PyObject *_wrap_MouseEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20805 PyObject *resultobj = 0;
20806 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20807 wxPoint result;
20808 void *argp1 = 0 ;
20809 int res1 = 0 ;
20810 PyObject *swig_obj[1] ;
20811
20812 if (!args) SWIG_fail;
20813 swig_obj[0] = args;
20814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20815 if (!SWIG_IsOK(res1)) {
20816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPosition" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20817 }
20818 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20819 {
20820 PyThreadState* __tstate = wxPyBeginAllowThreads();
20821 result = (arg1)->GetPosition();
20822 wxPyEndAllowThreads(__tstate);
20823 if (PyErr_Occurred()) SWIG_fail;
20824 }
20825 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20826 return resultobj;
20827 fail:
20828 return NULL;
20829 }
20830
20831
20832 SWIGINTERN PyObject *_wrap_MouseEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20833 PyObject *resultobj = 0;
20834 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20835 long *arg2 = (long *) 0 ;
20836 long *arg3 = (long *) 0 ;
20837 void *argp1 = 0 ;
20838 int res1 = 0 ;
20839 long temp2 ;
20840 int res2 = SWIG_TMPOBJ ;
20841 long temp3 ;
20842 int res3 = SWIG_TMPOBJ ;
20843 PyObject *swig_obj[1] ;
20844
20845 arg2 = &temp2;
20846 arg3 = &temp3;
20847 if (!args) SWIG_fail;
20848 swig_obj[0] = args;
20849 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20850 if (!SWIG_IsOK(res1)) {
20851 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
20852 }
20853 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20854 {
20855 PyThreadState* __tstate = wxPyBeginAllowThreads();
20856 (arg1)->GetPosition(arg2,arg3);
20857 wxPyEndAllowThreads(__tstate);
20858 if (PyErr_Occurred()) SWIG_fail;
20859 }
20860 resultobj = SWIG_Py_Void();
20861 if (SWIG_IsTmpObj(res2)) {
20862 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
20863 } else {
20864 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20865 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
20866 }
20867 if (SWIG_IsTmpObj(res3)) {
20868 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
20869 } else {
20870 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
20871 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
20872 }
20873 return resultobj;
20874 fail:
20875 return NULL;
20876 }
20877
20878
20879 SWIGINTERN PyObject *_wrap_MouseEvent_GetLogicalPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
20880 PyObject *resultobj = 0;
20881 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20882 wxDC *arg2 = 0 ;
20883 wxPoint result;
20884 void *argp1 = 0 ;
20885 int res1 = 0 ;
20886 void *argp2 = 0 ;
20887 int res2 = 0 ;
20888 PyObject * obj0 = 0 ;
20889 PyObject * obj1 = 0 ;
20890 char * kwnames[] = {
20891 (char *) "self",(char *) "dc", NULL
20892 };
20893
20894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MouseEvent_GetLogicalPosition",kwnames,&obj0,&obj1)) SWIG_fail;
20895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20896 if (!SWIG_IsOK(res1)) {
20897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20898 }
20899 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20900 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 | 0);
20901 if (!SWIG_IsOK(res2)) {
20902 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20903 }
20904 if (!argp2) {
20905 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MouseEvent_GetLogicalPosition" "', expected argument " "2"" of type '" "wxDC const &""'");
20906 }
20907 arg2 = reinterpret_cast< wxDC * >(argp2);
20908 {
20909 PyThreadState* __tstate = wxPyBeginAllowThreads();
20910 result = ((wxMouseEvent const *)arg1)->GetLogicalPosition((wxDC const &)*arg2);
20911 wxPyEndAllowThreads(__tstate);
20912 if (PyErr_Occurred()) SWIG_fail;
20913 }
20914 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
20915 return resultobj;
20916 fail:
20917 return NULL;
20918 }
20919
20920
20921 SWIGINTERN PyObject *_wrap_MouseEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20922 PyObject *resultobj = 0;
20923 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20924 int result;
20925 void *argp1 = 0 ;
20926 int res1 = 0 ;
20927 PyObject *swig_obj[1] ;
20928
20929 if (!args) SWIG_fail;
20930 swig_obj[0] = args;
20931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20932 if (!SWIG_IsOK(res1)) {
20933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetX" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20934 }
20935 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20936 {
20937 PyThreadState* __tstate = wxPyBeginAllowThreads();
20938 result = (int)((wxMouseEvent const *)arg1)->GetX();
20939 wxPyEndAllowThreads(__tstate);
20940 if (PyErr_Occurred()) SWIG_fail;
20941 }
20942 resultobj = SWIG_From_int(static_cast< int >(result));
20943 return resultobj;
20944 fail:
20945 return NULL;
20946 }
20947
20948
20949 SWIGINTERN PyObject *_wrap_MouseEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20950 PyObject *resultobj = 0;
20951 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20952 int result;
20953 void *argp1 = 0 ;
20954 int res1 = 0 ;
20955 PyObject *swig_obj[1] ;
20956
20957 if (!args) SWIG_fail;
20958 swig_obj[0] = args;
20959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20960 if (!SWIG_IsOK(res1)) {
20961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetY" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20962 }
20963 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20964 {
20965 PyThreadState* __tstate = wxPyBeginAllowThreads();
20966 result = (int)((wxMouseEvent const *)arg1)->GetY();
20967 wxPyEndAllowThreads(__tstate);
20968 if (PyErr_Occurred()) SWIG_fail;
20969 }
20970 resultobj = SWIG_From_int(static_cast< int >(result));
20971 return resultobj;
20972 fail:
20973 return NULL;
20974 }
20975
20976
20977 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelRotation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
20978 PyObject *resultobj = 0;
20979 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
20980 int result;
20981 void *argp1 = 0 ;
20982 int res1 = 0 ;
20983 PyObject *swig_obj[1] ;
20984
20985 if (!args) SWIG_fail;
20986 swig_obj[0] = args;
20987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
20988 if (!SWIG_IsOK(res1)) {
20989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelRotation" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
20990 }
20991 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
20992 {
20993 PyThreadState* __tstate = wxPyBeginAllowThreads();
20994 result = (int)((wxMouseEvent const *)arg1)->GetWheelRotation();
20995 wxPyEndAllowThreads(__tstate);
20996 if (PyErr_Occurred()) SWIG_fail;
20997 }
20998 resultobj = SWIG_From_int(static_cast< int >(result));
20999 return resultobj;
21000 fail:
21001 return NULL;
21002 }
21003
21004
21005 SWIGINTERN PyObject *_wrap_MouseEvent_GetWheelDelta(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21006 PyObject *resultobj = 0;
21007 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21008 int result;
21009 void *argp1 = 0 ;
21010 int res1 = 0 ;
21011 PyObject *swig_obj[1] ;
21012
21013 if (!args) SWIG_fail;
21014 swig_obj[0] = args;
21015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21016 if (!SWIG_IsOK(res1)) {
21017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetWheelDelta" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21018 }
21019 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21020 {
21021 PyThreadState* __tstate = wxPyBeginAllowThreads();
21022 result = (int)((wxMouseEvent const *)arg1)->GetWheelDelta();
21023 wxPyEndAllowThreads(__tstate);
21024 if (PyErr_Occurred()) SWIG_fail;
21025 }
21026 resultobj = SWIG_From_int(static_cast< int >(result));
21027 return resultobj;
21028 fail:
21029 return NULL;
21030 }
21031
21032
21033 SWIGINTERN PyObject *_wrap_MouseEvent_GetLinesPerAction(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21034 PyObject *resultobj = 0;
21035 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21036 int result;
21037 void *argp1 = 0 ;
21038 int res1 = 0 ;
21039 PyObject *swig_obj[1] ;
21040
21041 if (!args) SWIG_fail;
21042 swig_obj[0] = args;
21043 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21044 if (!SWIG_IsOK(res1)) {
21045 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_GetLinesPerAction" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21046 }
21047 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21048 {
21049 PyThreadState* __tstate = wxPyBeginAllowThreads();
21050 result = (int)((wxMouseEvent const *)arg1)->GetLinesPerAction();
21051 wxPyEndAllowThreads(__tstate);
21052 if (PyErr_Occurred()) SWIG_fail;
21053 }
21054 resultobj = SWIG_From_int(static_cast< int >(result));
21055 return resultobj;
21056 fail:
21057 return NULL;
21058 }
21059
21060
21061 SWIGINTERN PyObject *_wrap_MouseEvent_IsPageScroll(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21062 PyObject *resultobj = 0;
21063 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21064 bool result;
21065 void *argp1 = 0 ;
21066 int res1 = 0 ;
21067 PyObject *swig_obj[1] ;
21068
21069 if (!args) SWIG_fail;
21070 swig_obj[0] = args;
21071 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21072 if (!SWIG_IsOK(res1)) {
21073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_IsPageScroll" "', expected argument " "1"" of type '" "wxMouseEvent const *""'");
21074 }
21075 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21076 {
21077 PyThreadState* __tstate = wxPyBeginAllowThreads();
21078 result = (bool)((wxMouseEvent const *)arg1)->IsPageScroll();
21079 wxPyEndAllowThreads(__tstate);
21080 if (PyErr_Occurred()) SWIG_fail;
21081 }
21082 {
21083 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21084 }
21085 return resultobj;
21086 fail:
21087 return NULL;
21088 }
21089
21090
21091 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21092 PyObject *resultobj = 0;
21093 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21094 int arg2 ;
21095 void *argp1 = 0 ;
21096 int res1 = 0 ;
21097 int val2 ;
21098 int ecode2 = 0 ;
21099 PyObject *swig_obj[2] ;
21100
21101 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
21102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21103 if (!SWIG_IsOK(res1)) {
21104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21105 }
21106 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21107 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21108 if (!SWIG_IsOK(ecode2)) {
21109 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
21110 }
21111 arg2 = static_cast< int >(val2);
21112 if (arg1) (arg1)->m_x = arg2;
21113
21114 resultobj = SWIG_Py_Void();
21115 return resultobj;
21116 fail:
21117 return NULL;
21118 }
21119
21120
21121 SWIGINTERN PyObject *_wrap_MouseEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21122 PyObject *resultobj = 0;
21123 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21124 int result;
21125 void *argp1 = 0 ;
21126 int res1 = 0 ;
21127 PyObject *swig_obj[1] ;
21128
21129 if (!args) SWIG_fail;
21130 swig_obj[0] = args;
21131 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21132 if (!SWIG_IsOK(res1)) {
21133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_x_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21134 }
21135 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21136 result = (int) ((arg1)->m_x);
21137 resultobj = SWIG_From_int(static_cast< int >(result));
21138 return resultobj;
21139 fail:
21140 return NULL;
21141 }
21142
21143
21144 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21145 PyObject *resultobj = 0;
21146 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21147 int arg2 ;
21148 void *argp1 = 0 ;
21149 int res1 = 0 ;
21150 int val2 ;
21151 int ecode2 = 0 ;
21152 PyObject *swig_obj[2] ;
21153
21154 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
21155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21156 if (!SWIG_IsOK(res1)) {
21157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21158 }
21159 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21160 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21161 if (!SWIG_IsOK(ecode2)) {
21162 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
21163 }
21164 arg2 = static_cast< int >(val2);
21165 if (arg1) (arg1)->m_y = arg2;
21166
21167 resultobj = SWIG_Py_Void();
21168 return resultobj;
21169 fail:
21170 return NULL;
21171 }
21172
21173
21174 SWIGINTERN PyObject *_wrap_MouseEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21175 PyObject *resultobj = 0;
21176 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21177 int result;
21178 void *argp1 = 0 ;
21179 int res1 = 0 ;
21180 PyObject *swig_obj[1] ;
21181
21182 if (!args) SWIG_fail;
21183 swig_obj[0] = args;
21184 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21185 if (!SWIG_IsOK(res1)) {
21186 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_y_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21187 }
21188 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21189 result = (int) ((arg1)->m_y);
21190 resultobj = SWIG_From_int(static_cast< int >(result));
21191 return resultobj;
21192 fail:
21193 return NULL;
21194 }
21195
21196
21197 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21198 PyObject *resultobj = 0;
21199 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21200 bool arg2 ;
21201 void *argp1 = 0 ;
21202 int res1 = 0 ;
21203 bool val2 ;
21204 int ecode2 = 0 ;
21205 PyObject *swig_obj[2] ;
21206
21207 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_leftDown_set",2,2,swig_obj)) SWIG_fail;
21208 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21209 if (!SWIG_IsOK(res1)) {
21210 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21211 }
21212 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21213 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21214 if (!SWIG_IsOK(ecode2)) {
21215 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_leftDown_set" "', expected argument " "2"" of type '" "bool""'");
21216 }
21217 arg2 = static_cast< bool >(val2);
21218 if (arg1) (arg1)->m_leftDown = arg2;
21219
21220 resultobj = SWIG_Py_Void();
21221 return resultobj;
21222 fail:
21223 return NULL;
21224 }
21225
21226
21227 SWIGINTERN PyObject *_wrap_MouseEvent_m_leftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21228 PyObject *resultobj = 0;
21229 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21230 bool result;
21231 void *argp1 = 0 ;
21232 int res1 = 0 ;
21233 PyObject *swig_obj[1] ;
21234
21235 if (!args) SWIG_fail;
21236 swig_obj[0] = args;
21237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21238 if (!SWIG_IsOK(res1)) {
21239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_leftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21240 }
21241 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21242 result = (bool) ((arg1)->m_leftDown);
21243 {
21244 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21245 }
21246 return resultobj;
21247 fail:
21248 return NULL;
21249 }
21250
21251
21252 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21253 PyObject *resultobj = 0;
21254 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21255 bool arg2 ;
21256 void *argp1 = 0 ;
21257 int res1 = 0 ;
21258 bool val2 ;
21259 int ecode2 = 0 ;
21260 PyObject *swig_obj[2] ;
21261
21262 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_middleDown_set",2,2,swig_obj)) SWIG_fail;
21263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21264 if (!SWIG_IsOK(res1)) {
21265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21266 }
21267 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21268 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21269 if (!SWIG_IsOK(ecode2)) {
21270 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_middleDown_set" "', expected argument " "2"" of type '" "bool""'");
21271 }
21272 arg2 = static_cast< bool >(val2);
21273 if (arg1) (arg1)->m_middleDown = arg2;
21274
21275 resultobj = SWIG_Py_Void();
21276 return resultobj;
21277 fail:
21278 return NULL;
21279 }
21280
21281
21282 SWIGINTERN PyObject *_wrap_MouseEvent_m_middleDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21283 PyObject *resultobj = 0;
21284 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21285 bool result;
21286 void *argp1 = 0 ;
21287 int res1 = 0 ;
21288 PyObject *swig_obj[1] ;
21289
21290 if (!args) SWIG_fail;
21291 swig_obj[0] = args;
21292 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21293 if (!SWIG_IsOK(res1)) {
21294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_middleDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21295 }
21296 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21297 result = (bool) ((arg1)->m_middleDown);
21298 {
21299 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21300 }
21301 return resultobj;
21302 fail:
21303 return NULL;
21304 }
21305
21306
21307 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21308 PyObject *resultobj = 0;
21309 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21310 bool arg2 ;
21311 void *argp1 = 0 ;
21312 int res1 = 0 ;
21313 bool val2 ;
21314 int ecode2 = 0 ;
21315 PyObject *swig_obj[2] ;
21316
21317 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_rightDown_set",2,2,swig_obj)) SWIG_fail;
21318 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21319 if (!SWIG_IsOK(res1)) {
21320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21321 }
21322 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21323 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21324 if (!SWIG_IsOK(ecode2)) {
21325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_rightDown_set" "', expected argument " "2"" of type '" "bool""'");
21326 }
21327 arg2 = static_cast< bool >(val2);
21328 if (arg1) (arg1)->m_rightDown = arg2;
21329
21330 resultobj = SWIG_Py_Void();
21331 return resultobj;
21332 fail:
21333 return NULL;
21334 }
21335
21336
21337 SWIGINTERN PyObject *_wrap_MouseEvent_m_rightDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21338 PyObject *resultobj = 0;
21339 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21340 bool result;
21341 void *argp1 = 0 ;
21342 int res1 = 0 ;
21343 PyObject *swig_obj[1] ;
21344
21345 if (!args) SWIG_fail;
21346 swig_obj[0] = args;
21347 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21348 if (!SWIG_IsOK(res1)) {
21349 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_rightDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21350 }
21351 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21352 result = (bool) ((arg1)->m_rightDown);
21353 {
21354 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21355 }
21356 return resultobj;
21357 fail:
21358 return NULL;
21359 }
21360
21361
21362 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21363 PyObject *resultobj = 0;
21364 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21365 bool arg2 ;
21366 void *argp1 = 0 ;
21367 int res1 = 0 ;
21368 bool val2 ;
21369 int ecode2 = 0 ;
21370 PyObject *swig_obj[2] ;
21371
21372 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
21373 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21374 if (!SWIG_IsOK(res1)) {
21375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21376 }
21377 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21378 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21379 if (!SWIG_IsOK(ecode2)) {
21380 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
21381 }
21382 arg2 = static_cast< bool >(val2);
21383 if (arg1) (arg1)->m_controlDown = arg2;
21384
21385 resultobj = SWIG_Py_Void();
21386 return resultobj;
21387 fail:
21388 return NULL;
21389 }
21390
21391
21392 SWIGINTERN PyObject *_wrap_MouseEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21393 PyObject *resultobj = 0;
21394 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21395 bool result;
21396 void *argp1 = 0 ;
21397 int res1 = 0 ;
21398 PyObject *swig_obj[1] ;
21399
21400 if (!args) SWIG_fail;
21401 swig_obj[0] = args;
21402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21403 if (!SWIG_IsOK(res1)) {
21404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21405 }
21406 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21407 result = (bool) ((arg1)->m_controlDown);
21408 {
21409 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21410 }
21411 return resultobj;
21412 fail:
21413 return NULL;
21414 }
21415
21416
21417 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21418 PyObject *resultobj = 0;
21419 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21420 bool arg2 ;
21421 void *argp1 = 0 ;
21422 int res1 = 0 ;
21423 bool val2 ;
21424 int ecode2 = 0 ;
21425 PyObject *swig_obj[2] ;
21426
21427 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
21428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21429 if (!SWIG_IsOK(res1)) {
21430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21431 }
21432 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21433 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21434 if (!SWIG_IsOK(ecode2)) {
21435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
21436 }
21437 arg2 = static_cast< bool >(val2);
21438 if (arg1) (arg1)->m_shiftDown = arg2;
21439
21440 resultobj = SWIG_Py_Void();
21441 return resultobj;
21442 fail:
21443 return NULL;
21444 }
21445
21446
21447 SWIGINTERN PyObject *_wrap_MouseEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21448 PyObject *resultobj = 0;
21449 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21450 bool result;
21451 void *argp1 = 0 ;
21452 int res1 = 0 ;
21453 PyObject *swig_obj[1] ;
21454
21455 if (!args) SWIG_fail;
21456 swig_obj[0] = args;
21457 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21458 if (!SWIG_IsOK(res1)) {
21459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21460 }
21461 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21462 result = (bool) ((arg1)->m_shiftDown);
21463 {
21464 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21465 }
21466 return resultobj;
21467 fail:
21468 return NULL;
21469 }
21470
21471
21472 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21473 PyObject *resultobj = 0;
21474 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21475 bool arg2 ;
21476 void *argp1 = 0 ;
21477 int res1 = 0 ;
21478 bool val2 ;
21479 int ecode2 = 0 ;
21480 PyObject *swig_obj[2] ;
21481
21482 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
21483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21484 if (!SWIG_IsOK(res1)) {
21485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21486 }
21487 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21488 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21489 if (!SWIG_IsOK(ecode2)) {
21490 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
21491 }
21492 arg2 = static_cast< bool >(val2);
21493 if (arg1) (arg1)->m_altDown = arg2;
21494
21495 resultobj = SWIG_Py_Void();
21496 return resultobj;
21497 fail:
21498 return NULL;
21499 }
21500
21501
21502 SWIGINTERN PyObject *_wrap_MouseEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21503 PyObject *resultobj = 0;
21504 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21505 bool result;
21506 void *argp1 = 0 ;
21507 int res1 = 0 ;
21508 PyObject *swig_obj[1] ;
21509
21510 if (!args) SWIG_fail;
21511 swig_obj[0] = args;
21512 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21513 if (!SWIG_IsOK(res1)) {
21514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21515 }
21516 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21517 result = (bool) ((arg1)->m_altDown);
21518 {
21519 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21520 }
21521 return resultobj;
21522 fail:
21523 return NULL;
21524 }
21525
21526
21527 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21528 PyObject *resultobj = 0;
21529 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21530 bool arg2 ;
21531 void *argp1 = 0 ;
21532 int res1 = 0 ;
21533 bool val2 ;
21534 int ecode2 = 0 ;
21535 PyObject *swig_obj[2] ;
21536
21537 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
21538 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21539 if (!SWIG_IsOK(res1)) {
21540 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21541 }
21542 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21543 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
21544 if (!SWIG_IsOK(ecode2)) {
21545 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
21546 }
21547 arg2 = static_cast< bool >(val2);
21548 if (arg1) (arg1)->m_metaDown = arg2;
21549
21550 resultobj = SWIG_Py_Void();
21551 return resultobj;
21552 fail:
21553 return NULL;
21554 }
21555
21556
21557 SWIGINTERN PyObject *_wrap_MouseEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21558 PyObject *resultobj = 0;
21559 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21560 bool result;
21561 void *argp1 = 0 ;
21562 int res1 = 0 ;
21563 PyObject *swig_obj[1] ;
21564
21565 if (!args) SWIG_fail;
21566 swig_obj[0] = args;
21567 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21568 if (!SWIG_IsOK(res1)) {
21569 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21570 }
21571 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21572 result = (bool) ((arg1)->m_metaDown);
21573 {
21574 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21575 }
21576 return resultobj;
21577 fail:
21578 return NULL;
21579 }
21580
21581
21582 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21583 PyObject *resultobj = 0;
21584 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21585 int arg2 ;
21586 void *argp1 = 0 ;
21587 int res1 = 0 ;
21588 int val2 ;
21589 int ecode2 = 0 ;
21590 PyObject *swig_obj[2] ;
21591
21592 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelRotation_set",2,2,swig_obj)) SWIG_fail;
21593 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21594 if (!SWIG_IsOK(res1)) {
21595 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21596 }
21597 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21598 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21599 if (!SWIG_IsOK(ecode2)) {
21600 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelRotation_set" "', expected argument " "2"" of type '" "int""'");
21601 }
21602 arg2 = static_cast< int >(val2);
21603 if (arg1) (arg1)->m_wheelRotation = arg2;
21604
21605 resultobj = SWIG_Py_Void();
21606 return resultobj;
21607 fail:
21608 return NULL;
21609 }
21610
21611
21612 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelRotation_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21613 PyObject *resultobj = 0;
21614 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21615 int result;
21616 void *argp1 = 0 ;
21617 int res1 = 0 ;
21618 PyObject *swig_obj[1] ;
21619
21620 if (!args) SWIG_fail;
21621 swig_obj[0] = args;
21622 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21623 if (!SWIG_IsOK(res1)) {
21624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelRotation_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21625 }
21626 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21627 result = (int) ((arg1)->m_wheelRotation);
21628 resultobj = SWIG_From_int(static_cast< int >(result));
21629 return resultobj;
21630 fail:
21631 return NULL;
21632 }
21633
21634
21635 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21636 PyObject *resultobj = 0;
21637 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21638 int arg2 ;
21639 void *argp1 = 0 ;
21640 int res1 = 0 ;
21641 int val2 ;
21642 int ecode2 = 0 ;
21643 PyObject *swig_obj[2] ;
21644
21645 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_wheelDelta_set",2,2,swig_obj)) SWIG_fail;
21646 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21647 if (!SWIG_IsOK(res1)) {
21648 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21649 }
21650 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21651 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21652 if (!SWIG_IsOK(ecode2)) {
21653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_wheelDelta_set" "', expected argument " "2"" of type '" "int""'");
21654 }
21655 arg2 = static_cast< int >(val2);
21656 if (arg1) (arg1)->m_wheelDelta = arg2;
21657
21658 resultobj = SWIG_Py_Void();
21659 return resultobj;
21660 fail:
21661 return NULL;
21662 }
21663
21664
21665 SWIGINTERN PyObject *_wrap_MouseEvent_m_wheelDelta_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21666 PyObject *resultobj = 0;
21667 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21668 int result;
21669 void *argp1 = 0 ;
21670 int res1 = 0 ;
21671 PyObject *swig_obj[1] ;
21672
21673 if (!args) SWIG_fail;
21674 swig_obj[0] = args;
21675 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21676 if (!SWIG_IsOK(res1)) {
21677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_wheelDelta_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21678 }
21679 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21680 result = (int) ((arg1)->m_wheelDelta);
21681 resultobj = SWIG_From_int(static_cast< int >(result));
21682 return resultobj;
21683 fail:
21684 return NULL;
21685 }
21686
21687
21688 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21689 PyObject *resultobj = 0;
21690 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21691 int arg2 ;
21692 void *argp1 = 0 ;
21693 int res1 = 0 ;
21694 int val2 ;
21695 int ecode2 = 0 ;
21696 PyObject *swig_obj[2] ;
21697
21698 if (!SWIG_Python_UnpackTuple(args,"MouseEvent_m_linesPerAction_set",2,2,swig_obj)) SWIG_fail;
21699 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21700 if (!SWIG_IsOK(res1)) {
21701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21702 }
21703 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21704 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
21705 if (!SWIG_IsOK(ecode2)) {
21706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MouseEvent_m_linesPerAction_set" "', expected argument " "2"" of type '" "int""'");
21707 }
21708 arg2 = static_cast< int >(val2);
21709 if (arg1) (arg1)->m_linesPerAction = arg2;
21710
21711 resultobj = SWIG_Py_Void();
21712 return resultobj;
21713 fail:
21714 return NULL;
21715 }
21716
21717
21718 SWIGINTERN PyObject *_wrap_MouseEvent_m_linesPerAction_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21719 PyObject *resultobj = 0;
21720 wxMouseEvent *arg1 = (wxMouseEvent *) 0 ;
21721 int result;
21722 void *argp1 = 0 ;
21723 int res1 = 0 ;
21724 PyObject *swig_obj[1] ;
21725
21726 if (!args) SWIG_fail;
21727 swig_obj[0] = args;
21728 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseEvent, 0 | 0 );
21729 if (!SWIG_IsOK(res1)) {
21730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseEvent_m_linesPerAction_get" "', expected argument " "1"" of type '" "wxMouseEvent *""'");
21731 }
21732 arg1 = reinterpret_cast< wxMouseEvent * >(argp1);
21733 result = (int) ((arg1)->m_linesPerAction);
21734 resultobj = SWIG_From_int(static_cast< int >(result));
21735 return resultobj;
21736 fail:
21737 return NULL;
21738 }
21739
21740
21741 SWIGINTERN PyObject *MouseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21742 PyObject *obj;
21743 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21744 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseEvent, SWIG_NewClientData(obj));
21745 return SWIG_Py_Void();
21746 }
21747
21748 SWIGINTERN PyObject *MouseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21749 return SWIG_Python_InitShadowInstance(args);
21750 }
21751
21752 SWIGINTERN PyObject *_wrap_new_SetCursorEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21753 PyObject *resultobj = 0;
21754 int arg1 = (int) 0 ;
21755 int arg2 = (int) 0 ;
21756 wxSetCursorEvent *result = 0 ;
21757 int val1 ;
21758 int ecode1 = 0 ;
21759 int val2 ;
21760 int ecode2 = 0 ;
21761 PyObject * obj0 = 0 ;
21762 PyObject * obj1 = 0 ;
21763 char * kwnames[] = {
21764 (char *) "x",(char *) "y", NULL
21765 };
21766
21767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SetCursorEvent",kwnames,&obj0,&obj1)) SWIG_fail;
21768 if (obj0) {
21769 ecode1 = SWIG_AsVal_int(obj0, &val1);
21770 if (!SWIG_IsOK(ecode1)) {
21771 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SetCursorEvent" "', expected argument " "1"" of type '" "int""'");
21772 }
21773 arg1 = static_cast< int >(val1);
21774 }
21775 if (obj1) {
21776 ecode2 = SWIG_AsVal_int(obj1, &val2);
21777 if (!SWIG_IsOK(ecode2)) {
21778 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SetCursorEvent" "', expected argument " "2"" of type '" "int""'");
21779 }
21780 arg2 = static_cast< int >(val2);
21781 }
21782 {
21783 PyThreadState* __tstate = wxPyBeginAllowThreads();
21784 result = (wxSetCursorEvent *)new wxSetCursorEvent(arg1,arg2);
21785 wxPyEndAllowThreads(__tstate);
21786 if (PyErr_Occurred()) SWIG_fail;
21787 }
21788 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSetCursorEvent, SWIG_POINTER_NEW | 0 );
21789 return resultobj;
21790 fail:
21791 return NULL;
21792 }
21793
21794
21795 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21796 PyObject *resultobj = 0;
21797 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21798 int result;
21799 void *argp1 = 0 ;
21800 int res1 = 0 ;
21801 PyObject *swig_obj[1] ;
21802
21803 if (!args) SWIG_fail;
21804 swig_obj[0] = args;
21805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21806 if (!SWIG_IsOK(res1)) {
21807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetX" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21808 }
21809 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21810 {
21811 PyThreadState* __tstate = wxPyBeginAllowThreads();
21812 result = (int)((wxSetCursorEvent const *)arg1)->GetX();
21813 wxPyEndAllowThreads(__tstate);
21814 if (PyErr_Occurred()) SWIG_fail;
21815 }
21816 resultobj = SWIG_From_int(static_cast< int >(result));
21817 return resultobj;
21818 fail:
21819 return NULL;
21820 }
21821
21822
21823 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21824 PyObject *resultobj = 0;
21825 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21826 int result;
21827 void *argp1 = 0 ;
21828 int res1 = 0 ;
21829 PyObject *swig_obj[1] ;
21830
21831 if (!args) SWIG_fail;
21832 swig_obj[0] = args;
21833 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21834 if (!SWIG_IsOK(res1)) {
21835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetY" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21836 }
21837 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21838 {
21839 PyThreadState* __tstate = wxPyBeginAllowThreads();
21840 result = (int)((wxSetCursorEvent const *)arg1)->GetY();
21841 wxPyEndAllowThreads(__tstate);
21842 if (PyErr_Occurred()) SWIG_fail;
21843 }
21844 resultobj = SWIG_From_int(static_cast< int >(result));
21845 return resultobj;
21846 fail:
21847 return NULL;
21848 }
21849
21850
21851 SWIGINTERN PyObject *_wrap_SetCursorEvent_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21852 PyObject *resultobj = 0;
21853 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21854 wxCursor *arg2 = 0 ;
21855 void *argp1 = 0 ;
21856 int res1 = 0 ;
21857 void *argp2 = 0 ;
21858 int res2 = 0 ;
21859 PyObject * obj0 = 0 ;
21860 PyObject * obj1 = 0 ;
21861 char * kwnames[] = {
21862 (char *) "self",(char *) "cursor", NULL
21863 };
21864
21865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SetCursorEvent_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
21866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21867 if (!SWIG_IsOK(res1)) {
21868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent *""'");
21869 }
21870 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21871 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
21872 if (!SWIG_IsOK(res2)) {
21873 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21874 }
21875 if (!argp2) {
21876 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SetCursorEvent_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
21877 }
21878 arg2 = reinterpret_cast< wxCursor * >(argp2);
21879 {
21880 PyThreadState* __tstate = wxPyBeginAllowThreads();
21881 (arg1)->SetCursor((wxCursor const &)*arg2);
21882 wxPyEndAllowThreads(__tstate);
21883 if (PyErr_Occurred()) SWIG_fail;
21884 }
21885 resultobj = SWIG_Py_Void();
21886 return resultobj;
21887 fail:
21888 return NULL;
21889 }
21890
21891
21892 SWIGINTERN PyObject *_wrap_SetCursorEvent_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21893 PyObject *resultobj = 0;
21894 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21895 wxCursor *result = 0 ;
21896 void *argp1 = 0 ;
21897 int res1 = 0 ;
21898 PyObject *swig_obj[1] ;
21899
21900 if (!args) SWIG_fail;
21901 swig_obj[0] = args;
21902 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21903 if (!SWIG_IsOK(res1)) {
21904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_GetCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21905 }
21906 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21907 {
21908 PyThreadState* __tstate = wxPyBeginAllowThreads();
21909 {
21910 wxCursor const &_result_ref = ((wxSetCursorEvent const *)arg1)->GetCursor();
21911 result = (wxCursor *) &_result_ref;
21912 }
21913 wxPyEndAllowThreads(__tstate);
21914 if (PyErr_Occurred()) SWIG_fail;
21915 }
21916 {
21917 wxCursor* resultptr = new wxCursor(*result);
21918 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxCursor, 1);
21919 }
21920 return resultobj;
21921 fail:
21922 return NULL;
21923 }
21924
21925
21926 SWIGINTERN PyObject *_wrap_SetCursorEvent_HasCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21927 PyObject *resultobj = 0;
21928 wxSetCursorEvent *arg1 = (wxSetCursorEvent *) 0 ;
21929 bool result;
21930 void *argp1 = 0 ;
21931 int res1 = 0 ;
21932 PyObject *swig_obj[1] ;
21933
21934 if (!args) SWIG_fail;
21935 swig_obj[0] = args;
21936 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSetCursorEvent, 0 | 0 );
21937 if (!SWIG_IsOK(res1)) {
21938 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetCursorEvent_HasCursor" "', expected argument " "1"" of type '" "wxSetCursorEvent const *""'");
21939 }
21940 arg1 = reinterpret_cast< wxSetCursorEvent * >(argp1);
21941 {
21942 PyThreadState* __tstate = wxPyBeginAllowThreads();
21943 result = (bool)((wxSetCursorEvent const *)arg1)->HasCursor();
21944 wxPyEndAllowThreads(__tstate);
21945 if (PyErr_Occurred()) SWIG_fail;
21946 }
21947 {
21948 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
21949 }
21950 return resultobj;
21951 fail:
21952 return NULL;
21953 }
21954
21955
21956 SWIGINTERN PyObject *SetCursorEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21957 PyObject *obj;
21958 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
21959 SWIG_TypeNewClientData(SWIGTYPE_p_wxSetCursorEvent, SWIG_NewClientData(obj));
21960 return SWIG_Py_Void();
21961 }
21962
21963 SWIGINTERN PyObject *SetCursorEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
21964 return SWIG_Python_InitShadowInstance(args);
21965 }
21966
21967 SWIGINTERN PyObject *_wrap_new_KeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
21968 PyObject *resultobj = 0;
21969 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
21970 wxKeyEvent *result = 0 ;
21971 int val1 ;
21972 int ecode1 = 0 ;
21973 PyObject * obj0 = 0 ;
21974 char * kwnames[] = {
21975 (char *) "eventType", NULL
21976 };
21977
21978 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_KeyEvent",kwnames,&obj0)) SWIG_fail;
21979 if (obj0) {
21980 ecode1 = SWIG_AsVal_int(obj0, &val1);
21981 if (!SWIG_IsOK(ecode1)) {
21982 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_KeyEvent" "', expected argument " "1"" of type '" "wxEventType""'");
21983 }
21984 arg1 = static_cast< wxEventType >(val1);
21985 }
21986 {
21987 PyThreadState* __tstate = wxPyBeginAllowThreads();
21988 result = (wxKeyEvent *)new wxKeyEvent(arg1);
21989 wxPyEndAllowThreads(__tstate);
21990 if (PyErr_Occurred()) SWIG_fail;
21991 }
21992 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxKeyEvent, SWIG_POINTER_NEW | 0 );
21993 return resultobj;
21994 fail:
21995 return NULL;
21996 }
21997
21998
21999 SWIGINTERN PyObject *_wrap_KeyEvent_GetModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22000 PyObject *resultobj = 0;
22001 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22002 int result;
22003 void *argp1 = 0 ;
22004 int res1 = 0 ;
22005 PyObject *swig_obj[1] ;
22006
22007 if (!args) SWIG_fail;
22008 swig_obj[0] = args;
22009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22010 if (!SWIG_IsOK(res1)) {
22011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22012 }
22013 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22014 {
22015 PyThreadState* __tstate = wxPyBeginAllowThreads();
22016 result = (int)((wxKeyEvent const *)arg1)->GetModifiers();
22017 wxPyEndAllowThreads(__tstate);
22018 if (PyErr_Occurred()) SWIG_fail;
22019 }
22020 resultobj = SWIG_From_int(static_cast< int >(result));
22021 return resultobj;
22022 fail:
22023 return NULL;
22024 }
22025
22026
22027 SWIGINTERN PyObject *_wrap_KeyEvent_ControlDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22028 PyObject *resultobj = 0;
22029 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22030 bool result;
22031 void *argp1 = 0 ;
22032 int res1 = 0 ;
22033 PyObject *swig_obj[1] ;
22034
22035 if (!args) SWIG_fail;
22036 swig_obj[0] = args;
22037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22038 if (!SWIG_IsOK(res1)) {
22039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ControlDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22040 }
22041 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22042 {
22043 PyThreadState* __tstate = wxPyBeginAllowThreads();
22044 result = (bool)((wxKeyEvent const *)arg1)->ControlDown();
22045 wxPyEndAllowThreads(__tstate);
22046 if (PyErr_Occurred()) SWIG_fail;
22047 }
22048 {
22049 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22050 }
22051 return resultobj;
22052 fail:
22053 return NULL;
22054 }
22055
22056
22057 SWIGINTERN PyObject *_wrap_KeyEvent_MetaDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22058 PyObject *resultobj = 0;
22059 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22060 bool result;
22061 void *argp1 = 0 ;
22062 int res1 = 0 ;
22063 PyObject *swig_obj[1] ;
22064
22065 if (!args) SWIG_fail;
22066 swig_obj[0] = args;
22067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22068 if (!SWIG_IsOK(res1)) {
22069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_MetaDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22070 }
22071 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22072 {
22073 PyThreadState* __tstate = wxPyBeginAllowThreads();
22074 result = (bool)((wxKeyEvent const *)arg1)->MetaDown();
22075 wxPyEndAllowThreads(__tstate);
22076 if (PyErr_Occurred()) SWIG_fail;
22077 }
22078 {
22079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22080 }
22081 return resultobj;
22082 fail:
22083 return NULL;
22084 }
22085
22086
22087 SWIGINTERN PyObject *_wrap_KeyEvent_AltDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22088 PyObject *resultobj = 0;
22089 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22090 bool result;
22091 void *argp1 = 0 ;
22092 int res1 = 0 ;
22093 PyObject *swig_obj[1] ;
22094
22095 if (!args) SWIG_fail;
22096 swig_obj[0] = args;
22097 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22098 if (!SWIG_IsOK(res1)) {
22099 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_AltDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22100 }
22101 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22102 {
22103 PyThreadState* __tstate = wxPyBeginAllowThreads();
22104 result = (bool)((wxKeyEvent const *)arg1)->AltDown();
22105 wxPyEndAllowThreads(__tstate);
22106 if (PyErr_Occurred()) SWIG_fail;
22107 }
22108 {
22109 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22110 }
22111 return resultobj;
22112 fail:
22113 return NULL;
22114 }
22115
22116
22117 SWIGINTERN PyObject *_wrap_KeyEvent_ShiftDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22118 PyObject *resultobj = 0;
22119 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22120 bool result;
22121 void *argp1 = 0 ;
22122 int res1 = 0 ;
22123 PyObject *swig_obj[1] ;
22124
22125 if (!args) SWIG_fail;
22126 swig_obj[0] = args;
22127 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22128 if (!SWIG_IsOK(res1)) {
22129 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_ShiftDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22130 }
22131 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22132 {
22133 PyThreadState* __tstate = wxPyBeginAllowThreads();
22134 result = (bool)((wxKeyEvent const *)arg1)->ShiftDown();
22135 wxPyEndAllowThreads(__tstate);
22136 if (PyErr_Occurred()) SWIG_fail;
22137 }
22138 {
22139 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22140 }
22141 return resultobj;
22142 fail:
22143 return NULL;
22144 }
22145
22146
22147 SWIGINTERN PyObject *_wrap_KeyEvent_CmdDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22148 PyObject *resultobj = 0;
22149 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22150 bool result;
22151 void *argp1 = 0 ;
22152 int res1 = 0 ;
22153 PyObject *swig_obj[1] ;
22154
22155 if (!args) SWIG_fail;
22156 swig_obj[0] = args;
22157 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22158 if (!SWIG_IsOK(res1)) {
22159 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_CmdDown" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22160 }
22161 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22162 {
22163 PyThreadState* __tstate = wxPyBeginAllowThreads();
22164 result = (bool)((wxKeyEvent const *)arg1)->CmdDown();
22165 wxPyEndAllowThreads(__tstate);
22166 if (PyErr_Occurred()) SWIG_fail;
22167 }
22168 {
22169 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22170 }
22171 return resultobj;
22172 fail:
22173 return NULL;
22174 }
22175
22176
22177 SWIGINTERN PyObject *_wrap_KeyEvent_HasModifiers(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22178 PyObject *resultobj = 0;
22179 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22180 bool result;
22181 void *argp1 = 0 ;
22182 int res1 = 0 ;
22183 PyObject *swig_obj[1] ;
22184
22185 if (!args) SWIG_fail;
22186 swig_obj[0] = args;
22187 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22188 if (!SWIG_IsOK(res1)) {
22189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_HasModifiers" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22190 }
22191 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22192 {
22193 PyThreadState* __tstate = wxPyBeginAllowThreads();
22194 result = (bool)((wxKeyEvent const *)arg1)->HasModifiers();
22195 wxPyEndAllowThreads(__tstate);
22196 if (PyErr_Occurred()) SWIG_fail;
22197 }
22198 {
22199 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22200 }
22201 return resultobj;
22202 fail:
22203 return NULL;
22204 }
22205
22206
22207 SWIGINTERN PyObject *_wrap_KeyEvent_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22208 PyObject *resultobj = 0;
22209 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22210 int result;
22211 void *argp1 = 0 ;
22212 int res1 = 0 ;
22213 PyObject *swig_obj[1] ;
22214
22215 if (!args) SWIG_fail;
22216 swig_obj[0] = args;
22217 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22218 if (!SWIG_IsOK(res1)) {
22219 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22220 }
22221 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22222 {
22223 PyThreadState* __tstate = wxPyBeginAllowThreads();
22224 result = (int)((wxKeyEvent const *)arg1)->GetKeyCode();
22225 wxPyEndAllowThreads(__tstate);
22226 if (PyErr_Occurred()) SWIG_fail;
22227 }
22228 resultobj = SWIG_From_int(static_cast< int >(result));
22229 return resultobj;
22230 fail:
22231 return NULL;
22232 }
22233
22234
22235 SWIGINTERN PyObject *_wrap_KeyEvent_GetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22236 PyObject *resultobj = 0;
22237 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22238 int result;
22239 void *argp1 = 0 ;
22240 int res1 = 0 ;
22241 PyObject *swig_obj[1] ;
22242
22243 if (!args) SWIG_fail;
22244 swig_obj[0] = args;
22245 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22246 if (!SWIG_IsOK(res1)) {
22247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22248 }
22249 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22250 {
22251 PyThreadState* __tstate = wxPyBeginAllowThreads();
22252 result = (int)wxKeyEvent_GetUnicodeKey(arg1);
22253 wxPyEndAllowThreads(__tstate);
22254 if (PyErr_Occurred()) SWIG_fail;
22255 }
22256 resultobj = SWIG_From_int(static_cast< int >(result));
22257 return resultobj;
22258 fail:
22259 return NULL;
22260 }
22261
22262
22263 SWIGINTERN PyObject *_wrap_KeyEvent_SetUnicodeKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
22264 PyObject *resultobj = 0;
22265 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22266 int arg2 ;
22267 void *argp1 = 0 ;
22268 int res1 = 0 ;
22269 int val2 ;
22270 int ecode2 = 0 ;
22271 PyObject * obj0 = 0 ;
22272 PyObject * obj1 = 0 ;
22273 char * kwnames[] = {
22274 (char *) "self",(char *) "uniChar", NULL
22275 };
22276
22277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:KeyEvent_SetUnicodeKey",kwnames,&obj0,&obj1)) SWIG_fail;
22278 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22279 if (!SWIG_IsOK(res1)) {
22280 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22281 }
22282 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22283 ecode2 = SWIG_AsVal_int(obj1, &val2);
22284 if (!SWIG_IsOK(ecode2)) {
22285 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_SetUnicodeKey" "', expected argument " "2"" of type '" "int""'");
22286 }
22287 arg2 = static_cast< int >(val2);
22288 {
22289 PyThreadState* __tstate = wxPyBeginAllowThreads();
22290 wxKeyEvent_SetUnicodeKey(arg1,arg2);
22291 wxPyEndAllowThreads(__tstate);
22292 if (PyErr_Occurred()) SWIG_fail;
22293 }
22294 resultobj = SWIG_Py_Void();
22295 return resultobj;
22296 fail:
22297 return NULL;
22298 }
22299
22300
22301 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22302 PyObject *resultobj = 0;
22303 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22304 unsigned int result;
22305 void *argp1 = 0 ;
22306 int res1 = 0 ;
22307 PyObject *swig_obj[1] ;
22308
22309 if (!args) SWIG_fail;
22310 swig_obj[0] = args;
22311 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22312 if (!SWIG_IsOK(res1)) {
22313 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyCode" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22314 }
22315 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22316 {
22317 PyThreadState* __tstate = wxPyBeginAllowThreads();
22318 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyCode();
22319 wxPyEndAllowThreads(__tstate);
22320 if (PyErr_Occurred()) SWIG_fail;
22321 }
22322 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22323 return resultobj;
22324 fail:
22325 return NULL;
22326 }
22327
22328
22329 SWIGINTERN PyObject *_wrap_KeyEvent_GetRawKeyFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22330 PyObject *resultobj = 0;
22331 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22332 unsigned int result;
22333 void *argp1 = 0 ;
22334 int res1 = 0 ;
22335 PyObject *swig_obj[1] ;
22336
22337 if (!args) SWIG_fail;
22338 swig_obj[0] = args;
22339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22340 if (!SWIG_IsOK(res1)) {
22341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetRawKeyFlags" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22342 }
22343 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22344 {
22345 PyThreadState* __tstate = wxPyBeginAllowThreads();
22346 result = (unsigned int)((wxKeyEvent const *)arg1)->GetRawKeyFlags();
22347 wxPyEndAllowThreads(__tstate);
22348 if (PyErr_Occurred()) SWIG_fail;
22349 }
22350 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22351 return resultobj;
22352 fail:
22353 return NULL;
22354 }
22355
22356
22357 SWIGINTERN PyObject *_wrap_KeyEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22358 PyObject *resultobj = 0;
22359 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22360 wxPoint result;
22361 void *argp1 = 0 ;
22362 int res1 = 0 ;
22363 PyObject *swig_obj[1] ;
22364
22365 if (!args) SWIG_fail;
22366 swig_obj[0] = args;
22367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22368 if (!SWIG_IsOK(res1)) {
22369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPosition" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22370 }
22371 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22372 {
22373 PyThreadState* __tstate = wxPyBeginAllowThreads();
22374 result = (arg1)->GetPosition();
22375 wxPyEndAllowThreads(__tstate);
22376 if (PyErr_Occurred()) SWIG_fail;
22377 }
22378 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
22379 return resultobj;
22380 fail:
22381 return NULL;
22382 }
22383
22384
22385 SWIGINTERN PyObject *_wrap_KeyEvent_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22386 PyObject *resultobj = 0;
22387 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22388 long *arg2 = (long *) 0 ;
22389 long *arg3 = (long *) 0 ;
22390 void *argp1 = 0 ;
22391 int res1 = 0 ;
22392 long temp2 ;
22393 int res2 = SWIG_TMPOBJ ;
22394 long temp3 ;
22395 int res3 = SWIG_TMPOBJ ;
22396 PyObject *swig_obj[1] ;
22397
22398 arg2 = &temp2;
22399 arg3 = &temp3;
22400 if (!args) SWIG_fail;
22401 swig_obj[0] = args;
22402 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22403 if (!SWIG_IsOK(res1)) {
22404 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetPositionTuple" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22405 }
22406 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22407 {
22408 PyThreadState* __tstate = wxPyBeginAllowThreads();
22409 (arg1)->GetPosition(arg2,arg3);
22410 wxPyEndAllowThreads(__tstate);
22411 if (PyErr_Occurred()) SWIG_fail;
22412 }
22413 resultobj = SWIG_Py_Void();
22414 if (SWIG_IsTmpObj(res2)) {
22415 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg2)));
22416 } else {
22417 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22418 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_long, new_flags));
22419 }
22420 if (SWIG_IsTmpObj(res3)) {
22421 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_long((*arg3)));
22422 } else {
22423 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
22424 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_long, new_flags));
22425 }
22426 return resultobj;
22427 fail:
22428 return NULL;
22429 }
22430
22431
22432 SWIGINTERN PyObject *_wrap_KeyEvent_GetX(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22433 PyObject *resultobj = 0;
22434 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22435 int result;
22436 void *argp1 = 0 ;
22437 int res1 = 0 ;
22438 PyObject *swig_obj[1] ;
22439
22440 if (!args) SWIG_fail;
22441 swig_obj[0] = args;
22442 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22443 if (!SWIG_IsOK(res1)) {
22444 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetX" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22445 }
22446 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22447 {
22448 PyThreadState* __tstate = wxPyBeginAllowThreads();
22449 result = (int)((wxKeyEvent const *)arg1)->GetX();
22450 wxPyEndAllowThreads(__tstate);
22451 if (PyErr_Occurred()) SWIG_fail;
22452 }
22453 resultobj = SWIG_From_int(static_cast< int >(result));
22454 return resultobj;
22455 fail:
22456 return NULL;
22457 }
22458
22459
22460 SWIGINTERN PyObject *_wrap_KeyEvent_GetY(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22461 PyObject *resultobj = 0;
22462 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22463 int result;
22464 void *argp1 = 0 ;
22465 int res1 = 0 ;
22466 PyObject *swig_obj[1] ;
22467
22468 if (!args) SWIG_fail;
22469 swig_obj[0] = args;
22470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22471 if (!SWIG_IsOK(res1)) {
22472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_GetY" "', expected argument " "1"" of type '" "wxKeyEvent const *""'");
22473 }
22474 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22475 {
22476 PyThreadState* __tstate = wxPyBeginAllowThreads();
22477 result = (int)((wxKeyEvent const *)arg1)->GetY();
22478 wxPyEndAllowThreads(__tstate);
22479 if (PyErr_Occurred()) SWIG_fail;
22480 }
22481 resultobj = SWIG_From_int(static_cast< int >(result));
22482 return resultobj;
22483 fail:
22484 return NULL;
22485 }
22486
22487
22488 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22489 PyObject *resultobj = 0;
22490 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22491 int arg2 ;
22492 void *argp1 = 0 ;
22493 int res1 = 0 ;
22494 int val2 ;
22495 int ecode2 = 0 ;
22496 PyObject *swig_obj[2] ;
22497
22498 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_x_set",2,2,swig_obj)) SWIG_fail;
22499 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22500 if (!SWIG_IsOK(res1)) {
22501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22502 }
22503 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22504 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22505 if (!SWIG_IsOK(ecode2)) {
22506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_x_set" "', expected argument " "2"" of type '" "int""'");
22507 }
22508 arg2 = static_cast< int >(val2);
22509 if (arg1) (arg1)->m_x = arg2;
22510
22511 resultobj = SWIG_Py_Void();
22512 return resultobj;
22513 fail:
22514 return NULL;
22515 }
22516
22517
22518 SWIGINTERN PyObject *_wrap_KeyEvent_m_x_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22519 PyObject *resultobj = 0;
22520 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22521 int result;
22522 void *argp1 = 0 ;
22523 int res1 = 0 ;
22524 PyObject *swig_obj[1] ;
22525
22526 if (!args) SWIG_fail;
22527 swig_obj[0] = args;
22528 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22529 if (!SWIG_IsOK(res1)) {
22530 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_x_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22531 }
22532 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22533 result = (int) ((arg1)->m_x);
22534 resultobj = SWIG_From_int(static_cast< int >(result));
22535 return resultobj;
22536 fail:
22537 return NULL;
22538 }
22539
22540
22541 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22542 PyObject *resultobj = 0;
22543 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22544 int arg2 ;
22545 void *argp1 = 0 ;
22546 int res1 = 0 ;
22547 int val2 ;
22548 int ecode2 = 0 ;
22549 PyObject *swig_obj[2] ;
22550
22551 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_y_set",2,2,swig_obj)) SWIG_fail;
22552 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22553 if (!SWIG_IsOK(res1)) {
22554 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22555 }
22556 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22557 ecode2 = SWIG_AsVal_int(swig_obj[1], &val2);
22558 if (!SWIG_IsOK(ecode2)) {
22559 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_y_set" "', expected argument " "2"" of type '" "int""'");
22560 }
22561 arg2 = static_cast< int >(val2);
22562 if (arg1) (arg1)->m_y = arg2;
22563
22564 resultobj = SWIG_Py_Void();
22565 return resultobj;
22566 fail:
22567 return NULL;
22568 }
22569
22570
22571 SWIGINTERN PyObject *_wrap_KeyEvent_m_y_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22572 PyObject *resultobj = 0;
22573 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22574 int result;
22575 void *argp1 = 0 ;
22576 int res1 = 0 ;
22577 PyObject *swig_obj[1] ;
22578
22579 if (!args) SWIG_fail;
22580 swig_obj[0] = args;
22581 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22582 if (!SWIG_IsOK(res1)) {
22583 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_y_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22584 }
22585 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22586 result = (int) ((arg1)->m_y);
22587 resultobj = SWIG_From_int(static_cast< int >(result));
22588 return resultobj;
22589 fail:
22590 return NULL;
22591 }
22592
22593
22594 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22595 PyObject *resultobj = 0;
22596 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22597 long arg2 ;
22598 void *argp1 = 0 ;
22599 int res1 = 0 ;
22600 long val2 ;
22601 int ecode2 = 0 ;
22602 PyObject *swig_obj[2] ;
22603
22604 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_keyCode_set",2,2,swig_obj)) SWIG_fail;
22605 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22606 if (!SWIG_IsOK(res1)) {
22607 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22608 }
22609 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22610 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
22611 if (!SWIG_IsOK(ecode2)) {
22612 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_keyCode_set" "', expected argument " "2"" of type '" "long""'");
22613 }
22614 arg2 = static_cast< long >(val2);
22615 if (arg1) (arg1)->m_keyCode = arg2;
22616
22617 resultobj = SWIG_Py_Void();
22618 return resultobj;
22619 fail:
22620 return NULL;
22621 }
22622
22623
22624 SWIGINTERN PyObject *_wrap_KeyEvent_m_keyCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22625 PyObject *resultobj = 0;
22626 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22627 long result;
22628 void *argp1 = 0 ;
22629 int res1 = 0 ;
22630 PyObject *swig_obj[1] ;
22631
22632 if (!args) SWIG_fail;
22633 swig_obj[0] = args;
22634 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22635 if (!SWIG_IsOK(res1)) {
22636 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_keyCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22637 }
22638 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22639 result = (long) ((arg1)->m_keyCode);
22640 resultobj = SWIG_From_long(static_cast< long >(result));
22641 return resultobj;
22642 fail:
22643 return NULL;
22644 }
22645
22646
22647 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22648 PyObject *resultobj = 0;
22649 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22650 bool arg2 ;
22651 void *argp1 = 0 ;
22652 int res1 = 0 ;
22653 bool val2 ;
22654 int ecode2 = 0 ;
22655 PyObject *swig_obj[2] ;
22656
22657 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_controlDown_set",2,2,swig_obj)) SWIG_fail;
22658 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22659 if (!SWIG_IsOK(res1)) {
22660 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22661 }
22662 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22663 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22664 if (!SWIG_IsOK(ecode2)) {
22665 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_controlDown_set" "', expected argument " "2"" of type '" "bool""'");
22666 }
22667 arg2 = static_cast< bool >(val2);
22668 if (arg1) (arg1)->m_controlDown = arg2;
22669
22670 resultobj = SWIG_Py_Void();
22671 return resultobj;
22672 fail:
22673 return NULL;
22674 }
22675
22676
22677 SWIGINTERN PyObject *_wrap_KeyEvent_m_controlDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22678 PyObject *resultobj = 0;
22679 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22680 bool result;
22681 void *argp1 = 0 ;
22682 int res1 = 0 ;
22683 PyObject *swig_obj[1] ;
22684
22685 if (!args) SWIG_fail;
22686 swig_obj[0] = args;
22687 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22688 if (!SWIG_IsOK(res1)) {
22689 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_controlDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22690 }
22691 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22692 result = (bool) ((arg1)->m_controlDown);
22693 {
22694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22695 }
22696 return resultobj;
22697 fail:
22698 return NULL;
22699 }
22700
22701
22702 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22703 PyObject *resultobj = 0;
22704 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22705 bool arg2 ;
22706 void *argp1 = 0 ;
22707 int res1 = 0 ;
22708 bool val2 ;
22709 int ecode2 = 0 ;
22710 PyObject *swig_obj[2] ;
22711
22712 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_shiftDown_set",2,2,swig_obj)) SWIG_fail;
22713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22714 if (!SWIG_IsOK(res1)) {
22715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22716 }
22717 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22718 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22719 if (!SWIG_IsOK(ecode2)) {
22720 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_shiftDown_set" "', expected argument " "2"" of type '" "bool""'");
22721 }
22722 arg2 = static_cast< bool >(val2);
22723 if (arg1) (arg1)->m_shiftDown = arg2;
22724
22725 resultobj = SWIG_Py_Void();
22726 return resultobj;
22727 fail:
22728 return NULL;
22729 }
22730
22731
22732 SWIGINTERN PyObject *_wrap_KeyEvent_m_shiftDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22733 PyObject *resultobj = 0;
22734 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22735 bool result;
22736 void *argp1 = 0 ;
22737 int res1 = 0 ;
22738 PyObject *swig_obj[1] ;
22739
22740 if (!args) SWIG_fail;
22741 swig_obj[0] = args;
22742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22743 if (!SWIG_IsOK(res1)) {
22744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_shiftDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22745 }
22746 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22747 result = (bool) ((arg1)->m_shiftDown);
22748 {
22749 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22750 }
22751 return resultobj;
22752 fail:
22753 return NULL;
22754 }
22755
22756
22757 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22758 PyObject *resultobj = 0;
22759 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22760 bool arg2 ;
22761 void *argp1 = 0 ;
22762 int res1 = 0 ;
22763 bool val2 ;
22764 int ecode2 = 0 ;
22765 PyObject *swig_obj[2] ;
22766
22767 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_altDown_set",2,2,swig_obj)) SWIG_fail;
22768 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22769 if (!SWIG_IsOK(res1)) {
22770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22771 }
22772 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22773 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22774 if (!SWIG_IsOK(ecode2)) {
22775 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_altDown_set" "', expected argument " "2"" of type '" "bool""'");
22776 }
22777 arg2 = static_cast< bool >(val2);
22778 if (arg1) (arg1)->m_altDown = arg2;
22779
22780 resultobj = SWIG_Py_Void();
22781 return resultobj;
22782 fail:
22783 return NULL;
22784 }
22785
22786
22787 SWIGINTERN PyObject *_wrap_KeyEvent_m_altDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22788 PyObject *resultobj = 0;
22789 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22790 bool result;
22791 void *argp1 = 0 ;
22792 int res1 = 0 ;
22793 PyObject *swig_obj[1] ;
22794
22795 if (!args) SWIG_fail;
22796 swig_obj[0] = args;
22797 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22798 if (!SWIG_IsOK(res1)) {
22799 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_altDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22800 }
22801 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22802 result = (bool) ((arg1)->m_altDown);
22803 {
22804 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22805 }
22806 return resultobj;
22807 fail:
22808 return NULL;
22809 }
22810
22811
22812 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22813 PyObject *resultobj = 0;
22814 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22815 bool arg2 ;
22816 void *argp1 = 0 ;
22817 int res1 = 0 ;
22818 bool val2 ;
22819 int ecode2 = 0 ;
22820 PyObject *swig_obj[2] ;
22821
22822 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_metaDown_set",2,2,swig_obj)) SWIG_fail;
22823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22824 if (!SWIG_IsOK(res1)) {
22825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22826 }
22827 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22828 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22829 if (!SWIG_IsOK(ecode2)) {
22830 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_metaDown_set" "', expected argument " "2"" of type '" "bool""'");
22831 }
22832 arg2 = static_cast< bool >(val2);
22833 if (arg1) (arg1)->m_metaDown = arg2;
22834
22835 resultobj = SWIG_Py_Void();
22836 return resultobj;
22837 fail:
22838 return NULL;
22839 }
22840
22841
22842 SWIGINTERN PyObject *_wrap_KeyEvent_m_metaDown_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22843 PyObject *resultobj = 0;
22844 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22845 bool result;
22846 void *argp1 = 0 ;
22847 int res1 = 0 ;
22848 PyObject *swig_obj[1] ;
22849
22850 if (!args) SWIG_fail;
22851 swig_obj[0] = args;
22852 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22853 if (!SWIG_IsOK(res1)) {
22854 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_metaDown_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22855 }
22856 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22857 result = (bool) ((arg1)->m_metaDown);
22858 {
22859 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22860 }
22861 return resultobj;
22862 fail:
22863 return NULL;
22864 }
22865
22866
22867 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22868 PyObject *resultobj = 0;
22869 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22870 bool arg2 ;
22871 void *argp1 = 0 ;
22872 int res1 = 0 ;
22873 bool val2 ;
22874 int ecode2 = 0 ;
22875 PyObject *swig_obj[2] ;
22876
22877 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_scanCode_set",2,2,swig_obj)) SWIG_fail;
22878 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22879 if (!SWIG_IsOK(res1)) {
22880 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22881 }
22882 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22883 ecode2 = SWIG_AsVal_bool(swig_obj[1], &val2);
22884 if (!SWIG_IsOK(ecode2)) {
22885 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_scanCode_set" "', expected argument " "2"" of type '" "bool""'");
22886 }
22887 arg2 = static_cast< bool >(val2);
22888 if (arg1) (arg1)->m_scanCode = arg2;
22889
22890 resultobj = SWIG_Py_Void();
22891 return resultobj;
22892 fail:
22893 return NULL;
22894 }
22895
22896
22897 SWIGINTERN PyObject *_wrap_KeyEvent_m_scanCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22898 PyObject *resultobj = 0;
22899 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22900 bool result;
22901 void *argp1 = 0 ;
22902 int res1 = 0 ;
22903 PyObject *swig_obj[1] ;
22904
22905 if (!args) SWIG_fail;
22906 swig_obj[0] = args;
22907 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22908 if (!SWIG_IsOK(res1)) {
22909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_scanCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22910 }
22911 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22912 result = (bool) ((arg1)->m_scanCode);
22913 {
22914 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
22915 }
22916 return resultobj;
22917 fail:
22918 return NULL;
22919 }
22920
22921
22922 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22923 PyObject *resultobj = 0;
22924 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22925 unsigned int arg2 ;
22926 void *argp1 = 0 ;
22927 int res1 = 0 ;
22928 unsigned int val2 ;
22929 int ecode2 = 0 ;
22930 PyObject *swig_obj[2] ;
22931
22932 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawCode_set",2,2,swig_obj)) SWIG_fail;
22933 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22934 if (!SWIG_IsOK(res1)) {
22935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22936 }
22937 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22938 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22939 if (!SWIG_IsOK(ecode2)) {
22940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawCode_set" "', expected argument " "2"" of type '" "unsigned int""'");
22941 }
22942 arg2 = static_cast< unsigned int >(val2);
22943 if (arg1) (arg1)->m_rawCode = arg2;
22944
22945 resultobj = SWIG_Py_Void();
22946 return resultobj;
22947 fail:
22948 return NULL;
22949 }
22950
22951
22952 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawCode_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22953 PyObject *resultobj = 0;
22954 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22955 unsigned int result;
22956 void *argp1 = 0 ;
22957 int res1 = 0 ;
22958 PyObject *swig_obj[1] ;
22959
22960 if (!args) SWIG_fail;
22961 swig_obj[0] = args;
22962 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22963 if (!SWIG_IsOK(res1)) {
22964 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawCode_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22965 }
22966 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22967 result = (unsigned int) ((arg1)->m_rawCode);
22968 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
22969 return resultobj;
22970 fail:
22971 return NULL;
22972 }
22973
22974
22975 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
22976 PyObject *resultobj = 0;
22977 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
22978 unsigned int arg2 ;
22979 void *argp1 = 0 ;
22980 int res1 = 0 ;
22981 unsigned int val2 ;
22982 int ecode2 = 0 ;
22983 PyObject *swig_obj[2] ;
22984
22985 if (!SWIG_Python_UnpackTuple(args,"KeyEvent_m_rawFlags_set",2,2,swig_obj)) SWIG_fail;
22986 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
22987 if (!SWIG_IsOK(res1)) {
22988 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
22989 }
22990 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
22991 ecode2 = SWIG_AsVal_unsigned_SS_int(swig_obj[1], &val2);
22992 if (!SWIG_IsOK(ecode2)) {
22993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "KeyEvent_m_rawFlags_set" "', expected argument " "2"" of type '" "unsigned int""'");
22994 }
22995 arg2 = static_cast< unsigned int >(val2);
22996 if (arg1) (arg1)->m_rawFlags = arg2;
22997
22998 resultobj = SWIG_Py_Void();
22999 return resultobj;
23000 fail:
23001 return NULL;
23002 }
23003
23004
23005 SWIGINTERN PyObject *_wrap_KeyEvent_m_rawFlags_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23006 PyObject *resultobj = 0;
23007 wxKeyEvent *arg1 = (wxKeyEvent *) 0 ;
23008 unsigned int result;
23009 void *argp1 = 0 ;
23010 int res1 = 0 ;
23011 PyObject *swig_obj[1] ;
23012
23013 if (!args) SWIG_fail;
23014 swig_obj[0] = args;
23015 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxKeyEvent, 0 | 0 );
23016 if (!SWIG_IsOK(res1)) {
23017 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "KeyEvent_m_rawFlags_get" "', expected argument " "1"" of type '" "wxKeyEvent *""'");
23018 }
23019 arg1 = reinterpret_cast< wxKeyEvent * >(argp1);
23020 result = (unsigned int) ((arg1)->m_rawFlags);
23021 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
23022 return resultobj;
23023 fail:
23024 return NULL;
23025 }
23026
23027
23028 SWIGINTERN PyObject *KeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23029 PyObject *obj;
23030 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23031 SWIG_TypeNewClientData(SWIGTYPE_p_wxKeyEvent, SWIG_NewClientData(obj));
23032 return SWIG_Py_Void();
23033 }
23034
23035 SWIGINTERN PyObject *KeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23036 return SWIG_Python_InitShadowInstance(args);
23037 }
23038
23039 SWIGINTERN PyObject *_wrap_new_SizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23040 PyObject *resultobj = 0;
23041 wxSize const &arg1_defvalue = wxDefaultSize ;
23042 wxSize *arg1 = (wxSize *) &arg1_defvalue ;
23043 int arg2 = (int) 0 ;
23044 wxSizeEvent *result = 0 ;
23045 wxSize temp1 ;
23046 int val2 ;
23047 int ecode2 = 0 ;
23048 PyObject * obj0 = 0 ;
23049 PyObject * obj1 = 0 ;
23050 char * kwnames[] = {
23051 (char *) "sz",(char *) "winid", NULL
23052 };
23053
23054 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_SizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23055 if (obj0) {
23056 {
23057 arg1 = &temp1;
23058 if ( ! wxSize_helper(obj0, &arg1)) SWIG_fail;
23059 }
23060 }
23061 if (obj1) {
23062 ecode2 = SWIG_AsVal_int(obj1, &val2);
23063 if (!SWIG_IsOK(ecode2)) {
23064 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizeEvent" "', expected argument " "2"" of type '" "int""'");
23065 }
23066 arg2 = static_cast< int >(val2);
23067 }
23068 {
23069 PyThreadState* __tstate = wxPyBeginAllowThreads();
23070 result = (wxSizeEvent *)new wxSizeEvent((wxSize const &)*arg1,arg2);
23071 wxPyEndAllowThreads(__tstate);
23072 if (PyErr_Occurred()) SWIG_fail;
23073 }
23074 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizeEvent, SWIG_POINTER_NEW | 0 );
23075 return resultobj;
23076 fail:
23077 return NULL;
23078 }
23079
23080
23081 SWIGINTERN PyObject *_wrap_SizeEvent_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23082 PyObject *resultobj = 0;
23083 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23084 wxSize result;
23085 void *argp1 = 0 ;
23086 int res1 = 0 ;
23087 PyObject *swig_obj[1] ;
23088
23089 if (!args) SWIG_fail;
23090 swig_obj[0] = args;
23091 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23092 if (!SWIG_IsOK(res1)) {
23093 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetSize" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23094 }
23095 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23096 {
23097 PyThreadState* __tstate = wxPyBeginAllowThreads();
23098 result = ((wxSizeEvent const *)arg1)->GetSize();
23099 wxPyEndAllowThreads(__tstate);
23100 if (PyErr_Occurred()) SWIG_fail;
23101 }
23102 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
23103 return resultobj;
23104 fail:
23105 return NULL;
23106 }
23107
23108
23109 SWIGINTERN PyObject *_wrap_SizeEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23110 PyObject *resultobj = 0;
23111 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23112 wxRect result;
23113 void *argp1 = 0 ;
23114 int res1 = 0 ;
23115 PyObject *swig_obj[1] ;
23116
23117 if (!args) SWIG_fail;
23118 swig_obj[0] = args;
23119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23120 if (!SWIG_IsOK(res1)) {
23121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_GetRect" "', expected argument " "1"" of type '" "wxSizeEvent const *""'");
23122 }
23123 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23124 {
23125 PyThreadState* __tstate = wxPyBeginAllowThreads();
23126 result = ((wxSizeEvent const *)arg1)->GetRect();
23127 wxPyEndAllowThreads(__tstate);
23128 if (PyErr_Occurred()) SWIG_fail;
23129 }
23130 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23131 return resultobj;
23132 fail:
23133 return NULL;
23134 }
23135
23136
23137 SWIGINTERN PyObject *_wrap_SizeEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23138 PyObject *resultobj = 0;
23139 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23140 wxRect arg2 ;
23141 void *argp1 = 0 ;
23142 int res1 = 0 ;
23143 void *argp2 ;
23144 int res2 = 0 ;
23145 PyObject * obj0 = 0 ;
23146 PyObject * obj1 = 0 ;
23147 char * kwnames[] = {
23148 (char *) "self",(char *) "rect", NULL
23149 };
23150
23151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23153 if (!SWIG_IsOK(res1)) {
23154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetRect" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23155 }
23156 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23157 {
23158 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxRect, 0 | 0);
23159 if (!SWIG_IsOK(res2)) {
23160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23161 }
23162 if (!argp2) {
23163 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetRect" "', expected argument " "2"" of type '" "wxRect""'");
23164 } else {
23165 wxRect * temp = reinterpret_cast< wxRect * >(argp2);
23166 arg2 = *temp;
23167 if (SWIG_IsNewObj(res2)) delete temp;
23168 }
23169 }
23170 {
23171 PyThreadState* __tstate = wxPyBeginAllowThreads();
23172 (arg1)->SetRect(arg2);
23173 wxPyEndAllowThreads(__tstate);
23174 if (PyErr_Occurred()) SWIG_fail;
23175 }
23176 resultobj = SWIG_Py_Void();
23177 return resultobj;
23178 fail:
23179 return NULL;
23180 }
23181
23182
23183 SWIGINTERN PyObject *_wrap_SizeEvent_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23184 PyObject *resultobj = 0;
23185 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23186 wxSize arg2 ;
23187 void *argp1 = 0 ;
23188 int res1 = 0 ;
23189 void *argp2 ;
23190 int res2 = 0 ;
23191 PyObject * obj0 = 0 ;
23192 PyObject * obj1 = 0 ;
23193 char * kwnames[] = {
23194 (char *) "self",(char *) "size", NULL
23195 };
23196
23197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizeEvent_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
23198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23199 if (!SWIG_IsOK(res1)) {
23200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_SetSize" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23201 }
23202 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23203 {
23204 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxSize, 0 | 0);
23205 if (!SWIG_IsOK(res2)) {
23206 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23207 }
23208 if (!argp2) {
23209 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "SizeEvent_SetSize" "', expected argument " "2"" of type '" "wxSize""'");
23210 } else {
23211 wxSize * temp = reinterpret_cast< wxSize * >(argp2);
23212 arg2 = *temp;
23213 if (SWIG_IsNewObj(res2)) delete temp;
23214 }
23215 }
23216 {
23217 PyThreadState* __tstate = wxPyBeginAllowThreads();
23218 wxSizeEvent_SetSize(arg1,arg2);
23219 wxPyEndAllowThreads(__tstate);
23220 if (PyErr_Occurred()) SWIG_fail;
23221 }
23222 resultobj = SWIG_Py_Void();
23223 return resultobj;
23224 fail:
23225 return NULL;
23226 }
23227
23228
23229 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23230 PyObject *resultobj = 0;
23231 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23232 wxSize *arg2 = (wxSize *) 0 ;
23233 void *argp1 = 0 ;
23234 int res1 = 0 ;
23235 void *argp2 = 0 ;
23236 int res2 = 0 ;
23237 PyObject *swig_obj[2] ;
23238
23239 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_size_set",2,2,swig_obj)) SWIG_fail;
23240 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23241 if (!SWIG_IsOK(res1)) {
23242 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23243 }
23244 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23245 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSize, 0 | 0 );
23246 if (!SWIG_IsOK(res2)) {
23247 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_size_set" "', expected argument " "2"" of type '" "wxSize *""'");
23248 }
23249 arg2 = reinterpret_cast< wxSize * >(argp2);
23250 if (arg1) (arg1)->m_size = *arg2;
23251
23252 resultobj = SWIG_Py_Void();
23253 return resultobj;
23254 fail:
23255 return NULL;
23256 }
23257
23258
23259 SWIGINTERN PyObject *_wrap_SizeEvent_m_size_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23260 PyObject *resultobj = 0;
23261 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23262 wxSize *result = 0 ;
23263 void *argp1 = 0 ;
23264 int res1 = 0 ;
23265 PyObject *swig_obj[1] ;
23266
23267 if (!args) SWIG_fail;
23268 swig_obj[0] = args;
23269 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23270 if (!SWIG_IsOK(res1)) {
23271 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_size_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23272 }
23273 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23274 result = (wxSize *)& ((arg1)->m_size);
23275 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
23276 return resultobj;
23277 fail:
23278 return NULL;
23279 }
23280
23281
23282 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23283 PyObject *resultobj = 0;
23284 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23285 wxRect *arg2 = (wxRect *) 0 ;
23286 void *argp1 = 0 ;
23287 int res1 = 0 ;
23288 void *argp2 = 0 ;
23289 int res2 = 0 ;
23290 PyObject *swig_obj[2] ;
23291
23292 if (!SWIG_Python_UnpackTuple(args,"SizeEvent_m_rect_set",2,2,swig_obj)) SWIG_fail;
23293 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23294 if (!SWIG_IsOK(res1)) {
23295 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_set" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23296 }
23297 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23298 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxRect, 0 | 0 );
23299 if (!SWIG_IsOK(res2)) {
23300 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizeEvent_m_rect_set" "', expected argument " "2"" of type '" "wxRect *""'");
23301 }
23302 arg2 = reinterpret_cast< wxRect * >(argp2);
23303 if (arg1) (arg1)->m_rect = *arg2;
23304
23305 resultobj = SWIG_Py_Void();
23306 return resultobj;
23307 fail:
23308 return NULL;
23309 }
23310
23311
23312 SWIGINTERN PyObject *_wrap_SizeEvent_m_rect_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23313 PyObject *resultobj = 0;
23314 wxSizeEvent *arg1 = (wxSizeEvent *) 0 ;
23315 wxRect *result = 0 ;
23316 void *argp1 = 0 ;
23317 int res1 = 0 ;
23318 PyObject *swig_obj[1] ;
23319
23320 if (!args) SWIG_fail;
23321 swig_obj[0] = args;
23322 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizeEvent, 0 | 0 );
23323 if (!SWIG_IsOK(res1)) {
23324 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizeEvent_m_rect_get" "', expected argument " "1"" of type '" "wxSizeEvent *""'");
23325 }
23326 arg1 = reinterpret_cast< wxSizeEvent * >(argp1);
23327 result = (wxRect *)& ((arg1)->m_rect);
23328 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRect, 0 | 0 );
23329 return resultobj;
23330 fail:
23331 return NULL;
23332 }
23333
23334
23335 SWIGINTERN PyObject *SizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23336 PyObject *obj;
23337 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23338 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizeEvent, SWIG_NewClientData(obj));
23339 return SWIG_Py_Void();
23340 }
23341
23342 SWIGINTERN PyObject *SizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23343 return SWIG_Python_InitShadowInstance(args);
23344 }
23345
23346 SWIGINTERN PyObject *_wrap_new_MoveEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23347 PyObject *resultobj = 0;
23348 wxPoint const &arg1_defvalue = wxDefaultPosition ;
23349 wxPoint *arg1 = (wxPoint *) &arg1_defvalue ;
23350 int arg2 = (int) 0 ;
23351 wxMoveEvent *result = 0 ;
23352 wxPoint temp1 ;
23353 int val2 ;
23354 int ecode2 = 0 ;
23355 PyObject * obj0 = 0 ;
23356 PyObject * obj1 = 0 ;
23357 char * kwnames[] = {
23358 (char *) "pos",(char *) "winid", NULL
23359 };
23360
23361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MoveEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23362 if (obj0) {
23363 {
23364 arg1 = &temp1;
23365 if ( ! wxPoint_helper(obj0, &arg1)) SWIG_fail;
23366 }
23367 }
23368 if (obj1) {
23369 ecode2 = SWIG_AsVal_int(obj1, &val2);
23370 if (!SWIG_IsOK(ecode2)) {
23371 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MoveEvent" "', expected argument " "2"" of type '" "int""'");
23372 }
23373 arg2 = static_cast< int >(val2);
23374 }
23375 {
23376 PyThreadState* __tstate = wxPyBeginAllowThreads();
23377 result = (wxMoveEvent *)new wxMoveEvent((wxPoint const &)*arg1,arg2);
23378 wxPyEndAllowThreads(__tstate);
23379 if (PyErr_Occurred()) SWIG_fail;
23380 }
23381 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMoveEvent, SWIG_POINTER_NEW | 0 );
23382 return resultobj;
23383 fail:
23384 return NULL;
23385 }
23386
23387
23388 SWIGINTERN PyObject *_wrap_MoveEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23389 PyObject *resultobj = 0;
23390 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23391 wxPoint result;
23392 void *argp1 = 0 ;
23393 int res1 = 0 ;
23394 PyObject *swig_obj[1] ;
23395
23396 if (!args) SWIG_fail;
23397 swig_obj[0] = args;
23398 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23399 if (!SWIG_IsOK(res1)) {
23400 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetPosition" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23401 }
23402 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23403 {
23404 PyThreadState* __tstate = wxPyBeginAllowThreads();
23405 result = ((wxMoveEvent const *)arg1)->GetPosition();
23406 wxPyEndAllowThreads(__tstate);
23407 if (PyErr_Occurred()) SWIG_fail;
23408 }
23409 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
23410 return resultobj;
23411 fail:
23412 return NULL;
23413 }
23414
23415
23416 SWIGINTERN PyObject *_wrap_MoveEvent_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23417 PyObject *resultobj = 0;
23418 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23419 wxRect result;
23420 void *argp1 = 0 ;
23421 int res1 = 0 ;
23422 PyObject *swig_obj[1] ;
23423
23424 if (!args) SWIG_fail;
23425 swig_obj[0] = args;
23426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23427 if (!SWIG_IsOK(res1)) {
23428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_GetRect" "', expected argument " "1"" of type '" "wxMoveEvent const *""'");
23429 }
23430 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23431 {
23432 PyThreadState* __tstate = wxPyBeginAllowThreads();
23433 result = ((wxMoveEvent const *)arg1)->GetRect();
23434 wxPyEndAllowThreads(__tstate);
23435 if (PyErr_Occurred()) SWIG_fail;
23436 }
23437 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
23438 return resultobj;
23439 fail:
23440 return NULL;
23441 }
23442
23443
23444 SWIGINTERN PyObject *_wrap_MoveEvent_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23445 PyObject *resultobj = 0;
23446 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23447 wxRect *arg2 = 0 ;
23448 void *argp1 = 0 ;
23449 int res1 = 0 ;
23450 wxRect temp2 ;
23451 PyObject * obj0 = 0 ;
23452 PyObject * obj1 = 0 ;
23453 char * kwnames[] = {
23454 (char *) "self",(char *) "rect", NULL
23455 };
23456
23457 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetRect",kwnames,&obj0,&obj1)) SWIG_fail;
23458 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23459 if (!SWIG_IsOK(res1)) {
23460 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetRect" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23461 }
23462 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23463 {
23464 arg2 = &temp2;
23465 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
23466 }
23467 {
23468 PyThreadState* __tstate = wxPyBeginAllowThreads();
23469 (arg1)->SetRect((wxRect const &)*arg2);
23470 wxPyEndAllowThreads(__tstate);
23471 if (PyErr_Occurred()) SWIG_fail;
23472 }
23473 resultobj = SWIG_Py_Void();
23474 return resultobj;
23475 fail:
23476 return NULL;
23477 }
23478
23479
23480 SWIGINTERN PyObject *_wrap_MoveEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23481 PyObject *resultobj = 0;
23482 wxMoveEvent *arg1 = (wxMoveEvent *) 0 ;
23483 wxPoint *arg2 = 0 ;
23484 void *argp1 = 0 ;
23485 int res1 = 0 ;
23486 wxPoint temp2 ;
23487 PyObject * obj0 = 0 ;
23488 PyObject * obj1 = 0 ;
23489 char * kwnames[] = {
23490 (char *) "self",(char *) "pos", NULL
23491 };
23492
23493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MoveEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
23494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMoveEvent, 0 | 0 );
23495 if (!SWIG_IsOK(res1)) {
23496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MoveEvent_SetPosition" "', expected argument " "1"" of type '" "wxMoveEvent *""'");
23497 }
23498 arg1 = reinterpret_cast< wxMoveEvent * >(argp1);
23499 {
23500 arg2 = &temp2;
23501 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
23502 }
23503 {
23504 PyThreadState* __tstate = wxPyBeginAllowThreads();
23505 (arg1)->SetPosition((wxPoint const &)*arg2);
23506 wxPyEndAllowThreads(__tstate);
23507 if (PyErr_Occurred()) SWIG_fail;
23508 }
23509 resultobj = SWIG_Py_Void();
23510 return resultobj;
23511 fail:
23512 return NULL;
23513 }
23514
23515
23516 SWIGINTERN PyObject *MoveEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23517 PyObject *obj;
23518 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23519 SWIG_TypeNewClientData(SWIGTYPE_p_wxMoveEvent, SWIG_NewClientData(obj));
23520 return SWIG_Py_Void();
23521 }
23522
23523 SWIGINTERN PyObject *MoveEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23524 return SWIG_Python_InitShadowInstance(args);
23525 }
23526
23527 SWIGINTERN PyObject *_wrap_new_PaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23528 PyObject *resultobj = 0;
23529 int arg1 = (int) 0 ;
23530 wxPaintEvent *result = 0 ;
23531 int val1 ;
23532 int ecode1 = 0 ;
23533 PyObject * obj0 = 0 ;
23534 char * kwnames[] = {
23535 (char *) "Id", NULL
23536 };
23537
23538 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaintEvent",kwnames,&obj0)) SWIG_fail;
23539 if (obj0) {
23540 ecode1 = SWIG_AsVal_int(obj0, &val1);
23541 if (!SWIG_IsOK(ecode1)) {
23542 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaintEvent" "', expected argument " "1"" of type '" "int""'");
23543 }
23544 arg1 = static_cast< int >(val1);
23545 }
23546 {
23547 PyThreadState* __tstate = wxPyBeginAllowThreads();
23548 result = (wxPaintEvent *)new wxPaintEvent(arg1);
23549 wxPyEndAllowThreads(__tstate);
23550 if (PyErr_Occurred()) SWIG_fail;
23551 }
23552 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaintEvent, SWIG_POINTER_NEW | 0 );
23553 return resultobj;
23554 fail:
23555 return NULL;
23556 }
23557
23558
23559 SWIGINTERN PyObject *PaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23560 PyObject *obj;
23561 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23562 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaintEvent, SWIG_NewClientData(obj));
23563 return SWIG_Py_Void();
23564 }
23565
23566 SWIGINTERN PyObject *PaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23567 return SWIG_Python_InitShadowInstance(args);
23568 }
23569
23570 SWIGINTERN PyObject *_wrap_new_NcPaintEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23571 PyObject *resultobj = 0;
23572 int arg1 = (int) 0 ;
23573 wxNcPaintEvent *result = 0 ;
23574 int val1 ;
23575 int ecode1 = 0 ;
23576 PyObject * obj0 = 0 ;
23577 char * kwnames[] = {
23578 (char *) "winid", NULL
23579 };
23580
23581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_NcPaintEvent",kwnames,&obj0)) SWIG_fail;
23582 if (obj0) {
23583 ecode1 = SWIG_AsVal_int(obj0, &val1);
23584 if (!SWIG_IsOK(ecode1)) {
23585 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_NcPaintEvent" "', expected argument " "1"" of type '" "int""'");
23586 }
23587 arg1 = static_cast< int >(val1);
23588 }
23589 {
23590 PyThreadState* __tstate = wxPyBeginAllowThreads();
23591 result = (wxNcPaintEvent *)new wxNcPaintEvent(arg1);
23592 wxPyEndAllowThreads(__tstate);
23593 if (PyErr_Occurred()) SWIG_fail;
23594 }
23595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNcPaintEvent, SWIG_POINTER_NEW | 0 );
23596 return resultobj;
23597 fail:
23598 return NULL;
23599 }
23600
23601
23602 SWIGINTERN PyObject *NcPaintEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23603 PyObject *obj;
23604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23605 SWIG_TypeNewClientData(SWIGTYPE_p_wxNcPaintEvent, SWIG_NewClientData(obj));
23606 return SWIG_Py_Void();
23607 }
23608
23609 SWIGINTERN PyObject *NcPaintEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23610 return SWIG_Python_InitShadowInstance(args);
23611 }
23612
23613 SWIGINTERN PyObject *_wrap_new_EraseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23614 PyObject *resultobj = 0;
23615 int arg1 = (int) 0 ;
23616 wxDC *arg2 = (wxDC *) NULL ;
23617 wxEraseEvent *result = 0 ;
23618 int val1 ;
23619 int ecode1 = 0 ;
23620 void *argp2 = 0 ;
23621 int res2 = 0 ;
23622 PyObject * obj0 = 0 ;
23623 PyObject * obj1 = 0 ;
23624 char * kwnames[] = {
23625 (char *) "Id",(char *) "dc", NULL
23626 };
23627
23628 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_EraseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23629 if (obj0) {
23630 ecode1 = SWIG_AsVal_int(obj0, &val1);
23631 if (!SWIG_IsOK(ecode1)) {
23632 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_EraseEvent" "', expected argument " "1"" of type '" "int""'");
23633 }
23634 arg1 = static_cast< int >(val1);
23635 }
23636 if (obj1) {
23637 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxDC, 0 | 0 );
23638 if (!SWIG_IsOK(res2)) {
23639 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_EraseEvent" "', expected argument " "2"" of type '" "wxDC *""'");
23640 }
23641 arg2 = reinterpret_cast< wxDC * >(argp2);
23642 }
23643 {
23644 PyThreadState* __tstate = wxPyBeginAllowThreads();
23645 result = (wxEraseEvent *)new wxEraseEvent(arg1,arg2);
23646 wxPyEndAllowThreads(__tstate);
23647 if (PyErr_Occurred()) SWIG_fail;
23648 }
23649 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEraseEvent, SWIG_POINTER_NEW | 0 );
23650 return resultobj;
23651 fail:
23652 return NULL;
23653 }
23654
23655
23656 SWIGINTERN PyObject *_wrap_EraseEvent_GetDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23657 PyObject *resultobj = 0;
23658 wxEraseEvent *arg1 = (wxEraseEvent *) 0 ;
23659 wxDC *result = 0 ;
23660 void *argp1 = 0 ;
23661 int res1 = 0 ;
23662 PyObject *swig_obj[1] ;
23663
23664 if (!args) SWIG_fail;
23665 swig_obj[0] = args;
23666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEraseEvent, 0 | 0 );
23667 if (!SWIG_IsOK(res1)) {
23668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EraseEvent_GetDC" "', expected argument " "1"" of type '" "wxEraseEvent const *""'");
23669 }
23670 arg1 = reinterpret_cast< wxEraseEvent * >(argp1);
23671 {
23672 PyThreadState* __tstate = wxPyBeginAllowThreads();
23673 result = (wxDC *)((wxEraseEvent const *)arg1)->GetDC();
23674 wxPyEndAllowThreads(__tstate);
23675 if (PyErr_Occurred()) SWIG_fail;
23676 }
23677 {
23678 resultobj = wxPyMake_wxObject(result, (bool)0);
23679 }
23680 return resultobj;
23681 fail:
23682 return NULL;
23683 }
23684
23685
23686 SWIGINTERN PyObject *EraseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23687 PyObject *obj;
23688 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23689 SWIG_TypeNewClientData(SWIGTYPE_p_wxEraseEvent, SWIG_NewClientData(obj));
23690 return SWIG_Py_Void();
23691 }
23692
23693 SWIGINTERN PyObject *EraseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23694 return SWIG_Python_InitShadowInstance(args);
23695 }
23696
23697 SWIGINTERN PyObject *_wrap_new_FocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23698 PyObject *resultobj = 0;
23699 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23700 int arg2 = (int) 0 ;
23701 wxFocusEvent *result = 0 ;
23702 int val1 ;
23703 int ecode1 = 0 ;
23704 int val2 ;
23705 int ecode2 = 0 ;
23706 PyObject * obj0 = 0 ;
23707 PyObject * obj1 = 0 ;
23708 char * kwnames[] = {
23709 (char *) "type",(char *) "winid", NULL
23710 };
23711
23712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_FocusEvent",kwnames,&obj0,&obj1)) SWIG_fail;
23713 if (obj0) {
23714 ecode1 = SWIG_AsVal_int(obj0, &val1);
23715 if (!SWIG_IsOK(ecode1)) {
23716 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FocusEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23717 }
23718 arg1 = static_cast< wxEventType >(val1);
23719 }
23720 if (obj1) {
23721 ecode2 = SWIG_AsVal_int(obj1, &val2);
23722 if (!SWIG_IsOK(ecode2)) {
23723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FocusEvent" "', expected argument " "2"" of type '" "int""'");
23724 }
23725 arg2 = static_cast< int >(val2);
23726 }
23727 {
23728 PyThreadState* __tstate = wxPyBeginAllowThreads();
23729 result = (wxFocusEvent *)new wxFocusEvent(arg1,arg2);
23730 wxPyEndAllowThreads(__tstate);
23731 if (PyErr_Occurred()) SWIG_fail;
23732 }
23733 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFocusEvent, SWIG_POINTER_NEW | 0 );
23734 return resultobj;
23735 fail:
23736 return NULL;
23737 }
23738
23739
23740 SWIGINTERN PyObject *_wrap_FocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23741 PyObject *resultobj = 0;
23742 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23743 wxWindow *result = 0 ;
23744 void *argp1 = 0 ;
23745 int res1 = 0 ;
23746 PyObject *swig_obj[1] ;
23747
23748 if (!args) SWIG_fail;
23749 swig_obj[0] = args;
23750 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23751 if (!SWIG_IsOK(res1)) {
23752 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxFocusEvent const *""'");
23753 }
23754 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23755 {
23756 PyThreadState* __tstate = wxPyBeginAllowThreads();
23757 result = (wxWindow *)((wxFocusEvent const *)arg1)->GetWindow();
23758 wxPyEndAllowThreads(__tstate);
23759 if (PyErr_Occurred()) SWIG_fail;
23760 }
23761 {
23762 resultobj = wxPyMake_wxObject(result, (bool)0);
23763 }
23764 return resultobj;
23765 fail:
23766 return NULL;
23767 }
23768
23769
23770 SWIGINTERN PyObject *_wrap_FocusEvent_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23771 PyObject *resultobj = 0;
23772 wxFocusEvent *arg1 = (wxFocusEvent *) 0 ;
23773 wxWindow *arg2 = (wxWindow *) 0 ;
23774 void *argp1 = 0 ;
23775 int res1 = 0 ;
23776 void *argp2 = 0 ;
23777 int res2 = 0 ;
23778 PyObject * obj0 = 0 ;
23779 PyObject * obj1 = 0 ;
23780 char * kwnames[] = {
23781 (char *) "self",(char *) "win", NULL
23782 };
23783
23784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FocusEvent_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
23785 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFocusEvent, 0 | 0 );
23786 if (!SWIG_IsOK(res1)) {
23787 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FocusEvent_SetWindow" "', expected argument " "1"" of type '" "wxFocusEvent *""'");
23788 }
23789 arg1 = reinterpret_cast< wxFocusEvent * >(argp1);
23790 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
23791 if (!SWIG_IsOK(res2)) {
23792 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FocusEvent_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
23793 }
23794 arg2 = reinterpret_cast< wxWindow * >(argp2);
23795 {
23796 PyThreadState* __tstate = wxPyBeginAllowThreads();
23797 (arg1)->SetWindow(arg2);
23798 wxPyEndAllowThreads(__tstate);
23799 if (PyErr_Occurred()) SWIG_fail;
23800 }
23801 resultobj = SWIG_Py_Void();
23802 return resultobj;
23803 fail:
23804 return NULL;
23805 }
23806
23807
23808 SWIGINTERN PyObject *FocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23809 PyObject *obj;
23810 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23811 SWIG_TypeNewClientData(SWIGTYPE_p_wxFocusEvent, SWIG_NewClientData(obj));
23812 return SWIG_Py_Void();
23813 }
23814
23815 SWIGINTERN PyObject *FocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23816 return SWIG_Python_InitShadowInstance(args);
23817 }
23818
23819 SWIGINTERN PyObject *_wrap_new_ChildFocusEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23820 PyObject *resultobj = 0;
23821 wxWindow *arg1 = (wxWindow *) NULL ;
23822 wxChildFocusEvent *result = 0 ;
23823 void *argp1 = 0 ;
23824 int res1 = 0 ;
23825 PyObject * obj0 = 0 ;
23826 char * kwnames[] = {
23827 (char *) "win", NULL
23828 };
23829
23830 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_ChildFocusEvent",kwnames,&obj0)) SWIG_fail;
23831 if (obj0) {
23832 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
23833 if (!SWIG_IsOK(res1)) {
23834 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_ChildFocusEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
23835 }
23836 arg1 = reinterpret_cast< wxWindow * >(argp1);
23837 }
23838 {
23839 PyThreadState* __tstate = wxPyBeginAllowThreads();
23840 result = (wxChildFocusEvent *)new wxChildFocusEvent(arg1);
23841 wxPyEndAllowThreads(__tstate);
23842 if (PyErr_Occurred()) SWIG_fail;
23843 }
23844 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxChildFocusEvent, SWIG_POINTER_NEW | 0 );
23845 return resultobj;
23846 fail:
23847 return NULL;
23848 }
23849
23850
23851 SWIGINTERN PyObject *_wrap_ChildFocusEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23852 PyObject *resultobj = 0;
23853 wxChildFocusEvent *arg1 = (wxChildFocusEvent *) 0 ;
23854 wxWindow *result = 0 ;
23855 void *argp1 = 0 ;
23856 int res1 = 0 ;
23857 PyObject *swig_obj[1] ;
23858
23859 if (!args) SWIG_fail;
23860 swig_obj[0] = args;
23861 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxChildFocusEvent, 0 | 0 );
23862 if (!SWIG_IsOK(res1)) {
23863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ChildFocusEvent_GetWindow" "', expected argument " "1"" of type '" "wxChildFocusEvent const *""'");
23864 }
23865 arg1 = reinterpret_cast< wxChildFocusEvent * >(argp1);
23866 {
23867 PyThreadState* __tstate = wxPyBeginAllowThreads();
23868 result = (wxWindow *)((wxChildFocusEvent const *)arg1)->GetWindow();
23869 wxPyEndAllowThreads(__tstate);
23870 if (PyErr_Occurred()) SWIG_fail;
23871 }
23872 {
23873 resultobj = wxPyMake_wxObject(result, (bool)0);
23874 }
23875 return resultobj;
23876 fail:
23877 return NULL;
23878 }
23879
23880
23881 SWIGINTERN PyObject *ChildFocusEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23882 PyObject *obj;
23883 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23884 SWIG_TypeNewClientData(SWIGTYPE_p_wxChildFocusEvent, SWIG_NewClientData(obj));
23885 return SWIG_Py_Void();
23886 }
23887
23888 SWIGINTERN PyObject *ChildFocusEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23889 return SWIG_Python_InitShadowInstance(args);
23890 }
23891
23892 SWIGINTERN PyObject *_wrap_new_ActivateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23893 PyObject *resultobj = 0;
23894 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
23895 bool arg2 = (bool) true ;
23896 int arg3 = (int) 0 ;
23897 wxActivateEvent *result = 0 ;
23898 int val1 ;
23899 int ecode1 = 0 ;
23900 bool val2 ;
23901 int ecode2 = 0 ;
23902 int val3 ;
23903 int ecode3 = 0 ;
23904 PyObject * obj0 = 0 ;
23905 PyObject * obj1 = 0 ;
23906 PyObject * obj2 = 0 ;
23907 char * kwnames[] = {
23908 (char *) "type",(char *) "active",(char *) "Id", NULL
23909 };
23910
23911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ActivateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
23912 if (obj0) {
23913 ecode1 = SWIG_AsVal_int(obj0, &val1);
23914 if (!SWIG_IsOK(ecode1)) {
23915 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ActivateEvent" "', expected argument " "1"" of type '" "wxEventType""'");
23916 }
23917 arg1 = static_cast< wxEventType >(val1);
23918 }
23919 if (obj1) {
23920 ecode2 = SWIG_AsVal_bool(obj1, &val2);
23921 if (!SWIG_IsOK(ecode2)) {
23922 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ActivateEvent" "', expected argument " "2"" of type '" "bool""'");
23923 }
23924 arg2 = static_cast< bool >(val2);
23925 }
23926 if (obj2) {
23927 ecode3 = SWIG_AsVal_int(obj2, &val3);
23928 if (!SWIG_IsOK(ecode3)) {
23929 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_ActivateEvent" "', expected argument " "3"" of type '" "int""'");
23930 }
23931 arg3 = static_cast< int >(val3);
23932 }
23933 {
23934 PyThreadState* __tstate = wxPyBeginAllowThreads();
23935 result = (wxActivateEvent *)new wxActivateEvent(arg1,arg2,arg3);
23936 wxPyEndAllowThreads(__tstate);
23937 if (PyErr_Occurred()) SWIG_fail;
23938 }
23939 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxActivateEvent, SWIG_POINTER_NEW | 0 );
23940 return resultobj;
23941 fail:
23942 return NULL;
23943 }
23944
23945
23946 SWIGINTERN PyObject *_wrap_ActivateEvent_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23947 PyObject *resultobj = 0;
23948 wxActivateEvent *arg1 = (wxActivateEvent *) 0 ;
23949 bool result;
23950 void *argp1 = 0 ;
23951 int res1 = 0 ;
23952 PyObject *swig_obj[1] ;
23953
23954 if (!args) SWIG_fail;
23955 swig_obj[0] = args;
23956 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxActivateEvent, 0 | 0 );
23957 if (!SWIG_IsOK(res1)) {
23958 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ActivateEvent_GetActive" "', expected argument " "1"" of type '" "wxActivateEvent const *""'");
23959 }
23960 arg1 = reinterpret_cast< wxActivateEvent * >(argp1);
23961 {
23962 PyThreadState* __tstate = wxPyBeginAllowThreads();
23963 result = (bool)((wxActivateEvent const *)arg1)->GetActive();
23964 wxPyEndAllowThreads(__tstate);
23965 if (PyErr_Occurred()) SWIG_fail;
23966 }
23967 {
23968 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
23969 }
23970 return resultobj;
23971 fail:
23972 return NULL;
23973 }
23974
23975
23976 SWIGINTERN PyObject *ActivateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23977 PyObject *obj;
23978 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
23979 SWIG_TypeNewClientData(SWIGTYPE_p_wxActivateEvent, SWIG_NewClientData(obj));
23980 return SWIG_Py_Void();
23981 }
23982
23983 SWIGINTERN PyObject *ActivateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
23984 return SWIG_Python_InitShadowInstance(args);
23985 }
23986
23987 SWIGINTERN PyObject *_wrap_new_InitDialogEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
23988 PyObject *resultobj = 0;
23989 int arg1 = (int) 0 ;
23990 wxInitDialogEvent *result = 0 ;
23991 int val1 ;
23992 int ecode1 = 0 ;
23993 PyObject * obj0 = 0 ;
23994 char * kwnames[] = {
23995 (char *) "Id", NULL
23996 };
23997
23998 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_InitDialogEvent",kwnames,&obj0)) SWIG_fail;
23999 if (obj0) {
24000 ecode1 = SWIG_AsVal_int(obj0, &val1);
24001 if (!SWIG_IsOK(ecode1)) {
24002 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_InitDialogEvent" "', expected argument " "1"" of type '" "int""'");
24003 }
24004 arg1 = static_cast< int >(val1);
24005 }
24006 {
24007 PyThreadState* __tstate = wxPyBeginAllowThreads();
24008 result = (wxInitDialogEvent *)new wxInitDialogEvent(arg1);
24009 wxPyEndAllowThreads(__tstate);
24010 if (PyErr_Occurred()) SWIG_fail;
24011 }
24012 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxInitDialogEvent, SWIG_POINTER_NEW | 0 );
24013 return resultobj;
24014 fail:
24015 return NULL;
24016 }
24017
24018
24019 SWIGINTERN PyObject *InitDialogEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24020 PyObject *obj;
24021 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24022 SWIG_TypeNewClientData(SWIGTYPE_p_wxInitDialogEvent, SWIG_NewClientData(obj));
24023 return SWIG_Py_Void();
24024 }
24025
24026 SWIGINTERN PyObject *InitDialogEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24027 return SWIG_Python_InitShadowInstance(args);
24028 }
24029
24030 SWIGINTERN PyObject *_wrap_new_MenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24031 PyObject *resultobj = 0;
24032 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24033 int arg2 = (int) 0 ;
24034 wxMenu *arg3 = (wxMenu *) NULL ;
24035 wxMenuEvent *result = 0 ;
24036 int val1 ;
24037 int ecode1 = 0 ;
24038 int val2 ;
24039 int ecode2 = 0 ;
24040 void *argp3 = 0 ;
24041 int res3 = 0 ;
24042 PyObject * obj0 = 0 ;
24043 PyObject * obj1 = 0 ;
24044 PyObject * obj2 = 0 ;
24045 char * kwnames[] = {
24046 (char *) "type",(char *) "winid",(char *) "menu", NULL
24047 };
24048
24049 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_MenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
24050 if (obj0) {
24051 ecode1 = SWIG_AsVal_int(obj0, &val1);
24052 if (!SWIG_IsOK(ecode1)) {
24053 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24054 }
24055 arg1 = static_cast< wxEventType >(val1);
24056 }
24057 if (obj1) {
24058 ecode2 = SWIG_AsVal_int(obj1, &val2);
24059 if (!SWIG_IsOK(ecode2)) {
24060 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuEvent" "', expected argument " "2"" of type '" "int""'");
24061 }
24062 arg2 = static_cast< int >(val2);
24063 }
24064 if (obj2) {
24065 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
24066 if (!SWIG_IsOK(res3)) {
24067 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "new_MenuEvent" "', expected argument " "3"" of type '" "wxMenu *""'");
24068 }
24069 arg3 = reinterpret_cast< wxMenu * >(argp3);
24070 }
24071 {
24072 PyThreadState* __tstate = wxPyBeginAllowThreads();
24073 result = (wxMenuEvent *)new wxMenuEvent(arg1,arg2,arg3);
24074 wxPyEndAllowThreads(__tstate);
24075 if (PyErr_Occurred()) SWIG_fail;
24076 }
24077 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuEvent, SWIG_POINTER_NEW | 0 );
24078 return resultobj;
24079 fail:
24080 return NULL;
24081 }
24082
24083
24084 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenuId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24085 PyObject *resultobj = 0;
24086 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24087 int result;
24088 void *argp1 = 0 ;
24089 int res1 = 0 ;
24090 PyObject *swig_obj[1] ;
24091
24092 if (!args) SWIG_fail;
24093 swig_obj[0] = args;
24094 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24095 if (!SWIG_IsOK(res1)) {
24096 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenuId" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24097 }
24098 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24099 {
24100 PyThreadState* __tstate = wxPyBeginAllowThreads();
24101 result = (int)((wxMenuEvent const *)arg1)->GetMenuId();
24102 wxPyEndAllowThreads(__tstate);
24103 if (PyErr_Occurred()) SWIG_fail;
24104 }
24105 resultobj = SWIG_From_int(static_cast< int >(result));
24106 return resultobj;
24107 fail:
24108 return NULL;
24109 }
24110
24111
24112 SWIGINTERN PyObject *_wrap_MenuEvent_IsPopup(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24113 PyObject *resultobj = 0;
24114 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24115 bool result;
24116 void *argp1 = 0 ;
24117 int res1 = 0 ;
24118 PyObject *swig_obj[1] ;
24119
24120 if (!args) SWIG_fail;
24121 swig_obj[0] = args;
24122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24123 if (!SWIG_IsOK(res1)) {
24124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_IsPopup" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24125 }
24126 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24127 {
24128 PyThreadState* __tstate = wxPyBeginAllowThreads();
24129 result = (bool)((wxMenuEvent const *)arg1)->IsPopup();
24130 wxPyEndAllowThreads(__tstate);
24131 if (PyErr_Occurred()) SWIG_fail;
24132 }
24133 {
24134 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24135 }
24136 return resultobj;
24137 fail:
24138 return NULL;
24139 }
24140
24141
24142 SWIGINTERN PyObject *_wrap_MenuEvent_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24143 PyObject *resultobj = 0;
24144 wxMenuEvent *arg1 = (wxMenuEvent *) 0 ;
24145 wxMenu *result = 0 ;
24146 void *argp1 = 0 ;
24147 int res1 = 0 ;
24148 PyObject *swig_obj[1] ;
24149
24150 if (!args) SWIG_fail;
24151 swig_obj[0] = args;
24152 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuEvent, 0 | 0 );
24153 if (!SWIG_IsOK(res1)) {
24154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuEvent_GetMenu" "', expected argument " "1"" of type '" "wxMenuEvent const *""'");
24155 }
24156 arg1 = reinterpret_cast< wxMenuEvent * >(argp1);
24157 {
24158 PyThreadState* __tstate = wxPyBeginAllowThreads();
24159 result = (wxMenu *)((wxMenuEvent const *)arg1)->GetMenu();
24160 wxPyEndAllowThreads(__tstate);
24161 if (PyErr_Occurred()) SWIG_fail;
24162 }
24163 {
24164 resultobj = wxPyMake_wxObject(result, (bool)0);
24165 }
24166 return resultobj;
24167 fail:
24168 return NULL;
24169 }
24170
24171
24172 SWIGINTERN PyObject *MenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24173 PyObject *obj;
24174 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24175 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuEvent, SWIG_NewClientData(obj));
24176 return SWIG_Py_Void();
24177 }
24178
24179 SWIGINTERN PyObject *MenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24180 return SWIG_Python_InitShadowInstance(args);
24181 }
24182
24183 SWIGINTERN PyObject *_wrap_new_CloseEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24184 PyObject *resultobj = 0;
24185 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
24186 int arg2 = (int) 0 ;
24187 wxCloseEvent *result = 0 ;
24188 int val1 ;
24189 int ecode1 = 0 ;
24190 int val2 ;
24191 int ecode2 = 0 ;
24192 PyObject * obj0 = 0 ;
24193 PyObject * obj1 = 0 ;
24194 char * kwnames[] = {
24195 (char *) "type",(char *) "winid", NULL
24196 };
24197
24198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_CloseEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24199 if (obj0) {
24200 ecode1 = SWIG_AsVal_int(obj0, &val1);
24201 if (!SWIG_IsOK(ecode1)) {
24202 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_CloseEvent" "', expected argument " "1"" of type '" "wxEventType""'");
24203 }
24204 arg1 = static_cast< wxEventType >(val1);
24205 }
24206 if (obj1) {
24207 ecode2 = SWIG_AsVal_int(obj1, &val2);
24208 if (!SWIG_IsOK(ecode2)) {
24209 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_CloseEvent" "', expected argument " "2"" of type '" "int""'");
24210 }
24211 arg2 = static_cast< int >(val2);
24212 }
24213 {
24214 PyThreadState* __tstate = wxPyBeginAllowThreads();
24215 result = (wxCloseEvent *)new wxCloseEvent(arg1,arg2);
24216 wxPyEndAllowThreads(__tstate);
24217 if (PyErr_Occurred()) SWIG_fail;
24218 }
24219 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCloseEvent, SWIG_POINTER_NEW | 0 );
24220 return resultobj;
24221 fail:
24222 return NULL;
24223 }
24224
24225
24226 SWIGINTERN PyObject *_wrap_CloseEvent_SetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24227 PyObject *resultobj = 0;
24228 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24229 bool arg2 ;
24230 void *argp1 = 0 ;
24231 int res1 = 0 ;
24232 bool val2 ;
24233 int ecode2 = 0 ;
24234 PyObject * obj0 = 0 ;
24235 PyObject * obj1 = 0 ;
24236 char * kwnames[] = {
24237 (char *) "self",(char *) "logOff", NULL
24238 };
24239
24240 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetLoggingOff",kwnames,&obj0,&obj1)) SWIG_fail;
24241 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24242 if (!SWIG_IsOK(res1)) {
24243 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24244 }
24245 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24246 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24247 if (!SWIG_IsOK(ecode2)) {
24248 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetLoggingOff" "', expected argument " "2"" of type '" "bool""'");
24249 }
24250 arg2 = static_cast< bool >(val2);
24251 {
24252 PyThreadState* __tstate = wxPyBeginAllowThreads();
24253 (arg1)->SetLoggingOff(arg2);
24254 wxPyEndAllowThreads(__tstate);
24255 if (PyErr_Occurred()) SWIG_fail;
24256 }
24257 resultobj = SWIG_Py_Void();
24258 return resultobj;
24259 fail:
24260 return NULL;
24261 }
24262
24263
24264 SWIGINTERN PyObject *_wrap_CloseEvent_GetLoggingOff(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24265 PyObject *resultobj = 0;
24266 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24267 bool result;
24268 void *argp1 = 0 ;
24269 int res1 = 0 ;
24270 PyObject *swig_obj[1] ;
24271
24272 if (!args) SWIG_fail;
24273 swig_obj[0] = args;
24274 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24275 if (!SWIG_IsOK(res1)) {
24276 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetLoggingOff" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24277 }
24278 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24279 {
24280 PyThreadState* __tstate = wxPyBeginAllowThreads();
24281 result = (bool)((wxCloseEvent const *)arg1)->GetLoggingOff();
24282 wxPyEndAllowThreads(__tstate);
24283 if (PyErr_Occurred()) SWIG_fail;
24284 }
24285 {
24286 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24287 }
24288 return resultobj;
24289 fail:
24290 return NULL;
24291 }
24292
24293
24294 SWIGINTERN PyObject *_wrap_CloseEvent_Veto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24295 PyObject *resultobj = 0;
24296 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24297 bool arg2 = (bool) true ;
24298 void *argp1 = 0 ;
24299 int res1 = 0 ;
24300 bool val2 ;
24301 int ecode2 = 0 ;
24302 PyObject * obj0 = 0 ;
24303 PyObject * obj1 = 0 ;
24304 char * kwnames[] = {
24305 (char *) "self",(char *) "veto", NULL
24306 };
24307
24308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:CloseEvent_Veto",kwnames,&obj0,&obj1)) SWIG_fail;
24309 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24310 if (!SWIG_IsOK(res1)) {
24311 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_Veto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24312 }
24313 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24314 if (obj1) {
24315 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24316 if (!SWIG_IsOK(ecode2)) {
24317 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_Veto" "', expected argument " "2"" of type '" "bool""'");
24318 }
24319 arg2 = static_cast< bool >(val2);
24320 }
24321 {
24322 PyThreadState* __tstate = wxPyBeginAllowThreads();
24323 (arg1)->Veto(arg2);
24324 wxPyEndAllowThreads(__tstate);
24325 if (PyErr_Occurred()) SWIG_fail;
24326 }
24327 resultobj = SWIG_Py_Void();
24328 return resultobj;
24329 fail:
24330 return NULL;
24331 }
24332
24333
24334 SWIGINTERN PyObject *_wrap_CloseEvent_GetVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24335 PyObject *resultobj = 0;
24336 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24337 bool result;
24338 void *argp1 = 0 ;
24339 int res1 = 0 ;
24340 PyObject *swig_obj[1] ;
24341
24342 if (!args) SWIG_fail;
24343 swig_obj[0] = args;
24344 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24345 if (!SWIG_IsOK(res1)) {
24346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_GetVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24347 }
24348 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24349 {
24350 PyThreadState* __tstate = wxPyBeginAllowThreads();
24351 result = (bool)((wxCloseEvent const *)arg1)->GetVeto();
24352 wxPyEndAllowThreads(__tstate);
24353 if (PyErr_Occurred()) SWIG_fail;
24354 }
24355 {
24356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24357 }
24358 return resultobj;
24359 fail:
24360 return NULL;
24361 }
24362
24363
24364 SWIGINTERN PyObject *_wrap_CloseEvent_SetCanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24365 PyObject *resultobj = 0;
24366 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24367 bool arg2 ;
24368 void *argp1 = 0 ;
24369 int res1 = 0 ;
24370 bool val2 ;
24371 int ecode2 = 0 ;
24372 PyObject * obj0 = 0 ;
24373 PyObject * obj1 = 0 ;
24374 char * kwnames[] = {
24375 (char *) "self",(char *) "canVeto", NULL
24376 };
24377
24378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:CloseEvent_SetCanVeto",kwnames,&obj0,&obj1)) SWIG_fail;
24379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24380 if (!SWIG_IsOK(res1)) {
24381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "1"" of type '" "wxCloseEvent *""'");
24382 }
24383 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24384 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24385 if (!SWIG_IsOK(ecode2)) {
24386 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "CloseEvent_SetCanVeto" "', expected argument " "2"" of type '" "bool""'");
24387 }
24388 arg2 = static_cast< bool >(val2);
24389 {
24390 PyThreadState* __tstate = wxPyBeginAllowThreads();
24391 (arg1)->SetCanVeto(arg2);
24392 wxPyEndAllowThreads(__tstate);
24393 if (PyErr_Occurred()) SWIG_fail;
24394 }
24395 resultobj = SWIG_Py_Void();
24396 return resultobj;
24397 fail:
24398 return NULL;
24399 }
24400
24401
24402 SWIGINTERN PyObject *_wrap_CloseEvent_CanVeto(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24403 PyObject *resultobj = 0;
24404 wxCloseEvent *arg1 = (wxCloseEvent *) 0 ;
24405 bool result;
24406 void *argp1 = 0 ;
24407 int res1 = 0 ;
24408 PyObject *swig_obj[1] ;
24409
24410 if (!args) SWIG_fail;
24411 swig_obj[0] = args;
24412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxCloseEvent, 0 | 0 );
24413 if (!SWIG_IsOK(res1)) {
24414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "CloseEvent_CanVeto" "', expected argument " "1"" of type '" "wxCloseEvent const *""'");
24415 }
24416 arg1 = reinterpret_cast< wxCloseEvent * >(argp1);
24417 {
24418 PyThreadState* __tstate = wxPyBeginAllowThreads();
24419 result = (bool)((wxCloseEvent const *)arg1)->CanVeto();
24420 wxPyEndAllowThreads(__tstate);
24421 if (PyErr_Occurred()) SWIG_fail;
24422 }
24423 {
24424 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24425 }
24426 return resultobj;
24427 fail:
24428 return NULL;
24429 }
24430
24431
24432 SWIGINTERN PyObject *CloseEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24433 PyObject *obj;
24434 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24435 SWIG_TypeNewClientData(SWIGTYPE_p_wxCloseEvent, SWIG_NewClientData(obj));
24436 return SWIG_Py_Void();
24437 }
24438
24439 SWIGINTERN PyObject *CloseEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24440 return SWIG_Python_InitShadowInstance(args);
24441 }
24442
24443 SWIGINTERN PyObject *_wrap_new_ShowEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24444 PyObject *resultobj = 0;
24445 int arg1 = (int) 0 ;
24446 bool arg2 = (bool) false ;
24447 wxShowEvent *result = 0 ;
24448 int val1 ;
24449 int ecode1 = 0 ;
24450 bool val2 ;
24451 int ecode2 = 0 ;
24452 PyObject * obj0 = 0 ;
24453 PyObject * obj1 = 0 ;
24454 char * kwnames[] = {
24455 (char *) "winid",(char *) "show", NULL
24456 };
24457
24458 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ShowEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24459 if (obj0) {
24460 ecode1 = SWIG_AsVal_int(obj0, &val1);
24461 if (!SWIG_IsOK(ecode1)) {
24462 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ShowEvent" "', expected argument " "1"" of type '" "int""'");
24463 }
24464 arg1 = static_cast< int >(val1);
24465 }
24466 if (obj1) {
24467 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24468 if (!SWIG_IsOK(ecode2)) {
24469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ShowEvent" "', expected argument " "2"" of type '" "bool""'");
24470 }
24471 arg2 = static_cast< bool >(val2);
24472 }
24473 {
24474 PyThreadState* __tstate = wxPyBeginAllowThreads();
24475 result = (wxShowEvent *)new wxShowEvent(arg1,arg2);
24476 wxPyEndAllowThreads(__tstate);
24477 if (PyErr_Occurred()) SWIG_fail;
24478 }
24479 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxShowEvent, SWIG_POINTER_NEW | 0 );
24480 return resultobj;
24481 fail:
24482 return NULL;
24483 }
24484
24485
24486 SWIGINTERN PyObject *_wrap_ShowEvent_SetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24487 PyObject *resultobj = 0;
24488 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24489 bool arg2 ;
24490 void *argp1 = 0 ;
24491 int res1 = 0 ;
24492 bool val2 ;
24493 int ecode2 = 0 ;
24494 PyObject * obj0 = 0 ;
24495 PyObject * obj1 = 0 ;
24496 char * kwnames[] = {
24497 (char *) "self",(char *) "show", NULL
24498 };
24499
24500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ShowEvent_SetShow",kwnames,&obj0,&obj1)) SWIG_fail;
24501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24502 if (!SWIG_IsOK(res1)) {
24503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_SetShow" "', expected argument " "1"" of type '" "wxShowEvent *""'");
24504 }
24505 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24506 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24507 if (!SWIG_IsOK(ecode2)) {
24508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ShowEvent_SetShow" "', expected argument " "2"" of type '" "bool""'");
24509 }
24510 arg2 = static_cast< bool >(val2);
24511 {
24512 PyThreadState* __tstate = wxPyBeginAllowThreads();
24513 (arg1)->SetShow(arg2);
24514 wxPyEndAllowThreads(__tstate);
24515 if (PyErr_Occurred()) SWIG_fail;
24516 }
24517 resultobj = SWIG_Py_Void();
24518 return resultobj;
24519 fail:
24520 return NULL;
24521 }
24522
24523
24524 SWIGINTERN PyObject *_wrap_ShowEvent_GetShow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24525 PyObject *resultobj = 0;
24526 wxShowEvent *arg1 = (wxShowEvent *) 0 ;
24527 bool result;
24528 void *argp1 = 0 ;
24529 int res1 = 0 ;
24530 PyObject *swig_obj[1] ;
24531
24532 if (!args) SWIG_fail;
24533 swig_obj[0] = args;
24534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxShowEvent, 0 | 0 );
24535 if (!SWIG_IsOK(res1)) {
24536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ShowEvent_GetShow" "', expected argument " "1"" of type '" "wxShowEvent const *""'");
24537 }
24538 arg1 = reinterpret_cast< wxShowEvent * >(argp1);
24539 {
24540 PyThreadState* __tstate = wxPyBeginAllowThreads();
24541 result = (bool)((wxShowEvent const *)arg1)->GetShow();
24542 wxPyEndAllowThreads(__tstate);
24543 if (PyErr_Occurred()) SWIG_fail;
24544 }
24545 {
24546 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24547 }
24548 return resultobj;
24549 fail:
24550 return NULL;
24551 }
24552
24553
24554 SWIGINTERN PyObject *ShowEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24555 PyObject *obj;
24556 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24557 SWIG_TypeNewClientData(SWIGTYPE_p_wxShowEvent, SWIG_NewClientData(obj));
24558 return SWIG_Py_Void();
24559 }
24560
24561 SWIGINTERN PyObject *ShowEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24562 return SWIG_Python_InitShadowInstance(args);
24563 }
24564
24565 SWIGINTERN PyObject *_wrap_new_IconizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24566 PyObject *resultobj = 0;
24567 int arg1 = (int) 0 ;
24568 bool arg2 = (bool) true ;
24569 wxIconizeEvent *result = 0 ;
24570 int val1 ;
24571 int ecode1 = 0 ;
24572 bool val2 ;
24573 int ecode2 = 0 ;
24574 PyObject * obj0 = 0 ;
24575 PyObject * obj1 = 0 ;
24576 char * kwnames[] = {
24577 (char *) "id",(char *) "iconized", NULL
24578 };
24579
24580 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_IconizeEvent",kwnames,&obj0,&obj1)) SWIG_fail;
24581 if (obj0) {
24582 ecode1 = SWIG_AsVal_int(obj0, &val1);
24583 if (!SWIG_IsOK(ecode1)) {
24584 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_IconizeEvent" "', expected argument " "1"" of type '" "int""'");
24585 }
24586 arg1 = static_cast< int >(val1);
24587 }
24588 if (obj1) {
24589 ecode2 = SWIG_AsVal_bool(obj1, &val2);
24590 if (!SWIG_IsOK(ecode2)) {
24591 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_IconizeEvent" "', expected argument " "2"" of type '" "bool""'");
24592 }
24593 arg2 = static_cast< bool >(val2);
24594 }
24595 {
24596 PyThreadState* __tstate = wxPyBeginAllowThreads();
24597 result = (wxIconizeEvent *)new wxIconizeEvent(arg1,arg2);
24598 wxPyEndAllowThreads(__tstate);
24599 if (PyErr_Occurred()) SWIG_fail;
24600 }
24601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIconizeEvent, SWIG_POINTER_NEW | 0 );
24602 return resultobj;
24603 fail:
24604 return NULL;
24605 }
24606
24607
24608 SWIGINTERN PyObject *_wrap_IconizeEvent_Iconized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24609 PyObject *resultobj = 0;
24610 wxIconizeEvent *arg1 = (wxIconizeEvent *) 0 ;
24611 bool result;
24612 void *argp1 = 0 ;
24613 int res1 = 0 ;
24614 PyObject *swig_obj[1] ;
24615
24616 if (!args) SWIG_fail;
24617 swig_obj[0] = args;
24618 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIconizeEvent, 0 | 0 );
24619 if (!SWIG_IsOK(res1)) {
24620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IconizeEvent_Iconized" "', expected argument " "1"" of type '" "wxIconizeEvent *""'");
24621 }
24622 arg1 = reinterpret_cast< wxIconizeEvent * >(argp1);
24623 {
24624 PyThreadState* __tstate = wxPyBeginAllowThreads();
24625 result = (bool)(arg1)->Iconized();
24626 wxPyEndAllowThreads(__tstate);
24627 if (PyErr_Occurred()) SWIG_fail;
24628 }
24629 {
24630 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24631 }
24632 return resultobj;
24633 fail:
24634 return NULL;
24635 }
24636
24637
24638 SWIGINTERN PyObject *IconizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24639 PyObject *obj;
24640 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24641 SWIG_TypeNewClientData(SWIGTYPE_p_wxIconizeEvent, SWIG_NewClientData(obj));
24642 return SWIG_Py_Void();
24643 }
24644
24645 SWIGINTERN PyObject *IconizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24646 return SWIG_Python_InitShadowInstance(args);
24647 }
24648
24649 SWIGINTERN PyObject *_wrap_new_MaximizeEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24650 PyObject *resultobj = 0;
24651 int arg1 = (int) 0 ;
24652 wxMaximizeEvent *result = 0 ;
24653 int val1 ;
24654 int ecode1 = 0 ;
24655 PyObject * obj0 = 0 ;
24656 char * kwnames[] = {
24657 (char *) "id", NULL
24658 };
24659
24660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MaximizeEvent",kwnames,&obj0)) SWIG_fail;
24661 if (obj0) {
24662 ecode1 = SWIG_AsVal_int(obj0, &val1);
24663 if (!SWIG_IsOK(ecode1)) {
24664 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MaximizeEvent" "', expected argument " "1"" of type '" "int""'");
24665 }
24666 arg1 = static_cast< int >(val1);
24667 }
24668 {
24669 PyThreadState* __tstate = wxPyBeginAllowThreads();
24670 result = (wxMaximizeEvent *)new wxMaximizeEvent(arg1);
24671 wxPyEndAllowThreads(__tstate);
24672 if (PyErr_Occurred()) SWIG_fail;
24673 }
24674 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMaximizeEvent, SWIG_POINTER_NEW | 0 );
24675 return resultobj;
24676 fail:
24677 return NULL;
24678 }
24679
24680
24681 SWIGINTERN PyObject *MaximizeEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24682 PyObject *obj;
24683 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24684 SWIG_TypeNewClientData(SWIGTYPE_p_wxMaximizeEvent, SWIG_NewClientData(obj));
24685 return SWIG_Py_Void();
24686 }
24687
24688 SWIGINTERN PyObject *MaximizeEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24689 return SWIG_Python_InitShadowInstance(args);
24690 }
24691
24692 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24693 PyObject *resultobj = 0;
24694 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24695 wxPoint result;
24696 void *argp1 = 0 ;
24697 int res1 = 0 ;
24698 PyObject *swig_obj[1] ;
24699
24700 if (!args) SWIG_fail;
24701 swig_obj[0] = args;
24702 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24703 if (!SWIG_IsOK(res1)) {
24704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetPosition" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24705 }
24706 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24707 {
24708 PyThreadState* __tstate = wxPyBeginAllowThreads();
24709 result = (arg1)->GetPosition();
24710 wxPyEndAllowThreads(__tstate);
24711 if (PyErr_Occurred()) SWIG_fail;
24712 }
24713 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
24714 return resultobj;
24715 fail:
24716 return NULL;
24717 }
24718
24719
24720 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetNumberOfFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24721 PyObject *resultobj = 0;
24722 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24723 int result;
24724 void *argp1 = 0 ;
24725 int res1 = 0 ;
24726 PyObject *swig_obj[1] ;
24727
24728 if (!args) SWIG_fail;
24729 swig_obj[0] = args;
24730 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24731 if (!SWIG_IsOK(res1)) {
24732 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetNumberOfFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24733 }
24734 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24735 {
24736 PyThreadState* __tstate = wxPyBeginAllowThreads();
24737 result = (int)(arg1)->GetNumberOfFiles();
24738 wxPyEndAllowThreads(__tstate);
24739 if (PyErr_Occurred()) SWIG_fail;
24740 }
24741 resultobj = SWIG_From_int(static_cast< int >(result));
24742 return resultobj;
24743 fail:
24744 return NULL;
24745 }
24746
24747
24748 SWIGINTERN PyObject *_wrap_DropFilesEvent_GetFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24749 PyObject *resultobj = 0;
24750 wxDropFilesEvent *arg1 = (wxDropFilesEvent *) 0 ;
24751 PyObject *result = 0 ;
24752 void *argp1 = 0 ;
24753 int res1 = 0 ;
24754 PyObject *swig_obj[1] ;
24755
24756 if (!args) SWIG_fail;
24757 swig_obj[0] = args;
24758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDropFilesEvent, 0 | 0 );
24759 if (!SWIG_IsOK(res1)) {
24760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DropFilesEvent_GetFiles" "', expected argument " "1"" of type '" "wxDropFilesEvent *""'");
24761 }
24762 arg1 = reinterpret_cast< wxDropFilesEvent * >(argp1);
24763 {
24764 PyThreadState* __tstate = wxPyBeginAllowThreads();
24765 result = (PyObject *)wxDropFilesEvent_GetFiles(arg1);
24766 wxPyEndAllowThreads(__tstate);
24767 if (PyErr_Occurred()) SWIG_fail;
24768 }
24769 resultobj = result;
24770 return resultobj;
24771 fail:
24772 return NULL;
24773 }
24774
24775
24776 SWIGINTERN PyObject *DropFilesEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24777 PyObject *obj;
24778 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
24779 SWIG_TypeNewClientData(SWIGTYPE_p_wxDropFilesEvent, SWIG_NewClientData(obj));
24780 return SWIG_Py_Void();
24781 }
24782
24783 SWIGINTERN PyObject *_wrap_new_UpdateUIEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
24784 PyObject *resultobj = 0;
24785 int arg1 = (int) 0 ;
24786 wxUpdateUIEvent *result = 0 ;
24787 int val1 ;
24788 int ecode1 = 0 ;
24789 PyObject * obj0 = 0 ;
24790 char * kwnames[] = {
24791 (char *) "commandId", NULL
24792 };
24793
24794 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_UpdateUIEvent",kwnames,&obj0)) SWIG_fail;
24795 if (obj0) {
24796 ecode1 = SWIG_AsVal_int(obj0, &val1);
24797 if (!SWIG_IsOK(ecode1)) {
24798 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_UpdateUIEvent" "', expected argument " "1"" of type '" "int""'");
24799 }
24800 arg1 = static_cast< int >(val1);
24801 }
24802 {
24803 PyThreadState* __tstate = wxPyBeginAllowThreads();
24804 result = (wxUpdateUIEvent *)new wxUpdateUIEvent(arg1);
24805 wxPyEndAllowThreads(__tstate);
24806 if (PyErr_Occurred()) SWIG_fail;
24807 }
24808 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxUpdateUIEvent, SWIG_POINTER_NEW | 0 );
24809 return resultobj;
24810 fail:
24811 return NULL;
24812 }
24813
24814
24815 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24816 PyObject *resultobj = 0;
24817 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24818 bool result;
24819 void *argp1 = 0 ;
24820 int res1 = 0 ;
24821 PyObject *swig_obj[1] ;
24822
24823 if (!args) SWIG_fail;
24824 swig_obj[0] = args;
24825 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24826 if (!SWIG_IsOK(res1)) {
24827 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24828 }
24829 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24830 {
24831 PyThreadState* __tstate = wxPyBeginAllowThreads();
24832 result = (bool)((wxUpdateUIEvent const *)arg1)->GetChecked();
24833 wxPyEndAllowThreads(__tstate);
24834 if (PyErr_Occurred()) SWIG_fail;
24835 }
24836 {
24837 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24838 }
24839 return resultobj;
24840 fail:
24841 return NULL;
24842 }
24843
24844
24845 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24846 PyObject *resultobj = 0;
24847 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24848 bool result;
24849 void *argp1 = 0 ;
24850 int res1 = 0 ;
24851 PyObject *swig_obj[1] ;
24852
24853 if (!args) SWIG_fail;
24854 swig_obj[0] = args;
24855 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24856 if (!SWIG_IsOK(res1)) {
24857 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24858 }
24859 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24860 {
24861 PyThreadState* __tstate = wxPyBeginAllowThreads();
24862 result = (bool)((wxUpdateUIEvent const *)arg1)->GetEnabled();
24863 wxPyEndAllowThreads(__tstate);
24864 if (PyErr_Occurred()) SWIG_fail;
24865 }
24866 {
24867 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24868 }
24869 return resultobj;
24870 fail:
24871 return NULL;
24872 }
24873
24874
24875 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24876 PyObject *resultobj = 0;
24877 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24878 bool result;
24879 void *argp1 = 0 ;
24880 int res1 = 0 ;
24881 PyObject *swig_obj[1] ;
24882
24883 if (!args) SWIG_fail;
24884 swig_obj[0] = args;
24885 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24886 if (!SWIG_IsOK(res1)) {
24887 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24888 }
24889 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24890 {
24891 PyThreadState* __tstate = wxPyBeginAllowThreads();
24892 result = (bool)((wxUpdateUIEvent const *)arg1)->GetShown();
24893 wxPyEndAllowThreads(__tstate);
24894 if (PyErr_Occurred()) SWIG_fail;
24895 }
24896 {
24897 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24898 }
24899 return resultobj;
24900 fail:
24901 return NULL;
24902 }
24903
24904
24905 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24906 PyObject *resultobj = 0;
24907 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24908 wxString result;
24909 void *argp1 = 0 ;
24910 int res1 = 0 ;
24911 PyObject *swig_obj[1] ;
24912
24913 if (!args) SWIG_fail;
24914 swig_obj[0] = args;
24915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24916 if (!SWIG_IsOK(res1)) {
24917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24918 }
24919 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24920 {
24921 PyThreadState* __tstate = wxPyBeginAllowThreads();
24922 result = ((wxUpdateUIEvent const *)arg1)->GetText();
24923 wxPyEndAllowThreads(__tstate);
24924 if (PyErr_Occurred()) SWIG_fail;
24925 }
24926 {
24927 #if wxUSE_UNICODE
24928 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
24929 #else
24930 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
24931 #endif
24932 }
24933 return resultobj;
24934 fail:
24935 return NULL;
24936 }
24937
24938
24939 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24940 PyObject *resultobj = 0;
24941 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24942 bool result;
24943 void *argp1 = 0 ;
24944 int res1 = 0 ;
24945 PyObject *swig_obj[1] ;
24946
24947 if (!args) SWIG_fail;
24948 swig_obj[0] = args;
24949 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24950 if (!SWIG_IsOK(res1)) {
24951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24952 }
24953 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24954 {
24955 PyThreadState* __tstate = wxPyBeginAllowThreads();
24956 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetText();
24957 wxPyEndAllowThreads(__tstate);
24958 if (PyErr_Occurred()) SWIG_fail;
24959 }
24960 {
24961 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24962 }
24963 return resultobj;
24964 fail:
24965 return NULL;
24966 }
24967
24968
24969 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
24970 PyObject *resultobj = 0;
24971 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
24972 bool result;
24973 void *argp1 = 0 ;
24974 int res1 = 0 ;
24975 PyObject *swig_obj[1] ;
24976
24977 if (!args) SWIG_fail;
24978 swig_obj[0] = args;
24979 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
24980 if (!SWIG_IsOK(res1)) {
24981 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetChecked" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
24982 }
24983 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
24984 {
24985 PyThreadState* __tstate = wxPyBeginAllowThreads();
24986 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetChecked();
24987 wxPyEndAllowThreads(__tstate);
24988 if (PyErr_Occurred()) SWIG_fail;
24989 }
24990 {
24991 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
24992 }
24993 return resultobj;
24994 fail:
24995 return NULL;
24996 }
24997
24998
24999 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25000 PyObject *resultobj = 0;
25001 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25002 bool result;
25003 void *argp1 = 0 ;
25004 int res1 = 0 ;
25005 PyObject *swig_obj[1] ;
25006
25007 if (!args) SWIG_fail;
25008 swig_obj[0] = args;
25009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25010 if (!SWIG_IsOK(res1)) {
25011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetEnabled" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25012 }
25013 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25014 {
25015 PyThreadState* __tstate = wxPyBeginAllowThreads();
25016 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetEnabled();
25017 wxPyEndAllowThreads(__tstate);
25018 if (PyErr_Occurred()) SWIG_fail;
25019 }
25020 {
25021 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25022 }
25023 return resultobj;
25024 fail:
25025 return NULL;
25026 }
25027
25028
25029 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetSetShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25030 PyObject *resultobj = 0;
25031 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25032 bool result;
25033 void *argp1 = 0 ;
25034 int res1 = 0 ;
25035 PyObject *swig_obj[1] ;
25036
25037 if (!args) SWIG_fail;
25038 swig_obj[0] = args;
25039 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25040 if (!SWIG_IsOK(res1)) {
25041 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_GetSetShown" "', expected argument " "1"" of type '" "wxUpdateUIEvent const *""'");
25042 }
25043 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25044 {
25045 PyThreadState* __tstate = wxPyBeginAllowThreads();
25046 result = (bool)((wxUpdateUIEvent const *)arg1)->GetSetShown();
25047 wxPyEndAllowThreads(__tstate);
25048 if (PyErr_Occurred()) SWIG_fail;
25049 }
25050 {
25051 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25052 }
25053 return resultobj;
25054 fail:
25055 return NULL;
25056 }
25057
25058
25059 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25060 PyObject *resultobj = 0;
25061 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25062 bool arg2 ;
25063 void *argp1 = 0 ;
25064 int res1 = 0 ;
25065 bool val2 ;
25066 int ecode2 = 0 ;
25067 PyObject * obj0 = 0 ;
25068 PyObject * obj1 = 0 ;
25069 char * kwnames[] = {
25070 (char *) "self",(char *) "check", NULL
25071 };
25072
25073 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Check",kwnames,&obj0,&obj1)) SWIG_fail;
25074 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25075 if (!SWIG_IsOK(res1)) {
25076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Check" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25077 }
25078 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25079 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25080 if (!SWIG_IsOK(ecode2)) {
25081 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Check" "', expected argument " "2"" of type '" "bool""'");
25082 }
25083 arg2 = static_cast< bool >(val2);
25084 {
25085 PyThreadState* __tstate = wxPyBeginAllowThreads();
25086 (arg1)->Check(arg2);
25087 wxPyEndAllowThreads(__tstate);
25088 if (PyErr_Occurred()) SWIG_fail;
25089 }
25090 resultobj = SWIG_Py_Void();
25091 return resultobj;
25092 fail:
25093 return NULL;
25094 }
25095
25096
25097 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25098 PyObject *resultobj = 0;
25099 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25100 bool arg2 ;
25101 void *argp1 = 0 ;
25102 int res1 = 0 ;
25103 bool val2 ;
25104 int ecode2 = 0 ;
25105 PyObject * obj0 = 0 ;
25106 PyObject * obj1 = 0 ;
25107 char * kwnames[] = {
25108 (char *) "self",(char *) "enable", NULL
25109 };
25110
25111 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
25112 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25113 if (!SWIG_IsOK(res1)) {
25114 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Enable" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25115 }
25116 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25117 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25118 if (!SWIG_IsOK(ecode2)) {
25119 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Enable" "', expected argument " "2"" of type '" "bool""'");
25120 }
25121 arg2 = static_cast< bool >(val2);
25122 {
25123 PyThreadState* __tstate = wxPyBeginAllowThreads();
25124 (arg1)->Enable(arg2);
25125 wxPyEndAllowThreads(__tstate);
25126 if (PyErr_Occurred()) SWIG_fail;
25127 }
25128 resultobj = SWIG_Py_Void();
25129 return resultobj;
25130 fail:
25131 return NULL;
25132 }
25133
25134
25135 SWIGINTERN PyObject *_wrap_UpdateUIEvent_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25136 PyObject *resultobj = 0;
25137 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25138 bool arg2 ;
25139 void *argp1 = 0 ;
25140 int res1 = 0 ;
25141 bool val2 ;
25142 int ecode2 = 0 ;
25143 PyObject * obj0 = 0 ;
25144 PyObject * obj1 = 0 ;
25145 char * kwnames[] = {
25146 (char *) "self",(char *) "show", NULL
25147 };
25148
25149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_Show",kwnames,&obj0,&obj1)) SWIG_fail;
25150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25151 if (!SWIG_IsOK(res1)) {
25152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_Show" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25153 }
25154 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25155 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25156 if (!SWIG_IsOK(ecode2)) {
25157 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "UpdateUIEvent_Show" "', expected argument " "2"" of type '" "bool""'");
25158 }
25159 arg2 = static_cast< bool >(val2);
25160 {
25161 PyThreadState* __tstate = wxPyBeginAllowThreads();
25162 (arg1)->Show(arg2);
25163 wxPyEndAllowThreads(__tstate);
25164 if (PyErr_Occurred()) SWIG_fail;
25165 }
25166 resultobj = SWIG_Py_Void();
25167 return resultobj;
25168 fail:
25169 return NULL;
25170 }
25171
25172
25173 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25174 PyObject *resultobj = 0;
25175 wxUpdateUIEvent *arg1 = (wxUpdateUIEvent *) 0 ;
25176 wxString *arg2 = 0 ;
25177 void *argp1 = 0 ;
25178 int res1 = 0 ;
25179 bool temp2 = false ;
25180 PyObject * obj0 = 0 ;
25181 PyObject * obj1 = 0 ;
25182 char * kwnames[] = {
25183 (char *) "self",(char *) "text", NULL
25184 };
25185
25186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:UpdateUIEvent_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
25187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxUpdateUIEvent, 0 | 0 );
25188 if (!SWIG_IsOK(res1)) {
25189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_SetText" "', expected argument " "1"" of type '" "wxUpdateUIEvent *""'");
25190 }
25191 arg1 = reinterpret_cast< wxUpdateUIEvent * >(argp1);
25192 {
25193 arg2 = wxString_in_helper(obj1);
25194 if (arg2 == NULL) SWIG_fail;
25195 temp2 = true;
25196 }
25197 {
25198 PyThreadState* __tstate = wxPyBeginAllowThreads();
25199 (arg1)->SetText((wxString const &)*arg2);
25200 wxPyEndAllowThreads(__tstate);
25201 if (PyErr_Occurred()) SWIG_fail;
25202 }
25203 resultobj = SWIG_Py_Void();
25204 {
25205 if (temp2)
25206 delete arg2;
25207 }
25208 return resultobj;
25209 fail:
25210 {
25211 if (temp2)
25212 delete arg2;
25213 }
25214 return NULL;
25215 }
25216
25217
25218 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25219 PyObject *resultobj = 0;
25220 long arg1 ;
25221 long val1 ;
25222 int ecode1 = 0 ;
25223 PyObject * obj0 = 0 ;
25224 char * kwnames[] = {
25225 (char *) "updateInterval", NULL
25226 };
25227
25228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetUpdateInterval",kwnames,&obj0)) SWIG_fail;
25229 ecode1 = SWIG_AsVal_long(obj0, &val1);
25230 if (!SWIG_IsOK(ecode1)) {
25231 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetUpdateInterval" "', expected argument " "1"" of type '" "long""'");
25232 }
25233 arg1 = static_cast< long >(val1);
25234 {
25235 PyThreadState* __tstate = wxPyBeginAllowThreads();
25236 wxUpdateUIEvent::SetUpdateInterval(arg1);
25237 wxPyEndAllowThreads(__tstate);
25238 if (PyErr_Occurred()) SWIG_fail;
25239 }
25240 resultobj = SWIG_Py_Void();
25241 return resultobj;
25242 fail:
25243 return NULL;
25244 }
25245
25246
25247 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetUpdateInterval(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25248 PyObject *resultobj = 0;
25249 long result;
25250
25251 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetUpdateInterval",0,0,0)) SWIG_fail;
25252 {
25253 PyThreadState* __tstate = wxPyBeginAllowThreads();
25254 result = (long)wxUpdateUIEvent::GetUpdateInterval();
25255 wxPyEndAllowThreads(__tstate);
25256 if (PyErr_Occurred()) SWIG_fail;
25257 }
25258 resultobj = SWIG_From_long(static_cast< long >(result));
25259 return resultobj;
25260 fail:
25261 return NULL;
25262 }
25263
25264
25265 SWIGINTERN PyObject *_wrap_UpdateUIEvent_CanUpdate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25266 PyObject *resultobj = 0;
25267 wxWindow *arg1 = (wxWindow *) 0 ;
25268 bool result;
25269 void *argp1 = 0 ;
25270 int res1 = 0 ;
25271 PyObject * obj0 = 0 ;
25272 char * kwnames[] = {
25273 (char *) "win", NULL
25274 };
25275
25276 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_CanUpdate",kwnames,&obj0)) SWIG_fail;
25277 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
25278 if (!SWIG_IsOK(res1)) {
25279 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "UpdateUIEvent_CanUpdate" "', expected argument " "1"" of type '" "wxWindow *""'");
25280 }
25281 arg1 = reinterpret_cast< wxWindow * >(argp1);
25282 {
25283 PyThreadState* __tstate = wxPyBeginAllowThreads();
25284 result = (bool)wxUpdateUIEvent::CanUpdate(arg1);
25285 wxPyEndAllowThreads(__tstate);
25286 if (PyErr_Occurred()) SWIG_fail;
25287 }
25288 {
25289 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25290 }
25291 return resultobj;
25292 fail:
25293 return NULL;
25294 }
25295
25296
25297 SWIGINTERN PyObject *_wrap_UpdateUIEvent_ResetUpdateTime(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25298 PyObject *resultobj = 0;
25299
25300 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_ResetUpdateTime",0,0,0)) SWIG_fail;
25301 {
25302 PyThreadState* __tstate = wxPyBeginAllowThreads();
25303 wxUpdateUIEvent::ResetUpdateTime();
25304 wxPyEndAllowThreads(__tstate);
25305 if (PyErr_Occurred()) SWIG_fail;
25306 }
25307 resultobj = SWIG_Py_Void();
25308 return resultobj;
25309 fail:
25310 return NULL;
25311 }
25312
25313
25314 SWIGINTERN PyObject *_wrap_UpdateUIEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25315 PyObject *resultobj = 0;
25316 wxUpdateUIMode arg1 ;
25317 int val1 ;
25318 int ecode1 = 0 ;
25319 PyObject * obj0 = 0 ;
25320 char * kwnames[] = {
25321 (char *) "mode", NULL
25322 };
25323
25324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:UpdateUIEvent_SetMode",kwnames,&obj0)) SWIG_fail;
25325 ecode1 = SWIG_AsVal_int(obj0, &val1);
25326 if (!SWIG_IsOK(ecode1)) {
25327 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "UpdateUIEvent_SetMode" "', expected argument " "1"" of type '" "wxUpdateUIMode""'");
25328 }
25329 arg1 = static_cast< wxUpdateUIMode >(val1);
25330 {
25331 PyThreadState* __tstate = wxPyBeginAllowThreads();
25332 wxUpdateUIEvent::SetMode(arg1);
25333 wxPyEndAllowThreads(__tstate);
25334 if (PyErr_Occurred()) SWIG_fail;
25335 }
25336 resultobj = SWIG_Py_Void();
25337 return resultobj;
25338 fail:
25339 return NULL;
25340 }
25341
25342
25343 SWIGINTERN PyObject *_wrap_UpdateUIEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25344 PyObject *resultobj = 0;
25345 wxUpdateUIMode result;
25346
25347 if (!SWIG_Python_UnpackTuple(args,"UpdateUIEvent_GetMode",0,0,0)) SWIG_fail;
25348 {
25349 PyThreadState* __tstate = wxPyBeginAllowThreads();
25350 result = (wxUpdateUIMode)wxUpdateUIEvent::GetMode();
25351 wxPyEndAllowThreads(__tstate);
25352 if (PyErr_Occurred()) SWIG_fail;
25353 }
25354 resultobj = SWIG_From_int(static_cast< int >(result));
25355 return resultobj;
25356 fail:
25357 return NULL;
25358 }
25359
25360
25361 SWIGINTERN PyObject *UpdateUIEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25362 PyObject *obj;
25363 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25364 SWIG_TypeNewClientData(SWIGTYPE_p_wxUpdateUIEvent, SWIG_NewClientData(obj));
25365 return SWIG_Py_Void();
25366 }
25367
25368 SWIGINTERN PyObject *UpdateUIEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25369 return SWIG_Python_InitShadowInstance(args);
25370 }
25371
25372 SWIGINTERN PyObject *_wrap_new_SysColourChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25373 PyObject *resultobj = 0;
25374 wxSysColourChangedEvent *result = 0 ;
25375
25376 if (!SWIG_Python_UnpackTuple(args,"new_SysColourChangedEvent",0,0,0)) SWIG_fail;
25377 {
25378 PyThreadState* __tstate = wxPyBeginAllowThreads();
25379 result = (wxSysColourChangedEvent *)new wxSysColourChangedEvent();
25380 wxPyEndAllowThreads(__tstate);
25381 if (PyErr_Occurred()) SWIG_fail;
25382 }
25383 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSysColourChangedEvent, SWIG_POINTER_NEW | 0 );
25384 return resultobj;
25385 fail:
25386 return NULL;
25387 }
25388
25389
25390 SWIGINTERN PyObject *SysColourChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25391 PyObject *obj;
25392 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25393 SWIG_TypeNewClientData(SWIGTYPE_p_wxSysColourChangedEvent, SWIG_NewClientData(obj));
25394 return SWIG_Py_Void();
25395 }
25396
25397 SWIGINTERN PyObject *SysColourChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25398 return SWIG_Python_InitShadowInstance(args);
25399 }
25400
25401 SWIGINTERN PyObject *_wrap_new_MouseCaptureChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25402 PyObject *resultobj = 0;
25403 int arg1 = (int) 0 ;
25404 wxWindow *arg2 = (wxWindow *) NULL ;
25405 wxMouseCaptureChangedEvent *result = 0 ;
25406 int val1 ;
25407 int ecode1 = 0 ;
25408 void *argp2 = 0 ;
25409 int res2 = 0 ;
25410 PyObject * obj0 = 0 ;
25411 PyObject * obj1 = 0 ;
25412 char * kwnames[] = {
25413 (char *) "winid",(char *) "gainedCapture", NULL
25414 };
25415
25416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_MouseCaptureChangedEvent",kwnames,&obj0,&obj1)) SWIG_fail;
25417 if (obj0) {
25418 ecode1 = SWIG_AsVal_int(obj0, &val1);
25419 if (!SWIG_IsOK(ecode1)) {
25420 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "1"" of type '" "int""'");
25421 }
25422 arg1 = static_cast< int >(val1);
25423 }
25424 if (obj1) {
25425 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25426 if (!SWIG_IsOK(res2)) {
25427 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_MouseCaptureChangedEvent" "', expected argument " "2"" of type '" "wxWindow *""'");
25428 }
25429 arg2 = reinterpret_cast< wxWindow * >(argp2);
25430 }
25431 {
25432 PyThreadState* __tstate = wxPyBeginAllowThreads();
25433 result = (wxMouseCaptureChangedEvent *)new wxMouseCaptureChangedEvent(arg1,arg2);
25434 wxPyEndAllowThreads(__tstate);
25435 if (PyErr_Occurred()) SWIG_fail;
25436 }
25437 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_POINTER_NEW | 0 );
25438 return resultobj;
25439 fail:
25440 return NULL;
25441 }
25442
25443
25444 SWIGINTERN PyObject *_wrap_MouseCaptureChangedEvent_GetCapturedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25445 PyObject *resultobj = 0;
25446 wxMouseCaptureChangedEvent *arg1 = (wxMouseCaptureChangedEvent *) 0 ;
25447 wxWindow *result = 0 ;
25448 void *argp1 = 0 ;
25449 int res1 = 0 ;
25450 PyObject *swig_obj[1] ;
25451
25452 if (!args) SWIG_fail;
25453 swig_obj[0] = args;
25454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMouseCaptureChangedEvent, 0 | 0 );
25455 if (!SWIG_IsOK(res1)) {
25456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MouseCaptureChangedEvent_GetCapturedWindow" "', expected argument " "1"" of type '" "wxMouseCaptureChangedEvent const *""'");
25457 }
25458 arg1 = reinterpret_cast< wxMouseCaptureChangedEvent * >(argp1);
25459 {
25460 PyThreadState* __tstate = wxPyBeginAllowThreads();
25461 result = (wxWindow *)((wxMouseCaptureChangedEvent const *)arg1)->GetCapturedWindow();
25462 wxPyEndAllowThreads(__tstate);
25463 if (PyErr_Occurred()) SWIG_fail;
25464 }
25465 {
25466 resultobj = wxPyMake_wxObject(result, (bool)0);
25467 }
25468 return resultobj;
25469 fail:
25470 return NULL;
25471 }
25472
25473
25474 SWIGINTERN PyObject *MouseCaptureChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25475 PyObject *obj;
25476 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25477 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureChangedEvent, SWIG_NewClientData(obj));
25478 return SWIG_Py_Void();
25479 }
25480
25481 SWIGINTERN PyObject *MouseCaptureChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25482 return SWIG_Python_InitShadowInstance(args);
25483 }
25484
25485 SWIGINTERN PyObject *_wrap_new_MouseCaptureLostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25486 PyObject *resultobj = 0;
25487 int arg1 = (int) 0 ;
25488 wxMouseCaptureLostEvent *result = 0 ;
25489 int val1 ;
25490 int ecode1 = 0 ;
25491 PyObject * obj0 = 0 ;
25492 char * kwnames[] = {
25493 (char *) "winid", NULL
25494 };
25495
25496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MouseCaptureLostEvent",kwnames,&obj0)) SWIG_fail;
25497 if (obj0) {
25498 ecode1 = SWIG_AsVal_int(obj0, &val1);
25499 if (!SWIG_IsOK(ecode1)) {
25500 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MouseCaptureLostEvent" "', expected argument " "1"" of type '" "int""'");
25501 }
25502 arg1 = static_cast< int >(val1);
25503 }
25504 {
25505 PyThreadState* __tstate = wxPyBeginAllowThreads();
25506 result = (wxMouseCaptureLostEvent *)new wxMouseCaptureLostEvent(arg1);
25507 wxPyEndAllowThreads(__tstate);
25508 if (PyErr_Occurred()) SWIG_fail;
25509 }
25510 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_POINTER_NEW | 0 );
25511 return resultobj;
25512 fail:
25513 return NULL;
25514 }
25515
25516
25517 SWIGINTERN PyObject *MouseCaptureLostEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25518 PyObject *obj;
25519 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25520 SWIG_TypeNewClientData(SWIGTYPE_p_wxMouseCaptureLostEvent, SWIG_NewClientData(obj));
25521 return SWIG_Py_Void();
25522 }
25523
25524 SWIGINTERN PyObject *MouseCaptureLostEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25525 return SWIG_Python_InitShadowInstance(args);
25526 }
25527
25528 SWIGINTERN PyObject *_wrap_new_DisplayChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25529 PyObject *resultobj = 0;
25530 wxDisplayChangedEvent *result = 0 ;
25531
25532 if (!SWIG_Python_UnpackTuple(args,"new_DisplayChangedEvent",0,0,0)) SWIG_fail;
25533 {
25534 PyThreadState* __tstate = wxPyBeginAllowThreads();
25535 result = (wxDisplayChangedEvent *)new wxDisplayChangedEvent();
25536 wxPyEndAllowThreads(__tstate);
25537 if (PyErr_Occurred()) SWIG_fail;
25538 }
25539 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDisplayChangedEvent, SWIG_POINTER_NEW | 0 );
25540 return resultobj;
25541 fail:
25542 return NULL;
25543 }
25544
25545
25546 SWIGINTERN PyObject *DisplayChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25547 PyObject *obj;
25548 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25549 SWIG_TypeNewClientData(SWIGTYPE_p_wxDisplayChangedEvent, SWIG_NewClientData(obj));
25550 return SWIG_Py_Void();
25551 }
25552
25553 SWIGINTERN PyObject *DisplayChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25554 return SWIG_Python_InitShadowInstance(args);
25555 }
25556
25557 SWIGINTERN PyObject *_wrap_new_PaletteChangedEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25558 PyObject *resultobj = 0;
25559 int arg1 = (int) 0 ;
25560 wxPaletteChangedEvent *result = 0 ;
25561 int val1 ;
25562 int ecode1 = 0 ;
25563 PyObject * obj0 = 0 ;
25564 char * kwnames[] = {
25565 (char *) "id", NULL
25566 };
25567
25568 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_PaletteChangedEvent",kwnames,&obj0)) SWIG_fail;
25569 if (obj0) {
25570 ecode1 = SWIG_AsVal_int(obj0, &val1);
25571 if (!SWIG_IsOK(ecode1)) {
25572 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PaletteChangedEvent" "', expected argument " "1"" of type '" "int""'");
25573 }
25574 arg1 = static_cast< int >(val1);
25575 }
25576 {
25577 PyThreadState* __tstate = wxPyBeginAllowThreads();
25578 result = (wxPaletteChangedEvent *)new wxPaletteChangedEvent(arg1);
25579 wxPyEndAllowThreads(__tstate);
25580 if (PyErr_Occurred()) SWIG_fail;
25581 }
25582 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPaletteChangedEvent, SWIG_POINTER_NEW | 0 );
25583 return resultobj;
25584 fail:
25585 return NULL;
25586 }
25587
25588
25589 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_SetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25590 PyObject *resultobj = 0;
25591 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25592 wxWindow *arg2 = (wxWindow *) 0 ;
25593 void *argp1 = 0 ;
25594 int res1 = 0 ;
25595 void *argp2 = 0 ;
25596 int res2 = 0 ;
25597 PyObject * obj0 = 0 ;
25598 PyObject * obj1 = 0 ;
25599 char * kwnames[] = {
25600 (char *) "self",(char *) "win", NULL
25601 };
25602
25603 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PaletteChangedEvent_SetChangedWindow",kwnames,&obj0,&obj1)) SWIG_fail;
25604 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25605 if (!SWIG_IsOK(res1)) {
25606 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25607 }
25608 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25609 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
25610 if (!SWIG_IsOK(res2)) {
25611 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PaletteChangedEvent_SetChangedWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
25612 }
25613 arg2 = reinterpret_cast< wxWindow * >(argp2);
25614 {
25615 PyThreadState* __tstate = wxPyBeginAllowThreads();
25616 (arg1)->SetChangedWindow(arg2);
25617 wxPyEndAllowThreads(__tstate);
25618 if (PyErr_Occurred()) SWIG_fail;
25619 }
25620 resultobj = SWIG_Py_Void();
25621 return resultobj;
25622 fail:
25623 return NULL;
25624 }
25625
25626
25627 SWIGINTERN PyObject *_wrap_PaletteChangedEvent_GetChangedWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25628 PyObject *resultobj = 0;
25629 wxPaletteChangedEvent *arg1 = (wxPaletteChangedEvent *) 0 ;
25630 wxWindow *result = 0 ;
25631 void *argp1 = 0 ;
25632 int res1 = 0 ;
25633 PyObject *swig_obj[1] ;
25634
25635 if (!args) SWIG_fail;
25636 swig_obj[0] = args;
25637 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPaletteChangedEvent, 0 | 0 );
25638 if (!SWIG_IsOK(res1)) {
25639 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PaletteChangedEvent_GetChangedWindow" "', expected argument " "1"" of type '" "wxPaletteChangedEvent *""'");
25640 }
25641 arg1 = reinterpret_cast< wxPaletteChangedEvent * >(argp1);
25642 {
25643 PyThreadState* __tstate = wxPyBeginAllowThreads();
25644 result = (wxWindow *)(arg1)->GetChangedWindow();
25645 wxPyEndAllowThreads(__tstate);
25646 if (PyErr_Occurred()) SWIG_fail;
25647 }
25648 {
25649 resultobj = wxPyMake_wxObject(result, (bool)0);
25650 }
25651 return resultobj;
25652 fail:
25653 return NULL;
25654 }
25655
25656
25657 SWIGINTERN PyObject *PaletteChangedEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25658 PyObject *obj;
25659 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25660 SWIG_TypeNewClientData(SWIGTYPE_p_wxPaletteChangedEvent, SWIG_NewClientData(obj));
25661 return SWIG_Py_Void();
25662 }
25663
25664 SWIGINTERN PyObject *PaletteChangedEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25665 return SWIG_Python_InitShadowInstance(args);
25666 }
25667
25668 SWIGINTERN PyObject *_wrap_new_QueryNewPaletteEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25669 PyObject *resultobj = 0;
25670 int arg1 = (int) 0 ;
25671 wxQueryNewPaletteEvent *result = 0 ;
25672 int val1 ;
25673 int ecode1 = 0 ;
25674 PyObject * obj0 = 0 ;
25675 char * kwnames[] = {
25676 (char *) "winid", NULL
25677 };
25678
25679 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_QueryNewPaletteEvent",kwnames,&obj0)) SWIG_fail;
25680 if (obj0) {
25681 ecode1 = SWIG_AsVal_int(obj0, &val1);
25682 if (!SWIG_IsOK(ecode1)) {
25683 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_QueryNewPaletteEvent" "', expected argument " "1"" of type '" "int""'");
25684 }
25685 arg1 = static_cast< int >(val1);
25686 }
25687 {
25688 PyThreadState* __tstate = wxPyBeginAllowThreads();
25689 result = (wxQueryNewPaletteEvent *)new wxQueryNewPaletteEvent(arg1);
25690 wxPyEndAllowThreads(__tstate);
25691 if (PyErr_Occurred()) SWIG_fail;
25692 }
25693 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_POINTER_NEW | 0 );
25694 return resultobj;
25695 fail:
25696 return NULL;
25697 }
25698
25699
25700 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_SetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25701 PyObject *resultobj = 0;
25702 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25703 bool arg2 ;
25704 void *argp1 = 0 ;
25705 int res1 = 0 ;
25706 bool val2 ;
25707 int ecode2 = 0 ;
25708 PyObject * obj0 = 0 ;
25709 PyObject * obj1 = 0 ;
25710 char * kwnames[] = {
25711 (char *) "self",(char *) "realized", NULL
25712 };
25713
25714 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:QueryNewPaletteEvent_SetPaletteRealized",kwnames,&obj0,&obj1)) SWIG_fail;
25715 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25716 if (!SWIG_IsOK(res1)) {
25717 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent *""'");
25718 }
25719 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25720 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25721 if (!SWIG_IsOK(ecode2)) {
25722 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "QueryNewPaletteEvent_SetPaletteRealized" "', expected argument " "2"" of type '" "bool""'");
25723 }
25724 arg2 = static_cast< bool >(val2);
25725 {
25726 PyThreadState* __tstate = wxPyBeginAllowThreads();
25727 (arg1)->SetPaletteRealized(arg2);
25728 wxPyEndAllowThreads(__tstate);
25729 if (PyErr_Occurred()) SWIG_fail;
25730 }
25731 resultobj = SWIG_Py_Void();
25732 return resultobj;
25733 fail:
25734 return NULL;
25735 }
25736
25737
25738 SWIGINTERN PyObject *_wrap_QueryNewPaletteEvent_GetPaletteRealized(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25739 PyObject *resultobj = 0;
25740 wxQueryNewPaletteEvent *arg1 = (wxQueryNewPaletteEvent *) 0 ;
25741 bool result;
25742 void *argp1 = 0 ;
25743 int res1 = 0 ;
25744 PyObject *swig_obj[1] ;
25745
25746 if (!args) SWIG_fail;
25747 swig_obj[0] = args;
25748 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxQueryNewPaletteEvent, 0 | 0 );
25749 if (!SWIG_IsOK(res1)) {
25750 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "QueryNewPaletteEvent_GetPaletteRealized" "', expected argument " "1"" of type '" "wxQueryNewPaletteEvent const *""'");
25751 }
25752 arg1 = reinterpret_cast< wxQueryNewPaletteEvent * >(argp1);
25753 {
25754 PyThreadState* __tstate = wxPyBeginAllowThreads();
25755 result = (bool)((wxQueryNewPaletteEvent const *)arg1)->GetPaletteRealized();
25756 wxPyEndAllowThreads(__tstate);
25757 if (PyErr_Occurred()) SWIG_fail;
25758 }
25759 {
25760 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25761 }
25762 return resultobj;
25763 fail:
25764 return NULL;
25765 }
25766
25767
25768 SWIGINTERN PyObject *QueryNewPaletteEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25769 PyObject *obj;
25770 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
25771 SWIG_TypeNewClientData(SWIGTYPE_p_wxQueryNewPaletteEvent, SWIG_NewClientData(obj));
25772 return SWIG_Py_Void();
25773 }
25774
25775 SWIGINTERN PyObject *QueryNewPaletteEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25776 return SWIG_Python_InitShadowInstance(args);
25777 }
25778
25779 SWIGINTERN PyObject *_wrap_new_NavigationKeyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25780 PyObject *resultobj = 0;
25781 wxNavigationKeyEvent *result = 0 ;
25782
25783 if (!SWIG_Python_UnpackTuple(args,"new_NavigationKeyEvent",0,0,0)) SWIG_fail;
25784 {
25785 PyThreadState* __tstate = wxPyBeginAllowThreads();
25786 result = (wxNavigationKeyEvent *)new wxNavigationKeyEvent();
25787 wxPyEndAllowThreads(__tstate);
25788 if (PyErr_Occurred()) SWIG_fail;
25789 }
25790 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxNavigationKeyEvent, SWIG_POINTER_NEW | 0 );
25791 return resultobj;
25792 fail:
25793 return NULL;
25794 }
25795
25796
25797 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25798 PyObject *resultobj = 0;
25799 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25800 bool result;
25801 void *argp1 = 0 ;
25802 int res1 = 0 ;
25803 PyObject *swig_obj[1] ;
25804
25805 if (!args) SWIG_fail;
25806 swig_obj[0] = args;
25807 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25808 if (!SWIG_IsOK(res1)) {
25809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25810 }
25811 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25812 {
25813 PyThreadState* __tstate = wxPyBeginAllowThreads();
25814 result = (bool)((wxNavigationKeyEvent const *)arg1)->GetDirection();
25815 wxPyEndAllowThreads(__tstate);
25816 if (PyErr_Occurred()) SWIG_fail;
25817 }
25818 {
25819 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25820 }
25821 return resultobj;
25822 fail:
25823 return NULL;
25824 }
25825
25826
25827 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25828 PyObject *resultobj = 0;
25829 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25830 bool arg2 ;
25831 void *argp1 = 0 ;
25832 int res1 = 0 ;
25833 bool val2 ;
25834 int ecode2 = 0 ;
25835 PyObject * obj0 = 0 ;
25836 PyObject * obj1 = 0 ;
25837 char * kwnames[] = {
25838 (char *) "self",(char *) "forward", NULL
25839 };
25840
25841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetDirection",kwnames,&obj0,&obj1)) SWIG_fail;
25842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25843 if (!SWIG_IsOK(res1)) {
25844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25845 }
25846 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25847 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25848 if (!SWIG_IsOK(ecode2)) {
25849 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetDirection" "', expected argument " "2"" of type '" "bool""'");
25850 }
25851 arg2 = static_cast< bool >(val2);
25852 {
25853 PyThreadState* __tstate = wxPyBeginAllowThreads();
25854 (arg1)->SetDirection(arg2);
25855 wxPyEndAllowThreads(__tstate);
25856 if (PyErr_Occurred()) SWIG_fail;
25857 }
25858 resultobj = SWIG_Py_Void();
25859 return resultobj;
25860 fail:
25861 return NULL;
25862 }
25863
25864
25865 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25866 PyObject *resultobj = 0;
25867 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25868 bool result;
25869 void *argp1 = 0 ;
25870 int res1 = 0 ;
25871 PyObject *swig_obj[1] ;
25872
25873 if (!args) SWIG_fail;
25874 swig_obj[0] = args;
25875 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25876 if (!SWIG_IsOK(res1)) {
25877 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25878 }
25879 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25880 {
25881 PyThreadState* __tstate = wxPyBeginAllowThreads();
25882 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsWindowChange();
25883 wxPyEndAllowThreads(__tstate);
25884 if (PyErr_Occurred()) SWIG_fail;
25885 }
25886 {
25887 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25888 }
25889 return resultobj;
25890 fail:
25891 return NULL;
25892 }
25893
25894
25895 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetWindowChange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25896 PyObject *resultobj = 0;
25897 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25898 bool arg2 ;
25899 void *argp1 = 0 ;
25900 int res1 = 0 ;
25901 bool val2 ;
25902 int ecode2 = 0 ;
25903 PyObject * obj0 = 0 ;
25904 PyObject * obj1 = 0 ;
25905 char * kwnames[] = {
25906 (char *) "self",(char *) "ischange", NULL
25907 };
25908
25909 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetWindowChange",kwnames,&obj0,&obj1)) SWIG_fail;
25910 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25911 if (!SWIG_IsOK(res1)) {
25912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25913 }
25914 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25915 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25916 if (!SWIG_IsOK(ecode2)) {
25917 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetWindowChange" "', expected argument " "2"" of type '" "bool""'");
25918 }
25919 arg2 = static_cast< bool >(val2);
25920 {
25921 PyThreadState* __tstate = wxPyBeginAllowThreads();
25922 (arg1)->SetWindowChange(arg2);
25923 wxPyEndAllowThreads(__tstate);
25924 if (PyErr_Occurred()) SWIG_fail;
25925 }
25926 resultobj = SWIG_Py_Void();
25927 return resultobj;
25928 fail:
25929 return NULL;
25930 }
25931
25932
25933 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_IsFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
25934 PyObject *resultobj = 0;
25935 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25936 bool result;
25937 void *argp1 = 0 ;
25938 int res1 = 0 ;
25939 PyObject *swig_obj[1] ;
25940
25941 if (!args) SWIG_fail;
25942 swig_obj[0] = args;
25943 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25944 if (!SWIG_IsOK(res1)) {
25945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_IsFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
25946 }
25947 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25948 {
25949 PyThreadState* __tstate = wxPyBeginAllowThreads();
25950 result = (bool)((wxNavigationKeyEvent const *)arg1)->IsFromTab();
25951 wxPyEndAllowThreads(__tstate);
25952 if (PyErr_Occurred()) SWIG_fail;
25953 }
25954 {
25955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
25956 }
25957 return resultobj;
25958 fail:
25959 return NULL;
25960 }
25961
25962
25963 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFromTab(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
25964 PyObject *resultobj = 0;
25965 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
25966 bool arg2 ;
25967 void *argp1 = 0 ;
25968 int res1 = 0 ;
25969 bool val2 ;
25970 int ecode2 = 0 ;
25971 PyObject * obj0 = 0 ;
25972 PyObject * obj1 = 0 ;
25973 char * kwnames[] = {
25974 (char *) "self",(char *) "bIs", NULL
25975 };
25976
25977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFromTab",kwnames,&obj0,&obj1)) SWIG_fail;
25978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
25979 if (!SWIG_IsOK(res1)) {
25980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
25981 }
25982 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
25983 ecode2 = SWIG_AsVal_bool(obj1, &val2);
25984 if (!SWIG_IsOK(ecode2)) {
25985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFromTab" "', expected argument " "2"" of type '" "bool""'");
25986 }
25987 arg2 = static_cast< bool >(val2);
25988 {
25989 PyThreadState* __tstate = wxPyBeginAllowThreads();
25990 (arg1)->SetFromTab(arg2);
25991 wxPyEndAllowThreads(__tstate);
25992 if (PyErr_Occurred()) SWIG_fail;
25993 }
25994 resultobj = SWIG_Py_Void();
25995 return resultobj;
25996 fail:
25997 return NULL;
25998 }
25999
26000
26001 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26002 PyObject *resultobj = 0;
26003 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26004 long arg2 ;
26005 void *argp1 = 0 ;
26006 int res1 = 0 ;
26007 long val2 ;
26008 int ecode2 = 0 ;
26009 PyObject * obj0 = 0 ;
26010 PyObject * obj1 = 0 ;
26011 char * kwnames[] = {
26012 (char *) "self",(char *) "flags", NULL
26013 };
26014
26015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetFlags",kwnames,&obj0,&obj1)) SWIG_fail;
26016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26017 if (!SWIG_IsOK(res1)) {
26018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26019 }
26020 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26021 ecode2 = SWIG_AsVal_long(obj1, &val2);
26022 if (!SWIG_IsOK(ecode2)) {
26023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "NavigationKeyEvent_SetFlags" "', expected argument " "2"" of type '" "long""'");
26024 }
26025 arg2 = static_cast< long >(val2);
26026 {
26027 PyThreadState* __tstate = wxPyBeginAllowThreads();
26028 (arg1)->SetFlags(arg2);
26029 wxPyEndAllowThreads(__tstate);
26030 if (PyErr_Occurred()) SWIG_fail;
26031 }
26032 resultobj = SWIG_Py_Void();
26033 return resultobj;
26034 fail:
26035 return NULL;
26036 }
26037
26038
26039 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_GetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26040 PyObject *resultobj = 0;
26041 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26042 wxWindow *result = 0 ;
26043 void *argp1 = 0 ;
26044 int res1 = 0 ;
26045 PyObject *swig_obj[1] ;
26046
26047 if (!args) SWIG_fail;
26048 swig_obj[0] = args;
26049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26050 if (!SWIG_IsOK(res1)) {
26051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_GetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent const *""'");
26052 }
26053 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26054 {
26055 PyThreadState* __tstate = wxPyBeginAllowThreads();
26056 result = (wxWindow *)((wxNavigationKeyEvent const *)arg1)->GetCurrentFocus();
26057 wxPyEndAllowThreads(__tstate);
26058 if (PyErr_Occurred()) SWIG_fail;
26059 }
26060 {
26061 resultobj = wxPyMake_wxObject(result, (bool)0);
26062 }
26063 return resultobj;
26064 fail:
26065 return NULL;
26066 }
26067
26068
26069 SWIGINTERN PyObject *_wrap_NavigationKeyEvent_SetCurrentFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26070 PyObject *resultobj = 0;
26071 wxNavigationKeyEvent *arg1 = (wxNavigationKeyEvent *) 0 ;
26072 wxWindow *arg2 = (wxWindow *) 0 ;
26073 void *argp1 = 0 ;
26074 int res1 = 0 ;
26075 void *argp2 = 0 ;
26076 int res2 = 0 ;
26077 PyObject * obj0 = 0 ;
26078 PyObject * obj1 = 0 ;
26079 char * kwnames[] = {
26080 (char *) "self",(char *) "win", NULL
26081 };
26082
26083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:NavigationKeyEvent_SetCurrentFocus",kwnames,&obj0,&obj1)) SWIG_fail;
26084 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxNavigationKeyEvent, 0 | 0 );
26085 if (!SWIG_IsOK(res1)) {
26086 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "1"" of type '" "wxNavigationKeyEvent *""'");
26087 }
26088 arg1 = reinterpret_cast< wxNavigationKeyEvent * >(argp1);
26089 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
26090 if (!SWIG_IsOK(res2)) {
26091 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "NavigationKeyEvent_SetCurrentFocus" "', expected argument " "2"" of type '" "wxWindow *""'");
26092 }
26093 arg2 = reinterpret_cast< wxWindow * >(argp2);
26094 {
26095 PyThreadState* __tstate = wxPyBeginAllowThreads();
26096 (arg1)->SetCurrentFocus(arg2);
26097 wxPyEndAllowThreads(__tstate);
26098 if (PyErr_Occurred()) SWIG_fail;
26099 }
26100 resultobj = SWIG_Py_Void();
26101 return resultobj;
26102 fail:
26103 return NULL;
26104 }
26105
26106
26107 SWIGINTERN PyObject *NavigationKeyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26108 PyObject *obj;
26109 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26110 SWIG_TypeNewClientData(SWIGTYPE_p_wxNavigationKeyEvent, SWIG_NewClientData(obj));
26111 return SWIG_Py_Void();
26112 }
26113
26114 SWIGINTERN PyObject *NavigationKeyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26115 return SWIG_Python_InitShadowInstance(args);
26116 }
26117
26118 SWIGINTERN PyObject *_wrap_new_WindowCreateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26119 PyObject *resultobj = 0;
26120 wxWindow *arg1 = (wxWindow *) NULL ;
26121 wxWindowCreateEvent *result = 0 ;
26122 void *argp1 = 0 ;
26123 int res1 = 0 ;
26124 PyObject * obj0 = 0 ;
26125 char * kwnames[] = {
26126 (char *) "win", NULL
26127 };
26128
26129 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowCreateEvent",kwnames,&obj0)) SWIG_fail;
26130 if (obj0) {
26131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26132 if (!SWIG_IsOK(res1)) {
26133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowCreateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26134 }
26135 arg1 = reinterpret_cast< wxWindow * >(argp1);
26136 }
26137 {
26138 PyThreadState* __tstate = wxPyBeginAllowThreads();
26139 result = (wxWindowCreateEvent *)new wxWindowCreateEvent(arg1);
26140 wxPyEndAllowThreads(__tstate);
26141 if (PyErr_Occurred()) SWIG_fail;
26142 }
26143 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowCreateEvent, SWIG_POINTER_NEW | 0 );
26144 return resultobj;
26145 fail:
26146 return NULL;
26147 }
26148
26149
26150 SWIGINTERN PyObject *_wrap_WindowCreateEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26151 PyObject *resultobj = 0;
26152 wxWindowCreateEvent *arg1 = (wxWindowCreateEvent *) 0 ;
26153 wxWindow *result = 0 ;
26154 void *argp1 = 0 ;
26155 int res1 = 0 ;
26156 PyObject *swig_obj[1] ;
26157
26158 if (!args) SWIG_fail;
26159 swig_obj[0] = args;
26160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowCreateEvent, 0 | 0 );
26161 if (!SWIG_IsOK(res1)) {
26162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowCreateEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowCreateEvent const *""'");
26163 }
26164 arg1 = reinterpret_cast< wxWindowCreateEvent * >(argp1);
26165 {
26166 PyThreadState* __tstate = wxPyBeginAllowThreads();
26167 result = (wxWindow *)((wxWindowCreateEvent const *)arg1)->GetWindow();
26168 wxPyEndAllowThreads(__tstate);
26169 if (PyErr_Occurred()) SWIG_fail;
26170 }
26171 {
26172 resultobj = wxPyMake_wxObject(result, (bool)0);
26173 }
26174 return resultobj;
26175 fail:
26176 return NULL;
26177 }
26178
26179
26180 SWIGINTERN PyObject *WindowCreateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26181 PyObject *obj;
26182 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26183 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowCreateEvent, SWIG_NewClientData(obj));
26184 return SWIG_Py_Void();
26185 }
26186
26187 SWIGINTERN PyObject *WindowCreateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26188 return SWIG_Python_InitShadowInstance(args);
26189 }
26190
26191 SWIGINTERN PyObject *_wrap_new_WindowDestroyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26192 PyObject *resultobj = 0;
26193 wxWindow *arg1 = (wxWindow *) NULL ;
26194 wxWindowDestroyEvent *result = 0 ;
26195 void *argp1 = 0 ;
26196 int res1 = 0 ;
26197 PyObject * obj0 = 0 ;
26198 char * kwnames[] = {
26199 (char *) "win", NULL
26200 };
26201
26202 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_WindowDestroyEvent",kwnames,&obj0)) SWIG_fail;
26203 if (obj0) {
26204 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26205 if (!SWIG_IsOK(res1)) {
26206 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_WindowDestroyEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26207 }
26208 arg1 = reinterpret_cast< wxWindow * >(argp1);
26209 }
26210 {
26211 PyThreadState* __tstate = wxPyBeginAllowThreads();
26212 result = (wxWindowDestroyEvent *)new wxWindowDestroyEvent(arg1);
26213 wxPyEndAllowThreads(__tstate);
26214 if (PyErr_Occurred()) SWIG_fail;
26215 }
26216 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindowDestroyEvent, SWIG_POINTER_NEW | 0 );
26217 return resultobj;
26218 fail:
26219 return NULL;
26220 }
26221
26222
26223 SWIGINTERN PyObject *_wrap_WindowDestroyEvent_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26224 PyObject *resultobj = 0;
26225 wxWindowDestroyEvent *arg1 = (wxWindowDestroyEvent *) 0 ;
26226 wxWindow *result = 0 ;
26227 void *argp1 = 0 ;
26228 int res1 = 0 ;
26229 PyObject *swig_obj[1] ;
26230
26231 if (!args) SWIG_fail;
26232 swig_obj[0] = args;
26233 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindowDestroyEvent, 0 | 0 );
26234 if (!SWIG_IsOK(res1)) {
26235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "WindowDestroyEvent_GetWindow" "', expected argument " "1"" of type '" "wxWindowDestroyEvent const *""'");
26236 }
26237 arg1 = reinterpret_cast< wxWindowDestroyEvent * >(argp1);
26238 {
26239 PyThreadState* __tstate = wxPyBeginAllowThreads();
26240 result = (wxWindow *)((wxWindowDestroyEvent const *)arg1)->GetWindow();
26241 wxPyEndAllowThreads(__tstate);
26242 if (PyErr_Occurred()) SWIG_fail;
26243 }
26244 {
26245 resultobj = wxPyMake_wxObject(result, (bool)0);
26246 }
26247 return resultobj;
26248 fail:
26249 return NULL;
26250 }
26251
26252
26253 SWIGINTERN PyObject *WindowDestroyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26254 PyObject *obj;
26255 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26256 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindowDestroyEvent, SWIG_NewClientData(obj));
26257 return SWIG_Py_Void();
26258 }
26259
26260 SWIGINTERN PyObject *WindowDestroyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26261 return SWIG_Python_InitShadowInstance(args);
26262 }
26263
26264 SWIGINTERN PyObject *_wrap_new_ContextMenuEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26265 PyObject *resultobj = 0;
26266 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26267 int arg2 = (int) 0 ;
26268 wxPoint const &arg3_defvalue = wxDefaultPosition ;
26269 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
26270 wxContextMenuEvent *result = 0 ;
26271 int val1 ;
26272 int ecode1 = 0 ;
26273 int val2 ;
26274 int ecode2 = 0 ;
26275 wxPoint temp3 ;
26276 PyObject * obj0 = 0 ;
26277 PyObject * obj1 = 0 ;
26278 PyObject * obj2 = 0 ;
26279 char * kwnames[] = {
26280 (char *) "type",(char *) "winid",(char *) "pt", NULL
26281 };
26282
26283 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_ContextMenuEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26284 if (obj0) {
26285 ecode1 = SWIG_AsVal_int(obj0, &val1);
26286 if (!SWIG_IsOK(ecode1)) {
26287 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ContextMenuEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26288 }
26289 arg1 = static_cast< wxEventType >(val1);
26290 }
26291 if (obj1) {
26292 ecode2 = SWIG_AsVal_int(obj1, &val2);
26293 if (!SWIG_IsOK(ecode2)) {
26294 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ContextMenuEvent" "', expected argument " "2"" of type '" "int""'");
26295 }
26296 arg2 = static_cast< int >(val2);
26297 }
26298 if (obj2) {
26299 {
26300 arg3 = &temp3;
26301 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
26302 }
26303 }
26304 {
26305 PyThreadState* __tstate = wxPyBeginAllowThreads();
26306 result = (wxContextMenuEvent *)new wxContextMenuEvent(arg1,arg2,(wxPoint const &)*arg3);
26307 wxPyEndAllowThreads(__tstate);
26308 if (PyErr_Occurred()) SWIG_fail;
26309 }
26310 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxContextMenuEvent, SWIG_POINTER_NEW | 0 );
26311 return resultobj;
26312 fail:
26313 return NULL;
26314 }
26315
26316
26317 SWIGINTERN PyObject *_wrap_ContextMenuEvent_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26318 PyObject *resultobj = 0;
26319 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26320 wxPoint *result = 0 ;
26321 void *argp1 = 0 ;
26322 int res1 = 0 ;
26323 PyObject *swig_obj[1] ;
26324
26325 if (!args) SWIG_fail;
26326 swig_obj[0] = args;
26327 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26328 if (!SWIG_IsOK(res1)) {
26329 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_GetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent const *""'");
26330 }
26331 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26332 {
26333 PyThreadState* __tstate = wxPyBeginAllowThreads();
26334 {
26335 wxPoint const &_result_ref = ((wxContextMenuEvent const *)arg1)->GetPosition();
26336 result = (wxPoint *) &_result_ref;
26337 }
26338 wxPyEndAllowThreads(__tstate);
26339 if (PyErr_Occurred()) SWIG_fail;
26340 }
26341 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPoint, 0 | 0 );
26342 return resultobj;
26343 fail:
26344 return NULL;
26345 }
26346
26347
26348 SWIGINTERN PyObject *_wrap_ContextMenuEvent_SetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26349 PyObject *resultobj = 0;
26350 wxContextMenuEvent *arg1 = (wxContextMenuEvent *) 0 ;
26351 wxPoint *arg2 = 0 ;
26352 void *argp1 = 0 ;
26353 int res1 = 0 ;
26354 wxPoint temp2 ;
26355 PyObject * obj0 = 0 ;
26356 PyObject * obj1 = 0 ;
26357 char * kwnames[] = {
26358 (char *) "self",(char *) "pos", NULL
26359 };
26360
26361 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ContextMenuEvent_SetPosition",kwnames,&obj0,&obj1)) SWIG_fail;
26362 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxContextMenuEvent, 0 | 0 );
26363 if (!SWIG_IsOK(res1)) {
26364 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ContextMenuEvent_SetPosition" "', expected argument " "1"" of type '" "wxContextMenuEvent *""'");
26365 }
26366 arg1 = reinterpret_cast< wxContextMenuEvent * >(argp1);
26367 {
26368 arg2 = &temp2;
26369 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
26370 }
26371 {
26372 PyThreadState* __tstate = wxPyBeginAllowThreads();
26373 (arg1)->SetPosition((wxPoint const &)*arg2);
26374 wxPyEndAllowThreads(__tstate);
26375 if (PyErr_Occurred()) SWIG_fail;
26376 }
26377 resultobj = SWIG_Py_Void();
26378 return resultobj;
26379 fail:
26380 return NULL;
26381 }
26382
26383
26384 SWIGINTERN PyObject *ContextMenuEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26385 PyObject *obj;
26386 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26387 SWIG_TypeNewClientData(SWIGTYPE_p_wxContextMenuEvent, SWIG_NewClientData(obj));
26388 return SWIG_Py_Void();
26389 }
26390
26391 SWIGINTERN PyObject *ContextMenuEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26392 return SWIG_Python_InitShadowInstance(args);
26393 }
26394
26395 SWIGINTERN PyObject *_wrap_new_IdleEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26396 PyObject *resultobj = 0;
26397 wxIdleEvent *result = 0 ;
26398
26399 if (!SWIG_Python_UnpackTuple(args,"new_IdleEvent",0,0,0)) SWIG_fail;
26400 {
26401 PyThreadState* __tstate = wxPyBeginAllowThreads();
26402 result = (wxIdleEvent *)new wxIdleEvent();
26403 wxPyEndAllowThreads(__tstate);
26404 if (PyErr_Occurred()) SWIG_fail;
26405 }
26406 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIdleEvent, SWIG_POINTER_NEW | 0 );
26407 return resultobj;
26408 fail:
26409 return NULL;
26410 }
26411
26412
26413 SWIGINTERN PyObject *_wrap_IdleEvent_RequestMore(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26414 PyObject *resultobj = 0;
26415 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26416 bool arg2 = (bool) true ;
26417 void *argp1 = 0 ;
26418 int res1 = 0 ;
26419 bool val2 ;
26420 int ecode2 = 0 ;
26421 PyObject * obj0 = 0 ;
26422 PyObject * obj1 = 0 ;
26423 char * kwnames[] = {
26424 (char *) "self",(char *) "needMore", NULL
26425 };
26426
26427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:IdleEvent_RequestMore",kwnames,&obj0,&obj1)) SWIG_fail;
26428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26429 if (!SWIG_IsOK(res1)) {
26430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_RequestMore" "', expected argument " "1"" of type '" "wxIdleEvent *""'");
26431 }
26432 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26433 if (obj1) {
26434 ecode2 = SWIG_AsVal_bool(obj1, &val2);
26435 if (!SWIG_IsOK(ecode2)) {
26436 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IdleEvent_RequestMore" "', expected argument " "2"" of type '" "bool""'");
26437 }
26438 arg2 = static_cast< bool >(val2);
26439 }
26440 {
26441 PyThreadState* __tstate = wxPyBeginAllowThreads();
26442 (arg1)->RequestMore(arg2);
26443 wxPyEndAllowThreads(__tstate);
26444 if (PyErr_Occurred()) SWIG_fail;
26445 }
26446 resultobj = SWIG_Py_Void();
26447 return resultobj;
26448 fail:
26449 return NULL;
26450 }
26451
26452
26453 SWIGINTERN PyObject *_wrap_IdleEvent_MoreRequested(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26454 PyObject *resultobj = 0;
26455 wxIdleEvent *arg1 = (wxIdleEvent *) 0 ;
26456 bool result;
26457 void *argp1 = 0 ;
26458 int res1 = 0 ;
26459 PyObject *swig_obj[1] ;
26460
26461 if (!args) SWIG_fail;
26462 swig_obj[0] = args;
26463 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIdleEvent, 0 | 0 );
26464 if (!SWIG_IsOK(res1)) {
26465 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_MoreRequested" "', expected argument " "1"" of type '" "wxIdleEvent const *""'");
26466 }
26467 arg1 = reinterpret_cast< wxIdleEvent * >(argp1);
26468 {
26469 PyThreadState* __tstate = wxPyBeginAllowThreads();
26470 result = (bool)((wxIdleEvent const *)arg1)->MoreRequested();
26471 wxPyEndAllowThreads(__tstate);
26472 if (PyErr_Occurred()) SWIG_fail;
26473 }
26474 {
26475 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26476 }
26477 return resultobj;
26478 fail:
26479 return NULL;
26480 }
26481
26482
26483 SWIGINTERN PyObject *_wrap_IdleEvent_SetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26484 PyObject *resultobj = 0;
26485 wxIdleMode arg1 ;
26486 int val1 ;
26487 int ecode1 = 0 ;
26488 PyObject * obj0 = 0 ;
26489 char * kwnames[] = {
26490 (char *) "mode", NULL
26491 };
26492
26493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_SetMode",kwnames,&obj0)) SWIG_fail;
26494 ecode1 = SWIG_AsVal_int(obj0, &val1);
26495 if (!SWIG_IsOK(ecode1)) {
26496 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "IdleEvent_SetMode" "', expected argument " "1"" of type '" "wxIdleMode""'");
26497 }
26498 arg1 = static_cast< wxIdleMode >(val1);
26499 {
26500 PyThreadState* __tstate = wxPyBeginAllowThreads();
26501 wxIdleEvent::SetMode(arg1);
26502 wxPyEndAllowThreads(__tstate);
26503 if (PyErr_Occurred()) SWIG_fail;
26504 }
26505 resultobj = SWIG_Py_Void();
26506 return resultobj;
26507 fail:
26508 return NULL;
26509 }
26510
26511
26512 SWIGINTERN PyObject *_wrap_IdleEvent_GetMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26513 PyObject *resultobj = 0;
26514 wxIdleMode result;
26515
26516 if (!SWIG_Python_UnpackTuple(args,"IdleEvent_GetMode",0,0,0)) SWIG_fail;
26517 {
26518 PyThreadState* __tstate = wxPyBeginAllowThreads();
26519 result = (wxIdleMode)wxIdleEvent::GetMode();
26520 wxPyEndAllowThreads(__tstate);
26521 if (PyErr_Occurred()) SWIG_fail;
26522 }
26523 resultobj = SWIG_From_int(static_cast< int >(result));
26524 return resultobj;
26525 fail:
26526 return NULL;
26527 }
26528
26529
26530 SWIGINTERN PyObject *_wrap_IdleEvent_CanSend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26531 PyObject *resultobj = 0;
26532 wxWindow *arg1 = (wxWindow *) 0 ;
26533 bool result;
26534 void *argp1 = 0 ;
26535 int res1 = 0 ;
26536 PyObject * obj0 = 0 ;
26537 char * kwnames[] = {
26538 (char *) "win", NULL
26539 };
26540
26541 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:IdleEvent_CanSend",kwnames,&obj0)) SWIG_fail;
26542 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26543 if (!SWIG_IsOK(res1)) {
26544 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IdleEvent_CanSend" "', expected argument " "1"" of type '" "wxWindow *""'");
26545 }
26546 arg1 = reinterpret_cast< wxWindow * >(argp1);
26547 {
26548 PyThreadState* __tstate = wxPyBeginAllowThreads();
26549 result = (bool)wxIdleEvent::CanSend(arg1);
26550 wxPyEndAllowThreads(__tstate);
26551 if (PyErr_Occurred()) SWIG_fail;
26552 }
26553 {
26554 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
26555 }
26556 return resultobj;
26557 fail:
26558 return NULL;
26559 }
26560
26561
26562 SWIGINTERN PyObject *IdleEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26563 PyObject *obj;
26564 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26565 SWIG_TypeNewClientData(SWIGTYPE_p_wxIdleEvent, SWIG_NewClientData(obj));
26566 return SWIG_Py_Void();
26567 }
26568
26569 SWIGINTERN PyObject *IdleEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26570 return SWIG_Python_InitShadowInstance(args);
26571 }
26572
26573 SWIGINTERN PyObject *_wrap_new_ClipboardTextEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26574 PyObject *resultobj = 0;
26575 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26576 int arg2 = (int) 0 ;
26577 wxClipboardTextEvent *result = 0 ;
26578 int val1 ;
26579 int ecode1 = 0 ;
26580 int val2 ;
26581 int ecode2 = 0 ;
26582 PyObject * obj0 = 0 ;
26583 PyObject * obj1 = 0 ;
26584 char * kwnames[] = {
26585 (char *) "type",(char *) "winid", NULL
26586 };
26587
26588 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_ClipboardTextEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26589 if (obj0) {
26590 ecode1 = SWIG_AsVal_int(obj0, &val1);
26591 if (!SWIG_IsOK(ecode1)) {
26592 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_ClipboardTextEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26593 }
26594 arg1 = static_cast< wxEventType >(val1);
26595 }
26596 if (obj1) {
26597 ecode2 = SWIG_AsVal_int(obj1, &val2);
26598 if (!SWIG_IsOK(ecode2)) {
26599 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_ClipboardTextEvent" "', expected argument " "2"" of type '" "int""'");
26600 }
26601 arg2 = static_cast< int >(val2);
26602 }
26603 {
26604 PyThreadState* __tstate = wxPyBeginAllowThreads();
26605 result = (wxClipboardTextEvent *)new wxClipboardTextEvent(arg1,arg2);
26606 wxPyEndAllowThreads(__tstate);
26607 if (PyErr_Occurred()) SWIG_fail;
26608 }
26609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxClipboardTextEvent, SWIG_POINTER_NEW | 0 );
26610 return resultobj;
26611 fail:
26612 return NULL;
26613 }
26614
26615
26616 SWIGINTERN PyObject *ClipboardTextEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26617 PyObject *obj;
26618 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26619 SWIG_TypeNewClientData(SWIGTYPE_p_wxClipboardTextEvent, SWIG_NewClientData(obj));
26620 return SWIG_Py_Void();
26621 }
26622
26623 SWIGINTERN PyObject *ClipboardTextEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26624 return SWIG_Python_InitShadowInstance(args);
26625 }
26626
26627 SWIGINTERN PyObject *_wrap_new_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26628 PyObject *resultobj = 0;
26629 int arg1 = (int) 0 ;
26630 wxEventType arg2 = (wxEventType) wxEVT_NULL ;
26631 wxPyEvent *result = 0 ;
26632 int val1 ;
26633 int ecode1 = 0 ;
26634 int val2 ;
26635 int ecode2 = 0 ;
26636 PyObject * obj0 = 0 ;
26637 PyObject * obj1 = 0 ;
26638 char * kwnames[] = {
26639 (char *) "winid",(char *) "eventType", NULL
26640 };
26641
26642 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26643 if (obj0) {
26644 ecode1 = SWIG_AsVal_int(obj0, &val1);
26645 if (!SWIG_IsOK(ecode1)) {
26646 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyEvent" "', expected argument " "1"" of type '" "int""'");
26647 }
26648 arg1 = static_cast< int >(val1);
26649 }
26650 if (obj1) {
26651 ecode2 = SWIG_AsVal_int(obj1, &val2);
26652 if (!SWIG_IsOK(ecode2)) {
26653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyEvent" "', expected argument " "2"" of type '" "wxEventType""'");
26654 }
26655 arg2 = static_cast< wxEventType >(val2);
26656 }
26657 {
26658 PyThreadState* __tstate = wxPyBeginAllowThreads();
26659 result = (wxPyEvent *)new wxPyEvent(arg1,arg2);
26660 wxPyEndAllowThreads(__tstate);
26661 if (PyErr_Occurred()) SWIG_fail;
26662 }
26663 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyEvent, SWIG_POINTER_NEW | 0 );
26664 return resultobj;
26665 fail:
26666 return NULL;
26667 }
26668
26669
26670 SWIGINTERN PyObject *_wrap_delete_PyEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26671 PyObject *resultobj = 0;
26672 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26673 void *argp1 = 0 ;
26674 int res1 = 0 ;
26675 PyObject *swig_obj[1] ;
26676
26677 if (!args) SWIG_fail;
26678 swig_obj[0] = args;
26679 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, SWIG_POINTER_DISOWN | 0 );
26680 if (!SWIG_IsOK(res1)) {
26681 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyEvent" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26682 }
26683 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26684 {
26685 PyThreadState* __tstate = wxPyBeginAllowThreads();
26686 delete arg1;
26687
26688 wxPyEndAllowThreads(__tstate);
26689 if (PyErr_Occurred()) SWIG_fail;
26690 }
26691 resultobj = SWIG_Py_Void();
26692 return resultobj;
26693 fail:
26694 return NULL;
26695 }
26696
26697
26698 SWIGINTERN PyObject *_wrap_PyEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26699 PyObject *resultobj = 0;
26700 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26701 PyObject *arg2 = (PyObject *) 0 ;
26702 void *argp1 = 0 ;
26703 int res1 = 0 ;
26704 PyObject * obj0 = 0 ;
26705 PyObject * obj1 = 0 ;
26706 char * kwnames[] = {
26707 (char *) "self",(char *) "self", NULL
26708 };
26709
26710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26712 if (!SWIG_IsOK(res1)) {
26713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26714 }
26715 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26716 arg2 = obj1;
26717 {
26718 PyThreadState* __tstate = wxPyBeginAllowThreads();
26719 (arg1)->SetSelf(arg2);
26720 wxPyEndAllowThreads(__tstate);
26721 if (PyErr_Occurred()) SWIG_fail;
26722 }
26723 resultobj = SWIG_Py_Void();
26724 return resultobj;
26725 fail:
26726 return NULL;
26727 }
26728
26729
26730 SWIGINTERN PyObject *_wrap_PyEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26731 PyObject *resultobj = 0;
26732 wxPyEvent *arg1 = (wxPyEvent *) 0 ;
26733 PyObject *result = 0 ;
26734 void *argp1 = 0 ;
26735 int res1 = 0 ;
26736 PyObject *swig_obj[1] ;
26737
26738 if (!args) SWIG_fail;
26739 swig_obj[0] = args;
26740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyEvent, 0 | 0 );
26741 if (!SWIG_IsOK(res1)) {
26742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyEvent *""'");
26743 }
26744 arg1 = reinterpret_cast< wxPyEvent * >(argp1);
26745 {
26746 PyThreadState* __tstate = wxPyBeginAllowThreads();
26747 result = (PyObject *)(arg1)->GetSelf();
26748 wxPyEndAllowThreads(__tstate);
26749 if (PyErr_Occurred()) SWIG_fail;
26750 }
26751 resultobj = result;
26752 return resultobj;
26753 fail:
26754 return NULL;
26755 }
26756
26757
26758 SWIGINTERN PyObject *PyEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26759 PyObject *obj;
26760 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26761 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyEvent, SWIG_NewClientData(obj));
26762 return SWIG_Py_Void();
26763 }
26764
26765 SWIGINTERN PyObject *PyEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26766 return SWIG_Python_InitShadowInstance(args);
26767 }
26768
26769 SWIGINTERN PyObject *_wrap_new_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26770 PyObject *resultobj = 0;
26771 wxEventType arg1 = (wxEventType) wxEVT_NULL ;
26772 int arg2 = (int) 0 ;
26773 wxPyCommandEvent *result = 0 ;
26774 int val1 ;
26775 int ecode1 = 0 ;
26776 int val2 ;
26777 int ecode2 = 0 ;
26778 PyObject * obj0 = 0 ;
26779 PyObject * obj1 = 0 ;
26780 char * kwnames[] = {
26781 (char *) "eventType",(char *) "id", NULL
26782 };
26783
26784 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_PyCommandEvent",kwnames,&obj0,&obj1)) SWIG_fail;
26785 if (obj0) {
26786 ecode1 = SWIG_AsVal_int(obj0, &val1);
26787 if (!SWIG_IsOK(ecode1)) {
26788 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_PyCommandEvent" "', expected argument " "1"" of type '" "wxEventType""'");
26789 }
26790 arg1 = static_cast< wxEventType >(val1);
26791 }
26792 if (obj1) {
26793 ecode2 = SWIG_AsVal_int(obj1, &val2);
26794 if (!SWIG_IsOK(ecode2)) {
26795 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_PyCommandEvent" "', expected argument " "2"" of type '" "int""'");
26796 }
26797 arg2 = static_cast< int >(val2);
26798 }
26799 {
26800 PyThreadState* __tstate = wxPyBeginAllowThreads();
26801 result = (wxPyCommandEvent *)new wxPyCommandEvent(arg1,arg2);
26802 wxPyEndAllowThreads(__tstate);
26803 if (PyErr_Occurred()) SWIG_fail;
26804 }
26805 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_NEW | 0 );
26806 return resultobj;
26807 fail:
26808 return NULL;
26809 }
26810
26811
26812 SWIGINTERN PyObject *_wrap_delete_PyCommandEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26813 PyObject *resultobj = 0;
26814 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26815 void *argp1 = 0 ;
26816 int res1 = 0 ;
26817 PyObject *swig_obj[1] ;
26818
26819 if (!args) SWIG_fail;
26820 swig_obj[0] = args;
26821 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, SWIG_POINTER_DISOWN | 0 );
26822 if (!SWIG_IsOK(res1)) {
26823 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyCommandEvent" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26824 }
26825 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26826 {
26827 PyThreadState* __tstate = wxPyBeginAllowThreads();
26828 delete arg1;
26829
26830 wxPyEndAllowThreads(__tstate);
26831 if (PyErr_Occurred()) SWIG_fail;
26832 }
26833 resultobj = SWIG_Py_Void();
26834 return resultobj;
26835 fail:
26836 return NULL;
26837 }
26838
26839
26840 SWIGINTERN PyObject *_wrap_PyCommandEvent__SetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26841 PyObject *resultobj = 0;
26842 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26843 PyObject *arg2 = (PyObject *) 0 ;
26844 void *argp1 = 0 ;
26845 int res1 = 0 ;
26846 PyObject * obj0 = 0 ;
26847 PyObject * obj1 = 0 ;
26848 char * kwnames[] = {
26849 (char *) "self",(char *) "self", NULL
26850 };
26851
26852 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyCommandEvent__SetSelf",kwnames,&obj0,&obj1)) SWIG_fail;
26853 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26854 if (!SWIG_IsOK(res1)) {
26855 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__SetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26856 }
26857 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26858 arg2 = obj1;
26859 {
26860 PyThreadState* __tstate = wxPyBeginAllowThreads();
26861 (arg1)->SetSelf(arg2);
26862 wxPyEndAllowThreads(__tstate);
26863 if (PyErr_Occurred()) SWIG_fail;
26864 }
26865 resultobj = SWIG_Py_Void();
26866 return resultobj;
26867 fail:
26868 return NULL;
26869 }
26870
26871
26872 SWIGINTERN PyObject *_wrap_PyCommandEvent__GetSelf(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26873 PyObject *resultobj = 0;
26874 wxPyCommandEvent *arg1 = (wxPyCommandEvent *) 0 ;
26875 PyObject *result = 0 ;
26876 void *argp1 = 0 ;
26877 int res1 = 0 ;
26878 PyObject *swig_obj[1] ;
26879
26880 if (!args) SWIG_fail;
26881 swig_obj[0] = args;
26882 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyCommandEvent, 0 | 0 );
26883 if (!SWIG_IsOK(res1)) {
26884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyCommandEvent__GetSelf" "', expected argument " "1"" of type '" "wxPyCommandEvent *""'");
26885 }
26886 arg1 = reinterpret_cast< wxPyCommandEvent * >(argp1);
26887 {
26888 PyThreadState* __tstate = wxPyBeginAllowThreads();
26889 result = (PyObject *)(arg1)->GetSelf();
26890 wxPyEndAllowThreads(__tstate);
26891 if (PyErr_Occurred()) SWIG_fail;
26892 }
26893 resultobj = result;
26894 return resultobj;
26895 fail:
26896 return NULL;
26897 }
26898
26899
26900 SWIGINTERN PyObject *PyCommandEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26901 PyObject *obj;
26902 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
26903 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyCommandEvent, SWIG_NewClientData(obj));
26904 return SWIG_Py_Void();
26905 }
26906
26907 SWIGINTERN PyObject *PyCommandEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26908 return SWIG_Python_InitShadowInstance(args);
26909 }
26910
26911 SWIGINTERN PyObject *_wrap_new_DateEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26912 PyObject *resultobj = 0;
26913 wxWindow *arg1 = (wxWindow *) 0 ;
26914 wxDateTime *arg2 = 0 ;
26915 wxEventType arg3 ;
26916 wxDateEvent *result = 0 ;
26917 void *argp1 = 0 ;
26918 int res1 = 0 ;
26919 void *argp2 = 0 ;
26920 int res2 = 0 ;
26921 int val3 ;
26922 int ecode3 = 0 ;
26923 PyObject * obj0 = 0 ;
26924 PyObject * obj1 = 0 ;
26925 PyObject * obj2 = 0 ;
26926 char * kwnames[] = {
26927 (char *) "win",(char *) "dt",(char *) "type", NULL
26928 };
26929
26930 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:new_DateEvent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
26931 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
26932 if (!SWIG_IsOK(res1)) {
26933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_DateEvent" "', expected argument " "1"" of type '" "wxWindow *""'");
26934 }
26935 arg1 = reinterpret_cast< wxWindow * >(argp1);
26936 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
26937 if (!SWIG_IsOK(res2)) {
26938 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26939 }
26940 if (!argp2) {
26941 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_DateEvent" "', expected argument " "2"" of type '" "wxDateTime const &""'");
26942 }
26943 arg2 = reinterpret_cast< wxDateTime * >(argp2);
26944 ecode3 = SWIG_AsVal_int(obj2, &val3);
26945 if (!SWIG_IsOK(ecode3)) {
26946 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_DateEvent" "', expected argument " "3"" of type '" "wxEventType""'");
26947 }
26948 arg3 = static_cast< wxEventType >(val3);
26949 {
26950 PyThreadState* __tstate = wxPyBeginAllowThreads();
26951 result = (wxDateEvent *)new wxDateEvent(arg1,(wxDateTime const &)*arg2,arg3);
26952 wxPyEndAllowThreads(__tstate);
26953 if (PyErr_Occurred()) SWIG_fail;
26954 }
26955 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateEvent, SWIG_POINTER_NEW | 0 );
26956 return resultobj;
26957 fail:
26958 return NULL;
26959 }
26960
26961
26962 SWIGINTERN PyObject *_wrap_DateEvent_GetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
26963 PyObject *resultobj = 0;
26964 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26965 wxDateTime *result = 0 ;
26966 void *argp1 = 0 ;
26967 int res1 = 0 ;
26968 PyObject *swig_obj[1] ;
26969
26970 if (!args) SWIG_fail;
26971 swig_obj[0] = args;
26972 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
26973 if (!SWIG_IsOK(res1)) {
26974 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_GetDate" "', expected argument " "1"" of type '" "wxDateEvent const *""'");
26975 }
26976 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
26977 {
26978 PyThreadState* __tstate = wxPyBeginAllowThreads();
26979 {
26980 wxDateTime const &_result_ref = ((wxDateEvent const *)arg1)->GetDate();
26981 result = (wxDateTime *) &_result_ref;
26982 }
26983 wxPyEndAllowThreads(__tstate);
26984 if (PyErr_Occurred()) SWIG_fail;
26985 }
26986 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxDateTime, 0 | 0 );
26987 return resultobj;
26988 fail:
26989 return NULL;
26990 }
26991
26992
26993 SWIGINTERN PyObject *_wrap_DateEvent_SetDate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
26994 PyObject *resultobj = 0;
26995 wxDateEvent *arg1 = (wxDateEvent *) 0 ;
26996 wxDateTime *arg2 = 0 ;
26997 void *argp1 = 0 ;
26998 int res1 = 0 ;
26999 void *argp2 = 0 ;
27000 int res2 = 0 ;
27001 PyObject * obj0 = 0 ;
27002 PyObject * obj1 = 0 ;
27003 char * kwnames[] = {
27004 (char *) "self",(char *) "date", NULL
27005 };
27006
27007 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:DateEvent_SetDate",kwnames,&obj0,&obj1)) SWIG_fail;
27008 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxDateEvent, 0 | 0 );
27009 if (!SWIG_IsOK(res1)) {
27010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "DateEvent_SetDate" "', expected argument " "1"" of type '" "wxDateEvent *""'");
27011 }
27012 arg1 = reinterpret_cast< wxDateEvent * >(argp1);
27013 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDateTime, 0 | 0);
27014 if (!SWIG_IsOK(res2)) {
27015 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27016 }
27017 if (!argp2) {
27018 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "DateEvent_SetDate" "', expected argument " "2"" of type '" "wxDateTime const &""'");
27019 }
27020 arg2 = reinterpret_cast< wxDateTime * >(argp2);
27021 {
27022 PyThreadState* __tstate = wxPyBeginAllowThreads();
27023 (arg1)->SetDate((wxDateTime const &)*arg2);
27024 wxPyEndAllowThreads(__tstate);
27025 if (PyErr_Occurred()) SWIG_fail;
27026 }
27027 resultobj = SWIG_Py_Void();
27028 return resultobj;
27029 fail:
27030 return NULL;
27031 }
27032
27033
27034 SWIGINTERN PyObject *DateEvent_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27035 PyObject *obj;
27036 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
27037 SWIG_TypeNewClientData(SWIGTYPE_p_wxDateEvent, SWIG_NewClientData(obj));
27038 return SWIG_Py_Void();
27039 }
27040
27041 SWIGINTERN PyObject *DateEvent_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27042 return SWIG_Python_InitShadowInstance(args);
27043 }
27044
27045 SWIGINTERN PyObject *_wrap_new_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27046 PyObject *resultobj = 0;
27047 wxPyApp *result = 0 ;
27048
27049 if (!SWIG_Python_UnpackTuple(args,"new_PyApp",0,0,0)) SWIG_fail;
27050 {
27051 PyThreadState* __tstate = wxPyBeginAllowThreads();
27052 result = (wxPyApp *)new_wxPyApp();
27053 wxPyEndAllowThreads(__tstate);
27054 if (PyErr_Occurred()) SWIG_fail;
27055 }
27056 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyApp, SWIG_POINTER_NEW | 0 );
27057 return resultobj;
27058 fail:
27059 return NULL;
27060 }
27061
27062
27063 SWIGINTERN PyObject *_wrap_delete_PyApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27064 PyObject *resultobj = 0;
27065 wxPyApp *arg1 = (wxPyApp *) 0 ;
27066 void *argp1 = 0 ;
27067 int res1 = 0 ;
27068 PyObject *swig_obj[1] ;
27069
27070 if (!args) SWIG_fail;
27071 swig_obj[0] = args;
27072 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, SWIG_POINTER_DISOWN | 0 );
27073 if (!SWIG_IsOK(res1)) {
27074 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_PyApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
27075 }
27076 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27077 {
27078 PyThreadState* __tstate = wxPyBeginAllowThreads();
27079 delete arg1;
27080
27081 wxPyEndAllowThreads(__tstate);
27082 if (PyErr_Occurred()) SWIG_fail;
27083 }
27084 resultobj = SWIG_Py_Void();
27085 return resultobj;
27086 fail:
27087 return NULL;
27088 }
27089
27090
27091 SWIGINTERN PyObject *_wrap_PyApp__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27092 PyObject *resultobj = 0;
27093 wxPyApp *arg1 = (wxPyApp *) 0 ;
27094 PyObject *arg2 = (PyObject *) 0 ;
27095 PyObject *arg3 = (PyObject *) 0 ;
27096 bool arg4 ;
27097 void *argp1 = 0 ;
27098 int res1 = 0 ;
27099 bool val4 ;
27100 int ecode4 = 0 ;
27101 PyObject * obj0 = 0 ;
27102 PyObject * obj1 = 0 ;
27103 PyObject * obj2 = 0 ;
27104 PyObject * obj3 = 0 ;
27105 char * kwnames[] = {
27106 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
27107 };
27108
27109 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:PyApp__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
27110 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27111 if (!SWIG_IsOK(res1)) {
27112 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyApp *""'");
27113 }
27114 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27115 arg2 = obj1;
27116 arg3 = obj2;
27117 ecode4 = SWIG_AsVal_bool(obj3, &val4);
27118 if (!SWIG_IsOK(ecode4)) {
27119 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyApp__setCallbackInfo" "', expected argument " "4"" of type '" "bool""'");
27120 }
27121 arg4 = static_cast< bool >(val4);
27122 {
27123 PyThreadState* __tstate = wxPyBeginAllowThreads();
27124 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
27125 wxPyEndAllowThreads(__tstate);
27126 if (PyErr_Occurred()) SWIG_fail;
27127 }
27128 resultobj = SWIG_Py_Void();
27129 return resultobj;
27130 fail:
27131 return NULL;
27132 }
27133
27134
27135 SWIGINTERN PyObject *_wrap_PyApp_GetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27136 PyObject *resultobj = 0;
27137 wxPyApp *arg1 = (wxPyApp *) 0 ;
27138 wxString result;
27139 void *argp1 = 0 ;
27140 int res1 = 0 ;
27141 PyObject *swig_obj[1] ;
27142
27143 if (!args) SWIG_fail;
27144 swig_obj[0] = args;
27145 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27146 if (!SWIG_IsOK(res1)) {
27147 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAppName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27148 }
27149 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27150 {
27151 PyThreadState* __tstate = wxPyBeginAllowThreads();
27152 result = ((wxPyApp const *)arg1)->GetAppName();
27153 wxPyEndAllowThreads(__tstate);
27154 if (PyErr_Occurred()) SWIG_fail;
27155 }
27156 {
27157 #if wxUSE_UNICODE
27158 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27159 #else
27160 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27161 #endif
27162 }
27163 return resultobj;
27164 fail:
27165 return NULL;
27166 }
27167
27168
27169 SWIGINTERN PyObject *_wrap_PyApp_SetAppName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27170 PyObject *resultobj = 0;
27171 wxPyApp *arg1 = (wxPyApp *) 0 ;
27172 wxString *arg2 = 0 ;
27173 void *argp1 = 0 ;
27174 int res1 = 0 ;
27175 bool temp2 = false ;
27176 PyObject * obj0 = 0 ;
27177 PyObject * obj1 = 0 ;
27178 char * kwnames[] = {
27179 (char *) "self",(char *) "name", NULL
27180 };
27181
27182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAppName",kwnames,&obj0,&obj1)) SWIG_fail;
27183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27184 if (!SWIG_IsOK(res1)) {
27185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAppName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27186 }
27187 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27188 {
27189 arg2 = wxString_in_helper(obj1);
27190 if (arg2 == NULL) SWIG_fail;
27191 temp2 = true;
27192 }
27193 {
27194 PyThreadState* __tstate = wxPyBeginAllowThreads();
27195 (arg1)->SetAppName((wxString const &)*arg2);
27196 wxPyEndAllowThreads(__tstate);
27197 if (PyErr_Occurred()) SWIG_fail;
27198 }
27199 resultobj = SWIG_Py_Void();
27200 {
27201 if (temp2)
27202 delete arg2;
27203 }
27204 return resultobj;
27205 fail:
27206 {
27207 if (temp2)
27208 delete arg2;
27209 }
27210 return NULL;
27211 }
27212
27213
27214 SWIGINTERN PyObject *_wrap_PyApp_GetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27215 PyObject *resultobj = 0;
27216 wxPyApp *arg1 = (wxPyApp *) 0 ;
27217 wxString result;
27218 void *argp1 = 0 ;
27219 int res1 = 0 ;
27220 PyObject *swig_obj[1] ;
27221
27222 if (!args) SWIG_fail;
27223 swig_obj[0] = args;
27224 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27225 if (!SWIG_IsOK(res1)) {
27226 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetClassName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27227 }
27228 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27229 {
27230 PyThreadState* __tstate = wxPyBeginAllowThreads();
27231 result = ((wxPyApp const *)arg1)->GetClassName();
27232 wxPyEndAllowThreads(__tstate);
27233 if (PyErr_Occurred()) SWIG_fail;
27234 }
27235 {
27236 #if wxUSE_UNICODE
27237 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
27238 #else
27239 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
27240 #endif
27241 }
27242 return resultobj;
27243 fail:
27244 return NULL;
27245 }
27246
27247
27248 SWIGINTERN PyObject *_wrap_PyApp_SetClassName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27249 PyObject *resultobj = 0;
27250 wxPyApp *arg1 = (wxPyApp *) 0 ;
27251 wxString *arg2 = 0 ;
27252 void *argp1 = 0 ;
27253 int res1 = 0 ;
27254 bool temp2 = false ;
27255 PyObject * obj0 = 0 ;
27256 PyObject * obj1 = 0 ;
27257 char * kwnames[] = {
27258 (char *) "self",(char *) "name", NULL
27259 };
27260
27261 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetClassName",kwnames,&obj0,&obj1)) SWIG_fail;
27262 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27263 if (!SWIG_IsOK(res1)) {
27264 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetClassName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27265 }
27266 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27267 {
27268 arg2 = wxString_in_helper(obj1);
27269 if (arg2 == NULL) SWIG_fail;
27270 temp2 = true;
27271 }
27272 {
27273 PyThreadState* __tstate = wxPyBeginAllowThreads();
27274 (arg1)->SetClassName((wxString const &)*arg2);
27275 wxPyEndAllowThreads(__tstate);
27276 if (PyErr_Occurred()) SWIG_fail;
27277 }
27278 resultobj = SWIG_Py_Void();
27279 {
27280 if (temp2)
27281 delete arg2;
27282 }
27283 return resultobj;
27284 fail:
27285 {
27286 if (temp2)
27287 delete arg2;
27288 }
27289 return NULL;
27290 }
27291
27292
27293 SWIGINTERN PyObject *_wrap_PyApp_GetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27294 PyObject *resultobj = 0;
27295 wxPyApp *arg1 = (wxPyApp *) 0 ;
27296 wxString *result = 0 ;
27297 void *argp1 = 0 ;
27298 int res1 = 0 ;
27299 PyObject *swig_obj[1] ;
27300
27301 if (!args) SWIG_fail;
27302 swig_obj[0] = args;
27303 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27304 if (!SWIG_IsOK(res1)) {
27305 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetVendorName" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27306 }
27307 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27308 {
27309 PyThreadState* __tstate = wxPyBeginAllowThreads();
27310 {
27311 wxString const &_result_ref = ((wxPyApp const *)arg1)->GetVendorName();
27312 result = (wxString *) &_result_ref;
27313 }
27314 wxPyEndAllowThreads(__tstate);
27315 if (PyErr_Occurred()) SWIG_fail;
27316 }
27317 {
27318 #if wxUSE_UNICODE
27319 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
27320 #else
27321 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
27322 #endif
27323 }
27324 return resultobj;
27325 fail:
27326 return NULL;
27327 }
27328
27329
27330 SWIGINTERN PyObject *_wrap_PyApp_SetVendorName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27331 PyObject *resultobj = 0;
27332 wxPyApp *arg1 = (wxPyApp *) 0 ;
27333 wxString *arg2 = 0 ;
27334 void *argp1 = 0 ;
27335 int res1 = 0 ;
27336 bool temp2 = false ;
27337 PyObject * obj0 = 0 ;
27338 PyObject * obj1 = 0 ;
27339 char * kwnames[] = {
27340 (char *) "self",(char *) "name", NULL
27341 };
27342
27343 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetVendorName",kwnames,&obj0,&obj1)) SWIG_fail;
27344 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27345 if (!SWIG_IsOK(res1)) {
27346 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetVendorName" "', expected argument " "1"" of type '" "wxPyApp *""'");
27347 }
27348 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27349 {
27350 arg2 = wxString_in_helper(obj1);
27351 if (arg2 == NULL) SWIG_fail;
27352 temp2 = true;
27353 }
27354 {
27355 PyThreadState* __tstate = wxPyBeginAllowThreads();
27356 (arg1)->SetVendorName((wxString const &)*arg2);
27357 wxPyEndAllowThreads(__tstate);
27358 if (PyErr_Occurred()) SWIG_fail;
27359 }
27360 resultobj = SWIG_Py_Void();
27361 {
27362 if (temp2)
27363 delete arg2;
27364 }
27365 return resultobj;
27366 fail:
27367 {
27368 if (temp2)
27369 delete arg2;
27370 }
27371 return NULL;
27372 }
27373
27374
27375 SWIGINTERN PyObject *_wrap_PyApp_GetTraits(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27376 PyObject *resultobj = 0;
27377 wxPyApp *arg1 = (wxPyApp *) 0 ;
27378 wxAppTraits *result = 0 ;
27379 void *argp1 = 0 ;
27380 int res1 = 0 ;
27381 PyObject *swig_obj[1] ;
27382
27383 if (!args) SWIG_fail;
27384 swig_obj[0] = args;
27385 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27386 if (!SWIG_IsOK(res1)) {
27387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTraits" "', expected argument " "1"" of type '" "wxPyApp *""'");
27388 }
27389 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27390 {
27391 PyThreadState* __tstate = wxPyBeginAllowThreads();
27392 result = (wxAppTraits *)(arg1)->GetTraits();
27393 wxPyEndAllowThreads(__tstate);
27394 if (PyErr_Occurred()) SWIG_fail;
27395 }
27396 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAppTraits, 0 | 0 );
27397 return resultobj;
27398 fail:
27399 return NULL;
27400 }
27401
27402
27403 SWIGINTERN PyObject *_wrap_PyApp_ProcessPendingEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27404 PyObject *resultobj = 0;
27405 wxPyApp *arg1 = (wxPyApp *) 0 ;
27406 void *argp1 = 0 ;
27407 int res1 = 0 ;
27408 PyObject *swig_obj[1] ;
27409
27410 if (!args) SWIG_fail;
27411 swig_obj[0] = args;
27412 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27413 if (!SWIG_IsOK(res1)) {
27414 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessPendingEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27415 }
27416 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27417 {
27418 PyThreadState* __tstate = wxPyBeginAllowThreads();
27419 (arg1)->ProcessPendingEvents();
27420 wxPyEndAllowThreads(__tstate);
27421 if (PyErr_Occurred()) SWIG_fail;
27422 }
27423 resultobj = SWIG_Py_Void();
27424 return resultobj;
27425 fail:
27426 return NULL;
27427 }
27428
27429
27430 SWIGINTERN PyObject *_wrap_PyApp_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27431 PyObject *resultobj = 0;
27432 wxPyApp *arg1 = (wxPyApp *) 0 ;
27433 bool arg2 = (bool) false ;
27434 bool result;
27435 void *argp1 = 0 ;
27436 int res1 = 0 ;
27437 bool val2 ;
27438 int ecode2 = 0 ;
27439 PyObject * obj0 = 0 ;
27440 PyObject * obj1 = 0 ;
27441 char * kwnames[] = {
27442 (char *) "self",(char *) "onlyIfNeeded", NULL
27443 };
27444
27445 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:PyApp_Yield",kwnames,&obj0,&obj1)) SWIG_fail;
27446 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27447 if (!SWIG_IsOK(res1)) {
27448 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Yield" "', expected argument " "1"" of type '" "wxPyApp *""'");
27449 }
27450 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27451 if (obj1) {
27452 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27453 if (!SWIG_IsOK(ecode2)) {
27454 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_Yield" "', expected argument " "2"" of type '" "bool""'");
27455 }
27456 arg2 = static_cast< bool >(val2);
27457 }
27458 {
27459 PyThreadState* __tstate = wxPyBeginAllowThreads();
27460 result = (bool)(arg1)->Yield(arg2);
27461 wxPyEndAllowThreads(__tstate);
27462 if (PyErr_Occurred()) SWIG_fail;
27463 }
27464 {
27465 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27466 }
27467 return resultobj;
27468 fail:
27469 return NULL;
27470 }
27471
27472
27473 SWIGINTERN PyObject *_wrap_PyApp_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27474 PyObject *resultobj = 0;
27475 wxPyApp *arg1 = (wxPyApp *) 0 ;
27476 void *argp1 = 0 ;
27477 int res1 = 0 ;
27478 PyObject *swig_obj[1] ;
27479
27480 if (!args) SWIG_fail;
27481 swig_obj[0] = args;
27482 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27483 if (!SWIG_IsOK(res1)) {
27484 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_WakeUpIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27485 }
27486 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27487 {
27488 PyThreadState* __tstate = wxPyBeginAllowThreads();
27489 (arg1)->WakeUpIdle();
27490 wxPyEndAllowThreads(__tstate);
27491 if (PyErr_Occurred()) SWIG_fail;
27492 }
27493 resultobj = SWIG_Py_Void();
27494 return resultobj;
27495 fail:
27496 return NULL;
27497 }
27498
27499
27500 SWIGINTERN PyObject *_wrap_PyApp_IsMainLoopRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27501 PyObject *resultobj = 0;
27502 bool result;
27503
27504 if (!SWIG_Python_UnpackTuple(args,"PyApp_IsMainLoopRunning",0,0,0)) SWIG_fail;
27505 {
27506 PyThreadState* __tstate = wxPyBeginAllowThreads();
27507 result = (bool)wxPyApp::IsMainLoopRunning();
27508 wxPyEndAllowThreads(__tstate);
27509 if (PyErr_Occurred()) SWIG_fail;
27510 }
27511 {
27512 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27513 }
27514 return resultobj;
27515 fail:
27516 return NULL;
27517 }
27518
27519
27520 SWIGINTERN PyObject *_wrap_PyApp_MainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27521 PyObject *resultobj = 0;
27522 wxPyApp *arg1 = (wxPyApp *) 0 ;
27523 int result;
27524 void *argp1 = 0 ;
27525 int res1 = 0 ;
27526 PyObject *swig_obj[1] ;
27527
27528 if (!args) SWIG_fail;
27529 swig_obj[0] = args;
27530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27531 if (!SWIG_IsOK(res1)) {
27532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_MainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27533 }
27534 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27535 {
27536 PyThreadState* __tstate = wxPyBeginAllowThreads();
27537 result = (int)(arg1)->MainLoop();
27538 wxPyEndAllowThreads(__tstate);
27539 if (PyErr_Occurred()) SWIG_fail;
27540 }
27541 resultobj = SWIG_From_int(static_cast< int >(result));
27542 return resultobj;
27543 fail:
27544 return NULL;
27545 }
27546
27547
27548 SWIGINTERN PyObject *_wrap_PyApp_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27549 PyObject *resultobj = 0;
27550 wxPyApp *arg1 = (wxPyApp *) 0 ;
27551 void *argp1 = 0 ;
27552 int res1 = 0 ;
27553 PyObject *swig_obj[1] ;
27554
27555 if (!args) SWIG_fail;
27556 swig_obj[0] = args;
27557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27558 if (!SWIG_IsOK(res1)) {
27559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Exit" "', expected argument " "1"" of type '" "wxPyApp *""'");
27560 }
27561 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27562 {
27563 PyThreadState* __tstate = wxPyBeginAllowThreads();
27564 (arg1)->Exit();
27565 wxPyEndAllowThreads(__tstate);
27566 if (PyErr_Occurred()) SWIG_fail;
27567 }
27568 resultobj = SWIG_Py_Void();
27569 return resultobj;
27570 fail:
27571 return NULL;
27572 }
27573
27574
27575 SWIGINTERN PyObject *_wrap_PyApp_ExitMainLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27576 PyObject *resultobj = 0;
27577 wxPyApp *arg1 = (wxPyApp *) 0 ;
27578 void *argp1 = 0 ;
27579 int res1 = 0 ;
27580 PyObject *swig_obj[1] ;
27581
27582 if (!args) SWIG_fail;
27583 swig_obj[0] = args;
27584 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27585 if (!SWIG_IsOK(res1)) {
27586 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ExitMainLoop" "', expected argument " "1"" of type '" "wxPyApp *""'");
27587 }
27588 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27589 {
27590 PyThreadState* __tstate = wxPyBeginAllowThreads();
27591 (arg1)->ExitMainLoop();
27592 wxPyEndAllowThreads(__tstate);
27593 if (PyErr_Occurred()) SWIG_fail;
27594 }
27595 resultobj = SWIG_Py_Void();
27596 return resultobj;
27597 fail:
27598 return NULL;
27599 }
27600
27601
27602 SWIGINTERN PyObject *_wrap_PyApp_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27603 PyObject *resultobj = 0;
27604 wxPyApp *arg1 = (wxPyApp *) 0 ;
27605 bool result;
27606 void *argp1 = 0 ;
27607 int res1 = 0 ;
27608 PyObject *swig_obj[1] ;
27609
27610 if (!args) SWIG_fail;
27611 swig_obj[0] = args;
27612 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27613 if (!SWIG_IsOK(res1)) {
27614 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Pending" "', expected argument " "1"" of type '" "wxPyApp *""'");
27615 }
27616 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27617 {
27618 PyThreadState* __tstate = wxPyBeginAllowThreads();
27619 result = (bool)(arg1)->Pending();
27620 wxPyEndAllowThreads(__tstate);
27621 if (PyErr_Occurred()) SWIG_fail;
27622 }
27623 {
27624 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27625 }
27626 return resultobj;
27627 fail:
27628 return NULL;
27629 }
27630
27631
27632 SWIGINTERN PyObject *_wrap_PyApp_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27633 PyObject *resultobj = 0;
27634 wxPyApp *arg1 = (wxPyApp *) 0 ;
27635 bool result;
27636 void *argp1 = 0 ;
27637 int res1 = 0 ;
27638 PyObject *swig_obj[1] ;
27639
27640 if (!args) SWIG_fail;
27641 swig_obj[0] = args;
27642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27643 if (!SWIG_IsOK(res1)) {
27644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_Dispatch" "', expected argument " "1"" of type '" "wxPyApp *""'");
27645 }
27646 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27647 {
27648 PyThreadState* __tstate = wxPyBeginAllowThreads();
27649 result = (bool)(arg1)->Dispatch();
27650 wxPyEndAllowThreads(__tstate);
27651 if (PyErr_Occurred()) SWIG_fail;
27652 }
27653 {
27654 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27655 }
27656 return resultobj;
27657 fail:
27658 return NULL;
27659 }
27660
27661
27662 SWIGINTERN PyObject *_wrap_PyApp_ProcessIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27663 PyObject *resultobj = 0;
27664 wxPyApp *arg1 = (wxPyApp *) 0 ;
27665 bool result;
27666 void *argp1 = 0 ;
27667 int res1 = 0 ;
27668 PyObject *swig_obj[1] ;
27669
27670 if (!args) SWIG_fail;
27671 swig_obj[0] = args;
27672 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27673 if (!SWIG_IsOK(res1)) {
27674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_ProcessIdle" "', expected argument " "1"" of type '" "wxPyApp *""'");
27675 }
27676 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27677 {
27678 PyThreadState* __tstate = wxPyBeginAllowThreads();
27679 result = (bool)(arg1)->ProcessIdle();
27680 wxPyEndAllowThreads(__tstate);
27681 if (PyErr_Occurred()) SWIG_fail;
27682 }
27683 {
27684 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27685 }
27686 return resultobj;
27687 fail:
27688 return NULL;
27689 }
27690
27691
27692 SWIGINTERN PyObject *_wrap_PyApp_SendIdleEvents(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27693 PyObject *resultobj = 0;
27694 wxPyApp *arg1 = (wxPyApp *) 0 ;
27695 wxWindow *arg2 = (wxWindow *) 0 ;
27696 wxIdleEvent *arg3 = 0 ;
27697 bool result;
27698 void *argp1 = 0 ;
27699 int res1 = 0 ;
27700 void *argp2 = 0 ;
27701 int res2 = 0 ;
27702 void *argp3 = 0 ;
27703 int res3 = 0 ;
27704 PyObject * obj0 = 0 ;
27705 PyObject * obj1 = 0 ;
27706 PyObject * obj2 = 0 ;
27707 char * kwnames[] = {
27708 (char *) "self",(char *) "win",(char *) "event", NULL
27709 };
27710
27711 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PyApp_SendIdleEvents",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
27712 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27713 if (!SWIG_IsOK(res1)) {
27714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SendIdleEvents" "', expected argument " "1"" of type '" "wxPyApp *""'");
27715 }
27716 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27717 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27718 if (!SWIG_IsOK(res2)) {
27719 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SendIdleEvents" "', expected argument " "2"" of type '" "wxWindow *""'");
27720 }
27721 arg2 = reinterpret_cast< wxWindow * >(argp2);
27722 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxIdleEvent, 0 );
27723 if (!SWIG_IsOK(res3)) {
27724 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27725 }
27726 if (!argp3) {
27727 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PyApp_SendIdleEvents" "', expected argument " "3"" of type '" "wxIdleEvent &""'");
27728 }
27729 arg3 = reinterpret_cast< wxIdleEvent * >(argp3);
27730 {
27731 PyThreadState* __tstate = wxPyBeginAllowThreads();
27732 result = (bool)(arg1)->SendIdleEvents(arg2,*arg3);
27733 wxPyEndAllowThreads(__tstate);
27734 if (PyErr_Occurred()) SWIG_fail;
27735 }
27736 {
27737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27738 }
27739 return resultobj;
27740 fail:
27741 return NULL;
27742 }
27743
27744
27745 SWIGINTERN PyObject *_wrap_PyApp_IsActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27746 PyObject *resultobj = 0;
27747 wxPyApp *arg1 = (wxPyApp *) 0 ;
27748 bool result;
27749 void *argp1 = 0 ;
27750 int res1 = 0 ;
27751 PyObject *swig_obj[1] ;
27752
27753 if (!args) SWIG_fail;
27754 swig_obj[0] = args;
27755 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27756 if (!SWIG_IsOK(res1)) {
27757 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_IsActive" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27758 }
27759 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27760 {
27761 PyThreadState* __tstate = wxPyBeginAllowThreads();
27762 result = (bool)((wxPyApp const *)arg1)->IsActive();
27763 wxPyEndAllowThreads(__tstate);
27764 if (PyErr_Occurred()) SWIG_fail;
27765 }
27766 {
27767 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27768 }
27769 return resultobj;
27770 fail:
27771 return NULL;
27772 }
27773
27774
27775 SWIGINTERN PyObject *_wrap_PyApp_SetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27776 PyObject *resultobj = 0;
27777 wxPyApp *arg1 = (wxPyApp *) 0 ;
27778 wxWindow *arg2 = (wxWindow *) 0 ;
27779 void *argp1 = 0 ;
27780 int res1 = 0 ;
27781 void *argp2 = 0 ;
27782 int res2 = 0 ;
27783 PyObject * obj0 = 0 ;
27784 PyObject * obj1 = 0 ;
27785 char * kwnames[] = {
27786 (char *) "self",(char *) "win", NULL
27787 };
27788
27789 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetTopWindow",kwnames,&obj0,&obj1)) SWIG_fail;
27790 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27791 if (!SWIG_IsOK(res1)) {
27792 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetTopWindow" "', expected argument " "1"" of type '" "wxPyApp *""'");
27793 }
27794 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27795 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
27796 if (!SWIG_IsOK(res2)) {
27797 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PyApp_SetTopWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
27798 }
27799 arg2 = reinterpret_cast< wxWindow * >(argp2);
27800 {
27801 PyThreadState* __tstate = wxPyBeginAllowThreads();
27802 (arg1)->SetTopWindow(arg2);
27803 wxPyEndAllowThreads(__tstate);
27804 if (PyErr_Occurred()) SWIG_fail;
27805 }
27806 resultobj = SWIG_Py_Void();
27807 return resultobj;
27808 fail:
27809 return NULL;
27810 }
27811
27812
27813 SWIGINTERN PyObject *_wrap_PyApp_GetTopWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27814 PyObject *resultobj = 0;
27815 wxPyApp *arg1 = (wxPyApp *) 0 ;
27816 wxWindow *result = 0 ;
27817 void *argp1 = 0 ;
27818 int res1 = 0 ;
27819 PyObject *swig_obj[1] ;
27820
27821 if (!args) SWIG_fail;
27822 swig_obj[0] = args;
27823 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27824 if (!SWIG_IsOK(res1)) {
27825 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetTopWindow" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27826 }
27827 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27828 {
27829 PyThreadState* __tstate = wxPyBeginAllowThreads();
27830 result = (wxWindow *)((wxPyApp const *)arg1)->GetTopWindow();
27831 wxPyEndAllowThreads(__tstate);
27832 if (PyErr_Occurred()) SWIG_fail;
27833 }
27834 {
27835 resultobj = wxPyMake_wxObject(result, (bool)0);
27836 }
27837 return resultobj;
27838 fail:
27839 return NULL;
27840 }
27841
27842
27843 SWIGINTERN PyObject *_wrap_PyApp_SetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27844 PyObject *resultobj = 0;
27845 wxPyApp *arg1 = (wxPyApp *) 0 ;
27846 bool arg2 ;
27847 void *argp1 = 0 ;
27848 int res1 = 0 ;
27849 bool val2 ;
27850 int ecode2 = 0 ;
27851 PyObject * obj0 = 0 ;
27852 PyObject * obj1 = 0 ;
27853 char * kwnames[] = {
27854 (char *) "self",(char *) "flag", NULL
27855 };
27856
27857 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetExitOnFrameDelete",kwnames,&obj0,&obj1)) SWIG_fail;
27858 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27859 if (!SWIG_IsOK(res1)) {
27860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp *""'");
27861 }
27862 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27863 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27864 if (!SWIG_IsOK(ecode2)) {
27865 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetExitOnFrameDelete" "', expected argument " "2"" of type '" "bool""'");
27866 }
27867 arg2 = static_cast< bool >(val2);
27868 {
27869 PyThreadState* __tstate = wxPyBeginAllowThreads();
27870 (arg1)->SetExitOnFrameDelete(arg2);
27871 wxPyEndAllowThreads(__tstate);
27872 if (PyErr_Occurred()) SWIG_fail;
27873 }
27874 resultobj = SWIG_Py_Void();
27875 return resultobj;
27876 fail:
27877 return NULL;
27878 }
27879
27880
27881 SWIGINTERN PyObject *_wrap_PyApp_GetExitOnFrameDelete(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27882 PyObject *resultobj = 0;
27883 wxPyApp *arg1 = (wxPyApp *) 0 ;
27884 bool result;
27885 void *argp1 = 0 ;
27886 int res1 = 0 ;
27887 PyObject *swig_obj[1] ;
27888
27889 if (!args) SWIG_fail;
27890 swig_obj[0] = args;
27891 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27892 if (!SWIG_IsOK(res1)) {
27893 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetExitOnFrameDelete" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27894 }
27895 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27896 {
27897 PyThreadState* __tstate = wxPyBeginAllowThreads();
27898 result = (bool)((wxPyApp const *)arg1)->GetExitOnFrameDelete();
27899 wxPyEndAllowThreads(__tstate);
27900 if (PyErr_Occurred()) SWIG_fail;
27901 }
27902 {
27903 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27904 }
27905 return resultobj;
27906 fail:
27907 return NULL;
27908 }
27909
27910
27911 SWIGINTERN PyObject *_wrap_PyApp_SetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27912 PyObject *resultobj = 0;
27913 wxPyApp *arg1 = (wxPyApp *) 0 ;
27914 bool arg2 ;
27915 void *argp1 = 0 ;
27916 int res1 = 0 ;
27917 bool val2 ;
27918 int ecode2 = 0 ;
27919 PyObject * obj0 = 0 ;
27920 PyObject * obj1 = 0 ;
27921 char * kwnames[] = {
27922 (char *) "self",(char *) "flag", NULL
27923 };
27924
27925 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetUseBestVisual",kwnames,&obj0,&obj1)) SWIG_fail;
27926 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27927 if (!SWIG_IsOK(res1)) {
27928 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp *""'");
27929 }
27930 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27931 ecode2 = SWIG_AsVal_bool(obj1, &val2);
27932 if (!SWIG_IsOK(ecode2)) {
27933 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetUseBestVisual" "', expected argument " "2"" of type '" "bool""'");
27934 }
27935 arg2 = static_cast< bool >(val2);
27936 {
27937 PyThreadState* __tstate = wxPyBeginAllowThreads();
27938 (arg1)->SetUseBestVisual(arg2);
27939 wxPyEndAllowThreads(__tstate);
27940 if (PyErr_Occurred()) SWIG_fail;
27941 }
27942 resultobj = SWIG_Py_Void();
27943 return resultobj;
27944 fail:
27945 return NULL;
27946 }
27947
27948
27949 SWIGINTERN PyObject *_wrap_PyApp_GetUseBestVisual(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
27950 PyObject *resultobj = 0;
27951 wxPyApp *arg1 = (wxPyApp *) 0 ;
27952 bool result;
27953 void *argp1 = 0 ;
27954 int res1 = 0 ;
27955 PyObject *swig_obj[1] ;
27956
27957 if (!args) SWIG_fail;
27958 swig_obj[0] = args;
27959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27960 if (!SWIG_IsOK(res1)) {
27961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetUseBestVisual" "', expected argument " "1"" of type '" "wxPyApp const *""'");
27962 }
27963 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27964 {
27965 PyThreadState* __tstate = wxPyBeginAllowThreads();
27966 result = (bool)((wxPyApp const *)arg1)->GetUseBestVisual();
27967 wxPyEndAllowThreads(__tstate);
27968 if (PyErr_Occurred()) SWIG_fail;
27969 }
27970 {
27971 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
27972 }
27973 return resultobj;
27974 fail:
27975 return NULL;
27976 }
27977
27978
27979 SWIGINTERN PyObject *_wrap_PyApp_SetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
27980 PyObject *resultobj = 0;
27981 wxPyApp *arg1 = (wxPyApp *) 0 ;
27982 int arg2 ;
27983 void *argp1 = 0 ;
27984 int res1 = 0 ;
27985 int val2 ;
27986 int ecode2 = 0 ;
27987 PyObject * obj0 = 0 ;
27988 PyObject * obj1 = 0 ;
27989 char * kwnames[] = {
27990 (char *) "self",(char *) "mode", NULL
27991 };
27992
27993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetPrintMode",kwnames,&obj0,&obj1)) SWIG_fail;
27994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
27995 if (!SWIG_IsOK(res1)) {
27996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetPrintMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
27997 }
27998 arg1 = reinterpret_cast< wxPyApp * >(argp1);
27999 ecode2 = SWIG_AsVal_int(obj1, &val2);
28000 if (!SWIG_IsOK(ecode2)) {
28001 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetPrintMode" "', expected argument " "2"" of type '" "int""'");
28002 }
28003 arg2 = static_cast< int >(val2);
28004 {
28005 PyThreadState* __tstate = wxPyBeginAllowThreads();
28006 (arg1)->SetPrintMode(arg2);
28007 wxPyEndAllowThreads(__tstate);
28008 if (PyErr_Occurred()) SWIG_fail;
28009 }
28010 resultobj = SWIG_Py_Void();
28011 return resultobj;
28012 fail:
28013 return NULL;
28014 }
28015
28016
28017 SWIGINTERN PyObject *_wrap_PyApp_GetPrintMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28018 PyObject *resultobj = 0;
28019 wxPyApp *arg1 = (wxPyApp *) 0 ;
28020 int result;
28021 void *argp1 = 0 ;
28022 int res1 = 0 ;
28023 PyObject *swig_obj[1] ;
28024
28025 if (!args) SWIG_fail;
28026 swig_obj[0] = args;
28027 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28028 if (!SWIG_IsOK(res1)) {
28029 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetPrintMode" "', expected argument " "1"" of type '" "wxPyApp const *""'");
28030 }
28031 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28032 {
28033 PyThreadState* __tstate = wxPyBeginAllowThreads();
28034 result = (int)((wxPyApp const *)arg1)->GetPrintMode();
28035 wxPyEndAllowThreads(__tstate);
28036 if (PyErr_Occurred()) SWIG_fail;
28037 }
28038 resultobj = SWIG_From_int(static_cast< int >(result));
28039 return resultobj;
28040 fail:
28041 return NULL;
28042 }
28043
28044
28045 SWIGINTERN PyObject *_wrap_PyApp_SetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28046 PyObject *resultobj = 0;
28047 wxPyApp *arg1 = (wxPyApp *) 0 ;
28048 int arg2 ;
28049 void *argp1 = 0 ;
28050 int res1 = 0 ;
28051 int val2 ;
28052 int ecode2 = 0 ;
28053 PyObject * obj0 = 0 ;
28054 PyObject * obj1 = 0 ;
28055 char * kwnames[] = {
28056 (char *) "self",(char *) "mode", NULL
28057 };
28058
28059 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PyApp_SetAssertMode",kwnames,&obj0,&obj1)) SWIG_fail;
28060 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28061 if (!SWIG_IsOK(res1)) {
28062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_SetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28063 }
28064 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28065 ecode2 = SWIG_AsVal_int(obj1, &val2);
28066 if (!SWIG_IsOK(ecode2)) {
28067 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "PyApp_SetAssertMode" "', expected argument " "2"" of type '" "int""'");
28068 }
28069 arg2 = static_cast< int >(val2);
28070 {
28071 PyThreadState* __tstate = wxPyBeginAllowThreads();
28072 (arg1)->SetAssertMode(arg2);
28073 wxPyEndAllowThreads(__tstate);
28074 if (PyErr_Occurred()) SWIG_fail;
28075 }
28076 resultobj = SWIG_Py_Void();
28077 return resultobj;
28078 fail:
28079 return NULL;
28080 }
28081
28082
28083 SWIGINTERN PyObject *_wrap_PyApp_GetAssertMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28084 PyObject *resultobj = 0;
28085 wxPyApp *arg1 = (wxPyApp *) 0 ;
28086 int result;
28087 void *argp1 = 0 ;
28088 int res1 = 0 ;
28089 PyObject *swig_obj[1] ;
28090
28091 if (!args) SWIG_fail;
28092 swig_obj[0] = args;
28093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28094 if (!SWIG_IsOK(res1)) {
28095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp_GetAssertMode" "', expected argument " "1"" of type '" "wxPyApp *""'");
28096 }
28097 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28098 {
28099 PyThreadState* __tstate = wxPyBeginAllowThreads();
28100 result = (int)(arg1)->GetAssertMode();
28101 wxPyEndAllowThreads(__tstate);
28102 if (PyErr_Occurred()) SWIG_fail;
28103 }
28104 resultobj = SWIG_From_int(static_cast< int >(result));
28105 return resultobj;
28106 fail:
28107 return NULL;
28108 }
28109
28110
28111 SWIGINTERN PyObject *_wrap_PyApp_GetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28112 PyObject *resultobj = 0;
28113 bool result;
28114
28115 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacSupportPCMenuShortcuts",0,0,0)) SWIG_fail;
28116 {
28117 PyThreadState* __tstate = wxPyBeginAllowThreads();
28118 result = (bool)wxPyApp::GetMacSupportPCMenuShortcuts();
28119 wxPyEndAllowThreads(__tstate);
28120 if (PyErr_Occurred()) SWIG_fail;
28121 }
28122 {
28123 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28124 }
28125 return resultobj;
28126 fail:
28127 return NULL;
28128 }
28129
28130
28131 SWIGINTERN PyObject *_wrap_PyApp_GetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28132 PyObject *resultobj = 0;
28133 long result;
28134
28135 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacAboutMenuItemId",0,0,0)) SWIG_fail;
28136 {
28137 PyThreadState* __tstate = wxPyBeginAllowThreads();
28138 result = (long)wxPyApp::GetMacAboutMenuItemId();
28139 wxPyEndAllowThreads(__tstate);
28140 if (PyErr_Occurred()) SWIG_fail;
28141 }
28142 resultobj = SWIG_From_long(static_cast< long >(result));
28143 return resultobj;
28144 fail:
28145 return NULL;
28146 }
28147
28148
28149 SWIGINTERN PyObject *_wrap_PyApp_GetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28150 PyObject *resultobj = 0;
28151 long result;
28152
28153 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacPreferencesMenuItemId",0,0,0)) SWIG_fail;
28154 {
28155 PyThreadState* __tstate = wxPyBeginAllowThreads();
28156 result = (long)wxPyApp::GetMacPreferencesMenuItemId();
28157 wxPyEndAllowThreads(__tstate);
28158 if (PyErr_Occurred()) SWIG_fail;
28159 }
28160 resultobj = SWIG_From_long(static_cast< long >(result));
28161 return resultobj;
28162 fail:
28163 return NULL;
28164 }
28165
28166
28167 SWIGINTERN PyObject *_wrap_PyApp_GetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28168 PyObject *resultobj = 0;
28169 long result;
28170
28171 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacExitMenuItemId",0,0,0)) SWIG_fail;
28172 {
28173 PyThreadState* __tstate = wxPyBeginAllowThreads();
28174 result = (long)wxPyApp::GetMacExitMenuItemId();
28175 wxPyEndAllowThreads(__tstate);
28176 if (PyErr_Occurred()) SWIG_fail;
28177 }
28178 resultobj = SWIG_From_long(static_cast< long >(result));
28179 return resultobj;
28180 fail:
28181 return NULL;
28182 }
28183
28184
28185 SWIGINTERN PyObject *_wrap_PyApp_GetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28186 PyObject *resultobj = 0;
28187 wxString result;
28188
28189 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetMacHelpMenuTitleName",0,0,0)) SWIG_fail;
28190 {
28191 PyThreadState* __tstate = wxPyBeginAllowThreads();
28192 result = wxPyApp::GetMacHelpMenuTitleName();
28193 wxPyEndAllowThreads(__tstate);
28194 if (PyErr_Occurred()) SWIG_fail;
28195 }
28196 {
28197 #if wxUSE_UNICODE
28198 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
28199 #else
28200 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
28201 #endif
28202 }
28203 return resultobj;
28204 fail:
28205 return NULL;
28206 }
28207
28208
28209 SWIGINTERN PyObject *_wrap_PyApp_SetMacSupportPCMenuShortcuts(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28210 PyObject *resultobj = 0;
28211 bool arg1 ;
28212 bool val1 ;
28213 int ecode1 = 0 ;
28214 PyObject * obj0 = 0 ;
28215 char * kwnames[] = {
28216 (char *) "val", NULL
28217 };
28218
28219 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacSupportPCMenuShortcuts",kwnames,&obj0)) SWIG_fail;
28220 ecode1 = SWIG_AsVal_bool(obj0, &val1);
28221 if (!SWIG_IsOK(ecode1)) {
28222 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacSupportPCMenuShortcuts" "', expected argument " "1"" of type '" "bool""'");
28223 }
28224 arg1 = static_cast< bool >(val1);
28225 {
28226 PyThreadState* __tstate = wxPyBeginAllowThreads();
28227 wxPyApp::SetMacSupportPCMenuShortcuts(arg1);
28228 wxPyEndAllowThreads(__tstate);
28229 if (PyErr_Occurred()) SWIG_fail;
28230 }
28231 resultobj = SWIG_Py_Void();
28232 return resultobj;
28233 fail:
28234 return NULL;
28235 }
28236
28237
28238 SWIGINTERN PyObject *_wrap_PyApp_SetMacAboutMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28239 PyObject *resultobj = 0;
28240 long arg1 ;
28241 long val1 ;
28242 int ecode1 = 0 ;
28243 PyObject * obj0 = 0 ;
28244 char * kwnames[] = {
28245 (char *) "val", NULL
28246 };
28247
28248 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacAboutMenuItemId",kwnames,&obj0)) SWIG_fail;
28249 ecode1 = SWIG_AsVal_long(obj0, &val1);
28250 if (!SWIG_IsOK(ecode1)) {
28251 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacAboutMenuItemId" "', expected argument " "1"" of type '" "long""'");
28252 }
28253 arg1 = static_cast< long >(val1);
28254 {
28255 PyThreadState* __tstate = wxPyBeginAllowThreads();
28256 wxPyApp::SetMacAboutMenuItemId(arg1);
28257 wxPyEndAllowThreads(__tstate);
28258 if (PyErr_Occurred()) SWIG_fail;
28259 }
28260 resultobj = SWIG_Py_Void();
28261 return resultobj;
28262 fail:
28263 return NULL;
28264 }
28265
28266
28267 SWIGINTERN PyObject *_wrap_PyApp_SetMacPreferencesMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28268 PyObject *resultobj = 0;
28269 long arg1 ;
28270 long val1 ;
28271 int ecode1 = 0 ;
28272 PyObject * obj0 = 0 ;
28273 char * kwnames[] = {
28274 (char *) "val", NULL
28275 };
28276
28277 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacPreferencesMenuItemId",kwnames,&obj0)) SWIG_fail;
28278 ecode1 = SWIG_AsVal_long(obj0, &val1);
28279 if (!SWIG_IsOK(ecode1)) {
28280 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacPreferencesMenuItemId" "', expected argument " "1"" of type '" "long""'");
28281 }
28282 arg1 = static_cast< long >(val1);
28283 {
28284 PyThreadState* __tstate = wxPyBeginAllowThreads();
28285 wxPyApp::SetMacPreferencesMenuItemId(arg1);
28286 wxPyEndAllowThreads(__tstate);
28287 if (PyErr_Occurred()) SWIG_fail;
28288 }
28289 resultobj = SWIG_Py_Void();
28290 return resultobj;
28291 fail:
28292 return NULL;
28293 }
28294
28295
28296 SWIGINTERN PyObject *_wrap_PyApp_SetMacExitMenuItemId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28297 PyObject *resultobj = 0;
28298 long arg1 ;
28299 long val1 ;
28300 int ecode1 = 0 ;
28301 PyObject * obj0 = 0 ;
28302 char * kwnames[] = {
28303 (char *) "val", NULL
28304 };
28305
28306 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacExitMenuItemId",kwnames,&obj0)) SWIG_fail;
28307 ecode1 = SWIG_AsVal_long(obj0, &val1);
28308 if (!SWIG_IsOK(ecode1)) {
28309 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "PyApp_SetMacExitMenuItemId" "', expected argument " "1"" of type '" "long""'");
28310 }
28311 arg1 = static_cast< long >(val1);
28312 {
28313 PyThreadState* __tstate = wxPyBeginAllowThreads();
28314 wxPyApp::SetMacExitMenuItemId(arg1);
28315 wxPyEndAllowThreads(__tstate);
28316 if (PyErr_Occurred()) SWIG_fail;
28317 }
28318 resultobj = SWIG_Py_Void();
28319 return resultobj;
28320 fail:
28321 return NULL;
28322 }
28323
28324
28325 SWIGINTERN PyObject *_wrap_PyApp_SetMacHelpMenuTitleName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28326 PyObject *resultobj = 0;
28327 wxString *arg1 = 0 ;
28328 bool temp1 = false ;
28329 PyObject * obj0 = 0 ;
28330 char * kwnames[] = {
28331 (char *) "val", NULL
28332 };
28333
28334 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:PyApp_SetMacHelpMenuTitleName",kwnames,&obj0)) SWIG_fail;
28335 {
28336 arg1 = wxString_in_helper(obj0);
28337 if (arg1 == NULL) SWIG_fail;
28338 temp1 = true;
28339 }
28340 {
28341 PyThreadState* __tstate = wxPyBeginAllowThreads();
28342 wxPyApp::SetMacHelpMenuTitleName((wxString const &)*arg1);
28343 wxPyEndAllowThreads(__tstate);
28344 if (PyErr_Occurred()) SWIG_fail;
28345 }
28346 resultobj = SWIG_Py_Void();
28347 {
28348 if (temp1)
28349 delete arg1;
28350 }
28351 return resultobj;
28352 fail:
28353 {
28354 if (temp1)
28355 delete arg1;
28356 }
28357 return NULL;
28358 }
28359
28360
28361 SWIGINTERN PyObject *_wrap_PyApp__BootstrapApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28362 PyObject *resultobj = 0;
28363 wxPyApp *arg1 = (wxPyApp *) 0 ;
28364 void *argp1 = 0 ;
28365 int res1 = 0 ;
28366 PyObject *swig_obj[1] ;
28367
28368 if (!args) SWIG_fail;
28369 swig_obj[0] = args;
28370 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxPyApp, 0 | 0 );
28371 if (!SWIG_IsOK(res1)) {
28372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyApp__BootstrapApp" "', expected argument " "1"" of type '" "wxPyApp *""'");
28373 }
28374 arg1 = reinterpret_cast< wxPyApp * >(argp1);
28375 {
28376 PyThreadState* __tstate = wxPyBeginAllowThreads();
28377 (arg1)->_BootstrapApp();
28378 wxPyEndAllowThreads(__tstate);
28379 if (PyErr_Occurred()) SWIG_fail;
28380 }
28381 resultobj = SWIG_Py_Void();
28382 return resultobj;
28383 fail:
28384 return NULL;
28385 }
28386
28387
28388 SWIGINTERN PyObject *_wrap_PyApp_GetComCtl32Version(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28389 PyObject *resultobj = 0;
28390 int result;
28391
28392 if (!SWIG_Python_UnpackTuple(args,"PyApp_GetComCtl32Version",0,0,0)) SWIG_fail;
28393 {
28394 PyThreadState* __tstate = wxPyBeginAllowThreads();
28395 result = (int)wxPyApp_GetComCtl32Version();
28396 wxPyEndAllowThreads(__tstate);
28397 if (PyErr_Occurred()) SWIG_fail;
28398 }
28399 resultobj = SWIG_From_int(static_cast< int >(result));
28400 return resultobj;
28401 fail:
28402 return NULL;
28403 }
28404
28405
28406 SWIGINTERN PyObject *PyApp_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28407 PyObject *obj;
28408 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28409 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyApp, SWIG_NewClientData(obj));
28410 return SWIG_Py_Void();
28411 }
28412
28413 SWIGINTERN PyObject *PyApp_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28414 return SWIG_Python_InitShadowInstance(args);
28415 }
28416
28417 SWIGINTERN PyObject *_wrap_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28418 PyObject *resultobj = 0;
28419
28420 if (!SWIG_Python_UnpackTuple(args,"Exit",0,0,0)) SWIG_fail;
28421 {
28422 PyThreadState* __tstate = wxPyBeginAllowThreads();
28423 wxExit();
28424 wxPyEndAllowThreads(__tstate);
28425 if (PyErr_Occurred()) SWIG_fail;
28426 }
28427 resultobj = SWIG_Py_Void();
28428 return resultobj;
28429 fail:
28430 return NULL;
28431 }
28432
28433
28434 SWIGINTERN PyObject *_wrap_Yield(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28435 PyObject *resultobj = 0;
28436 bool result;
28437
28438 if (!SWIG_Python_UnpackTuple(args,"Yield",0,0,0)) SWIG_fail;
28439 {
28440 PyThreadState* __tstate = wxPyBeginAllowThreads();
28441 result = (bool)wxYield();
28442 wxPyEndAllowThreads(__tstate);
28443 if (PyErr_Occurred()) SWIG_fail;
28444 }
28445 {
28446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28447 }
28448 return resultobj;
28449 fail:
28450 return NULL;
28451 }
28452
28453
28454 SWIGINTERN PyObject *_wrap_YieldIfNeeded(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28455 PyObject *resultobj = 0;
28456 bool result;
28457
28458 if (!SWIG_Python_UnpackTuple(args,"YieldIfNeeded",0,0,0)) SWIG_fail;
28459 {
28460 PyThreadState* __tstate = wxPyBeginAllowThreads();
28461 result = (bool)wxYieldIfNeeded();
28462 wxPyEndAllowThreads(__tstate);
28463 if (PyErr_Occurred()) SWIG_fail;
28464 }
28465 {
28466 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28467 }
28468 return resultobj;
28469 fail:
28470 return NULL;
28471 }
28472
28473
28474 SWIGINTERN PyObject *_wrap_SafeYield(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28475 PyObject *resultobj = 0;
28476 wxWindow *arg1 = (wxWindow *) NULL ;
28477 bool arg2 = (bool) false ;
28478 bool result;
28479 void *argp1 = 0 ;
28480 int res1 = 0 ;
28481 bool val2 ;
28482 int ecode2 = 0 ;
28483 PyObject * obj0 = 0 ;
28484 PyObject * obj1 = 0 ;
28485 char * kwnames[] = {
28486 (char *) "win",(char *) "onlyIfNeeded", NULL
28487 };
28488
28489 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:SafeYield",kwnames,&obj0,&obj1)) SWIG_fail;
28490 if (obj0) {
28491 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
28492 if (!SWIG_IsOK(res1)) {
28493 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SafeYield" "', expected argument " "1"" of type '" "wxWindow *""'");
28494 }
28495 arg1 = reinterpret_cast< wxWindow * >(argp1);
28496 }
28497 if (obj1) {
28498 ecode2 = SWIG_AsVal_bool(obj1, &val2);
28499 if (!SWIG_IsOK(ecode2)) {
28500 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SafeYield" "', expected argument " "2"" of type '" "bool""'");
28501 }
28502 arg2 = static_cast< bool >(val2);
28503 }
28504 {
28505 PyThreadState* __tstate = wxPyBeginAllowThreads();
28506 result = (bool)wxSafeYield(arg1,arg2);
28507 wxPyEndAllowThreads(__tstate);
28508 if (PyErr_Occurred()) SWIG_fail;
28509 }
28510 {
28511 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28512 }
28513 return resultobj;
28514 fail:
28515 return NULL;
28516 }
28517
28518
28519 SWIGINTERN PyObject *_wrap_WakeUpIdle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28520 PyObject *resultobj = 0;
28521
28522 if (!SWIG_Python_UnpackTuple(args,"WakeUpIdle",0,0,0)) SWIG_fail;
28523 {
28524 PyThreadState* __tstate = wxPyBeginAllowThreads();
28525 wxWakeUpIdle();
28526 wxPyEndAllowThreads(__tstate);
28527 if (PyErr_Occurred()) SWIG_fail;
28528 }
28529 resultobj = SWIG_Py_Void();
28530 return resultobj;
28531 fail:
28532 return NULL;
28533 }
28534
28535
28536 SWIGINTERN PyObject *_wrap_PostEvent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28537 PyObject *resultobj = 0;
28538 wxEvtHandler *arg1 = (wxEvtHandler *) 0 ;
28539 wxEvent *arg2 = 0 ;
28540 void *argp1 = 0 ;
28541 int res1 = 0 ;
28542 void *argp2 = 0 ;
28543 int res2 = 0 ;
28544 PyObject * obj0 = 0 ;
28545 PyObject * obj1 = 0 ;
28546 char * kwnames[] = {
28547 (char *) "dest",(char *) "event", NULL
28548 };
28549
28550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:PostEvent",kwnames,&obj0,&obj1)) SWIG_fail;
28551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
28552 if (!SWIG_IsOK(res1)) {
28553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PostEvent" "', expected argument " "1"" of type '" "wxEvtHandler *""'");
28554 }
28555 arg1 = reinterpret_cast< wxEvtHandler * >(argp1);
28556 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxEvent, 0 );
28557 if (!SWIG_IsOK(res2)) {
28558 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28559 }
28560 if (!argp2) {
28561 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "PostEvent" "', expected argument " "2"" of type '" "wxEvent &""'");
28562 }
28563 arg2 = reinterpret_cast< wxEvent * >(argp2);
28564 {
28565 PyThreadState* __tstate = wxPyBeginAllowThreads();
28566 wxPostEvent(arg1,*arg2);
28567 wxPyEndAllowThreads(__tstate);
28568 if (PyErr_Occurred()) SWIG_fail;
28569 }
28570 resultobj = SWIG_Py_Void();
28571 return resultobj;
28572 fail:
28573 return NULL;
28574 }
28575
28576
28577 SWIGINTERN PyObject *_wrap_App_CleanUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28578 PyObject *resultobj = 0;
28579
28580 if (!SWIG_Python_UnpackTuple(args,"App_CleanUp",0,0,0)) SWIG_fail;
28581 {
28582 PyThreadState* __tstate = wxPyBeginAllowThreads();
28583 wxApp_CleanUp();
28584 wxPyEndAllowThreads(__tstate);
28585 if (PyErr_Occurred()) SWIG_fail;
28586 }
28587 resultobj = SWIG_Py_Void();
28588 return resultobj;
28589 fail:
28590 return NULL;
28591 }
28592
28593
28594 SWIGINTERN PyObject *_wrap_GetApp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28595 PyObject *resultobj = 0;
28596 wxPyApp *result = 0 ;
28597
28598 if (!SWIG_Python_UnpackTuple(args,"GetApp",0,0,0)) SWIG_fail;
28599 {
28600 PyThreadState* __tstate = wxPyBeginAllowThreads();
28601 result = (wxPyApp *)wxPyGetApp();
28602 wxPyEndAllowThreads(__tstate);
28603 if (PyErr_Occurred()) SWIG_fail;
28604 }
28605 {
28606 resultobj = wxPyMake_wxObject(result, 0);
28607 }
28608 return resultobj;
28609 fail:
28610 return NULL;
28611 }
28612
28613
28614 SWIGINTERN PyObject *_wrap_SetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28615 PyObject *resultobj = 0;
28616 char *arg1 = (char *) 0 ;
28617 int res1 ;
28618 char *buf1 = 0 ;
28619 int alloc1 = 0 ;
28620 PyObject * obj0 = 0 ;
28621 char * kwnames[] = {
28622 (char *) "encoding", NULL
28623 };
28624
28625 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:SetDefaultPyEncoding",kwnames,&obj0)) SWIG_fail;
28626 res1 = SWIG_AsCharPtrAndSize(obj0, &buf1, NULL, &alloc1);
28627 if (!SWIG_IsOK(res1)) {
28628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SetDefaultPyEncoding" "', expected argument " "1"" of type '" "char const *""'");
28629 }
28630 arg1 = buf1;
28631 {
28632 PyThreadState* __tstate = wxPyBeginAllowThreads();
28633 wxSetDefaultPyEncoding((char const *)arg1);
28634 wxPyEndAllowThreads(__tstate);
28635 if (PyErr_Occurred()) SWIG_fail;
28636 }
28637 resultobj = SWIG_Py_Void();
28638 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28639 return resultobj;
28640 fail:
28641 if (alloc1 == SWIG_NEWOBJ) delete[] buf1;
28642 return NULL;
28643 }
28644
28645
28646 SWIGINTERN PyObject *_wrap_GetDefaultPyEncoding(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28647 PyObject *resultobj = 0;
28648 char *result = 0 ;
28649
28650 if (!SWIG_Python_UnpackTuple(args,"GetDefaultPyEncoding",0,0,0)) SWIG_fail;
28651 {
28652 PyThreadState* __tstate = wxPyBeginAllowThreads();
28653 result = (char *)wxGetDefaultPyEncoding();
28654 wxPyEndAllowThreads(__tstate);
28655 if (PyErr_Occurred()) SWIG_fail;
28656 }
28657 resultobj = SWIG_FromCharPtr(result);
28658 return resultobj;
28659 fail:
28660 return NULL;
28661 }
28662
28663
28664 SWIGINTERN PyObject *_wrap_new_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28665 PyObject *resultobj = 0;
28666 wxEventLoop *result = 0 ;
28667
28668 if (!SWIG_Python_UnpackTuple(args,"new_EventLoop",0,0,0)) SWIG_fail;
28669 {
28670 PyThreadState* __tstate = wxPyBeginAllowThreads();
28671 result = (wxEventLoop *)new wxEventLoop();
28672 wxPyEndAllowThreads(__tstate);
28673 if (PyErr_Occurred()) SWIG_fail;
28674 }
28675 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, SWIG_POINTER_NEW | 0 );
28676 return resultobj;
28677 fail:
28678 return NULL;
28679 }
28680
28681
28682 SWIGINTERN PyObject *_wrap_delete_EventLoop(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28683 PyObject *resultobj = 0;
28684 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28685 void *argp1 = 0 ;
28686 int res1 = 0 ;
28687 PyObject *swig_obj[1] ;
28688
28689 if (!args) SWIG_fail;
28690 swig_obj[0] = args;
28691 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, SWIG_POINTER_DISOWN | 0 );
28692 if (!SWIG_IsOK(res1)) {
28693 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoop" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28694 }
28695 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28696 {
28697 PyThreadState* __tstate = wxPyBeginAllowThreads();
28698 delete arg1;
28699
28700 wxPyEndAllowThreads(__tstate);
28701 if (PyErr_Occurred()) SWIG_fail;
28702 }
28703 resultobj = SWIG_Py_Void();
28704 return resultobj;
28705 fail:
28706 return NULL;
28707 }
28708
28709
28710 SWIGINTERN PyObject *_wrap_EventLoop_Run(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28711 PyObject *resultobj = 0;
28712 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28713 int result;
28714 void *argp1 = 0 ;
28715 int res1 = 0 ;
28716 PyObject *swig_obj[1] ;
28717
28718 if (!args) SWIG_fail;
28719 swig_obj[0] = args;
28720 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28721 if (!SWIG_IsOK(res1)) {
28722 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Run" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28723 }
28724 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28725 {
28726 PyThreadState* __tstate = wxPyBeginAllowThreads();
28727 result = (int)(arg1)->Run();
28728 wxPyEndAllowThreads(__tstate);
28729 if (PyErr_Occurred()) SWIG_fail;
28730 }
28731 resultobj = SWIG_From_int(static_cast< int >(result));
28732 return resultobj;
28733 fail:
28734 return NULL;
28735 }
28736
28737
28738 SWIGINTERN PyObject *_wrap_EventLoop_Exit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28739 PyObject *resultobj = 0;
28740 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28741 int arg2 = (int) 0 ;
28742 void *argp1 = 0 ;
28743 int res1 = 0 ;
28744 int val2 ;
28745 int ecode2 = 0 ;
28746 PyObject * obj0 = 0 ;
28747 PyObject * obj1 = 0 ;
28748 char * kwnames[] = {
28749 (char *) "self",(char *) "rc", NULL
28750 };
28751
28752 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:EventLoop_Exit",kwnames,&obj0,&obj1)) SWIG_fail;
28753 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28754 if (!SWIG_IsOK(res1)) {
28755 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Exit" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28756 }
28757 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28758 if (obj1) {
28759 ecode2 = SWIG_AsVal_int(obj1, &val2);
28760 if (!SWIG_IsOK(ecode2)) {
28761 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "EventLoop_Exit" "', expected argument " "2"" of type '" "int""'");
28762 }
28763 arg2 = static_cast< int >(val2);
28764 }
28765 {
28766 PyThreadState* __tstate = wxPyBeginAllowThreads();
28767 (arg1)->Exit(arg2);
28768 wxPyEndAllowThreads(__tstate);
28769 if (PyErr_Occurred()) SWIG_fail;
28770 }
28771 resultobj = SWIG_Py_Void();
28772 return resultobj;
28773 fail:
28774 return NULL;
28775 }
28776
28777
28778 SWIGINTERN PyObject *_wrap_EventLoop_Pending(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28779 PyObject *resultobj = 0;
28780 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28781 bool result;
28782 void *argp1 = 0 ;
28783 int res1 = 0 ;
28784 PyObject *swig_obj[1] ;
28785
28786 if (!args) SWIG_fail;
28787 swig_obj[0] = args;
28788 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28789 if (!SWIG_IsOK(res1)) {
28790 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Pending" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28791 }
28792 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28793 {
28794 PyThreadState* __tstate = wxPyBeginAllowThreads();
28795 result = (bool)((wxEventLoop const *)arg1)->Pending();
28796 wxPyEndAllowThreads(__tstate);
28797 if (PyErr_Occurred()) SWIG_fail;
28798 }
28799 {
28800 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28801 }
28802 return resultobj;
28803 fail:
28804 return NULL;
28805 }
28806
28807
28808 SWIGINTERN PyObject *_wrap_EventLoop_Dispatch(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28809 PyObject *resultobj = 0;
28810 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28811 bool result;
28812 void *argp1 = 0 ;
28813 int res1 = 0 ;
28814 PyObject *swig_obj[1] ;
28815
28816 if (!args) SWIG_fail;
28817 swig_obj[0] = args;
28818 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28819 if (!SWIG_IsOK(res1)) {
28820 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_Dispatch" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28821 }
28822 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28823 {
28824 PyThreadState* __tstate = wxPyBeginAllowThreads();
28825 result = (bool)(arg1)->Dispatch();
28826 wxPyEndAllowThreads(__tstate);
28827 if (PyErr_Occurred()) SWIG_fail;
28828 }
28829 {
28830 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28831 }
28832 return resultobj;
28833 fail:
28834 return NULL;
28835 }
28836
28837
28838 SWIGINTERN PyObject *_wrap_EventLoop_IsRunning(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28839 PyObject *resultobj = 0;
28840 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28841 bool result;
28842 void *argp1 = 0 ;
28843 int res1 = 0 ;
28844 PyObject *swig_obj[1] ;
28845
28846 if (!args) SWIG_fail;
28847 swig_obj[0] = args;
28848 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28849 if (!SWIG_IsOK(res1)) {
28850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_IsRunning" "', expected argument " "1"" of type '" "wxEventLoop const *""'");
28851 }
28852 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28853 {
28854 PyThreadState* __tstate = wxPyBeginAllowThreads();
28855 result = (bool)((wxEventLoop const *)arg1)->IsRunning();
28856 wxPyEndAllowThreads(__tstate);
28857 if (PyErr_Occurred()) SWIG_fail;
28858 }
28859 {
28860 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
28861 }
28862 return resultobj;
28863 fail:
28864 return NULL;
28865 }
28866
28867
28868 SWIGINTERN PyObject *_wrap_EventLoop_GetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28869 PyObject *resultobj = 0;
28870 wxEventLoop *result = 0 ;
28871
28872 if (!SWIG_Python_UnpackTuple(args,"EventLoop_GetActive",0,0,0)) SWIG_fail;
28873 {
28874 PyThreadState* __tstate = wxPyBeginAllowThreads();
28875 result = (wxEventLoop *)wxEventLoop::GetActive();
28876 wxPyEndAllowThreads(__tstate);
28877 if (PyErr_Occurred()) SWIG_fail;
28878 }
28879 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoop, 0 | 0 );
28880 return resultobj;
28881 fail:
28882 return NULL;
28883 }
28884
28885
28886 SWIGINTERN PyObject *_wrap_EventLoop_SetActive(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28887 PyObject *resultobj = 0;
28888 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28889 void *argp1 = 0 ;
28890 int res1 = 0 ;
28891 PyObject * obj0 = 0 ;
28892 char * kwnames[] = {
28893 (char *) "loop", NULL
28894 };
28895
28896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:EventLoop_SetActive",kwnames,&obj0)) SWIG_fail;
28897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28898 if (!SWIG_IsOK(res1)) {
28899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "EventLoop_SetActive" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28900 }
28901 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28902 {
28903 PyThreadState* __tstate = wxPyBeginAllowThreads();
28904 wxEventLoop::SetActive(arg1);
28905 wxPyEndAllowThreads(__tstate);
28906 if (PyErr_Occurred()) SWIG_fail;
28907 }
28908 resultobj = SWIG_Py_Void();
28909 return resultobj;
28910 fail:
28911 return NULL;
28912 }
28913
28914
28915 SWIGINTERN PyObject *EventLoop_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28916 PyObject *obj;
28917 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28918 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoop, SWIG_NewClientData(obj));
28919 return SWIG_Py_Void();
28920 }
28921
28922 SWIGINTERN PyObject *EventLoop_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28923 return SWIG_Python_InitShadowInstance(args);
28924 }
28925
28926 SWIGINTERN PyObject *_wrap_new_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28927 PyObject *resultobj = 0;
28928 wxEventLoop *arg1 = (wxEventLoop *) 0 ;
28929 wxEventLoopActivator *result = 0 ;
28930 void *argp1 = 0 ;
28931 int res1 = 0 ;
28932 PyObject * obj0 = 0 ;
28933 char * kwnames[] = {
28934 (char *) "evtLoop", NULL
28935 };
28936
28937 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_EventLoopActivator",kwnames,&obj0)) SWIG_fail;
28938 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxEventLoop, 0 | 0 );
28939 if (!SWIG_IsOK(res1)) {
28940 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoop *""'");
28941 }
28942 arg1 = reinterpret_cast< wxEventLoop * >(argp1);
28943 {
28944 PyThreadState* __tstate = wxPyBeginAllowThreads();
28945 result = (wxEventLoopActivator *)new wxEventLoopActivator(arg1);
28946 wxPyEndAllowThreads(__tstate);
28947 if (PyErr_Occurred()) SWIG_fail;
28948 }
28949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_NEW | 0 );
28950 return resultobj;
28951 fail:
28952 return NULL;
28953 }
28954
28955
28956 SWIGINTERN PyObject *_wrap_delete_EventLoopActivator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28957 PyObject *resultobj = 0;
28958 wxEventLoopActivator *arg1 = (wxEventLoopActivator *) 0 ;
28959 void *argp1 = 0 ;
28960 int res1 = 0 ;
28961 PyObject *swig_obj[1] ;
28962
28963 if (!args) SWIG_fail;
28964 swig_obj[0] = args;
28965 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxEventLoopActivator, SWIG_POINTER_DISOWN | 0 );
28966 if (!SWIG_IsOK(res1)) {
28967 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_EventLoopActivator" "', expected argument " "1"" of type '" "wxEventLoopActivator *""'");
28968 }
28969 arg1 = reinterpret_cast< wxEventLoopActivator * >(argp1);
28970 {
28971 PyThreadState* __tstate = wxPyBeginAllowThreads();
28972 delete arg1;
28973
28974 wxPyEndAllowThreads(__tstate);
28975 if (PyErr_Occurred()) SWIG_fail;
28976 }
28977 resultobj = SWIG_Py_Void();
28978 return resultobj;
28979 fail:
28980 return NULL;
28981 }
28982
28983
28984 SWIGINTERN PyObject *EventLoopActivator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28985 PyObject *obj;
28986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
28987 SWIG_TypeNewClientData(SWIGTYPE_p_wxEventLoopActivator, SWIG_NewClientData(obj));
28988 return SWIG_Py_Void();
28989 }
28990
28991 SWIGINTERN PyObject *EventLoopActivator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
28992 return SWIG_Python_InitShadowInstance(args);
28993 }
28994
28995 SWIGINTERN PyObject *_wrap_new_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
28996 PyObject *resultobj = 0;
28997 int arg1 = (int) 0 ;
28998 int arg2 = (int) 0 ;
28999 int arg3 = (int) 0 ;
29000 wxAcceleratorEntry *result = 0 ;
29001 int val1 ;
29002 int ecode1 = 0 ;
29003 int val2 ;
29004 int ecode2 = 0 ;
29005 int val3 ;
29006 int ecode3 = 0 ;
29007 PyObject * obj0 = 0 ;
29008 PyObject * obj1 = 0 ;
29009 PyObject * obj2 = 0 ;
29010 char * kwnames[] = {
29011 (char *) "flags",(char *) "keyCode",(char *) "cmdID", NULL
29012 };
29013
29014 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOO:new_AcceleratorEntry",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
29015 if (obj0) {
29016 ecode1 = SWIG_AsVal_int(obj0, &val1);
29017 if (!SWIG_IsOK(ecode1)) {
29018 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_AcceleratorEntry" "', expected argument " "1"" of type '" "int""'");
29019 }
29020 arg1 = static_cast< int >(val1);
29021 }
29022 if (obj1) {
29023 ecode2 = SWIG_AsVal_int(obj1, &val2);
29024 if (!SWIG_IsOK(ecode2)) {
29025 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_AcceleratorEntry" "', expected argument " "2"" of type '" "int""'");
29026 }
29027 arg2 = static_cast< int >(val2);
29028 }
29029 if (obj2) {
29030 ecode3 = SWIG_AsVal_int(obj2, &val3);
29031 if (!SWIG_IsOK(ecode3)) {
29032 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_AcceleratorEntry" "', expected argument " "3"" of type '" "int""'");
29033 }
29034 arg3 = static_cast< int >(val3);
29035 }
29036 {
29037 PyThreadState* __tstate = wxPyBeginAllowThreads();
29038 result = (wxAcceleratorEntry *)new wxAcceleratorEntry(arg1,arg2,arg3);
29039 wxPyEndAllowThreads(__tstate);
29040 if (PyErr_Occurred()) SWIG_fail;
29041 }
29042 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_NEW | 0 );
29043 return resultobj;
29044 fail:
29045 return NULL;
29046 }
29047
29048
29049 SWIGINTERN PyObject *_wrap_delete_AcceleratorEntry(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29050 PyObject *resultobj = 0;
29051 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29052 void *argp1 = 0 ;
29053 int res1 = 0 ;
29054 PyObject *swig_obj[1] ;
29055
29056 if (!args) SWIG_fail;
29057 swig_obj[0] = args;
29058 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, SWIG_POINTER_DISOWN | 0 );
29059 if (!SWIG_IsOK(res1)) {
29060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorEntry" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29061 }
29062 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29063 {
29064 PyThreadState* __tstate = wxPyBeginAllowThreads();
29065 delete arg1;
29066
29067 wxPyEndAllowThreads(__tstate);
29068 if (PyErr_Occurred()) SWIG_fail;
29069 }
29070 resultobj = SWIG_Py_Void();
29071 return resultobj;
29072 fail:
29073 return NULL;
29074 }
29075
29076
29077 SWIGINTERN PyObject *_wrap_AcceleratorEntry_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29078 PyObject *resultobj = 0;
29079 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29080 int arg2 ;
29081 int arg3 ;
29082 int arg4 ;
29083 void *argp1 = 0 ;
29084 int res1 = 0 ;
29085 int val2 ;
29086 int ecode2 = 0 ;
29087 int val3 ;
29088 int ecode3 = 0 ;
29089 int val4 ;
29090 int ecode4 = 0 ;
29091 PyObject * obj0 = 0 ;
29092 PyObject * obj1 = 0 ;
29093 PyObject * obj2 = 0 ;
29094 PyObject * obj3 = 0 ;
29095 char * kwnames[] = {
29096 (char *) "self",(char *) "flags",(char *) "keyCode",(char *) "cmd", NULL
29097 };
29098
29099 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:AcceleratorEntry_Set",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
29100 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29101 if (!SWIG_IsOK(res1)) {
29102 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_Set" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29103 }
29104 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29105 ecode2 = SWIG_AsVal_int(obj1, &val2);
29106 if (!SWIG_IsOK(ecode2)) {
29107 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "AcceleratorEntry_Set" "', expected argument " "2"" of type '" "int""'");
29108 }
29109 arg2 = static_cast< int >(val2);
29110 ecode3 = SWIG_AsVal_int(obj2, &val3);
29111 if (!SWIG_IsOK(ecode3)) {
29112 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "AcceleratorEntry_Set" "', expected argument " "3"" of type '" "int""'");
29113 }
29114 arg3 = static_cast< int >(val3);
29115 ecode4 = SWIG_AsVal_int(obj3, &val4);
29116 if (!SWIG_IsOK(ecode4)) {
29117 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "AcceleratorEntry_Set" "', expected argument " "4"" of type '" "int""'");
29118 }
29119 arg4 = static_cast< int >(val4);
29120 {
29121 PyThreadState* __tstate = wxPyBeginAllowThreads();
29122 (arg1)->Set(arg2,arg3,arg4);
29123 wxPyEndAllowThreads(__tstate);
29124 if (PyErr_Occurred()) SWIG_fail;
29125 }
29126 resultobj = SWIG_Py_Void();
29127 return resultobj;
29128 fail:
29129 return NULL;
29130 }
29131
29132
29133 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetFlags(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29134 PyObject *resultobj = 0;
29135 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29136 int result;
29137 void *argp1 = 0 ;
29138 int res1 = 0 ;
29139 PyObject *swig_obj[1] ;
29140
29141 if (!args) SWIG_fail;
29142 swig_obj[0] = args;
29143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29144 if (!SWIG_IsOK(res1)) {
29145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetFlags" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29146 }
29147 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29148 {
29149 PyThreadState* __tstate = wxPyBeginAllowThreads();
29150 result = (int)(arg1)->GetFlags();
29151 wxPyEndAllowThreads(__tstate);
29152 if (PyErr_Occurred()) SWIG_fail;
29153 }
29154 resultobj = SWIG_From_int(static_cast< int >(result));
29155 return resultobj;
29156 fail:
29157 return NULL;
29158 }
29159
29160
29161 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetKeyCode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29162 PyObject *resultobj = 0;
29163 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29164 int result;
29165 void *argp1 = 0 ;
29166 int res1 = 0 ;
29167 PyObject *swig_obj[1] ;
29168
29169 if (!args) SWIG_fail;
29170 swig_obj[0] = args;
29171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29172 if (!SWIG_IsOK(res1)) {
29173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetKeyCode" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29174 }
29175 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29176 {
29177 PyThreadState* __tstate = wxPyBeginAllowThreads();
29178 result = (int)(arg1)->GetKeyCode();
29179 wxPyEndAllowThreads(__tstate);
29180 if (PyErr_Occurred()) SWIG_fail;
29181 }
29182 resultobj = SWIG_From_int(static_cast< int >(result));
29183 return resultobj;
29184 fail:
29185 return NULL;
29186 }
29187
29188
29189 SWIGINTERN PyObject *_wrap_AcceleratorEntry_GetCommand(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29190 PyObject *resultobj = 0;
29191 wxAcceleratorEntry *arg1 = (wxAcceleratorEntry *) 0 ;
29192 int result;
29193 void *argp1 = 0 ;
29194 int res1 = 0 ;
29195 PyObject *swig_obj[1] ;
29196
29197 if (!args) SWIG_fail;
29198 swig_obj[0] = args;
29199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29200 if (!SWIG_IsOK(res1)) {
29201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorEntry_GetCommand" "', expected argument " "1"" of type '" "wxAcceleratorEntry *""'");
29202 }
29203 arg1 = reinterpret_cast< wxAcceleratorEntry * >(argp1);
29204 {
29205 PyThreadState* __tstate = wxPyBeginAllowThreads();
29206 result = (int)(arg1)->GetCommand();
29207 wxPyEndAllowThreads(__tstate);
29208 if (PyErr_Occurred()) SWIG_fail;
29209 }
29210 resultobj = SWIG_From_int(static_cast< int >(result));
29211 return resultobj;
29212 fail:
29213 return NULL;
29214 }
29215
29216
29217 SWIGINTERN PyObject *AcceleratorEntry_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29218 PyObject *obj;
29219 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29220 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorEntry, SWIG_NewClientData(obj));
29221 return SWIG_Py_Void();
29222 }
29223
29224 SWIGINTERN PyObject *AcceleratorEntry_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29225 return SWIG_Python_InitShadowInstance(args);
29226 }
29227
29228 SWIGINTERN PyObject *_wrap_new_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29229 PyObject *resultobj = 0;
29230 int arg1 ;
29231 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
29232 wxAcceleratorTable *result = 0 ;
29233 PyObject * obj0 = 0 ;
29234 char * kwnames[] = {
29235 (char *) "n", NULL
29236 };
29237
29238 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:new_AcceleratorTable",kwnames,&obj0)) SWIG_fail;
29239 {
29240 arg2 = wxAcceleratorEntry_LIST_helper(obj0);
29241 if (arg2) arg1 = PyList_Size(obj0);
29242 else arg1 = 0;
29243 }
29244 {
29245 PyThreadState* __tstate = wxPyBeginAllowThreads();
29246 result = (wxAcceleratorTable *)new wxAcceleratorTable(arg1,(wxAcceleratorEntry const *)arg2);
29247 wxPyEndAllowThreads(__tstate);
29248 if (PyErr_Occurred()) SWIG_fail;
29249 }
29250 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_NEW | 0 );
29251 return resultobj;
29252 fail:
29253 return NULL;
29254 }
29255
29256
29257 SWIGINTERN PyObject *_wrap_delete_AcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29258 PyObject *resultobj = 0;
29259 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29260 void *argp1 = 0 ;
29261 int res1 = 0 ;
29262 PyObject *swig_obj[1] ;
29263
29264 if (!args) SWIG_fail;
29265 swig_obj[0] = args;
29266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, SWIG_POINTER_DISOWN | 0 );
29267 if (!SWIG_IsOK(res1)) {
29268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_AcceleratorTable" "', expected argument " "1"" of type '" "wxAcceleratorTable *""'");
29269 }
29270 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29271 {
29272 PyThreadState* __tstate = wxPyBeginAllowThreads();
29273 delete arg1;
29274
29275 wxPyEndAllowThreads(__tstate);
29276 if (PyErr_Occurred()) SWIG_fail;
29277 }
29278 resultobj = SWIG_Py_Void();
29279 return resultobj;
29280 fail:
29281 return NULL;
29282 }
29283
29284
29285 SWIGINTERN PyObject *_wrap_AcceleratorTable_Ok(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29286 PyObject *resultobj = 0;
29287 wxAcceleratorTable *arg1 = (wxAcceleratorTable *) 0 ;
29288 bool result;
29289 void *argp1 = 0 ;
29290 int res1 = 0 ;
29291 PyObject *swig_obj[1] ;
29292
29293 if (!args) SWIG_fail;
29294 swig_obj[0] = args;
29295 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
29296 if (!SWIG_IsOK(res1)) {
29297 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "AcceleratorTable_Ok" "', expected argument " "1"" of type '" "wxAcceleratorTable const *""'");
29298 }
29299 arg1 = reinterpret_cast< wxAcceleratorTable * >(argp1);
29300 {
29301 PyThreadState* __tstate = wxPyBeginAllowThreads();
29302 result = (bool)((wxAcceleratorTable const *)arg1)->Ok();
29303 wxPyEndAllowThreads(__tstate);
29304 if (PyErr_Occurred()) SWIG_fail;
29305 }
29306 {
29307 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29308 }
29309 return resultobj;
29310 fail:
29311 return NULL;
29312 }
29313
29314
29315 SWIGINTERN PyObject *AcceleratorTable_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29316 PyObject *obj;
29317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29318 SWIG_TypeNewClientData(SWIGTYPE_p_wxAcceleratorTable, SWIG_NewClientData(obj));
29319 return SWIG_Py_Void();
29320 }
29321
29322 SWIGINTERN PyObject *AcceleratorTable_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29323 return SWIG_Python_InitShadowInstance(args);
29324 }
29325
29326 SWIGINTERN int NullAcceleratorTable_set(PyObject *) {
29327 SWIG_Error(SWIG_AttributeError,"Variable NullAcceleratorTable is read-only.");
29328 return 1;
29329 }
29330
29331
29332 SWIGINTERN PyObject *NullAcceleratorTable_get(void) {
29333 PyObject *pyobj = 0;
29334
29335 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxNullAcceleratorTable), SWIGTYPE_p_wxAcceleratorTable, 0 );
29336 return pyobj;
29337 }
29338
29339
29340 SWIGINTERN PyObject *_wrap_GetAccelFromString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29341 PyObject *resultobj = 0;
29342 wxString *arg1 = 0 ;
29343 wxAcceleratorEntry *result = 0 ;
29344 bool temp1 = false ;
29345 PyObject * obj0 = 0 ;
29346 char * kwnames[] = {
29347 (char *) "label", NULL
29348 };
29349
29350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:GetAccelFromString",kwnames,&obj0)) SWIG_fail;
29351 {
29352 arg1 = wxString_in_helper(obj0);
29353 if (arg1 == NULL) SWIG_fail;
29354 temp1 = true;
29355 }
29356 {
29357 PyThreadState* __tstate = wxPyBeginAllowThreads();
29358 result = (wxAcceleratorEntry *)wxGetAccelFromString((wxString const &)*arg1);
29359 wxPyEndAllowThreads(__tstate);
29360 if (PyErr_Occurred()) SWIG_fail;
29361 }
29362 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
29363 {
29364 if (temp1)
29365 delete arg1;
29366 }
29367 return resultobj;
29368 fail:
29369 {
29370 if (temp1)
29371 delete arg1;
29372 }
29373 return NULL;
29374 }
29375
29376
29377 SWIGINTERN int PanelNameStr_set(PyObject *) {
29378 SWIG_Error(SWIG_AttributeError,"Variable PanelNameStr is read-only.");
29379 return 1;
29380 }
29381
29382
29383 SWIGINTERN PyObject *PanelNameStr_get(void) {
29384 PyObject *pyobj = 0;
29385
29386 {
29387 #if wxUSE_UNICODE
29388 pyobj = PyUnicode_FromWideChar((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29389 #else
29390 pyobj = PyString_FromStringAndSize((&wxPyPanelNameStr)->c_str(), (&wxPyPanelNameStr)->Len());
29391 #endif
29392 }
29393 return pyobj;
29394 }
29395
29396
29397 SWIGINTERN PyObject *_wrap_new_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29398 PyObject *resultobj = 0;
29399 wxVisualAttributes *result = 0 ;
29400
29401 if (!SWIG_Python_UnpackTuple(args,"new_VisualAttributes",0,0,0)) SWIG_fail;
29402 {
29403 PyThreadState* __tstate = wxPyBeginAllowThreads();
29404 result = (wxVisualAttributes *)new_wxVisualAttributes();
29405 wxPyEndAllowThreads(__tstate);
29406 if (PyErr_Occurred()) SWIG_fail;
29407 }
29408 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_NEW | 0 );
29409 return resultobj;
29410 fail:
29411 return NULL;
29412 }
29413
29414
29415 SWIGINTERN PyObject *_wrap_delete_VisualAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29416 PyObject *resultobj = 0;
29417 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29418 void *argp1 = 0 ;
29419 int res1 = 0 ;
29420 PyObject *swig_obj[1] ;
29421
29422 if (!args) SWIG_fail;
29423 swig_obj[0] = args;
29424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_DISOWN | 0 );
29425 if (!SWIG_IsOK(res1)) {
29426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_VisualAttributes" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29427 }
29428 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29429 {
29430 PyThreadState* __tstate = wxPyBeginAllowThreads();
29431 delete_wxVisualAttributes(arg1);
29432
29433 wxPyEndAllowThreads(__tstate);
29434 if (PyErr_Occurred()) SWIG_fail;
29435 }
29436 resultobj = SWIG_Py_Void();
29437 return resultobj;
29438 fail:
29439 return NULL;
29440 }
29441
29442
29443 SWIGINTERN PyObject *_wrap_VisualAttributes_font_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29444 PyObject *resultobj = 0;
29445 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29446 wxFont *arg2 = (wxFont *) 0 ;
29447 void *argp1 = 0 ;
29448 int res1 = 0 ;
29449 void *argp2 = 0 ;
29450 int res2 = 0 ;
29451 PyObject *swig_obj[2] ;
29452
29453 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_font_set",2,2,swig_obj)) SWIG_fail;
29454 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29455 if (!SWIG_IsOK(res1)) {
29456 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29457 }
29458 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29459 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxFont, 0 | 0 );
29460 if (!SWIG_IsOK(res2)) {
29461 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_font_set" "', expected argument " "2"" of type '" "wxFont *""'");
29462 }
29463 arg2 = reinterpret_cast< wxFont * >(argp2);
29464 if (arg1) (arg1)->font = *arg2;
29465
29466 resultobj = SWIG_Py_Void();
29467 return resultobj;
29468 fail:
29469 return NULL;
29470 }
29471
29472
29473 SWIGINTERN PyObject *_wrap_VisualAttributes_font_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29474 PyObject *resultobj = 0;
29475 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29476 wxFont *result = 0 ;
29477 void *argp1 = 0 ;
29478 int res1 = 0 ;
29479 PyObject *swig_obj[1] ;
29480
29481 if (!args) SWIG_fail;
29482 swig_obj[0] = args;
29483 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29484 if (!SWIG_IsOK(res1)) {
29485 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_font_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29486 }
29487 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29488 result = (wxFont *)& ((arg1)->font);
29489 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFont, 0 | 0 );
29490 return resultobj;
29491 fail:
29492 return NULL;
29493 }
29494
29495
29496 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29497 PyObject *resultobj = 0;
29498 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29499 wxColour *arg2 = (wxColour *) 0 ;
29500 void *argp1 = 0 ;
29501 int res1 = 0 ;
29502 void *argp2 = 0 ;
29503 int res2 = 0 ;
29504 PyObject *swig_obj[2] ;
29505
29506 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colFg_set",2,2,swig_obj)) SWIG_fail;
29507 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29508 if (!SWIG_IsOK(res1)) {
29509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29510 }
29511 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29512 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29513 if (!SWIG_IsOK(res2)) {
29514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colFg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29515 }
29516 arg2 = reinterpret_cast< wxColour * >(argp2);
29517 if (arg1) (arg1)->colFg = *arg2;
29518
29519 resultobj = SWIG_Py_Void();
29520 return resultobj;
29521 fail:
29522 return NULL;
29523 }
29524
29525
29526 SWIGINTERN PyObject *_wrap_VisualAttributes_colFg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29527 PyObject *resultobj = 0;
29528 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29529 wxColour *result = 0 ;
29530 void *argp1 = 0 ;
29531 int res1 = 0 ;
29532 PyObject *swig_obj[1] ;
29533
29534 if (!args) SWIG_fail;
29535 swig_obj[0] = args;
29536 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29537 if (!SWIG_IsOK(res1)) {
29538 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colFg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29539 }
29540 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29541 result = (wxColour *)& ((arg1)->colFg);
29542 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29543 return resultobj;
29544 fail:
29545 return NULL;
29546 }
29547
29548
29549 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_set(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29550 PyObject *resultobj = 0;
29551 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29552 wxColour *arg2 = (wxColour *) 0 ;
29553 void *argp1 = 0 ;
29554 int res1 = 0 ;
29555 void *argp2 = 0 ;
29556 int res2 = 0 ;
29557 PyObject *swig_obj[2] ;
29558
29559 if (!SWIG_Python_UnpackTuple(args,"VisualAttributes_colBg_set",2,2,swig_obj)) SWIG_fail;
29560 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29561 if (!SWIG_IsOK(res1)) {
29562 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_set" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29563 }
29564 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29565 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxColour, 0 | 0 );
29566 if (!SWIG_IsOK(res2)) {
29567 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "VisualAttributes_colBg_set" "', expected argument " "2"" of type '" "wxColour *""'");
29568 }
29569 arg2 = reinterpret_cast< wxColour * >(argp2);
29570 if (arg1) (arg1)->colBg = *arg2;
29571
29572 resultobj = SWIG_Py_Void();
29573 return resultobj;
29574 fail:
29575 return NULL;
29576 }
29577
29578
29579 SWIGINTERN PyObject *_wrap_VisualAttributes_colBg_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29580 PyObject *resultobj = 0;
29581 wxVisualAttributes *arg1 = (wxVisualAttributes *) 0 ;
29582 wxColour *result = 0 ;
29583 void *argp1 = 0 ;
29584 int res1 = 0 ;
29585 PyObject *swig_obj[1] ;
29586
29587 if (!args) SWIG_fail;
29588 swig_obj[0] = args;
29589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxVisualAttributes, 0 | 0 );
29590 if (!SWIG_IsOK(res1)) {
29591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "VisualAttributes_colBg_get" "', expected argument " "1"" of type '" "wxVisualAttributes *""'");
29592 }
29593 arg1 = reinterpret_cast< wxVisualAttributes * >(argp1);
29594 result = (wxColour *)& ((arg1)->colBg);
29595 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxColour, 0 | 0 );
29596 return resultobj;
29597 fail:
29598 return NULL;
29599 }
29600
29601
29602 SWIGINTERN PyObject *VisualAttributes_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29603 PyObject *obj;
29604 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
29605 SWIG_TypeNewClientData(SWIGTYPE_p_wxVisualAttributes, SWIG_NewClientData(obj));
29606 return SWIG_Py_Void();
29607 }
29608
29609 SWIGINTERN PyObject *VisualAttributes_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29610 return SWIG_Python_InitShadowInstance(args);
29611 }
29612
29613 SWIGINTERN PyObject *_wrap_new_Window(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29614 PyObject *resultobj = 0;
29615 wxWindow *arg1 = (wxWindow *) 0 ;
29616 int arg2 = (int) (int)-1 ;
29617 wxPoint const &arg3_defvalue = wxDefaultPosition ;
29618 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
29619 wxSize const &arg4_defvalue = wxDefaultSize ;
29620 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
29621 long arg5 = (long) 0 ;
29622 wxString const &arg6_defvalue = wxPyPanelNameStr ;
29623 wxString *arg6 = (wxString *) &arg6_defvalue ;
29624 wxWindow *result = 0 ;
29625 void *argp1 = 0 ;
29626 int res1 = 0 ;
29627 int val2 ;
29628 int ecode2 = 0 ;
29629 wxPoint temp3 ;
29630 wxSize temp4 ;
29631 long val5 ;
29632 int ecode5 = 0 ;
29633 bool temp6 = false ;
29634 PyObject * obj0 = 0 ;
29635 PyObject * obj1 = 0 ;
29636 PyObject * obj2 = 0 ;
29637 PyObject * obj3 = 0 ;
29638 PyObject * obj4 = 0 ;
29639 PyObject * obj5 = 0 ;
29640 char * kwnames[] = {
29641 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29642 };
29643
29644 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOO:new_Window",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
29645 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29646 if (!SWIG_IsOK(res1)) {
29647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Window" "', expected argument " "1"" of type '" "wxWindow *""'");
29648 }
29649 arg1 = reinterpret_cast< wxWindow * >(argp1);
29650 if (obj1) {
29651 ecode2 = SWIG_AsVal_int(obj1, &val2);
29652 if (!SWIG_IsOK(ecode2)) {
29653 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Window" "', expected argument " "2"" of type '" "int""'");
29654 }
29655 arg2 = static_cast< int >(val2);
29656 }
29657 if (obj2) {
29658 {
29659 arg3 = &temp3;
29660 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
29661 }
29662 }
29663 if (obj3) {
29664 {
29665 arg4 = &temp4;
29666 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
29667 }
29668 }
29669 if (obj4) {
29670 ecode5 = SWIG_AsVal_long(obj4, &val5);
29671 if (!SWIG_IsOK(ecode5)) {
29672 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Window" "', expected argument " "5"" of type '" "long""'");
29673 }
29674 arg5 = static_cast< long >(val5);
29675 }
29676 if (obj5) {
29677 {
29678 arg6 = wxString_in_helper(obj5);
29679 if (arg6 == NULL) SWIG_fail;
29680 temp6 = true;
29681 }
29682 }
29683 {
29684 if (!wxPyCheckForApp()) SWIG_fail;
29685 PyThreadState* __tstate = wxPyBeginAllowThreads();
29686 result = (wxWindow *)new wxWindow(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxString const &)*arg6);
29687 wxPyEndAllowThreads(__tstate);
29688 if (PyErr_Occurred()) SWIG_fail;
29689 }
29690 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_NEW | 0 );
29691 {
29692 if (temp6)
29693 delete arg6;
29694 }
29695 return resultobj;
29696 fail:
29697 {
29698 if (temp6)
29699 delete arg6;
29700 }
29701 return NULL;
29702 }
29703
29704
29705 SWIGINTERN PyObject *_wrap_new_PreWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29706 PyObject *resultobj = 0;
29707 wxWindow *result = 0 ;
29708
29709 if (!SWIG_Python_UnpackTuple(args,"new_PreWindow",0,0,0)) SWIG_fail;
29710 {
29711 if (!wxPyCheckForApp()) SWIG_fail;
29712 PyThreadState* __tstate = wxPyBeginAllowThreads();
29713 result = (wxWindow *)new wxWindow();
29714 wxPyEndAllowThreads(__tstate);
29715 if (PyErr_Occurred()) SWIG_fail;
29716 }
29717 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxWindow, SWIG_POINTER_OWN | 0 );
29718 return resultobj;
29719 fail:
29720 return NULL;
29721 }
29722
29723
29724 SWIGINTERN PyObject *_wrap_Window_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29725 PyObject *resultobj = 0;
29726 wxWindow *arg1 = (wxWindow *) 0 ;
29727 wxWindow *arg2 = (wxWindow *) 0 ;
29728 int arg3 = (int) (int)-1 ;
29729 wxPoint const &arg4_defvalue = wxDefaultPosition ;
29730 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
29731 wxSize const &arg5_defvalue = wxDefaultSize ;
29732 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
29733 long arg6 = (long) 0 ;
29734 wxString const &arg7_defvalue = wxPyPanelNameStr ;
29735 wxString *arg7 = (wxString *) &arg7_defvalue ;
29736 bool result;
29737 void *argp1 = 0 ;
29738 int res1 = 0 ;
29739 void *argp2 = 0 ;
29740 int res2 = 0 ;
29741 int val3 ;
29742 int ecode3 = 0 ;
29743 wxPoint temp4 ;
29744 wxSize temp5 ;
29745 long val6 ;
29746 int ecode6 = 0 ;
29747 bool temp7 = false ;
29748 PyObject * obj0 = 0 ;
29749 PyObject * obj1 = 0 ;
29750 PyObject * obj2 = 0 ;
29751 PyObject * obj3 = 0 ;
29752 PyObject * obj4 = 0 ;
29753 PyObject * obj5 = 0 ;
29754 PyObject * obj6 = 0 ;
29755 char * kwnames[] = {
29756 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "name", NULL
29757 };
29758
29759 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOO:Window_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
29760 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29761 if (!SWIG_IsOK(res1)) {
29762 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Create" "', expected argument " "1"" of type '" "wxWindow *""'");
29763 }
29764 arg1 = reinterpret_cast< wxWindow * >(argp1);
29765 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
29766 if (!SWIG_IsOK(res2)) {
29767 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
29768 }
29769 arg2 = reinterpret_cast< wxWindow * >(argp2);
29770 if (obj2) {
29771 ecode3 = SWIG_AsVal_int(obj2, &val3);
29772 if (!SWIG_IsOK(ecode3)) {
29773 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Create" "', expected argument " "3"" of type '" "int""'");
29774 }
29775 arg3 = static_cast< int >(val3);
29776 }
29777 if (obj3) {
29778 {
29779 arg4 = &temp4;
29780 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
29781 }
29782 }
29783 if (obj4) {
29784 {
29785 arg5 = &temp5;
29786 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
29787 }
29788 }
29789 if (obj5) {
29790 ecode6 = SWIG_AsVal_long(obj5, &val6);
29791 if (!SWIG_IsOK(ecode6)) {
29792 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_Create" "', expected argument " "6"" of type '" "long""'");
29793 }
29794 arg6 = static_cast< long >(val6);
29795 }
29796 if (obj6) {
29797 {
29798 arg7 = wxString_in_helper(obj6);
29799 if (arg7 == NULL) SWIG_fail;
29800 temp7 = true;
29801 }
29802 }
29803 {
29804 PyThreadState* __tstate = wxPyBeginAllowThreads();
29805 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxString const &)*arg7);
29806 wxPyEndAllowThreads(__tstate);
29807 if (PyErr_Occurred()) SWIG_fail;
29808 }
29809 {
29810 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29811 }
29812 {
29813 if (temp7)
29814 delete arg7;
29815 }
29816 return resultobj;
29817 fail:
29818 {
29819 if (temp7)
29820 delete arg7;
29821 }
29822 return NULL;
29823 }
29824
29825
29826 SWIGINTERN PyObject *_wrap_Window_Close(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29827 PyObject *resultobj = 0;
29828 wxWindow *arg1 = (wxWindow *) 0 ;
29829 bool arg2 = (bool) false ;
29830 bool result;
29831 void *argp1 = 0 ;
29832 int res1 = 0 ;
29833 bool val2 ;
29834 int ecode2 = 0 ;
29835 PyObject * obj0 = 0 ;
29836 PyObject * obj1 = 0 ;
29837 char * kwnames[] = {
29838 (char *) "self",(char *) "force", NULL
29839 };
29840
29841 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Close",kwnames,&obj0,&obj1)) SWIG_fail;
29842 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29843 if (!SWIG_IsOK(res1)) {
29844 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Close" "', expected argument " "1"" of type '" "wxWindow *""'");
29845 }
29846 arg1 = reinterpret_cast< wxWindow * >(argp1);
29847 if (obj1) {
29848 ecode2 = SWIG_AsVal_bool(obj1, &val2);
29849 if (!SWIG_IsOK(ecode2)) {
29850 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Close" "', expected argument " "2"" of type '" "bool""'");
29851 }
29852 arg2 = static_cast< bool >(val2);
29853 }
29854 {
29855 PyThreadState* __tstate = wxPyBeginAllowThreads();
29856 result = (bool)(arg1)->Close(arg2);
29857 wxPyEndAllowThreads(__tstate);
29858 if (PyErr_Occurred()) SWIG_fail;
29859 }
29860 {
29861 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29862 }
29863 return resultobj;
29864 fail:
29865 return NULL;
29866 }
29867
29868
29869 SWIGINTERN PyObject *_wrap_Window_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29870 PyObject *resultobj = 0;
29871 wxWindow *arg1 = (wxWindow *) 0 ;
29872 bool result;
29873 void *argp1 = 0 ;
29874 int res1 = 0 ;
29875 PyObject *swig_obj[1] ;
29876
29877 if (!args) SWIG_fail;
29878 swig_obj[0] = args;
29879 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29880 if (!SWIG_IsOK(res1)) {
29881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Destroy" "', expected argument " "1"" of type '" "wxWindow *""'");
29882 }
29883 arg1 = reinterpret_cast< wxWindow * >(argp1);
29884 {
29885 PyThreadState* __tstate = wxPyBeginAllowThreads();
29886 result = (bool)(arg1)->Destroy();
29887 wxPyEndAllowThreads(__tstate);
29888 if (PyErr_Occurred()) SWIG_fail;
29889 }
29890 {
29891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29892 }
29893 return resultobj;
29894 fail:
29895 return NULL;
29896 }
29897
29898
29899 SWIGINTERN PyObject *_wrap_Window_DestroyChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29900 PyObject *resultobj = 0;
29901 wxWindow *arg1 = (wxWindow *) 0 ;
29902 bool result;
29903 void *argp1 = 0 ;
29904 int res1 = 0 ;
29905 PyObject *swig_obj[1] ;
29906
29907 if (!args) SWIG_fail;
29908 swig_obj[0] = args;
29909 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29910 if (!SWIG_IsOK(res1)) {
29911 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DestroyChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
29912 }
29913 arg1 = reinterpret_cast< wxWindow * >(argp1);
29914 {
29915 PyThreadState* __tstate = wxPyBeginAllowThreads();
29916 result = (bool)(arg1)->DestroyChildren();
29917 wxPyEndAllowThreads(__tstate);
29918 if (PyErr_Occurred()) SWIG_fail;
29919 }
29920 {
29921 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29922 }
29923 return resultobj;
29924 fail:
29925 return NULL;
29926 }
29927
29928
29929 SWIGINTERN PyObject *_wrap_Window_IsBeingDeleted(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
29930 PyObject *resultobj = 0;
29931 wxWindow *arg1 = (wxWindow *) 0 ;
29932 bool result;
29933 void *argp1 = 0 ;
29934 int res1 = 0 ;
29935 PyObject *swig_obj[1] ;
29936
29937 if (!args) SWIG_fail;
29938 swig_obj[0] = args;
29939 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29940 if (!SWIG_IsOK(res1)) {
29941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsBeingDeleted" "', expected argument " "1"" of type '" "wxWindow const *""'");
29942 }
29943 arg1 = reinterpret_cast< wxWindow * >(argp1);
29944 {
29945 PyThreadState* __tstate = wxPyBeginAllowThreads();
29946 result = (bool)((wxWindow const *)arg1)->IsBeingDeleted();
29947 wxPyEndAllowThreads(__tstate);
29948 if (PyErr_Occurred()) SWIG_fail;
29949 }
29950 {
29951 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
29952 }
29953 return resultobj;
29954 fail:
29955 return NULL;
29956 }
29957
29958
29959 SWIGINTERN PyObject *_wrap_Window_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
29960 PyObject *resultobj = 0;
29961 wxWindow *arg1 = (wxWindow *) 0 ;
29962 wxString *arg2 = 0 ;
29963 void *argp1 = 0 ;
29964 int res1 = 0 ;
29965 bool temp2 = false ;
29966 PyObject * obj0 = 0 ;
29967 PyObject * obj1 = 0 ;
29968 char * kwnames[] = {
29969 (char *) "self",(char *) "label", NULL
29970 };
29971
29972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
29973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
29974 if (!SWIG_IsOK(res1)) {
29975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetLabel" "', expected argument " "1"" of type '" "wxWindow *""'");
29976 }
29977 arg1 = reinterpret_cast< wxWindow * >(argp1);
29978 {
29979 arg2 = wxString_in_helper(obj1);
29980 if (arg2 == NULL) SWIG_fail;
29981 temp2 = true;
29982 }
29983 {
29984 PyThreadState* __tstate = wxPyBeginAllowThreads();
29985 (arg1)->SetLabel((wxString const &)*arg2);
29986 wxPyEndAllowThreads(__tstate);
29987 if (PyErr_Occurred()) SWIG_fail;
29988 }
29989 resultobj = SWIG_Py_Void();
29990 {
29991 if (temp2)
29992 delete arg2;
29993 }
29994 return resultobj;
29995 fail:
29996 {
29997 if (temp2)
29998 delete arg2;
29999 }
30000 return NULL;
30001 }
30002
30003
30004 SWIGINTERN PyObject *_wrap_Window_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30005 PyObject *resultobj = 0;
30006 wxWindow *arg1 = (wxWindow *) 0 ;
30007 wxString result;
30008 void *argp1 = 0 ;
30009 int res1 = 0 ;
30010 PyObject *swig_obj[1] ;
30011
30012 if (!args) SWIG_fail;
30013 swig_obj[0] = args;
30014 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30015 if (!SWIG_IsOK(res1)) {
30016 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetLabel" "', expected argument " "1"" of type '" "wxWindow const *""'");
30017 }
30018 arg1 = reinterpret_cast< wxWindow * >(argp1);
30019 {
30020 PyThreadState* __tstate = wxPyBeginAllowThreads();
30021 result = ((wxWindow const *)arg1)->GetLabel();
30022 wxPyEndAllowThreads(__tstate);
30023 if (PyErr_Occurred()) SWIG_fail;
30024 }
30025 {
30026 #if wxUSE_UNICODE
30027 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30028 #else
30029 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30030 #endif
30031 }
30032 return resultobj;
30033 fail:
30034 return NULL;
30035 }
30036
30037
30038 SWIGINTERN PyObject *_wrap_Window_SetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30039 PyObject *resultobj = 0;
30040 wxWindow *arg1 = (wxWindow *) 0 ;
30041 wxString *arg2 = 0 ;
30042 void *argp1 = 0 ;
30043 int res1 = 0 ;
30044 bool temp2 = false ;
30045 PyObject * obj0 = 0 ;
30046 PyObject * obj1 = 0 ;
30047 char * kwnames[] = {
30048 (char *) "self",(char *) "name", NULL
30049 };
30050
30051 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetName",kwnames,&obj0,&obj1)) SWIG_fail;
30052 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30053 if (!SWIG_IsOK(res1)) {
30054 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetName" "', expected argument " "1"" of type '" "wxWindow *""'");
30055 }
30056 arg1 = reinterpret_cast< wxWindow * >(argp1);
30057 {
30058 arg2 = wxString_in_helper(obj1);
30059 if (arg2 == NULL) SWIG_fail;
30060 temp2 = true;
30061 }
30062 {
30063 PyThreadState* __tstate = wxPyBeginAllowThreads();
30064 (arg1)->SetName((wxString const &)*arg2);
30065 wxPyEndAllowThreads(__tstate);
30066 if (PyErr_Occurred()) SWIG_fail;
30067 }
30068 resultobj = SWIG_Py_Void();
30069 {
30070 if (temp2)
30071 delete arg2;
30072 }
30073 return resultobj;
30074 fail:
30075 {
30076 if (temp2)
30077 delete arg2;
30078 }
30079 return NULL;
30080 }
30081
30082
30083 SWIGINTERN PyObject *_wrap_Window_GetName(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30084 PyObject *resultobj = 0;
30085 wxWindow *arg1 = (wxWindow *) 0 ;
30086 wxString result;
30087 void *argp1 = 0 ;
30088 int res1 = 0 ;
30089 PyObject *swig_obj[1] ;
30090
30091 if (!args) SWIG_fail;
30092 swig_obj[0] = args;
30093 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30094 if (!SWIG_IsOK(res1)) {
30095 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetName" "', expected argument " "1"" of type '" "wxWindow const *""'");
30096 }
30097 arg1 = reinterpret_cast< wxWindow * >(argp1);
30098 {
30099 PyThreadState* __tstate = wxPyBeginAllowThreads();
30100 result = ((wxWindow const *)arg1)->GetName();
30101 wxPyEndAllowThreads(__tstate);
30102 if (PyErr_Occurred()) SWIG_fail;
30103 }
30104 {
30105 #if wxUSE_UNICODE
30106 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
30107 #else
30108 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
30109 #endif
30110 }
30111 return resultobj;
30112 fail:
30113 return NULL;
30114 }
30115
30116
30117 SWIGINTERN PyObject *_wrap_Window_SetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30118 PyObject *resultobj = 0;
30119 wxWindow *arg1 = (wxWindow *) 0 ;
30120 wxWindowVariant arg2 ;
30121 void *argp1 = 0 ;
30122 int res1 = 0 ;
30123 int val2 ;
30124 int ecode2 = 0 ;
30125 PyObject * obj0 = 0 ;
30126 PyObject * obj1 = 0 ;
30127 char * kwnames[] = {
30128 (char *) "self",(char *) "variant", NULL
30129 };
30130
30131 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowVariant",kwnames,&obj0,&obj1)) SWIG_fail;
30132 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30133 if (!SWIG_IsOK(res1)) {
30134 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowVariant" "', expected argument " "1"" of type '" "wxWindow *""'");
30135 }
30136 arg1 = reinterpret_cast< wxWindow * >(argp1);
30137 ecode2 = SWIG_AsVal_int(obj1, &val2);
30138 if (!SWIG_IsOK(ecode2)) {
30139 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowVariant" "', expected argument " "2"" of type '" "wxWindowVariant""'");
30140 }
30141 arg2 = static_cast< wxWindowVariant >(val2);
30142 {
30143 PyThreadState* __tstate = wxPyBeginAllowThreads();
30144 (arg1)->SetWindowVariant(arg2);
30145 wxPyEndAllowThreads(__tstate);
30146 if (PyErr_Occurred()) SWIG_fail;
30147 }
30148 resultobj = SWIG_Py_Void();
30149 return resultobj;
30150 fail:
30151 return NULL;
30152 }
30153
30154
30155 SWIGINTERN PyObject *_wrap_Window_GetWindowVariant(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30156 PyObject *resultobj = 0;
30157 wxWindow *arg1 = (wxWindow *) 0 ;
30158 wxWindowVariant result;
30159 void *argp1 = 0 ;
30160 int res1 = 0 ;
30161 PyObject *swig_obj[1] ;
30162
30163 if (!args) SWIG_fail;
30164 swig_obj[0] = args;
30165 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30166 if (!SWIG_IsOK(res1)) {
30167 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowVariant" "', expected argument " "1"" of type '" "wxWindow const *""'");
30168 }
30169 arg1 = reinterpret_cast< wxWindow * >(argp1);
30170 {
30171 PyThreadState* __tstate = wxPyBeginAllowThreads();
30172 result = (wxWindowVariant)((wxWindow const *)arg1)->GetWindowVariant();
30173 wxPyEndAllowThreads(__tstate);
30174 if (PyErr_Occurred()) SWIG_fail;
30175 }
30176 resultobj = SWIG_From_int(static_cast< int >(result));
30177 return resultobj;
30178 fail:
30179 return NULL;
30180 }
30181
30182
30183 SWIGINTERN PyObject *_wrap_Window_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30184 PyObject *resultobj = 0;
30185 wxWindow *arg1 = (wxWindow *) 0 ;
30186 int arg2 ;
30187 void *argp1 = 0 ;
30188 int res1 = 0 ;
30189 int val2 ;
30190 int ecode2 = 0 ;
30191 PyObject * obj0 = 0 ;
30192 PyObject * obj1 = 0 ;
30193 char * kwnames[] = {
30194 (char *) "self",(char *) "winid", NULL
30195 };
30196
30197 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
30198 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30199 if (!SWIG_IsOK(res1)) {
30200 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetId" "', expected argument " "1"" of type '" "wxWindow *""'");
30201 }
30202 arg1 = reinterpret_cast< wxWindow * >(argp1);
30203 ecode2 = SWIG_AsVal_int(obj1, &val2);
30204 if (!SWIG_IsOK(ecode2)) {
30205 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetId" "', expected argument " "2"" of type '" "int""'");
30206 }
30207 arg2 = static_cast< int >(val2);
30208 {
30209 PyThreadState* __tstate = wxPyBeginAllowThreads();
30210 (arg1)->SetId(arg2);
30211 wxPyEndAllowThreads(__tstate);
30212 if (PyErr_Occurred()) SWIG_fail;
30213 }
30214 resultobj = SWIG_Py_Void();
30215 return resultobj;
30216 fail:
30217 return NULL;
30218 }
30219
30220
30221 SWIGINTERN PyObject *_wrap_Window_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30222 PyObject *resultobj = 0;
30223 wxWindow *arg1 = (wxWindow *) 0 ;
30224 int result;
30225 void *argp1 = 0 ;
30226 int res1 = 0 ;
30227 PyObject *swig_obj[1] ;
30228
30229 if (!args) SWIG_fail;
30230 swig_obj[0] = args;
30231 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30232 if (!SWIG_IsOK(res1)) {
30233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetId" "', expected argument " "1"" of type '" "wxWindow const *""'");
30234 }
30235 arg1 = reinterpret_cast< wxWindow * >(argp1);
30236 {
30237 PyThreadState* __tstate = wxPyBeginAllowThreads();
30238 result = (int)((wxWindow const *)arg1)->GetId();
30239 wxPyEndAllowThreads(__tstate);
30240 if (PyErr_Occurred()) SWIG_fail;
30241 }
30242 resultobj = SWIG_From_int(static_cast< int >(result));
30243 return resultobj;
30244 fail:
30245 return NULL;
30246 }
30247
30248
30249 SWIGINTERN PyObject *_wrap_Window_NewControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30250 PyObject *resultobj = 0;
30251 int result;
30252
30253 if (!SWIG_Python_UnpackTuple(args,"Window_NewControlId",0,0,0)) SWIG_fail;
30254 {
30255 PyThreadState* __tstate = wxPyBeginAllowThreads();
30256 result = (int)wxWindow::NewControlId();
30257 wxPyEndAllowThreads(__tstate);
30258 if (PyErr_Occurred()) SWIG_fail;
30259 }
30260 resultobj = SWIG_From_int(static_cast< int >(result));
30261 return resultobj;
30262 fail:
30263 return NULL;
30264 }
30265
30266
30267 SWIGINTERN PyObject *_wrap_Window_NextControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30268 PyObject *resultobj = 0;
30269 int arg1 ;
30270 int result;
30271 int val1 ;
30272 int ecode1 = 0 ;
30273 PyObject * obj0 = 0 ;
30274 char * kwnames[] = {
30275 (char *) "winid", NULL
30276 };
30277
30278 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_NextControlId",kwnames,&obj0)) SWIG_fail;
30279 ecode1 = SWIG_AsVal_int(obj0, &val1);
30280 if (!SWIG_IsOK(ecode1)) {
30281 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_NextControlId" "', expected argument " "1"" of type '" "int""'");
30282 }
30283 arg1 = static_cast< int >(val1);
30284 {
30285 PyThreadState* __tstate = wxPyBeginAllowThreads();
30286 result = (int)wxWindow::NextControlId(arg1);
30287 wxPyEndAllowThreads(__tstate);
30288 if (PyErr_Occurred()) SWIG_fail;
30289 }
30290 resultobj = SWIG_From_int(static_cast< int >(result));
30291 return resultobj;
30292 fail:
30293 return NULL;
30294 }
30295
30296
30297 SWIGINTERN PyObject *_wrap_Window_PrevControlId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30298 PyObject *resultobj = 0;
30299 int arg1 ;
30300 int result;
30301 int val1 ;
30302 int ecode1 = 0 ;
30303 PyObject * obj0 = 0 ;
30304 char * kwnames[] = {
30305 (char *) "winid", NULL
30306 };
30307
30308 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:Window_PrevControlId",kwnames,&obj0)) SWIG_fail;
30309 ecode1 = SWIG_AsVal_int(obj0, &val1);
30310 if (!SWIG_IsOK(ecode1)) {
30311 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_PrevControlId" "', expected argument " "1"" of type '" "int""'");
30312 }
30313 arg1 = static_cast< int >(val1);
30314 {
30315 PyThreadState* __tstate = wxPyBeginAllowThreads();
30316 result = (int)wxWindow::PrevControlId(arg1);
30317 wxPyEndAllowThreads(__tstate);
30318 if (PyErr_Occurred()) SWIG_fail;
30319 }
30320 resultobj = SWIG_From_int(static_cast< int >(result));
30321 return resultobj;
30322 fail:
30323 return NULL;
30324 }
30325
30326
30327 SWIGINTERN PyObject *_wrap_Window_SetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30328 PyObject *resultobj = 0;
30329 wxWindow *arg1 = (wxWindow *) 0 ;
30330 wxSize *arg2 = 0 ;
30331 void *argp1 = 0 ;
30332 int res1 = 0 ;
30333 wxSize temp2 ;
30334 PyObject * obj0 = 0 ;
30335 PyObject * obj1 = 0 ;
30336 char * kwnames[] = {
30337 (char *) "self",(char *) "size", NULL
30338 };
30339
30340 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetSize",kwnames,&obj0,&obj1)) SWIG_fail;
30341 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30342 if (!SWIG_IsOK(res1)) {
30343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30344 }
30345 arg1 = reinterpret_cast< wxWindow * >(argp1);
30346 {
30347 arg2 = &temp2;
30348 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30349 }
30350 {
30351 PyThreadState* __tstate = wxPyBeginAllowThreads();
30352 (arg1)->SetSize((wxSize const &)*arg2);
30353 wxPyEndAllowThreads(__tstate);
30354 if (PyErr_Occurred()) SWIG_fail;
30355 }
30356 resultobj = SWIG_Py_Void();
30357 return resultobj;
30358 fail:
30359 return NULL;
30360 }
30361
30362
30363 SWIGINTERN PyObject *_wrap_Window_SetDimensions(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30364 PyObject *resultobj = 0;
30365 wxWindow *arg1 = (wxWindow *) 0 ;
30366 int arg2 ;
30367 int arg3 ;
30368 int arg4 ;
30369 int arg5 ;
30370 int arg6 = (int) wxSIZE_AUTO ;
30371 void *argp1 = 0 ;
30372 int res1 = 0 ;
30373 int val2 ;
30374 int ecode2 = 0 ;
30375 int val3 ;
30376 int ecode3 = 0 ;
30377 int val4 ;
30378 int ecode4 = 0 ;
30379 int val5 ;
30380 int ecode5 = 0 ;
30381 int val6 ;
30382 int ecode6 = 0 ;
30383 PyObject * obj0 = 0 ;
30384 PyObject * obj1 = 0 ;
30385 PyObject * obj2 = 0 ;
30386 PyObject * obj3 = 0 ;
30387 PyObject * obj4 = 0 ;
30388 PyObject * obj5 = 0 ;
30389 char * kwnames[] = {
30390 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height",(char *) "sizeFlags", NULL
30391 };
30392
30393 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetDimensions",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
30394 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30395 if (!SWIG_IsOK(res1)) {
30396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDimensions" "', expected argument " "1"" of type '" "wxWindow *""'");
30397 }
30398 arg1 = reinterpret_cast< wxWindow * >(argp1);
30399 ecode2 = SWIG_AsVal_int(obj1, &val2);
30400 if (!SWIG_IsOK(ecode2)) {
30401 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDimensions" "', expected argument " "2"" of type '" "int""'");
30402 }
30403 arg2 = static_cast< int >(val2);
30404 ecode3 = SWIG_AsVal_int(obj2, &val3);
30405 if (!SWIG_IsOK(ecode3)) {
30406 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetDimensions" "', expected argument " "3"" of type '" "int""'");
30407 }
30408 arg3 = static_cast< int >(val3);
30409 ecode4 = SWIG_AsVal_int(obj3, &val4);
30410 if (!SWIG_IsOK(ecode4)) {
30411 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetDimensions" "', expected argument " "4"" of type '" "int""'");
30412 }
30413 arg4 = static_cast< int >(val4);
30414 ecode5 = SWIG_AsVal_int(obj4, &val5);
30415 if (!SWIG_IsOK(ecode5)) {
30416 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetDimensions" "', expected argument " "5"" of type '" "int""'");
30417 }
30418 arg5 = static_cast< int >(val5);
30419 if (obj5) {
30420 ecode6 = SWIG_AsVal_int(obj5, &val6);
30421 if (!SWIG_IsOK(ecode6)) {
30422 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetDimensions" "', expected argument " "6"" of type '" "int""'");
30423 }
30424 arg6 = static_cast< int >(val6);
30425 }
30426 {
30427 PyThreadState* __tstate = wxPyBeginAllowThreads();
30428 (arg1)->SetSize(arg2,arg3,arg4,arg5,arg6);
30429 wxPyEndAllowThreads(__tstate);
30430 if (PyErr_Occurred()) SWIG_fail;
30431 }
30432 resultobj = SWIG_Py_Void();
30433 return resultobj;
30434 fail:
30435 return NULL;
30436 }
30437
30438
30439 SWIGINTERN PyObject *_wrap_Window_SetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30440 PyObject *resultobj = 0;
30441 wxWindow *arg1 = (wxWindow *) 0 ;
30442 wxRect *arg2 = 0 ;
30443 int arg3 = (int) wxSIZE_AUTO ;
30444 void *argp1 = 0 ;
30445 int res1 = 0 ;
30446 wxRect temp2 ;
30447 int val3 ;
30448 int ecode3 = 0 ;
30449 PyObject * obj0 = 0 ;
30450 PyObject * obj1 = 0 ;
30451 PyObject * obj2 = 0 ;
30452 char * kwnames[] = {
30453 (char *) "self",(char *) "rect",(char *) "sizeFlags", NULL
30454 };
30455
30456 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30457 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30458 if (!SWIG_IsOK(res1)) {
30459 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30460 }
30461 arg1 = reinterpret_cast< wxWindow * >(argp1);
30462 {
30463 arg2 = &temp2;
30464 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30465 }
30466 if (obj2) {
30467 ecode3 = SWIG_AsVal_int(obj2, &val3);
30468 if (!SWIG_IsOK(ecode3)) {
30469 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetRect" "', expected argument " "3"" of type '" "int""'");
30470 }
30471 arg3 = static_cast< int >(val3);
30472 }
30473 {
30474 PyThreadState* __tstate = wxPyBeginAllowThreads();
30475 (arg1)->SetSize((wxRect const &)*arg2,arg3);
30476 wxPyEndAllowThreads(__tstate);
30477 if (PyErr_Occurred()) SWIG_fail;
30478 }
30479 resultobj = SWIG_Py_Void();
30480 return resultobj;
30481 fail:
30482 return NULL;
30483 }
30484
30485
30486 SWIGINTERN PyObject *_wrap_Window_SetSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30487 PyObject *resultobj = 0;
30488 wxWindow *arg1 = (wxWindow *) 0 ;
30489 int arg2 ;
30490 int arg3 ;
30491 void *argp1 = 0 ;
30492 int res1 = 0 ;
30493 int val2 ;
30494 int ecode2 = 0 ;
30495 int val3 ;
30496 int ecode3 = 0 ;
30497 PyObject * obj0 = 0 ;
30498 PyObject * obj1 = 0 ;
30499 PyObject * obj2 = 0 ;
30500 char * kwnames[] = {
30501 (char *) "self",(char *) "width",(char *) "height", NULL
30502 };
30503
30504 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30505 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30506 if (!SWIG_IsOK(res1)) {
30507 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30508 }
30509 arg1 = reinterpret_cast< wxWindow * >(argp1);
30510 ecode2 = SWIG_AsVal_int(obj1, &val2);
30511 if (!SWIG_IsOK(ecode2)) {
30512 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeWH" "', expected argument " "2"" of type '" "int""'");
30513 }
30514 arg2 = static_cast< int >(val2);
30515 ecode3 = SWIG_AsVal_int(obj2, &val3);
30516 if (!SWIG_IsOK(ecode3)) {
30517 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeWH" "', expected argument " "3"" of type '" "int""'");
30518 }
30519 arg3 = static_cast< int >(val3);
30520 {
30521 PyThreadState* __tstate = wxPyBeginAllowThreads();
30522 (arg1)->SetSize(arg2,arg3);
30523 wxPyEndAllowThreads(__tstate);
30524 if (PyErr_Occurred()) SWIG_fail;
30525 }
30526 resultobj = SWIG_Py_Void();
30527 return resultobj;
30528 fail:
30529 return NULL;
30530 }
30531
30532
30533 SWIGINTERN PyObject *_wrap_Window_Move(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30534 PyObject *resultobj = 0;
30535 wxWindow *arg1 = (wxWindow *) 0 ;
30536 wxPoint *arg2 = 0 ;
30537 int arg3 = (int) wxSIZE_USE_EXISTING ;
30538 void *argp1 = 0 ;
30539 int res1 = 0 ;
30540 wxPoint temp2 ;
30541 int val3 ;
30542 int ecode3 = 0 ;
30543 PyObject * obj0 = 0 ;
30544 PyObject * obj1 = 0 ;
30545 PyObject * obj2 = 0 ;
30546 char * kwnames[] = {
30547 (char *) "self",(char *) "pt",(char *) "flags", NULL
30548 };
30549
30550 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_Move",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30551 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30552 if (!SWIG_IsOK(res1)) {
30553 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Move" "', expected argument " "1"" of type '" "wxWindow *""'");
30554 }
30555 arg1 = reinterpret_cast< wxWindow * >(argp1);
30556 {
30557 arg2 = &temp2;
30558 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
30559 }
30560 if (obj2) {
30561 ecode3 = SWIG_AsVal_int(obj2, &val3);
30562 if (!SWIG_IsOK(ecode3)) {
30563 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_Move" "', expected argument " "3"" of type '" "int""'");
30564 }
30565 arg3 = static_cast< int >(val3);
30566 }
30567 {
30568 PyThreadState* __tstate = wxPyBeginAllowThreads();
30569 (arg1)->Move((wxPoint const &)*arg2,arg3);
30570 wxPyEndAllowThreads(__tstate);
30571 if (PyErr_Occurred()) SWIG_fail;
30572 }
30573 resultobj = SWIG_Py_Void();
30574 return resultobj;
30575 fail:
30576 return NULL;
30577 }
30578
30579
30580 SWIGINTERN PyObject *_wrap_Window_MoveXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30581 PyObject *resultobj = 0;
30582 wxWindow *arg1 = (wxWindow *) 0 ;
30583 int arg2 ;
30584 int arg3 ;
30585 int arg4 = (int) wxSIZE_USE_EXISTING ;
30586 void *argp1 = 0 ;
30587 int res1 = 0 ;
30588 int val2 ;
30589 int ecode2 = 0 ;
30590 int val3 ;
30591 int ecode3 = 0 ;
30592 int val4 ;
30593 int ecode4 = 0 ;
30594 PyObject * obj0 = 0 ;
30595 PyObject * obj1 = 0 ;
30596 PyObject * obj2 = 0 ;
30597 PyObject * obj3 = 0 ;
30598 char * kwnames[] = {
30599 (char *) "self",(char *) "x",(char *) "y",(char *) "flags", NULL
30600 };
30601
30602 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_MoveXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
30603 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30604 if (!SWIG_IsOK(res1)) {
30605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveXY" "', expected argument " "1"" of type '" "wxWindow *""'");
30606 }
30607 arg1 = reinterpret_cast< wxWindow * >(argp1);
30608 ecode2 = SWIG_AsVal_int(obj1, &val2);
30609 if (!SWIG_IsOK(ecode2)) {
30610 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MoveXY" "', expected argument " "2"" of type '" "int""'");
30611 }
30612 arg2 = static_cast< int >(val2);
30613 ecode3 = SWIG_AsVal_int(obj2, &val3);
30614 if (!SWIG_IsOK(ecode3)) {
30615 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_MoveXY" "', expected argument " "3"" of type '" "int""'");
30616 }
30617 arg3 = static_cast< int >(val3);
30618 if (obj3) {
30619 ecode4 = SWIG_AsVal_int(obj3, &val4);
30620 if (!SWIG_IsOK(ecode4)) {
30621 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_MoveXY" "', expected argument " "4"" of type '" "int""'");
30622 }
30623 arg4 = static_cast< int >(val4);
30624 }
30625 {
30626 PyThreadState* __tstate = wxPyBeginAllowThreads();
30627 (arg1)->Move(arg2,arg3,arg4);
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_Window_SetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30639 PyObject *resultobj = 0;
30640 wxWindow *arg1 = (wxWindow *) 0 ;
30641 wxSize const &arg2_defvalue = wxDefaultSize ;
30642 wxSize *arg2 = (wxSize *) &arg2_defvalue ;
30643 void *argp1 = 0 ;
30644 int res1 = 0 ;
30645 wxSize temp2 ;
30646 PyObject * obj0 = 0 ;
30647 PyObject * obj1 = 0 ;
30648 char * kwnames[] = {
30649 (char *) "self",(char *) "size", NULL
30650 };
30651
30652 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_SetBestFittingSize",kwnames,&obj0,&obj1)) SWIG_fail;
30653 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30654 if (!SWIG_IsOK(res1)) {
30655 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30656 }
30657 arg1 = reinterpret_cast< wxWindow * >(argp1);
30658 if (obj1) {
30659 {
30660 arg2 = &temp2;
30661 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30662 }
30663 }
30664 {
30665 PyThreadState* __tstate = wxPyBeginAllowThreads();
30666 (arg1)->SetBestFittingSize((wxSize const &)*arg2);
30667 wxPyEndAllowThreads(__tstate);
30668 if (PyErr_Occurred()) SWIG_fail;
30669 }
30670 resultobj = SWIG_Py_Void();
30671 return resultobj;
30672 fail:
30673 return NULL;
30674 }
30675
30676
30677 SWIGINTERN PyObject *_wrap_Window_Raise(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30678 PyObject *resultobj = 0;
30679 wxWindow *arg1 = (wxWindow *) 0 ;
30680 void *argp1 = 0 ;
30681 int res1 = 0 ;
30682 PyObject *swig_obj[1] ;
30683
30684 if (!args) SWIG_fail;
30685 swig_obj[0] = args;
30686 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30687 if (!SWIG_IsOK(res1)) {
30688 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Raise" "', expected argument " "1"" of type '" "wxWindow *""'");
30689 }
30690 arg1 = reinterpret_cast< wxWindow * >(argp1);
30691 {
30692 PyThreadState* __tstate = wxPyBeginAllowThreads();
30693 (arg1)->Raise();
30694 wxPyEndAllowThreads(__tstate);
30695 if (PyErr_Occurred()) SWIG_fail;
30696 }
30697 resultobj = SWIG_Py_Void();
30698 return resultobj;
30699 fail:
30700 return NULL;
30701 }
30702
30703
30704 SWIGINTERN PyObject *_wrap_Window_Lower(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30705 PyObject *resultobj = 0;
30706 wxWindow *arg1 = (wxWindow *) 0 ;
30707 void *argp1 = 0 ;
30708 int res1 = 0 ;
30709 PyObject *swig_obj[1] ;
30710
30711 if (!args) SWIG_fail;
30712 swig_obj[0] = args;
30713 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30714 if (!SWIG_IsOK(res1)) {
30715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Lower" "', expected argument " "1"" of type '" "wxWindow *""'");
30716 }
30717 arg1 = reinterpret_cast< wxWindow * >(argp1);
30718 {
30719 PyThreadState* __tstate = wxPyBeginAllowThreads();
30720 (arg1)->Lower();
30721 wxPyEndAllowThreads(__tstate);
30722 if (PyErr_Occurred()) SWIG_fail;
30723 }
30724 resultobj = SWIG_Py_Void();
30725 return resultobj;
30726 fail:
30727 return NULL;
30728 }
30729
30730
30731 SWIGINTERN PyObject *_wrap_Window_SetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30732 PyObject *resultobj = 0;
30733 wxWindow *arg1 = (wxWindow *) 0 ;
30734 wxSize *arg2 = 0 ;
30735 void *argp1 = 0 ;
30736 int res1 = 0 ;
30737 wxSize temp2 ;
30738 PyObject * obj0 = 0 ;
30739 PyObject * obj1 = 0 ;
30740 char * kwnames[] = {
30741 (char *) "self",(char *) "size", NULL
30742 };
30743
30744 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientSize",kwnames,&obj0,&obj1)) SWIG_fail;
30745 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30746 if (!SWIG_IsOK(res1)) {
30747 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSize" "', expected argument " "1"" of type '" "wxWindow *""'");
30748 }
30749 arg1 = reinterpret_cast< wxWindow * >(argp1);
30750 {
30751 arg2 = &temp2;
30752 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
30753 }
30754 {
30755 PyThreadState* __tstate = wxPyBeginAllowThreads();
30756 (arg1)->SetClientSize((wxSize const &)*arg2);
30757 wxPyEndAllowThreads(__tstate);
30758 if (PyErr_Occurred()) SWIG_fail;
30759 }
30760 resultobj = SWIG_Py_Void();
30761 return resultobj;
30762 fail:
30763 return NULL;
30764 }
30765
30766
30767 SWIGINTERN PyObject *_wrap_Window_SetClientSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30768 PyObject *resultobj = 0;
30769 wxWindow *arg1 = (wxWindow *) 0 ;
30770 int arg2 ;
30771 int arg3 ;
30772 void *argp1 = 0 ;
30773 int res1 = 0 ;
30774 int val2 ;
30775 int ecode2 = 0 ;
30776 int val3 ;
30777 int ecode3 = 0 ;
30778 PyObject * obj0 = 0 ;
30779 PyObject * obj1 = 0 ;
30780 PyObject * obj2 = 0 ;
30781 char * kwnames[] = {
30782 (char *) "self",(char *) "width",(char *) "height", NULL
30783 };
30784
30785 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetClientSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
30786 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30787 if (!SWIG_IsOK(res1)) {
30788 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
30789 }
30790 arg1 = reinterpret_cast< wxWindow * >(argp1);
30791 ecode2 = SWIG_AsVal_int(obj1, &val2);
30792 if (!SWIG_IsOK(ecode2)) {
30793 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetClientSizeWH" "', expected argument " "2"" of type '" "int""'");
30794 }
30795 arg2 = static_cast< int >(val2);
30796 ecode3 = SWIG_AsVal_int(obj2, &val3);
30797 if (!SWIG_IsOK(ecode3)) {
30798 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetClientSizeWH" "', expected argument " "3"" of type '" "int""'");
30799 }
30800 arg3 = static_cast< int >(val3);
30801 {
30802 PyThreadState* __tstate = wxPyBeginAllowThreads();
30803 (arg1)->SetClientSize(arg2,arg3);
30804 wxPyEndAllowThreads(__tstate);
30805 if (PyErr_Occurred()) SWIG_fail;
30806 }
30807 resultobj = SWIG_Py_Void();
30808 return resultobj;
30809 fail:
30810 return NULL;
30811 }
30812
30813
30814 SWIGINTERN PyObject *_wrap_Window_SetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
30815 PyObject *resultobj = 0;
30816 wxWindow *arg1 = (wxWindow *) 0 ;
30817 wxRect *arg2 = 0 ;
30818 void *argp1 = 0 ;
30819 int res1 = 0 ;
30820 wxRect temp2 ;
30821 PyObject * obj0 = 0 ;
30822 PyObject * obj1 = 0 ;
30823 char * kwnames[] = {
30824 (char *) "self",(char *) "rect", NULL
30825 };
30826
30827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetClientRect",kwnames,&obj0,&obj1)) SWIG_fail;
30828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30829 if (!SWIG_IsOK(res1)) {
30830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetClientRect" "', expected argument " "1"" of type '" "wxWindow *""'");
30831 }
30832 arg1 = reinterpret_cast< wxWindow * >(argp1);
30833 {
30834 arg2 = &temp2;
30835 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
30836 }
30837 {
30838 PyThreadState* __tstate = wxPyBeginAllowThreads();
30839 (arg1)->SetClientSize((wxRect const &)*arg2);
30840 wxPyEndAllowThreads(__tstate);
30841 if (PyErr_Occurred()) SWIG_fail;
30842 }
30843 resultobj = SWIG_Py_Void();
30844 return resultobj;
30845 fail:
30846 return NULL;
30847 }
30848
30849
30850 SWIGINTERN PyObject *_wrap_Window_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30851 PyObject *resultobj = 0;
30852 wxWindow *arg1 = (wxWindow *) 0 ;
30853 wxPoint result;
30854 void *argp1 = 0 ;
30855 int res1 = 0 ;
30856 PyObject *swig_obj[1] ;
30857
30858 if (!args) SWIG_fail;
30859 swig_obj[0] = args;
30860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30861 if (!SWIG_IsOK(res1)) {
30862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30863 }
30864 arg1 = reinterpret_cast< wxWindow * >(argp1);
30865 {
30866 PyThreadState* __tstate = wxPyBeginAllowThreads();
30867 result = ((wxWindow const *)arg1)->GetPosition();
30868 wxPyEndAllowThreads(__tstate);
30869 if (PyErr_Occurred()) SWIG_fail;
30870 }
30871 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30872 return resultobj;
30873 fail:
30874 return NULL;
30875 }
30876
30877
30878 SWIGINTERN PyObject *_wrap_Window_GetPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30879 PyObject *resultobj = 0;
30880 wxWindow *arg1 = (wxWindow *) 0 ;
30881 int *arg2 = (int *) 0 ;
30882 int *arg3 = (int *) 0 ;
30883 void *argp1 = 0 ;
30884 int res1 = 0 ;
30885 int temp2 ;
30886 int res2 = SWIG_TMPOBJ ;
30887 int temp3 ;
30888 int res3 = SWIG_TMPOBJ ;
30889 PyObject *swig_obj[1] ;
30890
30891 arg2 = &temp2;
30892 arg3 = &temp3;
30893 if (!args) SWIG_fail;
30894 swig_obj[0] = args;
30895 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30896 if (!SWIG_IsOK(res1)) {
30897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30898 }
30899 arg1 = reinterpret_cast< wxWindow * >(argp1);
30900 {
30901 PyThreadState* __tstate = wxPyBeginAllowThreads();
30902 ((wxWindow const *)arg1)->GetPosition(arg2,arg3);
30903 wxPyEndAllowThreads(__tstate);
30904 if (PyErr_Occurred()) SWIG_fail;
30905 }
30906 resultobj = SWIG_Py_Void();
30907 if (SWIG_IsTmpObj(res2)) {
30908 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30909 } else {
30910 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30911 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30912 }
30913 if (SWIG_IsTmpObj(res3)) {
30914 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30915 } else {
30916 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30917 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30918 }
30919 return resultobj;
30920 fail:
30921 return NULL;
30922 }
30923
30924
30925 SWIGINTERN PyObject *_wrap_Window_GetScreenPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30926 PyObject *resultobj = 0;
30927 wxWindow *arg1 = (wxWindow *) 0 ;
30928 wxPoint result;
30929 void *argp1 = 0 ;
30930 int res1 = 0 ;
30931 PyObject *swig_obj[1] ;
30932
30933 if (!args) SWIG_fail;
30934 swig_obj[0] = args;
30935 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30936 if (!SWIG_IsOK(res1)) {
30937 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPosition" "', expected argument " "1"" of type '" "wxWindow const *""'");
30938 }
30939 arg1 = reinterpret_cast< wxWindow * >(argp1);
30940 {
30941 PyThreadState* __tstate = wxPyBeginAllowThreads();
30942 result = ((wxWindow const *)arg1)->GetScreenPosition();
30943 wxPyEndAllowThreads(__tstate);
30944 if (PyErr_Occurred()) SWIG_fail;
30945 }
30946 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
30947 return resultobj;
30948 fail:
30949 return NULL;
30950 }
30951
30952
30953 SWIGINTERN PyObject *_wrap_Window_GetScreenPositionTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
30954 PyObject *resultobj = 0;
30955 wxWindow *arg1 = (wxWindow *) 0 ;
30956 int *arg2 = (int *) 0 ;
30957 int *arg3 = (int *) 0 ;
30958 void *argp1 = 0 ;
30959 int res1 = 0 ;
30960 int temp2 ;
30961 int res2 = SWIG_TMPOBJ ;
30962 int temp3 ;
30963 int res3 = SWIG_TMPOBJ ;
30964 PyObject *swig_obj[1] ;
30965
30966 arg2 = &temp2;
30967 arg3 = &temp3;
30968 if (!args) SWIG_fail;
30969 swig_obj[0] = args;
30970 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
30971 if (!SWIG_IsOK(res1)) {
30972 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenPositionTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
30973 }
30974 arg1 = reinterpret_cast< wxWindow * >(argp1);
30975 {
30976 PyThreadState* __tstate = wxPyBeginAllowThreads();
30977 ((wxWindow const *)arg1)->GetScreenPosition(arg2,arg3);
30978 wxPyEndAllowThreads(__tstate);
30979 if (PyErr_Occurred()) SWIG_fail;
30980 }
30981 resultobj = SWIG_Py_Void();
30982 if (SWIG_IsTmpObj(res2)) {
30983 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
30984 } else {
30985 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30986 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
30987 }
30988 if (SWIG_IsTmpObj(res3)) {
30989 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
30990 } else {
30991 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
30992 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
30993 }
30994 return resultobj;
30995 fail:
30996 return NULL;
30997 }
30998
30999
31000 SWIGINTERN PyObject *_wrap_Window_GetScreenRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31001 PyObject *resultobj = 0;
31002 wxWindow *arg1 = (wxWindow *) 0 ;
31003 wxRect result;
31004 void *argp1 = 0 ;
31005 int res1 = 0 ;
31006 PyObject *swig_obj[1] ;
31007
31008 if (!args) SWIG_fail;
31009 swig_obj[0] = args;
31010 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31011 if (!SWIG_IsOK(res1)) {
31012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScreenRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31013 }
31014 arg1 = reinterpret_cast< wxWindow * >(argp1);
31015 {
31016 PyThreadState* __tstate = wxPyBeginAllowThreads();
31017 result = ((wxWindow const *)arg1)->GetScreenRect();
31018 wxPyEndAllowThreads(__tstate);
31019 if (PyErr_Occurred()) SWIG_fail;
31020 }
31021 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31022 return resultobj;
31023 fail:
31024 return NULL;
31025 }
31026
31027
31028 SWIGINTERN PyObject *_wrap_Window_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31029 PyObject *resultobj = 0;
31030 wxWindow *arg1 = (wxWindow *) 0 ;
31031 wxSize result;
31032 void *argp1 = 0 ;
31033 int res1 = 0 ;
31034 PyObject *swig_obj[1] ;
31035
31036 if (!args) SWIG_fail;
31037 swig_obj[0] = args;
31038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31039 if (!SWIG_IsOK(res1)) {
31040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31041 }
31042 arg1 = reinterpret_cast< wxWindow * >(argp1);
31043 {
31044 PyThreadState* __tstate = wxPyBeginAllowThreads();
31045 result = ((wxWindow const *)arg1)->GetSize();
31046 wxPyEndAllowThreads(__tstate);
31047 if (PyErr_Occurred()) SWIG_fail;
31048 }
31049 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31050 return resultobj;
31051 fail:
31052 return NULL;
31053 }
31054
31055
31056 SWIGINTERN PyObject *_wrap_Window_GetSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31057 PyObject *resultobj = 0;
31058 wxWindow *arg1 = (wxWindow *) 0 ;
31059 int *arg2 = (int *) 0 ;
31060 int *arg3 = (int *) 0 ;
31061 void *argp1 = 0 ;
31062 int res1 = 0 ;
31063 int temp2 ;
31064 int res2 = SWIG_TMPOBJ ;
31065 int temp3 ;
31066 int res3 = SWIG_TMPOBJ ;
31067 PyObject *swig_obj[1] ;
31068
31069 arg2 = &temp2;
31070 arg3 = &temp3;
31071 if (!args) SWIG_fail;
31072 swig_obj[0] = args;
31073 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31074 if (!SWIG_IsOK(res1)) {
31075 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31076 }
31077 arg1 = reinterpret_cast< wxWindow * >(argp1);
31078 {
31079 PyThreadState* __tstate = wxPyBeginAllowThreads();
31080 ((wxWindow const *)arg1)->GetSize(arg2,arg3);
31081 wxPyEndAllowThreads(__tstate);
31082 if (PyErr_Occurred()) SWIG_fail;
31083 }
31084 resultobj = SWIG_Py_Void();
31085 if (SWIG_IsTmpObj(res2)) {
31086 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31087 } else {
31088 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31089 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31090 }
31091 if (SWIG_IsTmpObj(res3)) {
31092 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31093 } else {
31094 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31095 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31096 }
31097 return resultobj;
31098 fail:
31099 return NULL;
31100 }
31101
31102
31103 SWIGINTERN PyObject *_wrap_Window_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31104 PyObject *resultobj = 0;
31105 wxWindow *arg1 = (wxWindow *) 0 ;
31106 wxRect result;
31107 void *argp1 = 0 ;
31108 int res1 = 0 ;
31109 PyObject *swig_obj[1] ;
31110
31111 if (!args) SWIG_fail;
31112 swig_obj[0] = args;
31113 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31114 if (!SWIG_IsOK(res1)) {
31115 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31116 }
31117 arg1 = reinterpret_cast< wxWindow * >(argp1);
31118 {
31119 PyThreadState* __tstate = wxPyBeginAllowThreads();
31120 result = ((wxWindow const *)arg1)->GetRect();
31121 wxPyEndAllowThreads(__tstate);
31122 if (PyErr_Occurred()) SWIG_fail;
31123 }
31124 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31125 return resultobj;
31126 fail:
31127 return NULL;
31128 }
31129
31130
31131 SWIGINTERN PyObject *_wrap_Window_GetClientSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31132 PyObject *resultobj = 0;
31133 wxWindow *arg1 = (wxWindow *) 0 ;
31134 wxSize result;
31135 void *argp1 = 0 ;
31136 int res1 = 0 ;
31137 PyObject *swig_obj[1] ;
31138
31139 if (!args) SWIG_fail;
31140 swig_obj[0] = args;
31141 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31142 if (!SWIG_IsOK(res1)) {
31143 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31144 }
31145 arg1 = reinterpret_cast< wxWindow * >(argp1);
31146 {
31147 PyThreadState* __tstate = wxPyBeginAllowThreads();
31148 result = ((wxWindow const *)arg1)->GetClientSize();
31149 wxPyEndAllowThreads(__tstate);
31150 if (PyErr_Occurred()) SWIG_fail;
31151 }
31152 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31153 return resultobj;
31154 fail:
31155 return NULL;
31156 }
31157
31158
31159 SWIGINTERN PyObject *_wrap_Window_GetClientSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31160 PyObject *resultobj = 0;
31161 wxWindow *arg1 = (wxWindow *) 0 ;
31162 int *arg2 = (int *) 0 ;
31163 int *arg3 = (int *) 0 ;
31164 void *argp1 = 0 ;
31165 int res1 = 0 ;
31166 int temp2 ;
31167 int res2 = SWIG_TMPOBJ ;
31168 int temp3 ;
31169 int res3 = SWIG_TMPOBJ ;
31170 PyObject *swig_obj[1] ;
31171
31172 arg2 = &temp2;
31173 arg3 = &temp3;
31174 if (!args) SWIG_fail;
31175 swig_obj[0] = args;
31176 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31177 if (!SWIG_IsOK(res1)) {
31178 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31179 }
31180 arg1 = reinterpret_cast< wxWindow * >(argp1);
31181 {
31182 PyThreadState* __tstate = wxPyBeginAllowThreads();
31183 ((wxWindow const *)arg1)->GetClientSize(arg2,arg3);
31184 wxPyEndAllowThreads(__tstate);
31185 if (PyErr_Occurred()) SWIG_fail;
31186 }
31187 resultobj = SWIG_Py_Void();
31188 if (SWIG_IsTmpObj(res2)) {
31189 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31190 } else {
31191 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31192 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31193 }
31194 if (SWIG_IsTmpObj(res3)) {
31195 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31196 } else {
31197 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31198 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31199 }
31200 return resultobj;
31201 fail:
31202 return NULL;
31203 }
31204
31205
31206 SWIGINTERN PyObject *_wrap_Window_GetClientAreaOrigin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31207 PyObject *resultobj = 0;
31208 wxWindow *arg1 = (wxWindow *) 0 ;
31209 wxPoint result;
31210 void *argp1 = 0 ;
31211 int res1 = 0 ;
31212 PyObject *swig_obj[1] ;
31213
31214 if (!args) SWIG_fail;
31215 swig_obj[0] = args;
31216 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31217 if (!SWIG_IsOK(res1)) {
31218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientAreaOrigin" "', expected argument " "1"" of type '" "wxWindow const *""'");
31219 }
31220 arg1 = reinterpret_cast< wxWindow * >(argp1);
31221 {
31222 PyThreadState* __tstate = wxPyBeginAllowThreads();
31223 result = ((wxWindow const *)arg1)->GetClientAreaOrigin();
31224 wxPyEndAllowThreads(__tstate);
31225 if (PyErr_Occurred()) SWIG_fail;
31226 }
31227 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
31228 return resultobj;
31229 fail:
31230 return NULL;
31231 }
31232
31233
31234 SWIGINTERN PyObject *_wrap_Window_GetClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31235 PyObject *resultobj = 0;
31236 wxWindow *arg1 = (wxWindow *) 0 ;
31237 wxRect result;
31238 void *argp1 = 0 ;
31239 int res1 = 0 ;
31240 PyObject *swig_obj[1] ;
31241
31242 if (!args) SWIG_fail;
31243 swig_obj[0] = args;
31244 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31245 if (!SWIG_IsOK(res1)) {
31246 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
31247 }
31248 arg1 = reinterpret_cast< wxWindow * >(argp1);
31249 {
31250 PyThreadState* __tstate = wxPyBeginAllowThreads();
31251 result = ((wxWindow const *)arg1)->GetClientRect();
31252 wxPyEndAllowThreads(__tstate);
31253 if (PyErr_Occurred()) SWIG_fail;
31254 }
31255 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
31256 return resultobj;
31257 fail:
31258 return NULL;
31259 }
31260
31261
31262 SWIGINTERN PyObject *_wrap_Window_GetBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31263 PyObject *resultobj = 0;
31264 wxWindow *arg1 = (wxWindow *) 0 ;
31265 wxSize result;
31266 void *argp1 = 0 ;
31267 int res1 = 0 ;
31268 PyObject *swig_obj[1] ;
31269
31270 if (!args) SWIG_fail;
31271 swig_obj[0] = args;
31272 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31273 if (!SWIG_IsOK(res1)) {
31274 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31275 }
31276 arg1 = reinterpret_cast< wxWindow * >(argp1);
31277 {
31278 PyThreadState* __tstate = wxPyBeginAllowThreads();
31279 result = ((wxWindow const *)arg1)->GetBestSize();
31280 wxPyEndAllowThreads(__tstate);
31281 if (PyErr_Occurred()) SWIG_fail;
31282 }
31283 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31284 return resultobj;
31285 fail:
31286 return NULL;
31287 }
31288
31289
31290 SWIGINTERN PyObject *_wrap_Window_GetBestSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31291 PyObject *resultobj = 0;
31292 wxWindow *arg1 = (wxWindow *) 0 ;
31293 int *arg2 = (int *) 0 ;
31294 int *arg3 = (int *) 0 ;
31295 void *argp1 = 0 ;
31296 int res1 = 0 ;
31297 int temp2 ;
31298 int res2 = SWIG_TMPOBJ ;
31299 int temp3 ;
31300 int res3 = SWIG_TMPOBJ ;
31301 PyObject *swig_obj[1] ;
31302
31303 arg2 = &temp2;
31304 arg3 = &temp3;
31305 if (!args) SWIG_fail;
31306 swig_obj[0] = args;
31307 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31308 if (!SWIG_IsOK(res1)) {
31309 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
31310 }
31311 arg1 = reinterpret_cast< wxWindow * >(argp1);
31312 {
31313 PyThreadState* __tstate = wxPyBeginAllowThreads();
31314 ((wxWindow const *)arg1)->GetBestSize(arg2,arg3);
31315 wxPyEndAllowThreads(__tstate);
31316 if (PyErr_Occurred()) SWIG_fail;
31317 }
31318 resultobj = SWIG_Py_Void();
31319 if (SWIG_IsTmpObj(res2)) {
31320 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
31321 } else {
31322 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31323 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
31324 }
31325 if (SWIG_IsTmpObj(res3)) {
31326 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
31327 } else {
31328 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
31329 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
31330 }
31331 return resultobj;
31332 fail:
31333 return NULL;
31334 }
31335
31336
31337 SWIGINTERN PyObject *_wrap_Window_InvalidateBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31338 PyObject *resultobj = 0;
31339 wxWindow *arg1 = (wxWindow *) 0 ;
31340 void *argp1 = 0 ;
31341 int res1 = 0 ;
31342 PyObject *swig_obj[1] ;
31343
31344 if (!args) SWIG_fail;
31345 swig_obj[0] = args;
31346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31347 if (!SWIG_IsOK(res1)) {
31348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InvalidateBestSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31349 }
31350 arg1 = reinterpret_cast< wxWindow * >(argp1);
31351 {
31352 PyThreadState* __tstate = wxPyBeginAllowThreads();
31353 (arg1)->InvalidateBestSize();
31354 wxPyEndAllowThreads(__tstate);
31355 if (PyErr_Occurred()) SWIG_fail;
31356 }
31357 resultobj = SWIG_Py_Void();
31358 return resultobj;
31359 fail:
31360 return NULL;
31361 }
31362
31363
31364 SWIGINTERN PyObject *_wrap_Window_CacheBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31365 PyObject *resultobj = 0;
31366 wxWindow *arg1 = (wxWindow *) 0 ;
31367 wxSize *arg2 = 0 ;
31368 void *argp1 = 0 ;
31369 int res1 = 0 ;
31370 wxSize temp2 ;
31371 PyObject * obj0 = 0 ;
31372 PyObject * obj1 = 0 ;
31373 char * kwnames[] = {
31374 (char *) "self",(char *) "size", NULL
31375 };
31376
31377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_CacheBestSize",kwnames,&obj0,&obj1)) SWIG_fail;
31378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31379 if (!SWIG_IsOK(res1)) {
31380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CacheBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31381 }
31382 arg1 = reinterpret_cast< wxWindow * >(argp1);
31383 {
31384 arg2 = &temp2;
31385 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31386 }
31387 {
31388 PyThreadState* __tstate = wxPyBeginAllowThreads();
31389 ((wxWindow const *)arg1)->CacheBestSize((wxSize const &)*arg2);
31390 wxPyEndAllowThreads(__tstate);
31391 if (PyErr_Occurred()) SWIG_fail;
31392 }
31393 resultobj = SWIG_Py_Void();
31394 return resultobj;
31395 fail:
31396 return NULL;
31397 }
31398
31399
31400 SWIGINTERN PyObject *_wrap_Window_GetBestFittingSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31401 PyObject *resultobj = 0;
31402 wxWindow *arg1 = (wxWindow *) 0 ;
31403 wxSize result;
31404 void *argp1 = 0 ;
31405 int res1 = 0 ;
31406 PyObject *swig_obj[1] ;
31407
31408 if (!args) SWIG_fail;
31409 swig_obj[0] = args;
31410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31411 if (!SWIG_IsOK(res1)) {
31412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestFittingSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31413 }
31414 arg1 = reinterpret_cast< wxWindow * >(argp1);
31415 {
31416 PyThreadState* __tstate = wxPyBeginAllowThreads();
31417 result = ((wxWindow const *)arg1)->GetBestFittingSize();
31418 wxPyEndAllowThreads(__tstate);
31419 if (PyErr_Occurred()) SWIG_fail;
31420 }
31421 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31422 return resultobj;
31423 fail:
31424 return NULL;
31425 }
31426
31427
31428 SWIGINTERN PyObject *_wrap_Window_GetAdjustedBestSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31429 PyObject *resultobj = 0;
31430 wxWindow *arg1 = (wxWindow *) 0 ;
31431 wxSize result;
31432 void *argp1 = 0 ;
31433 int res1 = 0 ;
31434 PyObject *swig_obj[1] ;
31435
31436 if (!args) SWIG_fail;
31437 swig_obj[0] = args;
31438 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31439 if (!SWIG_IsOK(res1)) {
31440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAdjustedBestSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31441 }
31442 arg1 = reinterpret_cast< wxWindow * >(argp1);
31443 {
31444 PyThreadState* __tstate = wxPyBeginAllowThreads();
31445 result = ((wxWindow const *)arg1)->GetAdjustedBestSize();
31446 wxPyEndAllowThreads(__tstate);
31447 if (PyErr_Occurred()) SWIG_fail;
31448 }
31449 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31450 return resultobj;
31451 fail:
31452 return NULL;
31453 }
31454
31455
31456 SWIGINTERN PyObject *_wrap_Window_Center(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31457 PyObject *resultobj = 0;
31458 wxWindow *arg1 = (wxWindow *) 0 ;
31459 int arg2 = (int) wxBOTH ;
31460 void *argp1 = 0 ;
31461 int res1 = 0 ;
31462 int val2 ;
31463 int ecode2 = 0 ;
31464 PyObject * obj0 = 0 ;
31465 PyObject * obj1 = 0 ;
31466 char * kwnames[] = {
31467 (char *) "self",(char *) "direction", NULL
31468 };
31469
31470 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Center",kwnames,&obj0,&obj1)) SWIG_fail;
31471 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31472 if (!SWIG_IsOK(res1)) {
31473 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Center" "', expected argument " "1"" of type '" "wxWindow *""'");
31474 }
31475 arg1 = reinterpret_cast< wxWindow * >(argp1);
31476 if (obj1) {
31477 ecode2 = SWIG_AsVal_int(obj1, &val2);
31478 if (!SWIG_IsOK(ecode2)) {
31479 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Center" "', expected argument " "2"" of type '" "int""'");
31480 }
31481 arg2 = static_cast< int >(val2);
31482 }
31483 {
31484 PyThreadState* __tstate = wxPyBeginAllowThreads();
31485 (arg1)->Center(arg2);
31486 wxPyEndAllowThreads(__tstate);
31487 if (PyErr_Occurred()) SWIG_fail;
31488 }
31489 resultobj = SWIG_Py_Void();
31490 return resultobj;
31491 fail:
31492 return NULL;
31493 }
31494
31495
31496 SWIGINTERN PyObject *_wrap_Window_CenterOnParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31497 PyObject *resultobj = 0;
31498 wxWindow *arg1 = (wxWindow *) 0 ;
31499 int arg2 = (int) wxBOTH ;
31500 void *argp1 = 0 ;
31501 int res1 = 0 ;
31502 int val2 ;
31503 int ecode2 = 0 ;
31504 PyObject * obj0 = 0 ;
31505 PyObject * obj1 = 0 ;
31506 char * kwnames[] = {
31507 (char *) "self",(char *) "dir", NULL
31508 };
31509
31510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_CenterOnParent",kwnames,&obj0,&obj1)) SWIG_fail;
31511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31512 if (!SWIG_IsOK(res1)) {
31513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CenterOnParent" "', expected argument " "1"" of type '" "wxWindow *""'");
31514 }
31515 arg1 = reinterpret_cast< wxWindow * >(argp1);
31516 if (obj1) {
31517 ecode2 = SWIG_AsVal_int(obj1, &val2);
31518 if (!SWIG_IsOK(ecode2)) {
31519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_CenterOnParent" "', expected argument " "2"" of type '" "int""'");
31520 }
31521 arg2 = static_cast< int >(val2);
31522 }
31523 {
31524 PyThreadState* __tstate = wxPyBeginAllowThreads();
31525 (arg1)->CenterOnParent(arg2);
31526 wxPyEndAllowThreads(__tstate);
31527 if (PyErr_Occurred()) SWIG_fail;
31528 }
31529 resultobj = SWIG_Py_Void();
31530 return resultobj;
31531 fail:
31532 return NULL;
31533 }
31534
31535
31536 SWIGINTERN PyObject *_wrap_Window_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31537 PyObject *resultobj = 0;
31538 wxWindow *arg1 = (wxWindow *) 0 ;
31539 void *argp1 = 0 ;
31540 int res1 = 0 ;
31541 PyObject *swig_obj[1] ;
31542
31543 if (!args) SWIG_fail;
31544 swig_obj[0] = args;
31545 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31546 if (!SWIG_IsOK(res1)) {
31547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Fit" "', expected argument " "1"" of type '" "wxWindow *""'");
31548 }
31549 arg1 = reinterpret_cast< wxWindow * >(argp1);
31550 {
31551 PyThreadState* __tstate = wxPyBeginAllowThreads();
31552 (arg1)->Fit();
31553 wxPyEndAllowThreads(__tstate);
31554 if (PyErr_Occurred()) SWIG_fail;
31555 }
31556 resultobj = SWIG_Py_Void();
31557 return resultobj;
31558 fail:
31559 return NULL;
31560 }
31561
31562
31563 SWIGINTERN PyObject *_wrap_Window_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31564 PyObject *resultobj = 0;
31565 wxWindow *arg1 = (wxWindow *) 0 ;
31566 void *argp1 = 0 ;
31567 int res1 = 0 ;
31568 PyObject *swig_obj[1] ;
31569
31570 if (!args) SWIG_fail;
31571 swig_obj[0] = args;
31572 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31573 if (!SWIG_IsOK(res1)) {
31574 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FitInside" "', expected argument " "1"" of type '" "wxWindow *""'");
31575 }
31576 arg1 = reinterpret_cast< wxWindow * >(argp1);
31577 {
31578 PyThreadState* __tstate = wxPyBeginAllowThreads();
31579 (arg1)->FitInside();
31580 wxPyEndAllowThreads(__tstate);
31581 if (PyErr_Occurred()) SWIG_fail;
31582 }
31583 resultobj = SWIG_Py_Void();
31584 return resultobj;
31585 fail:
31586 return NULL;
31587 }
31588
31589
31590 SWIGINTERN PyObject *_wrap_Window_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31591 PyObject *resultobj = 0;
31592 wxWindow *arg1 = (wxWindow *) 0 ;
31593 int arg2 ;
31594 int arg3 ;
31595 int arg4 = (int) -1 ;
31596 int arg5 = (int) -1 ;
31597 int arg6 = (int) -1 ;
31598 int arg7 = (int) -1 ;
31599 void *argp1 = 0 ;
31600 int res1 = 0 ;
31601 int val2 ;
31602 int ecode2 = 0 ;
31603 int val3 ;
31604 int ecode3 = 0 ;
31605 int val4 ;
31606 int ecode4 = 0 ;
31607 int val5 ;
31608 int ecode5 = 0 ;
31609 int val6 ;
31610 int ecode6 = 0 ;
31611 int val7 ;
31612 int ecode7 = 0 ;
31613 PyObject * obj0 = 0 ;
31614 PyObject * obj1 = 0 ;
31615 PyObject * obj2 = 0 ;
31616 PyObject * obj3 = 0 ;
31617 PyObject * obj4 = 0 ;
31618 PyObject * obj5 = 0 ;
31619 PyObject * obj6 = 0 ;
31620 char * kwnames[] = {
31621 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH",(char *) "incW",(char *) "incH", NULL
31622 };
31623
31624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Window_SetSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
31625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31626 if (!SWIG_IsOK(res1)) {
31627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31628 }
31629 arg1 = reinterpret_cast< wxWindow * >(argp1);
31630 ecode2 = SWIG_AsVal_int(obj1, &val2);
31631 if (!SWIG_IsOK(ecode2)) {
31632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetSizeHints" "', expected argument " "2"" of type '" "int""'");
31633 }
31634 arg2 = static_cast< int >(val2);
31635 ecode3 = SWIG_AsVal_int(obj2, &val3);
31636 if (!SWIG_IsOK(ecode3)) {
31637 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizeHints" "', expected argument " "3"" of type '" "int""'");
31638 }
31639 arg3 = static_cast< int >(val3);
31640 if (obj3) {
31641 ecode4 = SWIG_AsVal_int(obj3, &val4);
31642 if (!SWIG_IsOK(ecode4)) {
31643 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetSizeHints" "', expected argument " "4"" of type '" "int""'");
31644 }
31645 arg4 = static_cast< int >(val4);
31646 }
31647 if (obj4) {
31648 ecode5 = SWIG_AsVal_int(obj4, &val5);
31649 if (!SWIG_IsOK(ecode5)) {
31650 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetSizeHints" "', expected argument " "5"" of type '" "int""'");
31651 }
31652 arg5 = static_cast< int >(val5);
31653 }
31654 if (obj5) {
31655 ecode6 = SWIG_AsVal_int(obj5, &val6);
31656 if (!SWIG_IsOK(ecode6)) {
31657 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetSizeHints" "', expected argument " "6"" of type '" "int""'");
31658 }
31659 arg6 = static_cast< int >(val6);
31660 }
31661 if (obj6) {
31662 ecode7 = SWIG_AsVal_int(obj6, &val7);
31663 if (!SWIG_IsOK(ecode7)) {
31664 SWIG_exception_fail(SWIG_ArgError(ecode7), "in method '" "Window_SetSizeHints" "', expected argument " "7"" of type '" "int""'");
31665 }
31666 arg7 = static_cast< int >(val7);
31667 }
31668 {
31669 PyThreadState* __tstate = wxPyBeginAllowThreads();
31670 (arg1)->SetSizeHints(arg2,arg3,arg4,arg5,arg6,arg7);
31671 wxPyEndAllowThreads(__tstate);
31672 if (PyErr_Occurred()) SWIG_fail;
31673 }
31674 resultobj = SWIG_Py_Void();
31675 return resultobj;
31676 fail:
31677 return NULL;
31678 }
31679
31680
31681 SWIGINTERN PyObject *_wrap_Window_SetSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31682 PyObject *resultobj = 0;
31683 wxWindow *arg1 = (wxWindow *) 0 ;
31684 wxSize *arg2 = 0 ;
31685 wxSize const &arg3_defvalue = wxDefaultSize ;
31686 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31687 wxSize const &arg4_defvalue = wxDefaultSize ;
31688 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
31689 void *argp1 = 0 ;
31690 int res1 = 0 ;
31691 wxSize temp2 ;
31692 wxSize temp3 ;
31693 wxSize temp4 ;
31694 PyObject * obj0 = 0 ;
31695 PyObject * obj1 = 0 ;
31696 PyObject * obj2 = 0 ;
31697 PyObject * obj3 = 0 ;
31698 char * kwnames[] = {
31699 (char *) "self",(char *) "minSize",(char *) "maxSize",(char *) "incSize", NULL
31700 };
31701
31702 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_SetSizeHintsSz",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
31703 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31704 if (!SWIG_IsOK(res1)) {
31705 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31706 }
31707 arg1 = reinterpret_cast< wxWindow * >(argp1);
31708 {
31709 arg2 = &temp2;
31710 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31711 }
31712 if (obj2) {
31713 {
31714 arg3 = &temp3;
31715 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31716 }
31717 }
31718 if (obj3) {
31719 {
31720 arg4 = &temp4;
31721 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
31722 }
31723 }
31724 {
31725 PyThreadState* __tstate = wxPyBeginAllowThreads();
31726 (arg1)->SetSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3,(wxSize const &)*arg4);
31727 wxPyEndAllowThreads(__tstate);
31728 if (PyErr_Occurred()) SWIG_fail;
31729 }
31730 resultobj = SWIG_Py_Void();
31731 return resultobj;
31732 fail:
31733 return NULL;
31734 }
31735
31736
31737 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31738 PyObject *resultobj = 0;
31739 wxWindow *arg1 = (wxWindow *) 0 ;
31740 int arg2 ;
31741 int arg3 ;
31742 int arg4 = (int) -1 ;
31743 int arg5 = (int) -1 ;
31744 void *argp1 = 0 ;
31745 int res1 = 0 ;
31746 int val2 ;
31747 int ecode2 = 0 ;
31748 int val3 ;
31749 int ecode3 = 0 ;
31750 int val4 ;
31751 int ecode4 = 0 ;
31752 int val5 ;
31753 int ecode5 = 0 ;
31754 PyObject * obj0 = 0 ;
31755 PyObject * obj1 = 0 ;
31756 PyObject * obj2 = 0 ;
31757 PyObject * obj3 = 0 ;
31758 PyObject * obj4 = 0 ;
31759 char * kwnames[] = {
31760 (char *) "self",(char *) "minW",(char *) "minH",(char *) "maxW",(char *) "maxH", NULL
31761 };
31762
31763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_SetVirtualSizeHints",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
31764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31765 if (!SWIG_IsOK(res1)) {
31766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxWindow *""'");
31767 }
31768 arg1 = reinterpret_cast< wxWindow * >(argp1);
31769 ecode2 = SWIG_AsVal_int(obj1, &val2);
31770 if (!SWIG_IsOK(ecode2)) {
31771 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "2"" of type '" "int""'");
31772 }
31773 arg2 = static_cast< int >(val2);
31774 ecode3 = SWIG_AsVal_int(obj2, &val3);
31775 if (!SWIG_IsOK(ecode3)) {
31776 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "3"" of type '" "int""'");
31777 }
31778 arg3 = static_cast< int >(val3);
31779 if (obj3) {
31780 ecode4 = SWIG_AsVal_int(obj3, &val4);
31781 if (!SWIG_IsOK(ecode4)) {
31782 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "4"" of type '" "int""'");
31783 }
31784 arg4 = static_cast< int >(val4);
31785 }
31786 if (obj4) {
31787 ecode5 = SWIG_AsVal_int(obj4, &val5);
31788 if (!SWIG_IsOK(ecode5)) {
31789 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetVirtualSizeHints" "', expected argument " "5"" of type '" "int""'");
31790 }
31791 arg5 = static_cast< int >(val5);
31792 }
31793 {
31794 PyThreadState* __tstate = wxPyBeginAllowThreads();
31795 (arg1)->SetVirtualSizeHints(arg2,arg3,arg4,arg5);
31796 wxPyEndAllowThreads(__tstate);
31797 if (PyErr_Occurred()) SWIG_fail;
31798 }
31799 resultobj = SWIG_Py_Void();
31800 return resultobj;
31801 fail:
31802 return NULL;
31803 }
31804
31805
31806 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeHintsSz(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31807 PyObject *resultobj = 0;
31808 wxWindow *arg1 = (wxWindow *) 0 ;
31809 wxSize *arg2 = 0 ;
31810 wxSize const &arg3_defvalue = wxDefaultSize ;
31811 wxSize *arg3 = (wxSize *) &arg3_defvalue ;
31812 void *argp1 = 0 ;
31813 int res1 = 0 ;
31814 wxSize temp2 ;
31815 wxSize temp3 ;
31816 PyObject * obj0 = 0 ;
31817 PyObject * obj1 = 0 ;
31818 PyObject * obj2 = 0 ;
31819 char * kwnames[] = {
31820 (char *) "self",(char *) "minSize",(char *) "maxSize", NULL
31821 };
31822
31823 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetVirtualSizeHintsSz",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
31824 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31825 if (!SWIG_IsOK(res1)) {
31826 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeHintsSz" "', expected argument " "1"" of type '" "wxWindow *""'");
31827 }
31828 arg1 = reinterpret_cast< wxWindow * >(argp1);
31829 {
31830 arg2 = &temp2;
31831 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31832 }
31833 if (obj2) {
31834 {
31835 arg3 = &temp3;
31836 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
31837 }
31838 }
31839 {
31840 PyThreadState* __tstate = wxPyBeginAllowThreads();
31841 (arg1)->SetVirtualSizeHints((wxSize const &)*arg2,(wxSize const &)*arg3);
31842 wxPyEndAllowThreads(__tstate);
31843 if (PyErr_Occurred()) SWIG_fail;
31844 }
31845 resultobj = SWIG_Py_Void();
31846 return resultobj;
31847 fail:
31848 return NULL;
31849 }
31850
31851
31852 SWIGINTERN PyObject *_wrap_Window_GetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31853 PyObject *resultobj = 0;
31854 wxWindow *arg1 = (wxWindow *) 0 ;
31855 wxSize result;
31856 void *argp1 = 0 ;
31857 int res1 = 0 ;
31858 PyObject *swig_obj[1] ;
31859
31860 if (!args) SWIG_fail;
31861 swig_obj[0] = args;
31862 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31863 if (!SWIG_IsOK(res1)) {
31864 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31865 }
31866 arg1 = reinterpret_cast< wxWindow * >(argp1);
31867 {
31868 PyThreadState* __tstate = wxPyBeginAllowThreads();
31869 result = ((wxWindow const *)arg1)->GetMaxSize();
31870 wxPyEndAllowThreads(__tstate);
31871 if (PyErr_Occurred()) SWIG_fail;
31872 }
31873 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31874 return resultobj;
31875 fail:
31876 return NULL;
31877 }
31878
31879
31880 SWIGINTERN PyObject *_wrap_Window_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31881 PyObject *resultobj = 0;
31882 wxWindow *arg1 = (wxWindow *) 0 ;
31883 wxSize result;
31884 void *argp1 = 0 ;
31885 int res1 = 0 ;
31886 PyObject *swig_obj[1] ;
31887
31888 if (!args) SWIG_fail;
31889 swig_obj[0] = args;
31890 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31891 if (!SWIG_IsOK(res1)) {
31892 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
31893 }
31894 arg1 = reinterpret_cast< wxWindow * >(argp1);
31895 {
31896 PyThreadState* __tstate = wxPyBeginAllowThreads();
31897 result = ((wxWindow const *)arg1)->GetMinSize();
31898 wxPyEndAllowThreads(__tstate);
31899 if (PyErr_Occurred()) SWIG_fail;
31900 }
31901 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
31902 return resultobj;
31903 fail:
31904 return NULL;
31905 }
31906
31907
31908 SWIGINTERN PyObject *_wrap_Window_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31909 PyObject *resultobj = 0;
31910 wxWindow *arg1 = (wxWindow *) 0 ;
31911 wxSize *arg2 = 0 ;
31912 void *argp1 = 0 ;
31913 int res1 = 0 ;
31914 wxSize temp2 ;
31915 PyObject * obj0 = 0 ;
31916 PyObject * obj1 = 0 ;
31917 char * kwnames[] = {
31918 (char *) "self",(char *) "minSize", NULL
31919 };
31920
31921 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
31922 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31923 if (!SWIG_IsOK(res1)) {
31924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMinSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31925 }
31926 arg1 = reinterpret_cast< wxWindow * >(argp1);
31927 {
31928 arg2 = &temp2;
31929 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31930 }
31931 {
31932 PyThreadState* __tstate = wxPyBeginAllowThreads();
31933 (arg1)->SetMinSize((wxSize const &)*arg2);
31934 wxPyEndAllowThreads(__tstate);
31935 if (PyErr_Occurred()) SWIG_fail;
31936 }
31937 resultobj = SWIG_Py_Void();
31938 return resultobj;
31939 fail:
31940 return NULL;
31941 }
31942
31943
31944 SWIGINTERN PyObject *_wrap_Window_SetMaxSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
31945 PyObject *resultobj = 0;
31946 wxWindow *arg1 = (wxWindow *) 0 ;
31947 wxSize *arg2 = 0 ;
31948 void *argp1 = 0 ;
31949 int res1 = 0 ;
31950 wxSize temp2 ;
31951 PyObject * obj0 = 0 ;
31952 PyObject * obj1 = 0 ;
31953 char * kwnames[] = {
31954 (char *) "self",(char *) "maxSize", NULL
31955 };
31956
31957 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetMaxSize",kwnames,&obj0,&obj1)) SWIG_fail;
31958 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31959 if (!SWIG_IsOK(res1)) {
31960 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetMaxSize" "', expected argument " "1"" of type '" "wxWindow *""'");
31961 }
31962 arg1 = reinterpret_cast< wxWindow * >(argp1);
31963 {
31964 arg2 = &temp2;
31965 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
31966 }
31967 {
31968 PyThreadState* __tstate = wxPyBeginAllowThreads();
31969 (arg1)->SetMaxSize((wxSize const &)*arg2);
31970 wxPyEndAllowThreads(__tstate);
31971 if (PyErr_Occurred()) SWIG_fail;
31972 }
31973 resultobj = SWIG_Py_Void();
31974 return resultobj;
31975 fail:
31976 return NULL;
31977 }
31978
31979
31980 SWIGINTERN PyObject *_wrap_Window_GetMinWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
31981 PyObject *resultobj = 0;
31982 wxWindow *arg1 = (wxWindow *) 0 ;
31983 int result;
31984 void *argp1 = 0 ;
31985 int res1 = 0 ;
31986 PyObject *swig_obj[1] ;
31987
31988 if (!args) SWIG_fail;
31989 swig_obj[0] = args;
31990 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
31991 if (!SWIG_IsOK(res1)) {
31992 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
31993 }
31994 arg1 = reinterpret_cast< wxWindow * >(argp1);
31995 {
31996 PyThreadState* __tstate = wxPyBeginAllowThreads();
31997 result = (int)((wxWindow const *)arg1)->GetMinWidth();
31998 wxPyEndAllowThreads(__tstate);
31999 if (PyErr_Occurred()) SWIG_fail;
32000 }
32001 resultobj = SWIG_From_int(static_cast< int >(result));
32002 return resultobj;
32003 fail:
32004 return NULL;
32005 }
32006
32007
32008 SWIGINTERN PyObject *_wrap_Window_GetMinHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32009 PyObject *resultobj = 0;
32010 wxWindow *arg1 = (wxWindow *) 0 ;
32011 int result;
32012 void *argp1 = 0 ;
32013 int res1 = 0 ;
32014 PyObject *swig_obj[1] ;
32015
32016 if (!args) SWIG_fail;
32017 swig_obj[0] = args;
32018 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32019 if (!SWIG_IsOK(res1)) {
32020 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMinHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32021 }
32022 arg1 = reinterpret_cast< wxWindow * >(argp1);
32023 {
32024 PyThreadState* __tstate = wxPyBeginAllowThreads();
32025 result = (int)((wxWindow const *)arg1)->GetMinHeight();
32026 wxPyEndAllowThreads(__tstate);
32027 if (PyErr_Occurred()) SWIG_fail;
32028 }
32029 resultobj = SWIG_From_int(static_cast< int >(result));
32030 return resultobj;
32031 fail:
32032 return NULL;
32033 }
32034
32035
32036 SWIGINTERN PyObject *_wrap_Window_GetMaxWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32037 PyObject *resultobj = 0;
32038 wxWindow *arg1 = (wxWindow *) 0 ;
32039 int result;
32040 void *argp1 = 0 ;
32041 int res1 = 0 ;
32042 PyObject *swig_obj[1] ;
32043
32044 if (!args) SWIG_fail;
32045 swig_obj[0] = args;
32046 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32047 if (!SWIG_IsOK(res1)) {
32048 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
32049 }
32050 arg1 = reinterpret_cast< wxWindow * >(argp1);
32051 {
32052 PyThreadState* __tstate = wxPyBeginAllowThreads();
32053 result = (int)((wxWindow const *)arg1)->GetMaxWidth();
32054 wxPyEndAllowThreads(__tstate);
32055 if (PyErr_Occurred()) SWIG_fail;
32056 }
32057 resultobj = SWIG_From_int(static_cast< int >(result));
32058 return resultobj;
32059 fail:
32060 return NULL;
32061 }
32062
32063
32064 SWIGINTERN PyObject *_wrap_Window_GetMaxHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32065 PyObject *resultobj = 0;
32066 wxWindow *arg1 = (wxWindow *) 0 ;
32067 int result;
32068 void *argp1 = 0 ;
32069 int res1 = 0 ;
32070 PyObject *swig_obj[1] ;
32071
32072 if (!args) SWIG_fail;
32073 swig_obj[0] = args;
32074 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32075 if (!SWIG_IsOK(res1)) {
32076 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetMaxHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
32077 }
32078 arg1 = reinterpret_cast< wxWindow * >(argp1);
32079 {
32080 PyThreadState* __tstate = wxPyBeginAllowThreads();
32081 result = (int)((wxWindow const *)arg1)->GetMaxHeight();
32082 wxPyEndAllowThreads(__tstate);
32083 if (PyErr_Occurred()) SWIG_fail;
32084 }
32085 resultobj = SWIG_From_int(static_cast< int >(result));
32086 return resultobj;
32087 fail:
32088 return NULL;
32089 }
32090
32091
32092 SWIGINTERN PyObject *_wrap_Window_SetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32093 PyObject *resultobj = 0;
32094 wxWindow *arg1 = (wxWindow *) 0 ;
32095 wxSize *arg2 = 0 ;
32096 void *argp1 = 0 ;
32097 int res1 = 0 ;
32098 wxSize temp2 ;
32099 PyObject * obj0 = 0 ;
32100 PyObject * obj1 = 0 ;
32101 char * kwnames[] = {
32102 (char *) "self",(char *) "size", NULL
32103 };
32104
32105 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetVirtualSize",kwnames,&obj0,&obj1)) SWIG_fail;
32106 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32107 if (!SWIG_IsOK(res1)) {
32108 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSize" "', expected argument " "1"" of type '" "wxWindow *""'");
32109 }
32110 arg1 = reinterpret_cast< wxWindow * >(argp1);
32111 {
32112 arg2 = &temp2;
32113 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
32114 }
32115 {
32116 PyThreadState* __tstate = wxPyBeginAllowThreads();
32117 (arg1)->SetVirtualSize((wxSize const &)*arg2);
32118 wxPyEndAllowThreads(__tstate);
32119 if (PyErr_Occurred()) SWIG_fail;
32120 }
32121 resultobj = SWIG_Py_Void();
32122 return resultobj;
32123 fail:
32124 return NULL;
32125 }
32126
32127
32128 SWIGINTERN PyObject *_wrap_Window_SetVirtualSizeWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32129 PyObject *resultobj = 0;
32130 wxWindow *arg1 = (wxWindow *) 0 ;
32131 int arg2 ;
32132 int arg3 ;
32133 void *argp1 = 0 ;
32134 int res1 = 0 ;
32135 int val2 ;
32136 int ecode2 = 0 ;
32137 int val3 ;
32138 int ecode3 = 0 ;
32139 PyObject * obj0 = 0 ;
32140 PyObject * obj1 = 0 ;
32141 PyObject * obj2 = 0 ;
32142 char * kwnames[] = {
32143 (char *) "self",(char *) "w",(char *) "h", NULL
32144 };
32145
32146 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_SetVirtualSizeWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
32147 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32148 if (!SWIG_IsOK(res1)) {
32149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "1"" of type '" "wxWindow *""'");
32150 }
32151 arg1 = reinterpret_cast< wxWindow * >(argp1);
32152 ecode2 = SWIG_AsVal_int(obj1, &val2);
32153 if (!SWIG_IsOK(ecode2)) {
32154 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "2"" of type '" "int""'");
32155 }
32156 arg2 = static_cast< int >(val2);
32157 ecode3 = SWIG_AsVal_int(obj2, &val3);
32158 if (!SWIG_IsOK(ecode3)) {
32159 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetVirtualSizeWH" "', expected argument " "3"" of type '" "int""'");
32160 }
32161 arg3 = static_cast< int >(val3);
32162 {
32163 PyThreadState* __tstate = wxPyBeginAllowThreads();
32164 (arg1)->SetVirtualSize(arg2,arg3);
32165 wxPyEndAllowThreads(__tstate);
32166 if (PyErr_Occurred()) SWIG_fail;
32167 }
32168 resultobj = SWIG_Py_Void();
32169 return resultobj;
32170 fail:
32171 return NULL;
32172 }
32173
32174
32175 SWIGINTERN PyObject *_wrap_Window_GetVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32176 PyObject *resultobj = 0;
32177 wxWindow *arg1 = (wxWindow *) 0 ;
32178 wxSize result;
32179 void *argp1 = 0 ;
32180 int res1 = 0 ;
32181 PyObject *swig_obj[1] ;
32182
32183 if (!args) SWIG_fail;
32184 swig_obj[0] = args;
32185 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32186 if (!SWIG_IsOK(res1)) {
32187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32188 }
32189 arg1 = reinterpret_cast< wxWindow * >(argp1);
32190 {
32191 PyThreadState* __tstate = wxPyBeginAllowThreads();
32192 result = ((wxWindow const *)arg1)->GetVirtualSize();
32193 wxPyEndAllowThreads(__tstate);
32194 if (PyErr_Occurred()) SWIG_fail;
32195 }
32196 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32197 return resultobj;
32198 fail:
32199 return NULL;
32200 }
32201
32202
32203 SWIGINTERN PyObject *_wrap_Window_GetVirtualSizeTuple(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32204 PyObject *resultobj = 0;
32205 wxWindow *arg1 = (wxWindow *) 0 ;
32206 int *arg2 = (int *) 0 ;
32207 int *arg3 = (int *) 0 ;
32208 void *argp1 = 0 ;
32209 int res1 = 0 ;
32210 int temp2 ;
32211 int res2 = SWIG_TMPOBJ ;
32212 int temp3 ;
32213 int res3 = SWIG_TMPOBJ ;
32214 PyObject *swig_obj[1] ;
32215
32216 arg2 = &temp2;
32217 arg3 = &temp3;
32218 if (!args) SWIG_fail;
32219 swig_obj[0] = args;
32220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32221 if (!SWIG_IsOK(res1)) {
32222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetVirtualSizeTuple" "', expected argument " "1"" of type '" "wxWindow const *""'");
32223 }
32224 arg1 = reinterpret_cast< wxWindow * >(argp1);
32225 {
32226 PyThreadState* __tstate = wxPyBeginAllowThreads();
32227 ((wxWindow const *)arg1)->GetVirtualSize(arg2,arg3);
32228 wxPyEndAllowThreads(__tstate);
32229 if (PyErr_Occurred()) SWIG_fail;
32230 }
32231 resultobj = SWIG_Py_Void();
32232 if (SWIG_IsTmpObj(res2)) {
32233 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
32234 } else {
32235 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32236 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
32237 }
32238 if (SWIG_IsTmpObj(res3)) {
32239 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
32240 } else {
32241 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
32242 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
32243 }
32244 return resultobj;
32245 fail:
32246 return NULL;
32247 }
32248
32249
32250 SWIGINTERN PyObject *_wrap_Window_GetBestVirtualSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32251 PyObject *resultobj = 0;
32252 wxWindow *arg1 = (wxWindow *) 0 ;
32253 wxSize result;
32254 void *argp1 = 0 ;
32255 int res1 = 0 ;
32256 PyObject *swig_obj[1] ;
32257
32258 if (!args) SWIG_fail;
32259 swig_obj[0] = args;
32260 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32261 if (!SWIG_IsOK(res1)) {
32262 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBestVirtualSize" "', expected argument " "1"" of type '" "wxWindow const *""'");
32263 }
32264 arg1 = reinterpret_cast< wxWindow * >(argp1);
32265 {
32266 PyThreadState* __tstate = wxPyBeginAllowThreads();
32267 result = ((wxWindow const *)arg1)->GetBestVirtualSize();
32268 wxPyEndAllowThreads(__tstate);
32269 if (PyErr_Occurred()) SWIG_fail;
32270 }
32271 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
32272 return resultobj;
32273 fail:
32274 return NULL;
32275 }
32276
32277
32278 SWIGINTERN PyObject *_wrap_Window_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32279 PyObject *resultobj = 0;
32280 wxWindow *arg1 = (wxWindow *) 0 ;
32281 bool arg2 = (bool) true ;
32282 bool result;
32283 void *argp1 = 0 ;
32284 int res1 = 0 ;
32285 bool val2 ;
32286 int ecode2 = 0 ;
32287 PyObject * obj0 = 0 ;
32288 PyObject * obj1 = 0 ;
32289 char * kwnames[] = {
32290 (char *) "self",(char *) "show", NULL
32291 };
32292
32293 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Show",kwnames,&obj0,&obj1)) SWIG_fail;
32294 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32295 if (!SWIG_IsOK(res1)) {
32296 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Show" "', expected argument " "1"" of type '" "wxWindow *""'");
32297 }
32298 arg1 = reinterpret_cast< wxWindow * >(argp1);
32299 if (obj1) {
32300 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32301 if (!SWIG_IsOK(ecode2)) {
32302 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Show" "', expected argument " "2"" of type '" "bool""'");
32303 }
32304 arg2 = static_cast< bool >(val2);
32305 }
32306 {
32307 PyThreadState* __tstate = wxPyBeginAllowThreads();
32308 result = (bool)(arg1)->Show(arg2);
32309 wxPyEndAllowThreads(__tstate);
32310 if (PyErr_Occurred()) SWIG_fail;
32311 }
32312 {
32313 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32314 }
32315 return resultobj;
32316 fail:
32317 return NULL;
32318 }
32319
32320
32321 SWIGINTERN PyObject *_wrap_Window_Hide(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32322 PyObject *resultobj = 0;
32323 wxWindow *arg1 = (wxWindow *) 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_wxWindow, 0 | 0 );
32332 if (!SWIG_IsOK(res1)) {
32333 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Hide" "', expected argument " "1"" of type '" "wxWindow *""'");
32334 }
32335 arg1 = reinterpret_cast< wxWindow * >(argp1);
32336 {
32337 PyThreadState* __tstate = wxPyBeginAllowThreads();
32338 result = (bool)(arg1)->Hide();
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_Window_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32352 PyObject *resultobj = 0;
32353 wxWindow *arg1 = (wxWindow *) 0 ;
32354 bool arg2 = (bool) true ;
32355 bool result;
32356 void *argp1 = 0 ;
32357 int res1 = 0 ;
32358 bool val2 ;
32359 int ecode2 = 0 ;
32360 PyObject * obj0 = 0 ;
32361 PyObject * obj1 = 0 ;
32362 char * kwnames[] = {
32363 (char *) "self",(char *) "enable", NULL
32364 };
32365
32366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
32367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32368 if (!SWIG_IsOK(res1)) {
32369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Enable" "', expected argument " "1"" of type '" "wxWindow *""'");
32370 }
32371 arg1 = reinterpret_cast< wxWindow * >(argp1);
32372 if (obj1) {
32373 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32374 if (!SWIG_IsOK(ecode2)) {
32375 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Enable" "', expected argument " "2"" of type '" "bool""'");
32376 }
32377 arg2 = static_cast< bool >(val2);
32378 }
32379 {
32380 PyThreadState* __tstate = wxPyBeginAllowThreads();
32381 result = (bool)(arg1)->Enable(arg2);
32382 wxPyEndAllowThreads(__tstate);
32383 if (PyErr_Occurred()) SWIG_fail;
32384 }
32385 {
32386 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32387 }
32388 return resultobj;
32389 fail:
32390 return NULL;
32391 }
32392
32393
32394 SWIGINTERN PyObject *_wrap_Window_Disable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32395 PyObject *resultobj = 0;
32396 wxWindow *arg1 = (wxWindow *) 0 ;
32397 bool result;
32398 void *argp1 = 0 ;
32399 int res1 = 0 ;
32400 PyObject *swig_obj[1] ;
32401
32402 if (!args) SWIG_fail;
32403 swig_obj[0] = args;
32404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32405 if (!SWIG_IsOK(res1)) {
32406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Disable" "', expected argument " "1"" of type '" "wxWindow *""'");
32407 }
32408 arg1 = reinterpret_cast< wxWindow * >(argp1);
32409 {
32410 PyThreadState* __tstate = wxPyBeginAllowThreads();
32411 result = (bool)(arg1)->Disable();
32412 wxPyEndAllowThreads(__tstate);
32413 if (PyErr_Occurred()) SWIG_fail;
32414 }
32415 {
32416 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32417 }
32418 return resultobj;
32419 fail:
32420 return NULL;
32421 }
32422
32423
32424 SWIGINTERN PyObject *_wrap_Window_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32425 PyObject *resultobj = 0;
32426 wxWindow *arg1 = (wxWindow *) 0 ;
32427 bool result;
32428 void *argp1 = 0 ;
32429 int res1 = 0 ;
32430 PyObject *swig_obj[1] ;
32431
32432 if (!args) SWIG_fail;
32433 swig_obj[0] = args;
32434 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32435 if (!SWIG_IsOK(res1)) {
32436 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsShown" "', expected argument " "1"" of type '" "wxWindow const *""'");
32437 }
32438 arg1 = reinterpret_cast< wxWindow * >(argp1);
32439 {
32440 PyThreadState* __tstate = wxPyBeginAllowThreads();
32441 result = (bool)((wxWindow const *)arg1)->IsShown();
32442 wxPyEndAllowThreads(__tstate);
32443 if (PyErr_Occurred()) SWIG_fail;
32444 }
32445 {
32446 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32447 }
32448 return resultobj;
32449 fail:
32450 return NULL;
32451 }
32452
32453
32454 SWIGINTERN PyObject *_wrap_Window_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32455 PyObject *resultobj = 0;
32456 wxWindow *arg1 = (wxWindow *) 0 ;
32457 bool result;
32458 void *argp1 = 0 ;
32459 int res1 = 0 ;
32460 PyObject *swig_obj[1] ;
32461
32462 if (!args) SWIG_fail;
32463 swig_obj[0] = args;
32464 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32465 if (!SWIG_IsOK(res1)) {
32466 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32467 }
32468 arg1 = reinterpret_cast< wxWindow * >(argp1);
32469 {
32470 PyThreadState* __tstate = wxPyBeginAllowThreads();
32471 result = (bool)((wxWindow const *)arg1)->IsEnabled();
32472 wxPyEndAllowThreads(__tstate);
32473 if (PyErr_Occurred()) SWIG_fail;
32474 }
32475 {
32476 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32477 }
32478 return resultobj;
32479 fail:
32480 return NULL;
32481 }
32482
32483
32484 SWIGINTERN PyObject *_wrap_Window_SetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32485 PyObject *resultobj = 0;
32486 wxWindow *arg1 = (wxWindow *) 0 ;
32487 long arg2 ;
32488 void *argp1 = 0 ;
32489 int res1 = 0 ;
32490 long val2 ;
32491 int ecode2 = 0 ;
32492 PyObject * obj0 = 0 ;
32493 PyObject * obj1 = 0 ;
32494 char * kwnames[] = {
32495 (char *) "self",(char *) "style", NULL
32496 };
32497
32498 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetWindowStyleFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32499 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32500 if (!SWIG_IsOK(res1)) {
32501 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow *""'");
32502 }
32503 arg1 = reinterpret_cast< wxWindow * >(argp1);
32504 ecode2 = SWIG_AsVal_long(obj1, &val2);
32505 if (!SWIG_IsOK(ecode2)) {
32506 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetWindowStyleFlag" "', expected argument " "2"" of type '" "long""'");
32507 }
32508 arg2 = static_cast< long >(val2);
32509 {
32510 PyThreadState* __tstate = wxPyBeginAllowThreads();
32511 (arg1)->SetWindowStyleFlag(arg2);
32512 wxPyEndAllowThreads(__tstate);
32513 if (PyErr_Occurred()) SWIG_fail;
32514 }
32515 resultobj = SWIG_Py_Void();
32516 return resultobj;
32517 fail:
32518 return NULL;
32519 }
32520
32521
32522 SWIGINTERN PyObject *_wrap_Window_GetWindowStyleFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32523 PyObject *resultobj = 0;
32524 wxWindow *arg1 = (wxWindow *) 0 ;
32525 long result;
32526 void *argp1 = 0 ;
32527 int res1 = 0 ;
32528 PyObject *swig_obj[1] ;
32529
32530 if (!args) SWIG_fail;
32531 swig_obj[0] = args;
32532 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32533 if (!SWIG_IsOK(res1)) {
32534 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetWindowStyleFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32535 }
32536 arg1 = reinterpret_cast< wxWindow * >(argp1);
32537 {
32538 PyThreadState* __tstate = wxPyBeginAllowThreads();
32539 result = (long)((wxWindow const *)arg1)->GetWindowStyleFlag();
32540 wxPyEndAllowThreads(__tstate);
32541 if (PyErr_Occurred()) SWIG_fail;
32542 }
32543 resultobj = SWIG_From_long(static_cast< long >(result));
32544 return resultobj;
32545 fail:
32546 return NULL;
32547 }
32548
32549
32550 SWIGINTERN PyObject *_wrap_Window_HasFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32551 PyObject *resultobj = 0;
32552 wxWindow *arg1 = (wxWindow *) 0 ;
32553 int arg2 ;
32554 bool result;
32555 void *argp1 = 0 ;
32556 int res1 = 0 ;
32557 int val2 ;
32558 int ecode2 = 0 ;
32559 PyObject * obj0 = 0 ;
32560 PyObject * obj1 = 0 ;
32561 char * kwnames[] = {
32562 (char *) "self",(char *) "flag", NULL
32563 };
32564
32565 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasFlag",kwnames,&obj0,&obj1)) SWIG_fail;
32566 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32567 if (!SWIG_IsOK(res1)) {
32568 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasFlag" "', expected argument " "1"" of type '" "wxWindow const *""'");
32569 }
32570 arg1 = reinterpret_cast< wxWindow * >(argp1);
32571 ecode2 = SWIG_AsVal_int(obj1, &val2);
32572 if (!SWIG_IsOK(ecode2)) {
32573 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasFlag" "', expected argument " "2"" of type '" "int""'");
32574 }
32575 arg2 = static_cast< int >(val2);
32576 {
32577 PyThreadState* __tstate = wxPyBeginAllowThreads();
32578 result = (bool)((wxWindow const *)arg1)->HasFlag(arg2);
32579 wxPyEndAllowThreads(__tstate);
32580 if (PyErr_Occurred()) SWIG_fail;
32581 }
32582 {
32583 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32584 }
32585 return resultobj;
32586 fail:
32587 return NULL;
32588 }
32589
32590
32591 SWIGINTERN PyObject *_wrap_Window_IsRetained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32592 PyObject *resultobj = 0;
32593 wxWindow *arg1 = (wxWindow *) 0 ;
32594 bool result;
32595 void *argp1 = 0 ;
32596 int res1 = 0 ;
32597 PyObject *swig_obj[1] ;
32598
32599 if (!args) SWIG_fail;
32600 swig_obj[0] = args;
32601 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32602 if (!SWIG_IsOK(res1)) {
32603 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsRetained" "', expected argument " "1"" of type '" "wxWindow const *""'");
32604 }
32605 arg1 = reinterpret_cast< wxWindow * >(argp1);
32606 {
32607 PyThreadState* __tstate = wxPyBeginAllowThreads();
32608 result = (bool)((wxWindow const *)arg1)->IsRetained();
32609 wxPyEndAllowThreads(__tstate);
32610 if (PyErr_Occurred()) SWIG_fail;
32611 }
32612 {
32613 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32614 }
32615 return resultobj;
32616 fail:
32617 return NULL;
32618 }
32619
32620
32621 SWIGINTERN PyObject *_wrap_Window_SetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32622 PyObject *resultobj = 0;
32623 wxWindow *arg1 = (wxWindow *) 0 ;
32624 long arg2 ;
32625 void *argp1 = 0 ;
32626 int res1 = 0 ;
32627 long val2 ;
32628 int ecode2 = 0 ;
32629 PyObject * obj0 = 0 ;
32630 PyObject * obj1 = 0 ;
32631 char * kwnames[] = {
32632 (char *) "self",(char *) "exStyle", NULL
32633 };
32634
32635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetExtraStyle",kwnames,&obj0,&obj1)) SWIG_fail;
32636 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32637 if (!SWIG_IsOK(res1)) {
32638 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetExtraStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
32639 }
32640 arg1 = reinterpret_cast< wxWindow * >(argp1);
32641 ecode2 = SWIG_AsVal_long(obj1, &val2);
32642 if (!SWIG_IsOK(ecode2)) {
32643 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetExtraStyle" "', expected argument " "2"" of type '" "long""'");
32644 }
32645 arg2 = static_cast< long >(val2);
32646 {
32647 PyThreadState* __tstate = wxPyBeginAllowThreads();
32648 (arg1)->SetExtraStyle(arg2);
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_Window_GetExtraStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32660 PyObject *resultobj = 0;
32661 wxWindow *arg1 = (wxWindow *) 0 ;
32662 long result;
32663 void *argp1 = 0 ;
32664 int res1 = 0 ;
32665 PyObject *swig_obj[1] ;
32666
32667 if (!args) SWIG_fail;
32668 swig_obj[0] = args;
32669 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32670 if (!SWIG_IsOK(res1)) {
32671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetExtraStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
32672 }
32673 arg1 = reinterpret_cast< wxWindow * >(argp1);
32674 {
32675 PyThreadState* __tstate = wxPyBeginAllowThreads();
32676 result = (long)((wxWindow const *)arg1)->GetExtraStyle();
32677 wxPyEndAllowThreads(__tstate);
32678 if (PyErr_Occurred()) SWIG_fail;
32679 }
32680 resultobj = SWIG_From_long(static_cast< long >(result));
32681 return resultobj;
32682 fail:
32683 return NULL;
32684 }
32685
32686
32687 SWIGINTERN PyObject *_wrap_Window_MakeModal(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32688 PyObject *resultobj = 0;
32689 wxWindow *arg1 = (wxWindow *) 0 ;
32690 bool arg2 = (bool) true ;
32691 void *argp1 = 0 ;
32692 int res1 = 0 ;
32693 bool val2 ;
32694 int ecode2 = 0 ;
32695 PyObject * obj0 = 0 ;
32696 PyObject * obj1 = 0 ;
32697 char * kwnames[] = {
32698 (char *) "self",(char *) "modal", NULL
32699 };
32700
32701 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_MakeModal",kwnames,&obj0,&obj1)) SWIG_fail;
32702 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32703 if (!SWIG_IsOK(res1)) {
32704 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MakeModal" "', expected argument " "1"" of type '" "wxWindow *""'");
32705 }
32706 arg1 = reinterpret_cast< wxWindow * >(argp1);
32707 if (obj1) {
32708 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32709 if (!SWIG_IsOK(ecode2)) {
32710 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_MakeModal" "', expected argument " "2"" of type '" "bool""'");
32711 }
32712 arg2 = static_cast< bool >(val2);
32713 }
32714 {
32715 PyThreadState* __tstate = wxPyBeginAllowThreads();
32716 (arg1)->MakeModal(arg2);
32717 wxPyEndAllowThreads(__tstate);
32718 if (PyErr_Occurred()) SWIG_fail;
32719 }
32720 resultobj = SWIG_Py_Void();
32721 return resultobj;
32722 fail:
32723 return NULL;
32724 }
32725
32726
32727 SWIGINTERN PyObject *_wrap_Window_SetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32728 PyObject *resultobj = 0;
32729 wxWindow *arg1 = (wxWindow *) 0 ;
32730 bool arg2 ;
32731 void *argp1 = 0 ;
32732 int res1 = 0 ;
32733 bool val2 ;
32734 int ecode2 = 0 ;
32735 PyObject * obj0 = 0 ;
32736 PyObject * obj1 = 0 ;
32737 char * kwnames[] = {
32738 (char *) "self",(char *) "enableTheme", NULL
32739 };
32740
32741 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetThemeEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
32742 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32743 if (!SWIG_IsOK(res1)) {
32744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow *""'");
32745 }
32746 arg1 = reinterpret_cast< wxWindow * >(argp1);
32747 ecode2 = SWIG_AsVal_bool(obj1, &val2);
32748 if (!SWIG_IsOK(ecode2)) {
32749 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetThemeEnabled" "', expected argument " "2"" of type '" "bool""'");
32750 }
32751 arg2 = static_cast< bool >(val2);
32752 {
32753 PyThreadState* __tstate = wxPyBeginAllowThreads();
32754 (arg1)->SetThemeEnabled(arg2);
32755 wxPyEndAllowThreads(__tstate);
32756 if (PyErr_Occurred()) SWIG_fail;
32757 }
32758 resultobj = SWIG_Py_Void();
32759 return resultobj;
32760 fail:
32761 return NULL;
32762 }
32763
32764
32765 SWIGINTERN PyObject *_wrap_Window_GetThemeEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32766 PyObject *resultobj = 0;
32767 wxWindow *arg1 = (wxWindow *) 0 ;
32768 bool result;
32769 void *argp1 = 0 ;
32770 int res1 = 0 ;
32771 PyObject *swig_obj[1] ;
32772
32773 if (!args) SWIG_fail;
32774 swig_obj[0] = args;
32775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32776 if (!SWIG_IsOK(res1)) {
32777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetThemeEnabled" "', expected argument " "1"" of type '" "wxWindow const *""'");
32778 }
32779 arg1 = reinterpret_cast< wxWindow * >(argp1);
32780 {
32781 PyThreadState* __tstate = wxPyBeginAllowThreads();
32782 result = (bool)((wxWindow const *)arg1)->GetThemeEnabled();
32783 wxPyEndAllowThreads(__tstate);
32784 if (PyErr_Occurred()) SWIG_fail;
32785 }
32786 {
32787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32788 }
32789 return resultobj;
32790 fail:
32791 return NULL;
32792 }
32793
32794
32795 SWIGINTERN PyObject *_wrap_Window_SetFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32796 PyObject *resultobj = 0;
32797 wxWindow *arg1 = (wxWindow *) 0 ;
32798 void *argp1 = 0 ;
32799 int res1 = 0 ;
32800 PyObject *swig_obj[1] ;
32801
32802 if (!args) SWIG_fail;
32803 swig_obj[0] = args;
32804 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32805 if (!SWIG_IsOK(res1)) {
32806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocus" "', expected argument " "1"" of type '" "wxWindow *""'");
32807 }
32808 arg1 = reinterpret_cast< wxWindow * >(argp1);
32809 {
32810 PyThreadState* __tstate = wxPyBeginAllowThreads();
32811 (arg1)->SetFocus();
32812 wxPyEndAllowThreads(__tstate);
32813 if (PyErr_Occurred()) SWIG_fail;
32814 }
32815 resultobj = SWIG_Py_Void();
32816 return resultobj;
32817 fail:
32818 return NULL;
32819 }
32820
32821
32822 SWIGINTERN PyObject *_wrap_Window_SetFocusFromKbd(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32823 PyObject *resultobj = 0;
32824 wxWindow *arg1 = (wxWindow *) 0 ;
32825 void *argp1 = 0 ;
32826 int res1 = 0 ;
32827 PyObject *swig_obj[1] ;
32828
32829 if (!args) SWIG_fail;
32830 swig_obj[0] = args;
32831 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32832 if (!SWIG_IsOK(res1)) {
32833 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFocusFromKbd" "', expected argument " "1"" of type '" "wxWindow *""'");
32834 }
32835 arg1 = reinterpret_cast< wxWindow * >(argp1);
32836 {
32837 PyThreadState* __tstate = wxPyBeginAllowThreads();
32838 (arg1)->SetFocusFromKbd();
32839 wxPyEndAllowThreads(__tstate);
32840 if (PyErr_Occurred()) SWIG_fail;
32841 }
32842 resultobj = SWIG_Py_Void();
32843 return resultobj;
32844 fail:
32845 return NULL;
32846 }
32847
32848
32849 SWIGINTERN PyObject *_wrap_Window_FindFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32850 PyObject *resultobj = 0;
32851 wxWindow *result = 0 ;
32852
32853 if (!SWIG_Python_UnpackTuple(args,"Window_FindFocus",0,0,0)) SWIG_fail;
32854 {
32855 if (!wxPyCheckForApp()) SWIG_fail;
32856 PyThreadState* __tstate = wxPyBeginAllowThreads();
32857 result = (wxWindow *)wxWindow::FindFocus();
32858 wxPyEndAllowThreads(__tstate);
32859 if (PyErr_Occurred()) SWIG_fail;
32860 }
32861 {
32862 resultobj = wxPyMake_wxObject(result, 0);
32863 }
32864 return resultobj;
32865 fail:
32866 return NULL;
32867 }
32868
32869
32870 SWIGINTERN PyObject *_wrap_Window_AcceptsFocus(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32871 PyObject *resultobj = 0;
32872 wxWindow *arg1 = (wxWindow *) 0 ;
32873 bool result;
32874 void *argp1 = 0 ;
32875 int res1 = 0 ;
32876 PyObject *swig_obj[1] ;
32877
32878 if (!args) SWIG_fail;
32879 swig_obj[0] = args;
32880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32881 if (!SWIG_IsOK(res1)) {
32882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocus" "', expected argument " "1"" of type '" "wxWindow const *""'");
32883 }
32884 arg1 = reinterpret_cast< wxWindow * >(argp1);
32885 {
32886 PyThreadState* __tstate = wxPyBeginAllowThreads();
32887 result = (bool)((wxWindow const *)arg1)->AcceptsFocus();
32888 wxPyEndAllowThreads(__tstate);
32889 if (PyErr_Occurred()) SWIG_fail;
32890 }
32891 {
32892 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32893 }
32894 return resultobj;
32895 fail:
32896 return NULL;
32897 }
32898
32899
32900 SWIGINTERN PyObject *_wrap_Window_AcceptsFocusFromKeyboard(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
32901 PyObject *resultobj = 0;
32902 wxWindow *arg1 = (wxWindow *) 0 ;
32903 bool result;
32904 void *argp1 = 0 ;
32905 int res1 = 0 ;
32906 PyObject *swig_obj[1] ;
32907
32908 if (!args) SWIG_fail;
32909 swig_obj[0] = args;
32910 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32911 if (!SWIG_IsOK(res1)) {
32912 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AcceptsFocusFromKeyboard" "', expected argument " "1"" of type '" "wxWindow const *""'");
32913 }
32914 arg1 = reinterpret_cast< wxWindow * >(argp1);
32915 {
32916 PyThreadState* __tstate = wxPyBeginAllowThreads();
32917 result = (bool)((wxWindow const *)arg1)->AcceptsFocusFromKeyboard();
32918 wxPyEndAllowThreads(__tstate);
32919 if (PyErr_Occurred()) SWIG_fail;
32920 }
32921 {
32922 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32923 }
32924 return resultobj;
32925 fail:
32926 return NULL;
32927 }
32928
32929
32930 SWIGINTERN PyObject *_wrap_Window_Navigate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32931 PyObject *resultobj = 0;
32932 wxWindow *arg1 = (wxWindow *) 0 ;
32933 int arg2 = (int) wxNavigationKeyEvent::IsForward ;
32934 bool result;
32935 void *argp1 = 0 ;
32936 int res1 = 0 ;
32937 int val2 ;
32938 int ecode2 = 0 ;
32939 PyObject * obj0 = 0 ;
32940 PyObject * obj1 = 0 ;
32941 char * kwnames[] = {
32942 (char *) "self",(char *) "flags", NULL
32943 };
32944
32945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_Navigate",kwnames,&obj0,&obj1)) SWIG_fail;
32946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32947 if (!SWIG_IsOK(res1)) {
32948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Navigate" "', expected argument " "1"" of type '" "wxWindow *""'");
32949 }
32950 arg1 = reinterpret_cast< wxWindow * >(argp1);
32951 if (obj1) {
32952 ecode2 = SWIG_AsVal_int(obj1, &val2);
32953 if (!SWIG_IsOK(ecode2)) {
32954 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Navigate" "', expected argument " "2"" of type '" "int""'");
32955 }
32956 arg2 = static_cast< int >(val2);
32957 }
32958 {
32959 PyThreadState* __tstate = wxPyBeginAllowThreads();
32960 result = (bool)(arg1)->Navigate(arg2);
32961 wxPyEndAllowThreads(__tstate);
32962 if (PyErr_Occurred()) SWIG_fail;
32963 }
32964 {
32965 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
32966 }
32967 return resultobj;
32968 fail:
32969 return NULL;
32970 }
32971
32972
32973 SWIGINTERN PyObject *_wrap_Window_MoveAfterInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
32974 PyObject *resultobj = 0;
32975 wxWindow *arg1 = (wxWindow *) 0 ;
32976 wxWindow *arg2 = (wxWindow *) 0 ;
32977 void *argp1 = 0 ;
32978 int res1 = 0 ;
32979 void *argp2 = 0 ;
32980 int res2 = 0 ;
32981 PyObject * obj0 = 0 ;
32982 PyObject * obj1 = 0 ;
32983 char * kwnames[] = {
32984 (char *) "self",(char *) "win", NULL
32985 };
32986
32987 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveAfterInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
32988 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
32989 if (!SWIG_IsOK(res1)) {
32990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
32991 }
32992 arg1 = reinterpret_cast< wxWindow * >(argp1);
32993 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
32994 if (!SWIG_IsOK(res2)) {
32995 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveAfterInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
32996 }
32997 arg2 = reinterpret_cast< wxWindow * >(argp2);
32998 {
32999 PyThreadState* __tstate = wxPyBeginAllowThreads();
33000 (arg1)->MoveAfterInTabOrder(arg2);
33001 wxPyEndAllowThreads(__tstate);
33002 if (PyErr_Occurred()) SWIG_fail;
33003 }
33004 resultobj = SWIG_Py_Void();
33005 return resultobj;
33006 fail:
33007 return NULL;
33008 }
33009
33010
33011 SWIGINTERN PyObject *_wrap_Window_MoveBeforeInTabOrder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33012 PyObject *resultobj = 0;
33013 wxWindow *arg1 = (wxWindow *) 0 ;
33014 wxWindow *arg2 = (wxWindow *) 0 ;
33015 void *argp1 = 0 ;
33016 int res1 = 0 ;
33017 void *argp2 = 0 ;
33018 int res2 = 0 ;
33019 PyObject * obj0 = 0 ;
33020 PyObject * obj1 = 0 ;
33021 char * kwnames[] = {
33022 (char *) "self",(char *) "win", NULL
33023 };
33024
33025 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_MoveBeforeInTabOrder",kwnames,&obj0,&obj1)) SWIG_fail;
33026 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33027 if (!SWIG_IsOK(res1)) {
33028 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "1"" of type '" "wxWindow *""'");
33029 }
33030 arg1 = reinterpret_cast< wxWindow * >(argp1);
33031 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33032 if (!SWIG_IsOK(res2)) {
33033 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_MoveBeforeInTabOrder" "', expected argument " "2"" of type '" "wxWindow *""'");
33034 }
33035 arg2 = reinterpret_cast< wxWindow * >(argp2);
33036 {
33037 PyThreadState* __tstate = wxPyBeginAllowThreads();
33038 (arg1)->MoveBeforeInTabOrder(arg2);
33039 wxPyEndAllowThreads(__tstate);
33040 if (PyErr_Occurred()) SWIG_fail;
33041 }
33042 resultobj = SWIG_Py_Void();
33043 return resultobj;
33044 fail:
33045 return NULL;
33046 }
33047
33048
33049 SWIGINTERN PyObject *_wrap_Window_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33050 PyObject *resultobj = 0;
33051 wxWindow *arg1 = (wxWindow *) 0 ;
33052 PyObject *result = 0 ;
33053 void *argp1 = 0 ;
33054 int res1 = 0 ;
33055 PyObject *swig_obj[1] ;
33056
33057 if (!args) SWIG_fail;
33058 swig_obj[0] = args;
33059 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33060 if (!SWIG_IsOK(res1)) {
33061 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetChildren" "', expected argument " "1"" of type '" "wxWindow *""'");
33062 }
33063 arg1 = reinterpret_cast< wxWindow * >(argp1);
33064 {
33065 PyThreadState* __tstate = wxPyBeginAllowThreads();
33066 result = (PyObject *)wxWindow_GetChildren(arg1);
33067 wxPyEndAllowThreads(__tstate);
33068 if (PyErr_Occurred()) SWIG_fail;
33069 }
33070 resultobj = result;
33071 return resultobj;
33072 fail:
33073 return NULL;
33074 }
33075
33076
33077 SWIGINTERN PyObject *_wrap_Window_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33078 PyObject *resultobj = 0;
33079 wxWindow *arg1 = (wxWindow *) 0 ;
33080 wxWindow *result = 0 ;
33081 void *argp1 = 0 ;
33082 int res1 = 0 ;
33083 PyObject *swig_obj[1] ;
33084
33085 if (!args) SWIG_fail;
33086 swig_obj[0] = args;
33087 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33088 if (!SWIG_IsOK(res1)) {
33089 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33090 }
33091 arg1 = reinterpret_cast< wxWindow * >(argp1);
33092 {
33093 PyThreadState* __tstate = wxPyBeginAllowThreads();
33094 result = (wxWindow *)((wxWindow const *)arg1)->GetParent();
33095 wxPyEndAllowThreads(__tstate);
33096 if (PyErr_Occurred()) SWIG_fail;
33097 }
33098 {
33099 resultobj = wxPyMake_wxObject(result, 0);
33100 }
33101 return resultobj;
33102 fail:
33103 return NULL;
33104 }
33105
33106
33107 SWIGINTERN PyObject *_wrap_Window_GetGrandParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33108 PyObject *resultobj = 0;
33109 wxWindow *arg1 = (wxWindow *) 0 ;
33110 wxWindow *result = 0 ;
33111 void *argp1 = 0 ;
33112 int res1 = 0 ;
33113 PyObject *swig_obj[1] ;
33114
33115 if (!args) SWIG_fail;
33116 swig_obj[0] = args;
33117 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33118 if (!SWIG_IsOK(res1)) {
33119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetGrandParent" "', expected argument " "1"" of type '" "wxWindow const *""'");
33120 }
33121 arg1 = reinterpret_cast< wxWindow * >(argp1);
33122 {
33123 PyThreadState* __tstate = wxPyBeginAllowThreads();
33124 result = (wxWindow *)((wxWindow const *)arg1)->GetGrandParent();
33125 wxPyEndAllowThreads(__tstate);
33126 if (PyErr_Occurred()) SWIG_fail;
33127 }
33128 {
33129 resultobj = wxPyMake_wxObject(result, 0);
33130 }
33131 return resultobj;
33132 fail:
33133 return NULL;
33134 }
33135
33136
33137 SWIGINTERN PyObject *_wrap_Window_IsTopLevel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33138 PyObject *resultobj = 0;
33139 wxWindow *arg1 = (wxWindow *) 0 ;
33140 bool result;
33141 void *argp1 = 0 ;
33142 int res1 = 0 ;
33143 PyObject *swig_obj[1] ;
33144
33145 if (!args) SWIG_fail;
33146 swig_obj[0] = args;
33147 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33148 if (!SWIG_IsOK(res1)) {
33149 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsTopLevel" "', expected argument " "1"" of type '" "wxWindow const *""'");
33150 }
33151 arg1 = reinterpret_cast< wxWindow * >(argp1);
33152 {
33153 PyThreadState* __tstate = wxPyBeginAllowThreads();
33154 result = (bool)((wxWindow const *)arg1)->IsTopLevel();
33155 wxPyEndAllowThreads(__tstate);
33156 if (PyErr_Occurred()) SWIG_fail;
33157 }
33158 {
33159 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33160 }
33161 return resultobj;
33162 fail:
33163 return NULL;
33164 }
33165
33166
33167 SWIGINTERN PyObject *_wrap_Window_Reparent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33168 PyObject *resultobj = 0;
33169 wxWindow *arg1 = (wxWindow *) 0 ;
33170 wxWindow *arg2 = (wxWindow *) 0 ;
33171 bool result;
33172 void *argp1 = 0 ;
33173 int res1 = 0 ;
33174 void *argp2 = 0 ;
33175 int res2 = 0 ;
33176 PyObject * obj0 = 0 ;
33177 PyObject * obj1 = 0 ;
33178 char * kwnames[] = {
33179 (char *) "self",(char *) "newParent", NULL
33180 };
33181
33182 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_Reparent",kwnames,&obj0,&obj1)) SWIG_fail;
33183 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33184 if (!SWIG_IsOK(res1)) {
33185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Reparent" "', expected argument " "1"" of type '" "wxWindow *""'");
33186 }
33187 arg1 = reinterpret_cast< wxWindow * >(argp1);
33188 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33189 if (!SWIG_IsOK(res2)) {
33190 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_Reparent" "', expected argument " "2"" of type '" "wxWindow *""'");
33191 }
33192 arg2 = reinterpret_cast< wxWindow * >(argp2);
33193 {
33194 PyThreadState* __tstate = wxPyBeginAllowThreads();
33195 result = (bool)(arg1)->Reparent(arg2);
33196 wxPyEndAllowThreads(__tstate);
33197 if (PyErr_Occurred()) SWIG_fail;
33198 }
33199 {
33200 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33201 }
33202 return resultobj;
33203 fail:
33204 return NULL;
33205 }
33206
33207
33208 SWIGINTERN PyObject *_wrap_Window_AddChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33209 PyObject *resultobj = 0;
33210 wxWindow *arg1 = (wxWindow *) 0 ;
33211 wxWindow *arg2 = (wxWindow *) 0 ;
33212 void *argp1 = 0 ;
33213 int res1 = 0 ;
33214 void *argp2 = 0 ;
33215 int res2 = 0 ;
33216 PyObject * obj0 = 0 ;
33217 PyObject * obj1 = 0 ;
33218 char * kwnames[] = {
33219 (char *) "self",(char *) "child", NULL
33220 };
33221
33222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AddChild",kwnames,&obj0,&obj1)) SWIG_fail;
33223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33224 if (!SWIG_IsOK(res1)) {
33225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AddChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33226 }
33227 arg1 = reinterpret_cast< wxWindow * >(argp1);
33228 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33229 if (!SWIG_IsOK(res2)) {
33230 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_AddChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33231 }
33232 arg2 = reinterpret_cast< wxWindow * >(argp2);
33233 {
33234 PyThreadState* __tstate = wxPyBeginAllowThreads();
33235 (arg1)->AddChild(arg2);
33236 wxPyEndAllowThreads(__tstate);
33237 if (PyErr_Occurred()) SWIG_fail;
33238 }
33239 resultobj = SWIG_Py_Void();
33240 return resultobj;
33241 fail:
33242 return NULL;
33243 }
33244
33245
33246 SWIGINTERN PyObject *_wrap_Window_RemoveChild(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33247 PyObject *resultobj = 0;
33248 wxWindow *arg1 = (wxWindow *) 0 ;
33249 wxWindow *arg2 = (wxWindow *) 0 ;
33250 void *argp1 = 0 ;
33251 int res1 = 0 ;
33252 void *argp2 = 0 ;
33253 int res2 = 0 ;
33254 PyObject * obj0 = 0 ;
33255 PyObject * obj1 = 0 ;
33256 char * kwnames[] = {
33257 (char *) "self",(char *) "child", NULL
33258 };
33259
33260 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveChild",kwnames,&obj0,&obj1)) SWIG_fail;
33261 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33262 if (!SWIG_IsOK(res1)) {
33263 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveChild" "', expected argument " "1"" of type '" "wxWindow *""'");
33264 }
33265 arg1 = reinterpret_cast< wxWindow * >(argp1);
33266 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
33267 if (!SWIG_IsOK(res2)) {
33268 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveChild" "', expected argument " "2"" of type '" "wxWindow *""'");
33269 }
33270 arg2 = reinterpret_cast< wxWindow * >(argp2);
33271 {
33272 PyThreadState* __tstate = wxPyBeginAllowThreads();
33273 (arg1)->RemoveChild(arg2);
33274 wxPyEndAllowThreads(__tstate);
33275 if (PyErr_Occurred()) SWIG_fail;
33276 }
33277 resultobj = SWIG_Py_Void();
33278 return resultobj;
33279 fail:
33280 return NULL;
33281 }
33282
33283
33284 SWIGINTERN PyObject *_wrap_Window_SetDoubleBuffered(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33285 PyObject *resultobj = 0;
33286 wxWindow *arg1 = (wxWindow *) 0 ;
33287 bool arg2 ;
33288 void *argp1 = 0 ;
33289 int res1 = 0 ;
33290 bool val2 ;
33291 int ecode2 = 0 ;
33292 PyObject * obj0 = 0 ;
33293 PyObject * obj1 = 0 ;
33294 char * kwnames[] = {
33295 (char *) "self",(char *) "on", NULL
33296 };
33297
33298 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDoubleBuffered",kwnames,&obj0,&obj1)) SWIG_fail;
33299 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33300 if (!SWIG_IsOK(res1)) {
33301 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDoubleBuffered" "', expected argument " "1"" of type '" "wxWindow *""'");
33302 }
33303 arg1 = reinterpret_cast< wxWindow * >(argp1);
33304 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33305 if (!SWIG_IsOK(ecode2)) {
33306 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetDoubleBuffered" "', expected argument " "2"" of type '" "bool""'");
33307 }
33308 arg2 = static_cast< bool >(val2);
33309 {
33310 PyThreadState* __tstate = wxPyBeginAllowThreads();
33311 wxWindow_SetDoubleBuffered(arg1,arg2);
33312 wxPyEndAllowThreads(__tstate);
33313 if (PyErr_Occurred()) SWIG_fail;
33314 }
33315 resultobj = SWIG_Py_Void();
33316 return resultobj;
33317 fail:
33318 return NULL;
33319 }
33320
33321
33322 SWIGINTERN PyObject *_wrap_Window_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33323 PyObject *resultobj = 0;
33324 wxWindow *arg1 = (wxWindow *) 0 ;
33325 long arg2 ;
33326 wxWindow *result = 0 ;
33327 void *argp1 = 0 ;
33328 int res1 = 0 ;
33329 long val2 ;
33330 int ecode2 = 0 ;
33331 PyObject * obj0 = 0 ;
33332 PyObject * obj1 = 0 ;
33333 char * kwnames[] = {
33334 (char *) "self",(char *) "winid", NULL
33335 };
33336
33337 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
33338 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33339 if (!SWIG_IsOK(res1)) {
33340 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowById" "', expected argument " "1"" of type '" "wxWindow *""'");
33341 }
33342 arg1 = reinterpret_cast< wxWindow * >(argp1);
33343 ecode2 = SWIG_AsVal_long(obj1, &val2);
33344 if (!SWIG_IsOK(ecode2)) {
33345 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FindWindowById" "', expected argument " "2"" of type '" "long""'");
33346 }
33347 arg2 = static_cast< long >(val2);
33348 {
33349 PyThreadState* __tstate = wxPyBeginAllowThreads();
33350 result = (wxWindow *)(arg1)->FindWindow(arg2);
33351 wxPyEndAllowThreads(__tstate);
33352 if (PyErr_Occurred()) SWIG_fail;
33353 }
33354 {
33355 resultobj = wxPyMake_wxObject(result, 0);
33356 }
33357 return resultobj;
33358 fail:
33359 return NULL;
33360 }
33361
33362
33363 SWIGINTERN PyObject *_wrap_Window_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33364 PyObject *resultobj = 0;
33365 wxWindow *arg1 = (wxWindow *) 0 ;
33366 wxString *arg2 = 0 ;
33367 wxWindow *result = 0 ;
33368 void *argp1 = 0 ;
33369 int res1 = 0 ;
33370 bool temp2 = false ;
33371 PyObject * obj0 = 0 ;
33372 PyObject * obj1 = 0 ;
33373 char * kwnames[] = {
33374 (char *) "self",(char *) "name", NULL
33375 };
33376
33377 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
33378 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33379 if (!SWIG_IsOK(res1)) {
33380 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FindWindowByName" "', expected argument " "1"" of type '" "wxWindow *""'");
33381 }
33382 arg1 = reinterpret_cast< wxWindow * >(argp1);
33383 {
33384 arg2 = wxString_in_helper(obj1);
33385 if (arg2 == NULL) SWIG_fail;
33386 temp2 = true;
33387 }
33388 {
33389 PyThreadState* __tstate = wxPyBeginAllowThreads();
33390 result = (wxWindow *)(arg1)->FindWindow((wxString const &)*arg2);
33391 wxPyEndAllowThreads(__tstate);
33392 if (PyErr_Occurred()) SWIG_fail;
33393 }
33394 {
33395 resultobj = wxPyMake_wxObject(result, 0);
33396 }
33397 {
33398 if (temp2)
33399 delete arg2;
33400 }
33401 return resultobj;
33402 fail:
33403 {
33404 if (temp2)
33405 delete arg2;
33406 }
33407 return NULL;
33408 }
33409
33410
33411 SWIGINTERN PyObject *_wrap_Window_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33412 PyObject *resultobj = 0;
33413 wxWindow *arg1 = (wxWindow *) 0 ;
33414 wxEvtHandler *result = 0 ;
33415 void *argp1 = 0 ;
33416 int res1 = 0 ;
33417 PyObject *swig_obj[1] ;
33418
33419 if (!args) SWIG_fail;
33420 swig_obj[0] = args;
33421 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33422 if (!SWIG_IsOK(res1)) {
33423 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetEventHandler" "', expected argument " "1"" of type '" "wxWindow const *""'");
33424 }
33425 arg1 = reinterpret_cast< wxWindow * >(argp1);
33426 {
33427 PyThreadState* __tstate = wxPyBeginAllowThreads();
33428 result = (wxEvtHandler *)((wxWindow const *)arg1)->GetEventHandler();
33429 wxPyEndAllowThreads(__tstate);
33430 if (PyErr_Occurred()) SWIG_fail;
33431 }
33432 {
33433 resultobj = wxPyMake_wxObject(result, 0);
33434 }
33435 return resultobj;
33436 fail:
33437 return NULL;
33438 }
33439
33440
33441 SWIGINTERN PyObject *_wrap_Window_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33442 PyObject *resultobj = 0;
33443 wxWindow *arg1 = (wxWindow *) 0 ;
33444 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33445 void *argp1 = 0 ;
33446 int res1 = 0 ;
33447 void *argp2 = 0 ;
33448 int res2 = 0 ;
33449 PyObject * obj0 = 0 ;
33450 PyObject * obj1 = 0 ;
33451 char * kwnames[] = {
33452 (char *) "self",(char *) "handler", NULL
33453 };
33454
33455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33457 if (!SWIG_IsOK(res1)) {
33458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33459 }
33460 arg1 = reinterpret_cast< wxWindow * >(argp1);
33461 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33462 if (!SWIG_IsOK(res2)) {
33463 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33464 }
33465 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33466 {
33467 PyThreadState* __tstate = wxPyBeginAllowThreads();
33468 (arg1)->SetEventHandler(arg2);
33469 wxPyEndAllowThreads(__tstate);
33470 if (PyErr_Occurred()) SWIG_fail;
33471 }
33472 resultobj = SWIG_Py_Void();
33473 return resultobj;
33474 fail:
33475 return NULL;
33476 }
33477
33478
33479 SWIGINTERN PyObject *_wrap_Window_PushEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33480 PyObject *resultobj = 0;
33481 wxWindow *arg1 = (wxWindow *) 0 ;
33482 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33483 void *argp1 = 0 ;
33484 int res1 = 0 ;
33485 void *argp2 = 0 ;
33486 int res2 = 0 ;
33487 PyObject * obj0 = 0 ;
33488 PyObject * obj1 = 0 ;
33489 char * kwnames[] = {
33490 (char *) "self",(char *) "handler", NULL
33491 };
33492
33493 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PushEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33494 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33495 if (!SWIG_IsOK(res1)) {
33496 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PushEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33497 }
33498 arg1 = reinterpret_cast< wxWindow * >(argp1);
33499 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33500 if (!SWIG_IsOK(res2)) {
33501 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PushEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33502 }
33503 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33504 {
33505 PyThreadState* __tstate = wxPyBeginAllowThreads();
33506 (arg1)->PushEventHandler(arg2);
33507 wxPyEndAllowThreads(__tstate);
33508 if (PyErr_Occurred()) SWIG_fail;
33509 }
33510 resultobj = SWIG_Py_Void();
33511 return resultobj;
33512 fail:
33513 return NULL;
33514 }
33515
33516
33517 SWIGINTERN PyObject *_wrap_Window_PopEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33518 PyObject *resultobj = 0;
33519 wxWindow *arg1 = (wxWindow *) 0 ;
33520 bool arg2 = (bool) false ;
33521 wxEvtHandler *result = 0 ;
33522 void *argp1 = 0 ;
33523 int res1 = 0 ;
33524 bool val2 ;
33525 int ecode2 = 0 ;
33526 PyObject * obj0 = 0 ;
33527 PyObject * obj1 = 0 ;
33528 char * kwnames[] = {
33529 (char *) "self",(char *) "deleteHandler", NULL
33530 };
33531
33532 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_PopEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33533 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33534 if (!SWIG_IsOK(res1)) {
33535 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33536 }
33537 arg1 = reinterpret_cast< wxWindow * >(argp1);
33538 if (obj1) {
33539 ecode2 = SWIG_AsVal_bool(obj1, &val2);
33540 if (!SWIG_IsOK(ecode2)) {
33541 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_PopEventHandler" "', expected argument " "2"" of type '" "bool""'");
33542 }
33543 arg2 = static_cast< bool >(val2);
33544 }
33545 {
33546 PyThreadState* __tstate = wxPyBeginAllowThreads();
33547 result = (wxEvtHandler *)(arg1)->PopEventHandler(arg2);
33548 wxPyEndAllowThreads(__tstate);
33549 if (PyErr_Occurred()) SWIG_fail;
33550 }
33551 {
33552 resultobj = wxPyMake_wxObject(result, 0);
33553 }
33554 return resultobj;
33555 fail:
33556 return NULL;
33557 }
33558
33559
33560 SWIGINTERN PyObject *_wrap_Window_RemoveEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33561 PyObject *resultobj = 0;
33562 wxWindow *arg1 = (wxWindow *) 0 ;
33563 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
33564 bool result;
33565 void *argp1 = 0 ;
33566 int res1 = 0 ;
33567 void *argp2 = 0 ;
33568 int res2 = 0 ;
33569 PyObject * obj0 = 0 ;
33570 PyObject * obj1 = 0 ;
33571 char * kwnames[] = {
33572 (char *) "self",(char *) "handler", NULL
33573 };
33574
33575 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_RemoveEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
33576 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33577 if (!SWIG_IsOK(res1)) {
33578 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RemoveEventHandler" "', expected argument " "1"" of type '" "wxWindow *""'");
33579 }
33580 arg1 = reinterpret_cast< wxWindow * >(argp1);
33581 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
33582 if (!SWIG_IsOK(res2)) {
33583 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_RemoveEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
33584 }
33585 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
33586 {
33587 PyThreadState* __tstate = wxPyBeginAllowThreads();
33588 result = (bool)(arg1)->RemoveEventHandler(arg2);
33589 wxPyEndAllowThreads(__tstate);
33590 if (PyErr_Occurred()) SWIG_fail;
33591 }
33592 {
33593 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33594 }
33595 return resultobj;
33596 fail:
33597 return NULL;
33598 }
33599
33600
33601 SWIGINTERN PyObject *_wrap_Window_SetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33602 PyObject *resultobj = 0;
33603 wxWindow *arg1 = (wxWindow *) 0 ;
33604 wxValidator *arg2 = 0 ;
33605 void *argp1 = 0 ;
33606 int res1 = 0 ;
33607 void *argp2 = 0 ;
33608 int res2 = 0 ;
33609 PyObject * obj0 = 0 ;
33610 PyObject * obj1 = 0 ;
33611 char * kwnames[] = {
33612 (char *) "self",(char *) "validator", NULL
33613 };
33614
33615 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetValidator",kwnames,&obj0,&obj1)) SWIG_fail;
33616 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33617 if (!SWIG_IsOK(res1)) {
33618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33619 }
33620 arg1 = reinterpret_cast< wxWindow * >(argp1);
33621 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxValidator, 0 | 0);
33622 if (!SWIG_IsOK(res2)) {
33623 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33624 }
33625 if (!argp2) {
33626 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetValidator" "', expected argument " "2"" of type '" "wxValidator const &""'");
33627 }
33628 arg2 = reinterpret_cast< wxValidator * >(argp2);
33629 {
33630 PyThreadState* __tstate = wxPyBeginAllowThreads();
33631 (arg1)->SetValidator((wxValidator const &)*arg2);
33632 wxPyEndAllowThreads(__tstate);
33633 if (PyErr_Occurred()) SWIG_fail;
33634 }
33635 resultobj = SWIG_Py_Void();
33636 return resultobj;
33637 fail:
33638 return NULL;
33639 }
33640
33641
33642 SWIGINTERN PyObject *_wrap_Window_GetValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33643 PyObject *resultobj = 0;
33644 wxWindow *arg1 = (wxWindow *) 0 ;
33645 wxValidator *result = 0 ;
33646 void *argp1 = 0 ;
33647 int res1 = 0 ;
33648 PyObject *swig_obj[1] ;
33649
33650 if (!args) SWIG_fail;
33651 swig_obj[0] = args;
33652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33653 if (!SWIG_IsOK(res1)) {
33654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetValidator" "', expected argument " "1"" of type '" "wxWindow *""'");
33655 }
33656 arg1 = reinterpret_cast< wxWindow * >(argp1);
33657 {
33658 PyThreadState* __tstate = wxPyBeginAllowThreads();
33659 result = (wxValidator *)(arg1)->GetValidator();
33660 wxPyEndAllowThreads(__tstate);
33661 if (PyErr_Occurred()) SWIG_fail;
33662 }
33663 {
33664 resultobj = wxPyMake_wxObject(result, (bool)0);
33665 }
33666 return resultobj;
33667 fail:
33668 return NULL;
33669 }
33670
33671
33672 SWIGINTERN PyObject *_wrap_Window_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33673 PyObject *resultobj = 0;
33674 wxWindow *arg1 = (wxWindow *) 0 ;
33675 bool result;
33676 void *argp1 = 0 ;
33677 int res1 = 0 ;
33678 PyObject *swig_obj[1] ;
33679
33680 if (!args) SWIG_fail;
33681 swig_obj[0] = args;
33682 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33683 if (!SWIG_IsOK(res1)) {
33684 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Validate" "', expected argument " "1"" of type '" "wxWindow *""'");
33685 }
33686 arg1 = reinterpret_cast< wxWindow * >(argp1);
33687 {
33688 PyThreadState* __tstate = wxPyBeginAllowThreads();
33689 result = (bool)(arg1)->Validate();
33690 wxPyEndAllowThreads(__tstate);
33691 if (PyErr_Occurred()) SWIG_fail;
33692 }
33693 {
33694 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33695 }
33696 return resultobj;
33697 fail:
33698 return NULL;
33699 }
33700
33701
33702 SWIGINTERN PyObject *_wrap_Window_TransferDataToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33703 PyObject *resultobj = 0;
33704 wxWindow *arg1 = (wxWindow *) 0 ;
33705 bool result;
33706 void *argp1 = 0 ;
33707 int res1 = 0 ;
33708 PyObject *swig_obj[1] ;
33709
33710 if (!args) SWIG_fail;
33711 swig_obj[0] = args;
33712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33713 if (!SWIG_IsOK(res1)) {
33714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataToWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33715 }
33716 arg1 = reinterpret_cast< wxWindow * >(argp1);
33717 {
33718 PyThreadState* __tstate = wxPyBeginAllowThreads();
33719 result = (bool)(arg1)->TransferDataToWindow();
33720 wxPyEndAllowThreads(__tstate);
33721 if (PyErr_Occurred()) SWIG_fail;
33722 }
33723 {
33724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33725 }
33726 return resultobj;
33727 fail:
33728 return NULL;
33729 }
33730
33731
33732 SWIGINTERN PyObject *_wrap_Window_TransferDataFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33733 PyObject *resultobj = 0;
33734 wxWindow *arg1 = (wxWindow *) 0 ;
33735 bool result;
33736 void *argp1 = 0 ;
33737 int res1 = 0 ;
33738 PyObject *swig_obj[1] ;
33739
33740 if (!args) SWIG_fail;
33741 swig_obj[0] = args;
33742 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33743 if (!SWIG_IsOK(res1)) {
33744 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_TransferDataFromWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
33745 }
33746 arg1 = reinterpret_cast< wxWindow * >(argp1);
33747 {
33748 PyThreadState* __tstate = wxPyBeginAllowThreads();
33749 result = (bool)(arg1)->TransferDataFromWindow();
33750 wxPyEndAllowThreads(__tstate);
33751 if (PyErr_Occurred()) SWIG_fail;
33752 }
33753 {
33754 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33755 }
33756 return resultobj;
33757 fail:
33758 return NULL;
33759 }
33760
33761
33762 SWIGINTERN PyObject *_wrap_Window_InitDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33763 PyObject *resultobj = 0;
33764 wxWindow *arg1 = (wxWindow *) 0 ;
33765 void *argp1 = 0 ;
33766 int res1 = 0 ;
33767 PyObject *swig_obj[1] ;
33768
33769 if (!args) SWIG_fail;
33770 swig_obj[0] = args;
33771 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33772 if (!SWIG_IsOK(res1)) {
33773 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InitDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
33774 }
33775 arg1 = reinterpret_cast< wxWindow * >(argp1);
33776 {
33777 PyThreadState* __tstate = wxPyBeginAllowThreads();
33778 (arg1)->InitDialog();
33779 wxPyEndAllowThreads(__tstate);
33780 if (PyErr_Occurred()) SWIG_fail;
33781 }
33782 resultobj = SWIG_Py_Void();
33783 return resultobj;
33784 fail:
33785 return NULL;
33786 }
33787
33788
33789 SWIGINTERN PyObject *_wrap_Window_SetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33790 PyObject *resultobj = 0;
33791 wxWindow *arg1 = (wxWindow *) 0 ;
33792 wxAcceleratorTable *arg2 = 0 ;
33793 void *argp1 = 0 ;
33794 int res1 = 0 ;
33795 void *argp2 = 0 ;
33796 int res2 = 0 ;
33797 PyObject * obj0 = 0 ;
33798 PyObject * obj1 = 0 ;
33799 char * kwnames[] = {
33800 (char *) "self",(char *) "accel", NULL
33801 };
33802
33803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAcceleratorTable",kwnames,&obj0,&obj1)) SWIG_fail;
33804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33805 if (!SWIG_IsOK(res1)) {
33806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33807 }
33808 arg1 = reinterpret_cast< wxWindow * >(argp1);
33809 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxAcceleratorTable, 0 | 0);
33810 if (!SWIG_IsOK(res2)) {
33811 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33812 }
33813 if (!argp2) {
33814 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetAcceleratorTable" "', expected argument " "2"" of type '" "wxAcceleratorTable const &""'");
33815 }
33816 arg2 = reinterpret_cast< wxAcceleratorTable * >(argp2);
33817 {
33818 PyThreadState* __tstate = wxPyBeginAllowThreads();
33819 (arg1)->SetAcceleratorTable((wxAcceleratorTable const &)*arg2);
33820 wxPyEndAllowThreads(__tstate);
33821 if (PyErr_Occurred()) SWIG_fail;
33822 }
33823 resultobj = SWIG_Py_Void();
33824 return resultobj;
33825 fail:
33826 return NULL;
33827 }
33828
33829
33830 SWIGINTERN PyObject *_wrap_Window_GetAcceleratorTable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
33831 PyObject *resultobj = 0;
33832 wxWindow *arg1 = (wxWindow *) 0 ;
33833 wxAcceleratorTable *result = 0 ;
33834 void *argp1 = 0 ;
33835 int res1 = 0 ;
33836 PyObject *swig_obj[1] ;
33837
33838 if (!args) SWIG_fail;
33839 swig_obj[0] = args;
33840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33841 if (!SWIG_IsOK(res1)) {
33842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAcceleratorTable" "', expected argument " "1"" of type '" "wxWindow *""'");
33843 }
33844 arg1 = reinterpret_cast< wxWindow * >(argp1);
33845 {
33846 PyThreadState* __tstate = wxPyBeginAllowThreads();
33847 result = (wxAcceleratorTable *)(arg1)->GetAcceleratorTable();
33848 wxPyEndAllowThreads(__tstate);
33849 if (PyErr_Occurred()) SWIG_fail;
33850 }
33851 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorTable, 0 | 0 );
33852 return resultobj;
33853 fail:
33854 return NULL;
33855 }
33856
33857
33858 SWIGINTERN PyObject *_wrap_Window_RegisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33859 PyObject *resultobj = 0;
33860 wxWindow *arg1 = (wxWindow *) 0 ;
33861 int arg2 ;
33862 int arg3 ;
33863 int arg4 ;
33864 bool result;
33865 void *argp1 = 0 ;
33866 int res1 = 0 ;
33867 int val2 ;
33868 int ecode2 = 0 ;
33869 int val3 ;
33870 int ecode3 = 0 ;
33871 int val4 ;
33872 int ecode4 = 0 ;
33873 PyObject * obj0 = 0 ;
33874 PyObject * obj1 = 0 ;
33875 PyObject * obj2 = 0 ;
33876 PyObject * obj3 = 0 ;
33877 char * kwnames[] = {
33878 (char *) "self",(char *) "hotkeyId",(char *) "modifiers",(char *) "keycode", NULL
33879 };
33880
33881 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:Window_RegisterHotKey",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
33882 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33883 if (!SWIG_IsOK(res1)) {
33884 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RegisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33885 }
33886 arg1 = reinterpret_cast< wxWindow * >(argp1);
33887 ecode2 = SWIG_AsVal_int(obj1, &val2);
33888 if (!SWIG_IsOK(ecode2)) {
33889 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_RegisterHotKey" "', expected argument " "2"" of type '" "int""'");
33890 }
33891 arg2 = static_cast< int >(val2);
33892 ecode3 = SWIG_AsVal_int(obj2, &val3);
33893 if (!SWIG_IsOK(ecode3)) {
33894 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RegisterHotKey" "', expected argument " "3"" of type '" "int""'");
33895 }
33896 arg3 = static_cast< int >(val3);
33897 ecode4 = SWIG_AsVal_int(obj3, &val4);
33898 if (!SWIG_IsOK(ecode4)) {
33899 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_RegisterHotKey" "', expected argument " "4"" of type '" "int""'");
33900 }
33901 arg4 = static_cast< int >(val4);
33902 {
33903 PyThreadState* __tstate = wxPyBeginAllowThreads();
33904 result = (bool)wxWindow_RegisterHotKey(arg1,arg2,arg3,arg4);
33905 wxPyEndAllowThreads(__tstate);
33906 if (PyErr_Occurred()) SWIG_fail;
33907 }
33908 {
33909 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33910 }
33911 return resultobj;
33912 fail:
33913 return NULL;
33914 }
33915
33916
33917 SWIGINTERN PyObject *_wrap_Window_UnregisterHotKey(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33918 PyObject *resultobj = 0;
33919 wxWindow *arg1 = (wxWindow *) 0 ;
33920 int arg2 ;
33921 bool result;
33922 void *argp1 = 0 ;
33923 int res1 = 0 ;
33924 int val2 ;
33925 int ecode2 = 0 ;
33926 PyObject * obj0 = 0 ;
33927 PyObject * obj1 = 0 ;
33928 char * kwnames[] = {
33929 (char *) "self",(char *) "hotkeyId", NULL
33930 };
33931
33932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_UnregisterHotKey",kwnames,&obj0,&obj1)) SWIG_fail;
33933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33934 if (!SWIG_IsOK(res1)) {
33935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UnregisterHotKey" "', expected argument " "1"" of type '" "wxWindow *""'");
33936 }
33937 arg1 = reinterpret_cast< wxWindow * >(argp1);
33938 ecode2 = SWIG_AsVal_int(obj1, &val2);
33939 if (!SWIG_IsOK(ecode2)) {
33940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UnregisterHotKey" "', expected argument " "2"" of type '" "int""'");
33941 }
33942 arg2 = static_cast< int >(val2);
33943 {
33944 PyThreadState* __tstate = wxPyBeginAllowThreads();
33945 result = (bool)wxWindow_UnregisterHotKey(arg1,arg2);
33946 wxPyEndAllowThreads(__tstate);
33947 if (PyErr_Occurred()) SWIG_fail;
33948 }
33949 {
33950 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
33951 }
33952 return resultobj;
33953 fail:
33954 return NULL;
33955 }
33956
33957
33958 SWIGINTERN PyObject *_wrap_Window_ConvertDialogPointToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33959 PyObject *resultobj = 0;
33960 wxWindow *arg1 = (wxWindow *) 0 ;
33961 wxPoint *arg2 = 0 ;
33962 wxPoint result;
33963 void *argp1 = 0 ;
33964 int res1 = 0 ;
33965 wxPoint temp2 ;
33966 PyObject * obj0 = 0 ;
33967 PyObject * obj1 = 0 ;
33968 char * kwnames[] = {
33969 (char *) "self",(char *) "pt", NULL
33970 };
33971
33972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogPointToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
33973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
33974 if (!SWIG_IsOK(res1)) {
33975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogPointToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
33976 }
33977 arg1 = reinterpret_cast< wxWindow * >(argp1);
33978 {
33979 arg2 = &temp2;
33980 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
33981 }
33982 {
33983 PyThreadState* __tstate = wxPyBeginAllowThreads();
33984 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
33985 wxPyEndAllowThreads(__tstate);
33986 if (PyErr_Occurred()) SWIG_fail;
33987 }
33988 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
33989 return resultobj;
33990 fail:
33991 return NULL;
33992 }
33993
33994
33995 SWIGINTERN PyObject *_wrap_Window_ConvertDialogSizeToPixels(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
33996 PyObject *resultobj = 0;
33997 wxWindow *arg1 = (wxWindow *) 0 ;
33998 wxSize *arg2 = 0 ;
33999 wxSize result;
34000 void *argp1 = 0 ;
34001 int res1 = 0 ;
34002 wxSize temp2 ;
34003 PyObject * obj0 = 0 ;
34004 PyObject * obj1 = 0 ;
34005 char * kwnames[] = {
34006 (char *) "self",(char *) "sz", NULL
34007 };
34008
34009 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertDialogSizeToPixels",kwnames,&obj0,&obj1)) SWIG_fail;
34010 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34011 if (!SWIG_IsOK(res1)) {
34012 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertDialogSizeToPixels" "', expected argument " "1"" of type '" "wxWindow *""'");
34013 }
34014 arg1 = reinterpret_cast< wxWindow * >(argp1);
34015 {
34016 arg2 = &temp2;
34017 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34018 }
34019 {
34020 PyThreadState* __tstate = wxPyBeginAllowThreads();
34021 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34022 wxPyEndAllowThreads(__tstate);
34023 if (PyErr_Occurred()) SWIG_fail;
34024 }
34025 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34026 return resultobj;
34027 fail:
34028 return NULL;
34029 }
34030
34031
34032 SWIGINTERN PyObject *_wrap_Window_DLG_PNT(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34033 PyObject *resultobj = 0;
34034 wxWindow *arg1 = (wxWindow *) 0 ;
34035 wxPoint *arg2 = 0 ;
34036 wxPoint result;
34037 void *argp1 = 0 ;
34038 int res1 = 0 ;
34039 wxPoint temp2 ;
34040 PyObject * obj0 = 0 ;
34041 PyObject * obj1 = 0 ;
34042 char * kwnames[] = {
34043 (char *) "self",(char *) "pt", NULL
34044 };
34045
34046 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_PNT",kwnames,&obj0,&obj1)) SWIG_fail;
34047 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34048 if (!SWIG_IsOK(res1)) {
34049 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DLG_PNT" "', expected argument " "1"" of type '" "wxWindow *""'");
34050 }
34051 arg1 = reinterpret_cast< wxWindow * >(argp1);
34052 {
34053 arg2 = &temp2;
34054 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34055 }
34056 {
34057 PyThreadState* __tstate = wxPyBeginAllowThreads();
34058 result = (arg1)->ConvertDialogToPixels((wxPoint const &)*arg2);
34059 wxPyEndAllowThreads(__tstate);
34060 if (PyErr_Occurred()) SWIG_fail;
34061 }
34062 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34063 return resultobj;
34064 fail:
34065 return NULL;
34066 }
34067
34068
34069 SWIGINTERN PyObject *_wrap_Window_DLG_SZE(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34070 PyObject *resultobj = 0;
34071 wxWindow *arg1 = (wxWindow *) 0 ;
34072 wxSize *arg2 = 0 ;
34073 wxSize result;
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 *) "sz", NULL
34081 };
34082
34083 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DLG_SZE",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_DLG_SZE" "', 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 result = (arg1)->ConvertDialogToPixels((wxSize const &)*arg2);
34096 wxPyEndAllowThreads(__tstate);
34097 if (PyErr_Occurred()) SWIG_fail;
34098 }
34099 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34100 return resultobj;
34101 fail:
34102 return NULL;
34103 }
34104
34105
34106 SWIGINTERN PyObject *_wrap_Window_ConvertPixelPointToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34107 PyObject *resultobj = 0;
34108 wxWindow *arg1 = (wxWindow *) 0 ;
34109 wxPoint *arg2 = 0 ;
34110 wxPoint result;
34111 void *argp1 = 0 ;
34112 int res1 = 0 ;
34113 wxPoint temp2 ;
34114 PyObject * obj0 = 0 ;
34115 PyObject * obj1 = 0 ;
34116 char * kwnames[] = {
34117 (char *) "self",(char *) "pt", NULL
34118 };
34119
34120 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelPointToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34121 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34122 if (!SWIG_IsOK(res1)) {
34123 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelPointToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34124 }
34125 arg1 = reinterpret_cast< wxWindow * >(argp1);
34126 {
34127 arg2 = &temp2;
34128 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34129 }
34130 {
34131 PyThreadState* __tstate = wxPyBeginAllowThreads();
34132 result = (arg1)->ConvertPixelsToDialog((wxPoint const &)*arg2);
34133 wxPyEndAllowThreads(__tstate);
34134 if (PyErr_Occurred()) SWIG_fail;
34135 }
34136 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
34137 return resultobj;
34138 fail:
34139 return NULL;
34140 }
34141
34142
34143 SWIGINTERN PyObject *_wrap_Window_ConvertPixelSizeToDialog(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34144 PyObject *resultobj = 0;
34145 wxWindow *arg1 = (wxWindow *) 0 ;
34146 wxSize *arg2 = 0 ;
34147 wxSize result;
34148 void *argp1 = 0 ;
34149 int res1 = 0 ;
34150 wxSize temp2 ;
34151 PyObject * obj0 = 0 ;
34152 PyObject * obj1 = 0 ;
34153 char * kwnames[] = {
34154 (char *) "self",(char *) "sz", NULL
34155 };
34156
34157 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ConvertPixelSizeToDialog",kwnames,&obj0,&obj1)) SWIG_fail;
34158 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34159 if (!SWIG_IsOK(res1)) {
34160 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ConvertPixelSizeToDialog" "', expected argument " "1"" of type '" "wxWindow *""'");
34161 }
34162 arg1 = reinterpret_cast< wxWindow * >(argp1);
34163 {
34164 arg2 = &temp2;
34165 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
34166 }
34167 {
34168 PyThreadState* __tstate = wxPyBeginAllowThreads();
34169 result = (arg1)->ConvertPixelsToDialog((wxSize const &)*arg2);
34170 wxPyEndAllowThreads(__tstate);
34171 if (PyErr_Occurred()) SWIG_fail;
34172 }
34173 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
34174 return resultobj;
34175 fail:
34176 return NULL;
34177 }
34178
34179
34180 SWIGINTERN PyObject *_wrap_Window_WarpPointer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34181 PyObject *resultobj = 0;
34182 wxWindow *arg1 = (wxWindow *) 0 ;
34183 int arg2 ;
34184 int arg3 ;
34185 void *argp1 = 0 ;
34186 int res1 = 0 ;
34187 int val2 ;
34188 int ecode2 = 0 ;
34189 int val3 ;
34190 int ecode3 = 0 ;
34191 PyObject * obj0 = 0 ;
34192 PyObject * obj1 = 0 ;
34193 PyObject * obj2 = 0 ;
34194 char * kwnames[] = {
34195 (char *) "self",(char *) "x",(char *) "y", NULL
34196 };
34197
34198 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_WarpPointer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34199 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34200 if (!SWIG_IsOK(res1)) {
34201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_WarpPointer" "', expected argument " "1"" of type '" "wxWindow *""'");
34202 }
34203 arg1 = reinterpret_cast< wxWindow * >(argp1);
34204 ecode2 = SWIG_AsVal_int(obj1, &val2);
34205 if (!SWIG_IsOK(ecode2)) {
34206 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_WarpPointer" "', expected argument " "2"" of type '" "int""'");
34207 }
34208 arg2 = static_cast< int >(val2);
34209 ecode3 = SWIG_AsVal_int(obj2, &val3);
34210 if (!SWIG_IsOK(ecode3)) {
34211 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_WarpPointer" "', expected argument " "3"" of type '" "int""'");
34212 }
34213 arg3 = static_cast< int >(val3);
34214 {
34215 PyThreadState* __tstate = wxPyBeginAllowThreads();
34216 (arg1)->WarpPointer(arg2,arg3);
34217 wxPyEndAllowThreads(__tstate);
34218 if (PyErr_Occurred()) SWIG_fail;
34219 }
34220 resultobj = SWIG_Py_Void();
34221 return resultobj;
34222 fail:
34223 return NULL;
34224 }
34225
34226
34227 SWIGINTERN PyObject *_wrap_Window_CaptureMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34228 PyObject *resultobj = 0;
34229 wxWindow *arg1 = (wxWindow *) 0 ;
34230 void *argp1 = 0 ;
34231 int res1 = 0 ;
34232 PyObject *swig_obj[1] ;
34233
34234 if (!args) SWIG_fail;
34235 swig_obj[0] = args;
34236 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34237 if (!SWIG_IsOK(res1)) {
34238 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_CaptureMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34239 }
34240 arg1 = reinterpret_cast< wxWindow * >(argp1);
34241 {
34242 PyThreadState* __tstate = wxPyBeginAllowThreads();
34243 (arg1)->CaptureMouse();
34244 wxPyEndAllowThreads(__tstate);
34245 if (PyErr_Occurred()) SWIG_fail;
34246 }
34247 resultobj = SWIG_Py_Void();
34248 return resultobj;
34249 fail:
34250 return NULL;
34251 }
34252
34253
34254 SWIGINTERN PyObject *_wrap_Window_ReleaseMouse(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34255 PyObject *resultobj = 0;
34256 wxWindow *arg1 = (wxWindow *) 0 ;
34257 void *argp1 = 0 ;
34258 int res1 = 0 ;
34259 PyObject *swig_obj[1] ;
34260
34261 if (!args) SWIG_fail;
34262 swig_obj[0] = args;
34263 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34264 if (!SWIG_IsOK(res1)) {
34265 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ReleaseMouse" "', expected argument " "1"" of type '" "wxWindow *""'");
34266 }
34267 arg1 = reinterpret_cast< wxWindow * >(argp1);
34268 {
34269 PyThreadState* __tstate = wxPyBeginAllowThreads();
34270 (arg1)->ReleaseMouse();
34271 wxPyEndAllowThreads(__tstate);
34272 if (PyErr_Occurred()) SWIG_fail;
34273 }
34274 resultobj = SWIG_Py_Void();
34275 return resultobj;
34276 fail:
34277 return NULL;
34278 }
34279
34280
34281 SWIGINTERN PyObject *_wrap_Window_GetCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34282 PyObject *resultobj = 0;
34283 wxWindow *result = 0 ;
34284
34285 if (!SWIG_Python_UnpackTuple(args,"Window_GetCapture",0,0,0)) SWIG_fail;
34286 {
34287 if (!wxPyCheckForApp()) SWIG_fail;
34288 PyThreadState* __tstate = wxPyBeginAllowThreads();
34289 result = (wxWindow *)wxWindow::GetCapture();
34290 wxPyEndAllowThreads(__tstate);
34291 if (PyErr_Occurred()) SWIG_fail;
34292 }
34293 {
34294 resultobj = wxPyMake_wxObject(result, 0);
34295 }
34296 return resultobj;
34297 fail:
34298 return NULL;
34299 }
34300
34301
34302 SWIGINTERN PyObject *_wrap_Window_HasCapture(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34303 PyObject *resultobj = 0;
34304 wxWindow *arg1 = (wxWindow *) 0 ;
34305 bool result;
34306 void *argp1 = 0 ;
34307 int res1 = 0 ;
34308 PyObject *swig_obj[1] ;
34309
34310 if (!args) SWIG_fail;
34311 swig_obj[0] = args;
34312 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34313 if (!SWIG_IsOK(res1)) {
34314 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasCapture" "', expected argument " "1"" of type '" "wxWindow const *""'");
34315 }
34316 arg1 = reinterpret_cast< wxWindow * >(argp1);
34317 {
34318 PyThreadState* __tstate = wxPyBeginAllowThreads();
34319 result = (bool)((wxWindow const *)arg1)->HasCapture();
34320 wxPyEndAllowThreads(__tstate);
34321 if (PyErr_Occurred()) SWIG_fail;
34322 }
34323 {
34324 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34325 }
34326 return resultobj;
34327 fail:
34328 return NULL;
34329 }
34330
34331
34332 SWIGINTERN PyObject *_wrap_Window_Refresh(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34333 PyObject *resultobj = 0;
34334 wxWindow *arg1 = (wxWindow *) 0 ;
34335 bool arg2 = (bool) true ;
34336 wxRect *arg3 = (wxRect *) NULL ;
34337 void *argp1 = 0 ;
34338 int res1 = 0 ;
34339 bool val2 ;
34340 int ecode2 = 0 ;
34341 void *argp3 = 0 ;
34342 int res3 = 0 ;
34343 PyObject * obj0 = 0 ;
34344 PyObject * obj1 = 0 ;
34345 PyObject * obj2 = 0 ;
34346 char * kwnames[] = {
34347 (char *) "self",(char *) "eraseBackground",(char *) "rect", NULL
34348 };
34349
34350 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:Window_Refresh",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34351 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34352 if (!SWIG_IsOK(res1)) {
34353 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Refresh" "', expected argument " "1"" of type '" "wxWindow *""'");
34354 }
34355 arg1 = reinterpret_cast< wxWindow * >(argp1);
34356 if (obj1) {
34357 ecode2 = SWIG_AsVal_bool(obj1, &val2);
34358 if (!SWIG_IsOK(ecode2)) {
34359 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_Refresh" "', expected argument " "2"" of type '" "bool""'");
34360 }
34361 arg2 = static_cast< bool >(val2);
34362 }
34363 if (obj2) {
34364 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxRect, 0 | 0 );
34365 if (!SWIG_IsOK(res3)) {
34366 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_Refresh" "', expected argument " "3"" of type '" "wxRect const *""'");
34367 }
34368 arg3 = reinterpret_cast< wxRect * >(argp3);
34369 }
34370 {
34371 PyThreadState* __tstate = wxPyBeginAllowThreads();
34372 (arg1)->Refresh(arg2,(wxRect const *)arg3);
34373 wxPyEndAllowThreads(__tstate);
34374 if (PyErr_Occurred()) SWIG_fail;
34375 }
34376 resultobj = SWIG_Py_Void();
34377 return resultobj;
34378 fail:
34379 return NULL;
34380 }
34381
34382
34383 SWIGINTERN PyObject *_wrap_Window_RefreshRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34384 PyObject *resultobj = 0;
34385 wxWindow *arg1 = (wxWindow *) 0 ;
34386 wxRect *arg2 = 0 ;
34387 bool arg3 = (bool) true ;
34388 void *argp1 = 0 ;
34389 int res1 = 0 ;
34390 wxRect temp2 ;
34391 bool val3 ;
34392 int ecode3 = 0 ;
34393 PyObject * obj0 = 0 ;
34394 PyObject * obj1 = 0 ;
34395 PyObject * obj2 = 0 ;
34396 char * kwnames[] = {
34397 (char *) "self",(char *) "rect",(char *) "eraseBackground", NULL
34398 };
34399
34400 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_RefreshRect",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
34401 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34402 if (!SWIG_IsOK(res1)) {
34403 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_RefreshRect" "', expected argument " "1"" of type '" "wxWindow *""'");
34404 }
34405 arg1 = reinterpret_cast< wxWindow * >(argp1);
34406 {
34407 arg2 = &temp2;
34408 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34409 }
34410 if (obj2) {
34411 ecode3 = SWIG_AsVal_bool(obj2, &val3);
34412 if (!SWIG_IsOK(ecode3)) {
34413 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_RefreshRect" "', expected argument " "3"" of type '" "bool""'");
34414 }
34415 arg3 = static_cast< bool >(val3);
34416 }
34417 {
34418 PyThreadState* __tstate = wxPyBeginAllowThreads();
34419 (arg1)->RefreshRect((wxRect const &)*arg2,arg3);
34420 wxPyEndAllowThreads(__tstate);
34421 if (PyErr_Occurred()) SWIG_fail;
34422 }
34423 resultobj = SWIG_Py_Void();
34424 return resultobj;
34425 fail:
34426 return NULL;
34427 }
34428
34429
34430 SWIGINTERN PyObject *_wrap_Window_Update(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34431 PyObject *resultobj = 0;
34432 wxWindow *arg1 = (wxWindow *) 0 ;
34433 void *argp1 = 0 ;
34434 int res1 = 0 ;
34435 PyObject *swig_obj[1] ;
34436
34437 if (!args) SWIG_fail;
34438 swig_obj[0] = args;
34439 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34440 if (!SWIG_IsOK(res1)) {
34441 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Update" "', expected argument " "1"" of type '" "wxWindow *""'");
34442 }
34443 arg1 = reinterpret_cast< wxWindow * >(argp1);
34444 {
34445 PyThreadState* __tstate = wxPyBeginAllowThreads();
34446 (arg1)->Update();
34447 wxPyEndAllowThreads(__tstate);
34448 if (PyErr_Occurred()) SWIG_fail;
34449 }
34450 resultobj = SWIG_Py_Void();
34451 return resultobj;
34452 fail:
34453 return NULL;
34454 }
34455
34456
34457 SWIGINTERN PyObject *_wrap_Window_ClearBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34458 PyObject *resultobj = 0;
34459 wxWindow *arg1 = (wxWindow *) 0 ;
34460 void *argp1 = 0 ;
34461 int res1 = 0 ;
34462 PyObject *swig_obj[1] ;
34463
34464 if (!args) SWIG_fail;
34465 swig_obj[0] = args;
34466 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34467 if (!SWIG_IsOK(res1)) {
34468 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClearBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
34469 }
34470 arg1 = reinterpret_cast< wxWindow * >(argp1);
34471 {
34472 PyThreadState* __tstate = wxPyBeginAllowThreads();
34473 (arg1)->ClearBackground();
34474 wxPyEndAllowThreads(__tstate);
34475 if (PyErr_Occurred()) SWIG_fail;
34476 }
34477 resultobj = SWIG_Py_Void();
34478 return resultobj;
34479 fail:
34480 return NULL;
34481 }
34482
34483
34484 SWIGINTERN PyObject *_wrap_Window_Freeze(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34485 PyObject *resultobj = 0;
34486 wxWindow *arg1 = (wxWindow *) 0 ;
34487 void *argp1 = 0 ;
34488 int res1 = 0 ;
34489 PyObject *swig_obj[1] ;
34490
34491 if (!args) SWIG_fail;
34492 swig_obj[0] = args;
34493 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34494 if (!SWIG_IsOK(res1)) {
34495 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Freeze" "', expected argument " "1"" of type '" "wxWindow *""'");
34496 }
34497 arg1 = reinterpret_cast< wxWindow * >(argp1);
34498 {
34499 PyThreadState* __tstate = wxPyBeginAllowThreads();
34500 (arg1)->Freeze();
34501 wxPyEndAllowThreads(__tstate);
34502 if (PyErr_Occurred()) SWIG_fail;
34503 }
34504 resultobj = SWIG_Py_Void();
34505 return resultobj;
34506 fail:
34507 return NULL;
34508 }
34509
34510
34511 SWIGINTERN PyObject *_wrap_Window_Thaw(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34512 PyObject *resultobj = 0;
34513 wxWindow *arg1 = (wxWindow *) 0 ;
34514 void *argp1 = 0 ;
34515 int res1 = 0 ;
34516 PyObject *swig_obj[1] ;
34517
34518 if (!args) SWIG_fail;
34519 swig_obj[0] = args;
34520 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34521 if (!SWIG_IsOK(res1)) {
34522 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Thaw" "', expected argument " "1"" of type '" "wxWindow *""'");
34523 }
34524 arg1 = reinterpret_cast< wxWindow * >(argp1);
34525 {
34526 PyThreadState* __tstate = wxPyBeginAllowThreads();
34527 (arg1)->Thaw();
34528 wxPyEndAllowThreads(__tstate);
34529 if (PyErr_Occurred()) SWIG_fail;
34530 }
34531 resultobj = SWIG_Py_Void();
34532 return resultobj;
34533 fail:
34534 return NULL;
34535 }
34536
34537
34538 SWIGINTERN PyObject *_wrap_Window_PrepareDC(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34539 PyObject *resultobj = 0;
34540 wxWindow *arg1 = (wxWindow *) 0 ;
34541 wxDC *arg2 = 0 ;
34542 void *argp1 = 0 ;
34543 int res1 = 0 ;
34544 void *argp2 = 0 ;
34545 int res2 = 0 ;
34546 PyObject * obj0 = 0 ;
34547 PyObject * obj1 = 0 ;
34548 char * kwnames[] = {
34549 (char *) "self",(char *) "dc", NULL
34550 };
34551
34552 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_PrepareDC",kwnames,&obj0,&obj1)) SWIG_fail;
34553 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34554 if (!SWIG_IsOK(res1)) {
34555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PrepareDC" "', expected argument " "1"" of type '" "wxWindow *""'");
34556 }
34557 arg1 = reinterpret_cast< wxWindow * >(argp1);
34558 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxDC, 0 );
34559 if (!SWIG_IsOK(res2)) {
34560 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34561 }
34562 if (!argp2) {
34563 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_PrepareDC" "', expected argument " "2"" of type '" "wxDC &""'");
34564 }
34565 arg2 = reinterpret_cast< wxDC * >(argp2);
34566 {
34567 PyThreadState* __tstate = wxPyBeginAllowThreads();
34568 (arg1)->PrepareDC(*arg2);
34569 wxPyEndAllowThreads(__tstate);
34570 if (PyErr_Occurred()) SWIG_fail;
34571 }
34572 resultobj = SWIG_Py_Void();
34573 return resultobj;
34574 fail:
34575 return NULL;
34576 }
34577
34578
34579 SWIGINTERN PyObject *_wrap_Window_GetUpdateRegion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34580 PyObject *resultobj = 0;
34581 wxWindow *arg1 = (wxWindow *) 0 ;
34582 wxRegion *result = 0 ;
34583 void *argp1 = 0 ;
34584 int res1 = 0 ;
34585 PyObject *swig_obj[1] ;
34586
34587 if (!args) SWIG_fail;
34588 swig_obj[0] = args;
34589 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34590 if (!SWIG_IsOK(res1)) {
34591 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateRegion" "', expected argument " "1"" of type '" "wxWindow *""'");
34592 }
34593 arg1 = reinterpret_cast< wxWindow * >(argp1);
34594 {
34595 PyThreadState* __tstate = wxPyBeginAllowThreads();
34596 {
34597 wxRegion &_result_ref = (arg1)->GetUpdateRegion();
34598 result = (wxRegion *) &_result_ref;
34599 }
34600 wxPyEndAllowThreads(__tstate);
34601 if (PyErr_Occurred()) SWIG_fail;
34602 }
34603 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxRegion, 0 | 0 );
34604 return resultobj;
34605 fail:
34606 return NULL;
34607 }
34608
34609
34610 SWIGINTERN PyObject *_wrap_Window_GetUpdateClientRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34611 PyObject *resultobj = 0;
34612 wxWindow *arg1 = (wxWindow *) 0 ;
34613 wxRect result;
34614 void *argp1 = 0 ;
34615 int res1 = 0 ;
34616 PyObject *swig_obj[1] ;
34617
34618 if (!args) SWIG_fail;
34619 swig_obj[0] = args;
34620 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34621 if (!SWIG_IsOK(res1)) {
34622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetUpdateClientRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34623 }
34624 arg1 = reinterpret_cast< wxWindow * >(argp1);
34625 {
34626 PyThreadState* __tstate = wxPyBeginAllowThreads();
34627 result = ((wxWindow const *)arg1)->GetUpdateClientRect();
34628 wxPyEndAllowThreads(__tstate);
34629 if (PyErr_Occurred()) SWIG_fail;
34630 }
34631 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
34632 return resultobj;
34633 fail:
34634 return NULL;
34635 }
34636
34637
34638 SWIGINTERN PyObject *_wrap_Window_IsExposed(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34639 PyObject *resultobj = 0;
34640 wxWindow *arg1 = (wxWindow *) 0 ;
34641 int arg2 ;
34642 int arg3 ;
34643 int arg4 = (int) 1 ;
34644 int arg5 = (int) 1 ;
34645 bool result;
34646 void *argp1 = 0 ;
34647 int res1 = 0 ;
34648 int val2 ;
34649 int ecode2 = 0 ;
34650 int val3 ;
34651 int ecode3 = 0 ;
34652 int val4 ;
34653 int ecode4 = 0 ;
34654 int val5 ;
34655 int ecode5 = 0 ;
34656 PyObject * obj0 = 0 ;
34657 PyObject * obj1 = 0 ;
34658 PyObject * obj2 = 0 ;
34659 PyObject * obj3 = 0 ;
34660 PyObject * obj4 = 0 ;
34661 char * kwnames[] = {
34662 (char *) "self",(char *) "x",(char *) "y",(char *) "w",(char *) "h", NULL
34663 };
34664
34665 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Window_IsExposed",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
34666 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34667 if (!SWIG_IsOK(res1)) {
34668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposed" "', expected argument " "1"" of type '" "wxWindow const *""'");
34669 }
34670 arg1 = reinterpret_cast< wxWindow * >(argp1);
34671 ecode2 = SWIG_AsVal_int(obj1, &val2);
34672 if (!SWIG_IsOK(ecode2)) {
34673 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_IsExposed" "', expected argument " "2"" of type '" "int""'");
34674 }
34675 arg2 = static_cast< int >(val2);
34676 ecode3 = SWIG_AsVal_int(obj2, &val3);
34677 if (!SWIG_IsOK(ecode3)) {
34678 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_IsExposed" "', expected argument " "3"" of type '" "int""'");
34679 }
34680 arg3 = static_cast< int >(val3);
34681 if (obj3) {
34682 ecode4 = SWIG_AsVal_int(obj3, &val4);
34683 if (!SWIG_IsOK(ecode4)) {
34684 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_IsExposed" "', expected argument " "4"" of type '" "int""'");
34685 }
34686 arg4 = static_cast< int >(val4);
34687 }
34688 if (obj4) {
34689 ecode5 = SWIG_AsVal_int(obj4, &val5);
34690 if (!SWIG_IsOK(ecode5)) {
34691 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_IsExposed" "', expected argument " "5"" of type '" "int""'");
34692 }
34693 arg5 = static_cast< int >(val5);
34694 }
34695 {
34696 PyThreadState* __tstate = wxPyBeginAllowThreads();
34697 result = (bool)((wxWindow const *)arg1)->IsExposed(arg2,arg3,arg4,arg5);
34698 wxPyEndAllowThreads(__tstate);
34699 if (PyErr_Occurred()) SWIG_fail;
34700 }
34701 {
34702 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34703 }
34704 return resultobj;
34705 fail:
34706 return NULL;
34707 }
34708
34709
34710 SWIGINTERN PyObject *_wrap_Window_IsExposedPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34711 PyObject *resultobj = 0;
34712 wxWindow *arg1 = (wxWindow *) 0 ;
34713 wxPoint *arg2 = 0 ;
34714 bool result;
34715 void *argp1 = 0 ;
34716 int res1 = 0 ;
34717 wxPoint temp2 ;
34718 PyObject * obj0 = 0 ;
34719 PyObject * obj1 = 0 ;
34720 char * kwnames[] = {
34721 (char *) "self",(char *) "pt", NULL
34722 };
34723
34724 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedPoint",kwnames,&obj0,&obj1)) SWIG_fail;
34725 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34726 if (!SWIG_IsOK(res1)) {
34727 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
34728 }
34729 arg1 = reinterpret_cast< wxWindow * >(argp1);
34730 {
34731 arg2 = &temp2;
34732 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
34733 }
34734 {
34735 PyThreadState* __tstate = wxPyBeginAllowThreads();
34736 result = (bool)((wxWindow const *)arg1)->IsExposed((wxPoint const &)*arg2);
34737 wxPyEndAllowThreads(__tstate);
34738 if (PyErr_Occurred()) SWIG_fail;
34739 }
34740 {
34741 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34742 }
34743 return resultobj;
34744 fail:
34745 return NULL;
34746 }
34747
34748
34749 SWIGINTERN PyObject *_wrap_Window_IsExposedRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34750 PyObject *resultobj = 0;
34751 wxWindow *arg1 = (wxWindow *) 0 ;
34752 wxRect *arg2 = 0 ;
34753 bool result;
34754 void *argp1 = 0 ;
34755 int res1 = 0 ;
34756 wxRect temp2 ;
34757 PyObject * obj0 = 0 ;
34758 PyObject * obj1 = 0 ;
34759 char * kwnames[] = {
34760 (char *) "self",(char *) "rect", NULL
34761 };
34762
34763 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_IsExposedRect",kwnames,&obj0,&obj1)) SWIG_fail;
34764 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34765 if (!SWIG_IsOK(res1)) {
34766 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_IsExposedRect" "', expected argument " "1"" of type '" "wxWindow const *""'");
34767 }
34768 arg1 = reinterpret_cast< wxWindow * >(argp1);
34769 {
34770 arg2 = &temp2;
34771 if ( ! wxRect_helper(obj1, &arg2)) SWIG_fail;
34772 }
34773 {
34774 PyThreadState* __tstate = wxPyBeginAllowThreads();
34775 result = (bool)((wxWindow const *)arg1)->IsExposed((wxRect const &)*arg2);
34776 wxPyEndAllowThreads(__tstate);
34777 if (PyErr_Occurred()) SWIG_fail;
34778 }
34779 {
34780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34781 }
34782 return resultobj;
34783 fail:
34784 return NULL;
34785 }
34786
34787
34788 SWIGINTERN PyObject *_wrap_Window_GetDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
34789 PyObject *resultobj = 0;
34790 wxWindow *arg1 = (wxWindow *) 0 ;
34791 SwigValueWrapper<wxVisualAttributes > result;
34792 void *argp1 = 0 ;
34793 int res1 = 0 ;
34794 PyObject *swig_obj[1] ;
34795
34796 if (!args) SWIG_fail;
34797 swig_obj[0] = args;
34798 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34799 if (!SWIG_IsOK(res1)) {
34800 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDefaultAttributes" "', expected argument " "1"" of type '" "wxWindow const *""'");
34801 }
34802 arg1 = reinterpret_cast< wxWindow * >(argp1);
34803 {
34804 PyThreadState* __tstate = wxPyBeginAllowThreads();
34805 result = ((wxWindow const *)arg1)->GetDefaultAttributes();
34806 wxPyEndAllowThreads(__tstate);
34807 if (PyErr_Occurred()) SWIG_fail;
34808 }
34809 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34810 return resultobj;
34811 fail:
34812 return NULL;
34813 }
34814
34815
34816 SWIGINTERN PyObject *_wrap_Window_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34817 PyObject *resultobj = 0;
34818 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
34819 SwigValueWrapper<wxVisualAttributes > result;
34820 int val1 ;
34821 int ecode1 = 0 ;
34822 PyObject * obj0 = 0 ;
34823 char * kwnames[] = {
34824 (char *) "variant", NULL
34825 };
34826
34827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Window_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
34828 if (obj0) {
34829 ecode1 = SWIG_AsVal_int(obj0, &val1);
34830 if (!SWIG_IsOK(ecode1)) {
34831 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Window_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
34832 }
34833 arg1 = static_cast< wxWindowVariant >(val1);
34834 }
34835 {
34836 if (!wxPyCheckForApp()) SWIG_fail;
34837 PyThreadState* __tstate = wxPyBeginAllowThreads();
34838 result = wxWindow::GetClassDefaultAttributes(arg1);
34839 wxPyEndAllowThreads(__tstate);
34840 if (PyErr_Occurred()) SWIG_fail;
34841 }
34842 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
34843 return resultobj;
34844 fail:
34845 return NULL;
34846 }
34847
34848
34849 SWIGINTERN PyObject *_wrap_Window_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34850 PyObject *resultobj = 0;
34851 wxWindow *arg1 = (wxWindow *) 0 ;
34852 wxColour *arg2 = 0 ;
34853 bool result;
34854 void *argp1 = 0 ;
34855 int res1 = 0 ;
34856 wxColour temp2 ;
34857 PyObject * obj0 = 0 ;
34858 PyObject * obj1 = 0 ;
34859 char * kwnames[] = {
34860 (char *) "self",(char *) "colour", NULL
34861 };
34862
34863 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34864 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34865 if (!SWIG_IsOK(res1)) {
34866 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34867 }
34868 arg1 = reinterpret_cast< wxWindow * >(argp1);
34869 {
34870 arg2 = &temp2;
34871 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34872 }
34873 {
34874 PyThreadState* __tstate = wxPyBeginAllowThreads();
34875 result = (bool)(arg1)->SetBackgroundColour((wxColour const &)*arg2);
34876 wxPyEndAllowThreads(__tstate);
34877 if (PyErr_Occurred()) SWIG_fail;
34878 }
34879 {
34880 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34881 }
34882 return resultobj;
34883 fail:
34884 return NULL;
34885 }
34886
34887
34888 SWIGINTERN PyObject *_wrap_Window_SetOwnBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34889 PyObject *resultobj = 0;
34890 wxWindow *arg1 = (wxWindow *) 0 ;
34891 wxColour *arg2 = 0 ;
34892 void *argp1 = 0 ;
34893 int res1 = 0 ;
34894 wxColour temp2 ;
34895 PyObject * obj0 = 0 ;
34896 PyObject * obj1 = 0 ;
34897 char * kwnames[] = {
34898 (char *) "self",(char *) "colour", NULL
34899 };
34900
34901 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34902 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34903 if (!SWIG_IsOK(res1)) {
34904 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnBackgroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34905 }
34906 arg1 = reinterpret_cast< wxWindow * >(argp1);
34907 {
34908 arg2 = &temp2;
34909 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34910 }
34911 {
34912 PyThreadState* __tstate = wxPyBeginAllowThreads();
34913 (arg1)->SetOwnBackgroundColour((wxColour const &)*arg2);
34914 wxPyEndAllowThreads(__tstate);
34915 if (PyErr_Occurred()) SWIG_fail;
34916 }
34917 resultobj = SWIG_Py_Void();
34918 return resultobj;
34919 fail:
34920 return NULL;
34921 }
34922
34923
34924 SWIGINTERN PyObject *_wrap_Window_SetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34925 PyObject *resultobj = 0;
34926 wxWindow *arg1 = (wxWindow *) 0 ;
34927 wxColour *arg2 = 0 ;
34928 bool result;
34929 void *argp1 = 0 ;
34930 int res1 = 0 ;
34931 wxColour temp2 ;
34932 PyObject * obj0 = 0 ;
34933 PyObject * obj1 = 0 ;
34934 char * kwnames[] = {
34935 (char *) "self",(char *) "colour", NULL
34936 };
34937
34938 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34939 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34940 if (!SWIG_IsOK(res1)) {
34941 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34942 }
34943 arg1 = reinterpret_cast< wxWindow * >(argp1);
34944 {
34945 arg2 = &temp2;
34946 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34947 }
34948 {
34949 PyThreadState* __tstate = wxPyBeginAllowThreads();
34950 result = (bool)(arg1)->SetForegroundColour((wxColour const &)*arg2);
34951 wxPyEndAllowThreads(__tstate);
34952 if (PyErr_Occurred()) SWIG_fail;
34953 }
34954 {
34955 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
34956 }
34957 return resultobj;
34958 fail:
34959 return NULL;
34960 }
34961
34962
34963 SWIGINTERN PyObject *_wrap_Window_SetOwnForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
34964 PyObject *resultobj = 0;
34965 wxWindow *arg1 = (wxWindow *) 0 ;
34966 wxColour *arg2 = 0 ;
34967 void *argp1 = 0 ;
34968 int res1 = 0 ;
34969 wxColour temp2 ;
34970 PyObject * obj0 = 0 ;
34971 PyObject * obj1 = 0 ;
34972 char * kwnames[] = {
34973 (char *) "self",(char *) "colour", NULL
34974 };
34975
34976 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnForegroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
34977 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
34978 if (!SWIG_IsOK(res1)) {
34979 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnForegroundColour" "', expected argument " "1"" of type '" "wxWindow *""'");
34980 }
34981 arg1 = reinterpret_cast< wxWindow * >(argp1);
34982 {
34983 arg2 = &temp2;
34984 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
34985 }
34986 {
34987 PyThreadState* __tstate = wxPyBeginAllowThreads();
34988 (arg1)->SetOwnForegroundColour((wxColour const &)*arg2);
34989 wxPyEndAllowThreads(__tstate);
34990 if (PyErr_Occurred()) SWIG_fail;
34991 }
34992 resultobj = SWIG_Py_Void();
34993 return resultobj;
34994 fail:
34995 return NULL;
34996 }
34997
34998
34999 SWIGINTERN PyObject *_wrap_Window_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35000 PyObject *resultobj = 0;
35001 wxWindow *arg1 = (wxWindow *) 0 ;
35002 wxColour result;
35003 void *argp1 = 0 ;
35004 int res1 = 0 ;
35005 PyObject *swig_obj[1] ;
35006
35007 if (!args) SWIG_fail;
35008 swig_obj[0] = args;
35009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35010 if (!SWIG_IsOK(res1)) {
35011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35012 }
35013 arg1 = reinterpret_cast< wxWindow * >(argp1);
35014 {
35015 PyThreadState* __tstate = wxPyBeginAllowThreads();
35016 result = ((wxWindow const *)arg1)->GetBackgroundColour();
35017 wxPyEndAllowThreads(__tstate);
35018 if (PyErr_Occurred()) SWIG_fail;
35019 }
35020 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35021 return resultobj;
35022 fail:
35023 return NULL;
35024 }
35025
35026
35027 SWIGINTERN PyObject *_wrap_Window_GetForegroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35028 PyObject *resultobj = 0;
35029 wxWindow *arg1 = (wxWindow *) 0 ;
35030 wxColour result;
35031 void *argp1 = 0 ;
35032 int res1 = 0 ;
35033 PyObject *swig_obj[1] ;
35034
35035 if (!args) SWIG_fail;
35036 swig_obj[0] = args;
35037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35038 if (!SWIG_IsOK(res1)) {
35039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetForegroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35040 }
35041 arg1 = reinterpret_cast< wxWindow * >(argp1);
35042 {
35043 PyThreadState* __tstate = wxPyBeginAllowThreads();
35044 result = ((wxWindow const *)arg1)->GetForegroundColour();
35045 wxPyEndAllowThreads(__tstate);
35046 if (PyErr_Occurred()) SWIG_fail;
35047 }
35048 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
35049 return resultobj;
35050 fail:
35051 return NULL;
35052 }
35053
35054
35055 SWIGINTERN PyObject *_wrap_Window_InheritsBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35056 PyObject *resultobj = 0;
35057 wxWindow *arg1 = (wxWindow *) 0 ;
35058 bool result;
35059 void *argp1 = 0 ;
35060 int res1 = 0 ;
35061 PyObject *swig_obj[1] ;
35062
35063 if (!args) SWIG_fail;
35064 swig_obj[0] = args;
35065 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35066 if (!SWIG_IsOK(res1)) {
35067 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritsBackgroundColour" "', expected argument " "1"" of type '" "wxWindow const *""'");
35068 }
35069 arg1 = reinterpret_cast< wxWindow * >(argp1);
35070 {
35071 PyThreadState* __tstate = wxPyBeginAllowThreads();
35072 result = (bool)((wxWindow const *)arg1)->InheritsBackgroundColour();
35073 wxPyEndAllowThreads(__tstate);
35074 if (PyErr_Occurred()) SWIG_fail;
35075 }
35076 {
35077 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35078 }
35079 return resultobj;
35080 fail:
35081 return NULL;
35082 }
35083
35084
35085 SWIGINTERN PyObject *_wrap_Window_UseBgCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35086 PyObject *resultobj = 0;
35087 wxWindow *arg1 = (wxWindow *) 0 ;
35088 bool result;
35089 void *argp1 = 0 ;
35090 int res1 = 0 ;
35091 PyObject *swig_obj[1] ;
35092
35093 if (!args) SWIG_fail;
35094 swig_obj[0] = args;
35095 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35096 if (!SWIG_IsOK(res1)) {
35097 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UseBgCol" "', expected argument " "1"" of type '" "wxWindow const *""'");
35098 }
35099 arg1 = reinterpret_cast< wxWindow * >(argp1);
35100 {
35101 PyThreadState* __tstate = wxPyBeginAllowThreads();
35102 result = (bool)((wxWindow const *)arg1)->UseBgCol();
35103 wxPyEndAllowThreads(__tstate);
35104 if (PyErr_Occurred()) SWIG_fail;
35105 }
35106 {
35107 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35108 }
35109 return resultobj;
35110 fail:
35111 return NULL;
35112 }
35113
35114
35115 SWIGINTERN PyObject *_wrap_Window_SetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35116 PyObject *resultobj = 0;
35117 wxWindow *arg1 = (wxWindow *) 0 ;
35118 wxBackgroundStyle arg2 ;
35119 bool result;
35120 void *argp1 = 0 ;
35121 int res1 = 0 ;
35122 int val2 ;
35123 int ecode2 = 0 ;
35124 PyObject * obj0 = 0 ;
35125 PyObject * obj1 = 0 ;
35126 char * kwnames[] = {
35127 (char *) "self",(char *) "style", NULL
35128 };
35129
35130 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetBackgroundStyle",kwnames,&obj0,&obj1)) SWIG_fail;
35131 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35132 if (!SWIG_IsOK(res1)) {
35133 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow *""'");
35134 }
35135 arg1 = reinterpret_cast< wxWindow * >(argp1);
35136 ecode2 = SWIG_AsVal_int(obj1, &val2);
35137 if (!SWIG_IsOK(ecode2)) {
35138 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetBackgroundStyle" "', expected argument " "2"" of type '" "wxBackgroundStyle""'");
35139 }
35140 arg2 = static_cast< wxBackgroundStyle >(val2);
35141 {
35142 PyThreadState* __tstate = wxPyBeginAllowThreads();
35143 result = (bool)(arg1)->SetBackgroundStyle(arg2);
35144 wxPyEndAllowThreads(__tstate);
35145 if (PyErr_Occurred()) SWIG_fail;
35146 }
35147 {
35148 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35149 }
35150 return resultobj;
35151 fail:
35152 return NULL;
35153 }
35154
35155
35156 SWIGINTERN PyObject *_wrap_Window_GetBackgroundStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35157 PyObject *resultobj = 0;
35158 wxWindow *arg1 = (wxWindow *) 0 ;
35159 wxBackgroundStyle result;
35160 void *argp1 = 0 ;
35161 int res1 = 0 ;
35162 PyObject *swig_obj[1] ;
35163
35164 if (!args) SWIG_fail;
35165 swig_obj[0] = args;
35166 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35167 if (!SWIG_IsOK(res1)) {
35168 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBackgroundStyle" "', expected argument " "1"" of type '" "wxWindow const *""'");
35169 }
35170 arg1 = reinterpret_cast< wxWindow * >(argp1);
35171 {
35172 PyThreadState* __tstate = wxPyBeginAllowThreads();
35173 result = (wxBackgroundStyle)((wxWindow const *)arg1)->GetBackgroundStyle();
35174 wxPyEndAllowThreads(__tstate);
35175 if (PyErr_Occurred()) SWIG_fail;
35176 }
35177 resultobj = SWIG_From_int(static_cast< int >(result));
35178 return resultobj;
35179 fail:
35180 return NULL;
35181 }
35182
35183
35184 SWIGINTERN PyObject *_wrap_Window_HasTransparentBackground(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35185 PyObject *resultobj = 0;
35186 wxWindow *arg1 = (wxWindow *) 0 ;
35187 bool result;
35188 void *argp1 = 0 ;
35189 int res1 = 0 ;
35190 PyObject *swig_obj[1] ;
35191
35192 if (!args) SWIG_fail;
35193 swig_obj[0] = args;
35194 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35195 if (!SWIG_IsOK(res1)) {
35196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasTransparentBackground" "', expected argument " "1"" of type '" "wxWindow *""'");
35197 }
35198 arg1 = reinterpret_cast< wxWindow * >(argp1);
35199 {
35200 PyThreadState* __tstate = wxPyBeginAllowThreads();
35201 result = (bool)(arg1)->HasTransparentBackground();
35202 wxPyEndAllowThreads(__tstate);
35203 if (PyErr_Occurred()) SWIG_fail;
35204 }
35205 {
35206 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35207 }
35208 return resultobj;
35209 fail:
35210 return NULL;
35211 }
35212
35213
35214 SWIGINTERN PyObject *_wrap_Window_SetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35215 PyObject *resultobj = 0;
35216 wxWindow *arg1 = (wxWindow *) 0 ;
35217 wxCursor *arg2 = 0 ;
35218 bool result;
35219 void *argp1 = 0 ;
35220 int res1 = 0 ;
35221 void *argp2 = 0 ;
35222 int res2 = 0 ;
35223 PyObject * obj0 = 0 ;
35224 PyObject * obj1 = 0 ;
35225 char * kwnames[] = {
35226 (char *) "self",(char *) "cursor", NULL
35227 };
35228
35229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCursor",kwnames,&obj0,&obj1)) SWIG_fail;
35230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35231 if (!SWIG_IsOK(res1)) {
35232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35233 }
35234 arg1 = reinterpret_cast< wxWindow * >(argp1);
35235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCursor, 0 | 0);
35236 if (!SWIG_IsOK(res2)) {
35237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35238 }
35239 if (!argp2) {
35240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetCursor" "', expected argument " "2"" of type '" "wxCursor const &""'");
35241 }
35242 arg2 = reinterpret_cast< wxCursor * >(argp2);
35243 {
35244 PyThreadState* __tstate = wxPyBeginAllowThreads();
35245 result = (bool)(arg1)->SetCursor((wxCursor const &)*arg2);
35246 wxPyEndAllowThreads(__tstate);
35247 if (PyErr_Occurred()) SWIG_fail;
35248 }
35249 {
35250 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35251 }
35252 return resultobj;
35253 fail:
35254 return NULL;
35255 }
35256
35257
35258 SWIGINTERN PyObject *_wrap_Window_GetCursor(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35259 PyObject *resultobj = 0;
35260 wxWindow *arg1 = (wxWindow *) 0 ;
35261 wxCursor result;
35262 void *argp1 = 0 ;
35263 int res1 = 0 ;
35264 PyObject *swig_obj[1] ;
35265
35266 if (!args) SWIG_fail;
35267 swig_obj[0] = args;
35268 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35269 if (!SWIG_IsOK(res1)) {
35270 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCursor" "', expected argument " "1"" of type '" "wxWindow *""'");
35271 }
35272 arg1 = reinterpret_cast< wxWindow * >(argp1);
35273 {
35274 PyThreadState* __tstate = wxPyBeginAllowThreads();
35275 result = (arg1)->GetCursor();
35276 wxPyEndAllowThreads(__tstate);
35277 if (PyErr_Occurred()) SWIG_fail;
35278 }
35279 resultobj = SWIG_NewPointerObj((new wxCursor(static_cast< const wxCursor& >(result))), SWIGTYPE_p_wxCursor, SWIG_POINTER_OWN | 0 );
35280 return resultobj;
35281 fail:
35282 return NULL;
35283 }
35284
35285
35286 SWIGINTERN PyObject *_wrap_Window_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35287 PyObject *resultobj = 0;
35288 wxWindow *arg1 = (wxWindow *) 0 ;
35289 wxFont *arg2 = 0 ;
35290 bool result;
35291 void *argp1 = 0 ;
35292 int res1 = 0 ;
35293 void *argp2 = 0 ;
35294 int res2 = 0 ;
35295 PyObject * obj0 = 0 ;
35296 PyObject * obj1 = 0 ;
35297 char * kwnames[] = {
35298 (char *) "self",(char *) "font", NULL
35299 };
35300
35301 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
35302 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35303 if (!SWIG_IsOK(res1)) {
35304 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35305 }
35306 arg1 = reinterpret_cast< wxWindow * >(argp1);
35307 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35308 if (!SWIG_IsOK(res2)) {
35309 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35310 }
35311 if (!argp2) {
35312 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35313 }
35314 arg2 = reinterpret_cast< wxFont * >(argp2);
35315 {
35316 PyThreadState* __tstate = wxPyBeginAllowThreads();
35317 result = (bool)(arg1)->SetFont((wxFont const &)*arg2);
35318 wxPyEndAllowThreads(__tstate);
35319 if (PyErr_Occurred()) SWIG_fail;
35320 }
35321 {
35322 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
35323 }
35324 return resultobj;
35325 fail:
35326 return NULL;
35327 }
35328
35329
35330 SWIGINTERN PyObject *_wrap_Window_SetOwnFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35331 PyObject *resultobj = 0;
35332 wxWindow *arg1 = (wxWindow *) 0 ;
35333 wxFont *arg2 = 0 ;
35334 void *argp1 = 0 ;
35335 int res1 = 0 ;
35336 void *argp2 = 0 ;
35337 int res2 = 0 ;
35338 PyObject * obj0 = 0 ;
35339 PyObject * obj1 = 0 ;
35340 char * kwnames[] = {
35341 (char *) "self",(char *) "font", NULL
35342 };
35343
35344 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetOwnFont",kwnames,&obj0,&obj1)) SWIG_fail;
35345 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35346 if (!SWIG_IsOK(res1)) {
35347 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetOwnFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35348 }
35349 arg1 = reinterpret_cast< wxWindow * >(argp1);
35350 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
35351 if (!SWIG_IsOK(res2)) {
35352 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35353 }
35354 if (!argp2) {
35355 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_SetOwnFont" "', expected argument " "2"" of type '" "wxFont const &""'");
35356 }
35357 arg2 = reinterpret_cast< wxFont * >(argp2);
35358 {
35359 PyThreadState* __tstate = wxPyBeginAllowThreads();
35360 (arg1)->SetOwnFont((wxFont const &)*arg2);
35361 wxPyEndAllowThreads(__tstate);
35362 if (PyErr_Occurred()) SWIG_fail;
35363 }
35364 resultobj = SWIG_Py_Void();
35365 return resultobj;
35366 fail:
35367 return NULL;
35368 }
35369
35370
35371 SWIGINTERN PyObject *_wrap_Window_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35372 PyObject *resultobj = 0;
35373 wxWindow *arg1 = (wxWindow *) 0 ;
35374 wxFont result;
35375 void *argp1 = 0 ;
35376 int res1 = 0 ;
35377 PyObject *swig_obj[1] ;
35378
35379 if (!args) SWIG_fail;
35380 swig_obj[0] = args;
35381 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35382 if (!SWIG_IsOK(res1)) {
35383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFont" "', expected argument " "1"" of type '" "wxWindow *""'");
35384 }
35385 arg1 = reinterpret_cast< wxWindow * >(argp1);
35386 {
35387 PyThreadState* __tstate = wxPyBeginAllowThreads();
35388 result = (arg1)->GetFont();
35389 wxPyEndAllowThreads(__tstate);
35390 if (PyErr_Occurred()) SWIG_fail;
35391 }
35392 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
35393 return resultobj;
35394 fail:
35395 return NULL;
35396 }
35397
35398
35399 SWIGINTERN PyObject *_wrap_Window_SetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35400 PyObject *resultobj = 0;
35401 wxWindow *arg1 = (wxWindow *) 0 ;
35402 wxCaret *arg2 = (wxCaret *) 0 ;
35403 void *argp1 = 0 ;
35404 int res1 = 0 ;
35405 int res2 = 0 ;
35406 PyObject * obj0 = 0 ;
35407 PyObject * obj1 = 0 ;
35408 char * kwnames[] = {
35409 (char *) "self",(char *) "caret", NULL
35410 };
35411
35412 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetCaret",kwnames,&obj0,&obj1)) SWIG_fail;
35413 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35414 if (!SWIG_IsOK(res1)) {
35415 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetCaret" "', expected argument " "1"" of type '" "wxWindow *""'");
35416 }
35417 arg1 = reinterpret_cast< wxWindow * >(argp1);
35418 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxCaret, SWIG_POINTER_DISOWN | 0 );
35419 if (!SWIG_IsOK(res2)) {
35420 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetCaret" "', expected argument " "2"" of type '" "wxCaret *""'");
35421 }
35422 {
35423 PyThreadState* __tstate = wxPyBeginAllowThreads();
35424 (arg1)->SetCaret(arg2);
35425 wxPyEndAllowThreads(__tstate);
35426 if (PyErr_Occurred()) SWIG_fail;
35427 }
35428 resultobj = SWIG_Py_Void();
35429 return resultobj;
35430 fail:
35431 return NULL;
35432 }
35433
35434
35435 SWIGINTERN PyObject *_wrap_Window_GetCaret(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35436 PyObject *resultobj = 0;
35437 wxWindow *arg1 = (wxWindow *) 0 ;
35438 wxCaret *result = 0 ;
35439 void *argp1 = 0 ;
35440 int res1 = 0 ;
35441 PyObject *swig_obj[1] ;
35442
35443 if (!args) SWIG_fail;
35444 swig_obj[0] = args;
35445 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35446 if (!SWIG_IsOK(res1)) {
35447 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCaret" "', expected argument " "1"" of type '" "wxWindow const *""'");
35448 }
35449 arg1 = reinterpret_cast< wxWindow * >(argp1);
35450 {
35451 PyThreadState* __tstate = wxPyBeginAllowThreads();
35452 result = (wxCaret *)((wxWindow const *)arg1)->GetCaret();
35453 wxPyEndAllowThreads(__tstate);
35454 if (PyErr_Occurred()) SWIG_fail;
35455 }
35456 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxCaret, 0 | 0 );
35457 return resultobj;
35458 fail:
35459 return NULL;
35460 }
35461
35462
35463 SWIGINTERN PyObject *_wrap_Window_GetCharHeight(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35464 PyObject *resultobj = 0;
35465 wxWindow *arg1 = (wxWindow *) 0 ;
35466 int result;
35467 void *argp1 = 0 ;
35468 int res1 = 0 ;
35469 PyObject *swig_obj[1] ;
35470
35471 if (!args) SWIG_fail;
35472 swig_obj[0] = args;
35473 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35474 if (!SWIG_IsOK(res1)) {
35475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharHeight" "', expected argument " "1"" of type '" "wxWindow const *""'");
35476 }
35477 arg1 = reinterpret_cast< wxWindow * >(argp1);
35478 {
35479 PyThreadState* __tstate = wxPyBeginAllowThreads();
35480 result = (int)((wxWindow const *)arg1)->GetCharHeight();
35481 wxPyEndAllowThreads(__tstate);
35482 if (PyErr_Occurred()) SWIG_fail;
35483 }
35484 resultobj = SWIG_From_int(static_cast< int >(result));
35485 return resultobj;
35486 fail:
35487 return NULL;
35488 }
35489
35490
35491 SWIGINTERN PyObject *_wrap_Window_GetCharWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
35492 PyObject *resultobj = 0;
35493 wxWindow *arg1 = (wxWindow *) 0 ;
35494 int result;
35495 void *argp1 = 0 ;
35496 int res1 = 0 ;
35497 PyObject *swig_obj[1] ;
35498
35499 if (!args) SWIG_fail;
35500 swig_obj[0] = args;
35501 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35502 if (!SWIG_IsOK(res1)) {
35503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetCharWidth" "', expected argument " "1"" of type '" "wxWindow const *""'");
35504 }
35505 arg1 = reinterpret_cast< wxWindow * >(argp1);
35506 {
35507 PyThreadState* __tstate = wxPyBeginAllowThreads();
35508 result = (int)((wxWindow const *)arg1)->GetCharWidth();
35509 wxPyEndAllowThreads(__tstate);
35510 if (PyErr_Occurred()) SWIG_fail;
35511 }
35512 resultobj = SWIG_From_int(static_cast< int >(result));
35513 return resultobj;
35514 fail:
35515 return NULL;
35516 }
35517
35518
35519 SWIGINTERN PyObject *_wrap_Window_GetTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35520 PyObject *resultobj = 0;
35521 wxWindow *arg1 = (wxWindow *) 0 ;
35522 wxString *arg2 = 0 ;
35523 int *arg3 = (int *) 0 ;
35524 int *arg4 = (int *) 0 ;
35525 void *argp1 = 0 ;
35526 int res1 = 0 ;
35527 bool temp2 = false ;
35528 int temp3 ;
35529 int res3 = SWIG_TMPOBJ ;
35530 int temp4 ;
35531 int res4 = SWIG_TMPOBJ ;
35532 PyObject * obj0 = 0 ;
35533 PyObject * obj1 = 0 ;
35534 char * kwnames[] = {
35535 (char *) "self",(char *) "string", NULL
35536 };
35537
35538 arg3 = &temp3;
35539 arg4 = &temp4;
35540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetTextExtent",kwnames,&obj0,&obj1)) SWIG_fail;
35541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35542 if (!SWIG_IsOK(res1)) {
35543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35544 }
35545 arg1 = reinterpret_cast< wxWindow * >(argp1);
35546 {
35547 arg2 = wxString_in_helper(obj1);
35548 if (arg2 == NULL) SWIG_fail;
35549 temp2 = true;
35550 }
35551 {
35552 PyThreadState* __tstate = wxPyBeginAllowThreads();
35553 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4);
35554 wxPyEndAllowThreads(__tstate);
35555 if (PyErr_Occurred()) SWIG_fail;
35556 }
35557 resultobj = SWIG_Py_Void();
35558 if (SWIG_IsTmpObj(res3)) {
35559 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35560 } else {
35561 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35562 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35563 }
35564 if (SWIG_IsTmpObj(res4)) {
35565 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35566 } else {
35567 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35568 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35569 }
35570 {
35571 if (temp2)
35572 delete arg2;
35573 }
35574 return resultobj;
35575 fail:
35576 {
35577 if (temp2)
35578 delete arg2;
35579 }
35580 return NULL;
35581 }
35582
35583
35584 SWIGINTERN PyObject *_wrap_Window_GetFullTextExtent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35585 PyObject *resultobj = 0;
35586 wxWindow *arg1 = (wxWindow *) 0 ;
35587 wxString *arg2 = 0 ;
35588 int *arg3 = (int *) 0 ;
35589 int *arg4 = (int *) 0 ;
35590 int *arg5 = (int *) 0 ;
35591 int *arg6 = (int *) 0 ;
35592 wxFont *arg7 = (wxFont *) NULL ;
35593 void *argp1 = 0 ;
35594 int res1 = 0 ;
35595 bool temp2 = false ;
35596 int temp3 ;
35597 int res3 = SWIG_TMPOBJ ;
35598 int temp4 ;
35599 int res4 = SWIG_TMPOBJ ;
35600 int temp5 ;
35601 int res5 = SWIG_TMPOBJ ;
35602 int temp6 ;
35603 int res6 = SWIG_TMPOBJ ;
35604 void *argp7 = 0 ;
35605 int res7 = 0 ;
35606 PyObject * obj0 = 0 ;
35607 PyObject * obj1 = 0 ;
35608 PyObject * obj2 = 0 ;
35609 char * kwnames[] = {
35610 (char *) "self",(char *) "string",(char *) "font", NULL
35611 };
35612
35613 arg3 = &temp3;
35614 arg4 = &temp4;
35615 arg5 = &temp5;
35616 arg6 = &temp6;
35617 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_GetFullTextExtent",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35618 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35619 if (!SWIG_IsOK(res1)) {
35620 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetFullTextExtent" "', expected argument " "1"" of type '" "wxWindow *""'");
35621 }
35622 arg1 = reinterpret_cast< wxWindow * >(argp1);
35623 {
35624 arg2 = wxString_in_helper(obj1);
35625 if (arg2 == NULL) SWIG_fail;
35626 temp2 = true;
35627 }
35628 if (obj2) {
35629 res7 = SWIG_ConvertPtr(obj2, &argp7,SWIGTYPE_p_wxFont, 0 | 0 );
35630 if (!SWIG_IsOK(res7)) {
35631 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Window_GetFullTextExtent" "', expected argument " "7"" of type '" "wxFont const *""'");
35632 }
35633 arg7 = reinterpret_cast< wxFont * >(argp7);
35634 }
35635 {
35636 PyThreadState* __tstate = wxPyBeginAllowThreads();
35637 (arg1)->GetTextExtent((wxString const &)*arg2,arg3,arg4,arg5,arg6,(wxFont const *)arg7);
35638 wxPyEndAllowThreads(__tstate);
35639 if (PyErr_Occurred()) SWIG_fail;
35640 }
35641 resultobj = SWIG_Py_Void();
35642 if (SWIG_IsTmpObj(res3)) {
35643 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35644 } else {
35645 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35646 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35647 }
35648 if (SWIG_IsTmpObj(res4)) {
35649 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg4)));
35650 } else {
35651 int new_flags = SWIG_IsNewObj(res4) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35652 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg4), SWIGTYPE_p_int, new_flags));
35653 }
35654 if (SWIG_IsTmpObj(res5)) {
35655 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg5)));
35656 } else {
35657 int new_flags = SWIG_IsNewObj(res5) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35658 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg5), SWIGTYPE_p_int, new_flags));
35659 }
35660 if (SWIG_IsTmpObj(res6)) {
35661 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg6)));
35662 } else {
35663 int new_flags = SWIG_IsNewObj(res6) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35664 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg6), SWIGTYPE_p_int, new_flags));
35665 }
35666 {
35667 if (temp2)
35668 delete arg2;
35669 }
35670 return resultobj;
35671 fail:
35672 {
35673 if (temp2)
35674 delete arg2;
35675 }
35676 return NULL;
35677 }
35678
35679
35680 SWIGINTERN PyObject *_wrap_Window_ClientToScreenXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35681 PyObject *resultobj = 0;
35682 wxWindow *arg1 = (wxWindow *) 0 ;
35683 int *arg2 = (int *) 0 ;
35684 int *arg3 = (int *) 0 ;
35685 void *argp1 = 0 ;
35686 int res1 = 0 ;
35687 int temp2 ;
35688 int res2 = 0 ;
35689 int temp3 ;
35690 int res3 = 0 ;
35691 PyObject * obj0 = 0 ;
35692 PyObject * obj1 = 0 ;
35693 PyObject * obj2 = 0 ;
35694 char * kwnames[] = {
35695 (char *) "self",(char *) "x",(char *) "y", NULL
35696 };
35697
35698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ClientToScreenXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35700 if (!SWIG_IsOK(res1)) {
35701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreenXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35702 }
35703 arg1 = reinterpret_cast< wxWindow * >(argp1);
35704 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35705 int val;
35706 int ecode = SWIG_AsVal_int(obj1, &val);
35707 if (!SWIG_IsOK(ecode)) {
35708 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "2"" of type '" "int""'");
35709 }
35710 temp2 = static_cast< int >(val);
35711 arg2 = &temp2;
35712 res2 = SWIG_AddTmpMask(ecode);
35713 }
35714 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35715 int val;
35716 int ecode = SWIG_AsVal_int(obj2, &val);
35717 if (!SWIG_IsOK(ecode)) {
35718 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ClientToScreenXY" "', expected argument " "3"" of type '" "int""'");
35719 }
35720 temp3 = static_cast< int >(val);
35721 arg3 = &temp3;
35722 res3 = SWIG_AddTmpMask(ecode);
35723 }
35724 {
35725 PyThreadState* __tstate = wxPyBeginAllowThreads();
35726 ((wxWindow const *)arg1)->ClientToScreen(arg2,arg3);
35727 wxPyEndAllowThreads(__tstate);
35728 if (PyErr_Occurred()) SWIG_fail;
35729 }
35730 resultobj = SWIG_Py_Void();
35731 if (SWIG_IsTmpObj(res2)) {
35732 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35733 } else {
35734 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35735 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35736 }
35737 if (SWIG_IsTmpObj(res3)) {
35738 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35739 } else {
35740 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35741 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35742 }
35743 return resultobj;
35744 fail:
35745 return NULL;
35746 }
35747
35748
35749 SWIGINTERN PyObject *_wrap_Window_ScreenToClientXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35750 PyObject *resultobj = 0;
35751 wxWindow *arg1 = (wxWindow *) 0 ;
35752 int *arg2 = (int *) 0 ;
35753 int *arg3 = (int *) 0 ;
35754 void *argp1 = 0 ;
35755 int res1 = 0 ;
35756 int temp2 ;
35757 int res2 = 0 ;
35758 int temp3 ;
35759 int res3 = 0 ;
35760 PyObject * obj0 = 0 ;
35761 PyObject * obj1 = 0 ;
35762 PyObject * obj2 = 0 ;
35763 char * kwnames[] = {
35764 (char *) "self",(char *) "x",(char *) "y", NULL
35765 };
35766
35767 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_ScreenToClientXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35768 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35769 if (!SWIG_IsOK(res1)) {
35770 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClientXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35771 }
35772 arg1 = reinterpret_cast< wxWindow * >(argp1);
35773 if (!(SWIG_IsOK((res2 = SWIG_ConvertPtr(obj1,SWIG_as_voidptrptr(&arg2),SWIGTYPE_p_int,0))))) {
35774 int val;
35775 int ecode = SWIG_AsVal_int(obj1, &val);
35776 if (!SWIG_IsOK(ecode)) {
35777 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "2"" of type '" "int""'");
35778 }
35779 temp2 = static_cast< int >(val);
35780 arg2 = &temp2;
35781 res2 = SWIG_AddTmpMask(ecode);
35782 }
35783 if (!(SWIG_IsOK((res3 = SWIG_ConvertPtr(obj2,SWIG_as_voidptrptr(&arg3),SWIGTYPE_p_int,0))))) {
35784 int val;
35785 int ecode = SWIG_AsVal_int(obj2, &val);
35786 if (!SWIG_IsOK(ecode)) {
35787 SWIG_exception_fail(SWIG_ArgError(ecode), "in method '" "Window_ScreenToClientXY" "', expected argument " "3"" of type '" "int""'");
35788 }
35789 temp3 = static_cast< int >(val);
35790 arg3 = &temp3;
35791 res3 = SWIG_AddTmpMask(ecode);
35792 }
35793 {
35794 PyThreadState* __tstate = wxPyBeginAllowThreads();
35795 ((wxWindow const *)arg1)->ScreenToClient(arg2,arg3);
35796 wxPyEndAllowThreads(__tstate);
35797 if (PyErr_Occurred()) SWIG_fail;
35798 }
35799 resultobj = SWIG_Py_Void();
35800 if (SWIG_IsTmpObj(res2)) {
35801 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg2)));
35802 } else {
35803 int new_flags = SWIG_IsNewObj(res2) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35804 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg2), SWIGTYPE_p_int, new_flags));
35805 }
35806 if (SWIG_IsTmpObj(res3)) {
35807 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
35808 } else {
35809 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
35810 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
35811 }
35812 return resultobj;
35813 fail:
35814 return NULL;
35815 }
35816
35817
35818 SWIGINTERN PyObject *_wrap_Window_ClientToScreen(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35819 PyObject *resultobj = 0;
35820 wxWindow *arg1 = (wxWindow *) 0 ;
35821 wxPoint *arg2 = 0 ;
35822 wxPoint result;
35823 void *argp1 = 0 ;
35824 int res1 = 0 ;
35825 wxPoint temp2 ;
35826 PyObject * obj0 = 0 ;
35827 PyObject * obj1 = 0 ;
35828 char * kwnames[] = {
35829 (char *) "self",(char *) "pt", NULL
35830 };
35831
35832 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ClientToScreen",kwnames,&obj0,&obj1)) SWIG_fail;
35833 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35834 if (!SWIG_IsOK(res1)) {
35835 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ClientToScreen" "', expected argument " "1"" of type '" "wxWindow const *""'");
35836 }
35837 arg1 = reinterpret_cast< wxWindow * >(argp1);
35838 {
35839 arg2 = &temp2;
35840 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35841 }
35842 {
35843 PyThreadState* __tstate = wxPyBeginAllowThreads();
35844 result = ((wxWindow const *)arg1)->ClientToScreen((wxPoint const &)*arg2);
35845 wxPyEndAllowThreads(__tstate);
35846 if (PyErr_Occurred()) SWIG_fail;
35847 }
35848 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35849 return resultobj;
35850 fail:
35851 return NULL;
35852 }
35853
35854
35855 SWIGINTERN PyObject *_wrap_Window_ScreenToClient(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35856 PyObject *resultobj = 0;
35857 wxWindow *arg1 = (wxWindow *) 0 ;
35858 wxPoint *arg2 = 0 ;
35859 wxPoint result;
35860 void *argp1 = 0 ;
35861 int res1 = 0 ;
35862 wxPoint temp2 ;
35863 PyObject * obj0 = 0 ;
35864 PyObject * obj1 = 0 ;
35865 char * kwnames[] = {
35866 (char *) "self",(char *) "pt", NULL
35867 };
35868
35869 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScreenToClient",kwnames,&obj0,&obj1)) SWIG_fail;
35870 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35871 if (!SWIG_IsOK(res1)) {
35872 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScreenToClient" "', expected argument " "1"" of type '" "wxWindow const *""'");
35873 }
35874 arg1 = reinterpret_cast< wxWindow * >(argp1);
35875 {
35876 arg2 = &temp2;
35877 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35878 }
35879 {
35880 PyThreadState* __tstate = wxPyBeginAllowThreads();
35881 result = ((wxWindow const *)arg1)->ScreenToClient((wxPoint const &)*arg2);
35882 wxPyEndAllowThreads(__tstate);
35883 if (PyErr_Occurred()) SWIG_fail;
35884 }
35885 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
35886 return resultobj;
35887 fail:
35888 return NULL;
35889 }
35890
35891
35892 SWIGINTERN PyObject *_wrap_Window_HitTestXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35893 PyObject *resultobj = 0;
35894 wxWindow *arg1 = (wxWindow *) 0 ;
35895 int arg2 ;
35896 int arg3 ;
35897 wxHitTest result;
35898 void *argp1 = 0 ;
35899 int res1 = 0 ;
35900 int val2 ;
35901 int ecode2 = 0 ;
35902 int val3 ;
35903 int ecode3 = 0 ;
35904 PyObject * obj0 = 0 ;
35905 PyObject * obj1 = 0 ;
35906 PyObject * obj2 = 0 ;
35907 char * kwnames[] = {
35908 (char *) "self",(char *) "x",(char *) "y", NULL
35909 };
35910
35911 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_HitTestXY",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
35912 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35913 if (!SWIG_IsOK(res1)) {
35914 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTestXY" "', expected argument " "1"" of type '" "wxWindow const *""'");
35915 }
35916 arg1 = reinterpret_cast< wxWindow * >(argp1);
35917 ecode2 = SWIG_AsVal_int(obj1, &val2);
35918 if (!SWIG_IsOK(ecode2)) {
35919 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HitTestXY" "', expected argument " "2"" of type '" "int""'");
35920 }
35921 arg2 = static_cast< int >(val2);
35922 ecode3 = SWIG_AsVal_int(obj2, &val3);
35923 if (!SWIG_IsOK(ecode3)) {
35924 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_HitTestXY" "', expected argument " "3"" of type '" "int""'");
35925 }
35926 arg3 = static_cast< int >(val3);
35927 {
35928 PyThreadState* __tstate = wxPyBeginAllowThreads();
35929 result = (wxHitTest)((wxWindow const *)arg1)->HitTest(arg2,arg3);
35930 wxPyEndAllowThreads(__tstate);
35931 if (PyErr_Occurred()) SWIG_fail;
35932 }
35933 resultobj = SWIG_From_int(static_cast< int >(result));
35934 return resultobj;
35935 fail:
35936 return NULL;
35937 }
35938
35939
35940 SWIGINTERN PyObject *_wrap_Window_HitTest(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
35941 PyObject *resultobj = 0;
35942 wxWindow *arg1 = (wxWindow *) 0 ;
35943 wxPoint *arg2 = 0 ;
35944 wxHitTest result;
35945 void *argp1 = 0 ;
35946 int res1 = 0 ;
35947 wxPoint temp2 ;
35948 PyObject * obj0 = 0 ;
35949 PyObject * obj1 = 0 ;
35950 char * kwnames[] = {
35951 (char *) "self",(char *) "pt", NULL
35952 };
35953
35954 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HitTest",kwnames,&obj0,&obj1)) SWIG_fail;
35955 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35956 if (!SWIG_IsOK(res1)) {
35957 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HitTest" "', expected argument " "1"" of type '" "wxWindow const *""'");
35958 }
35959 arg1 = reinterpret_cast< wxWindow * >(argp1);
35960 {
35961 arg2 = &temp2;
35962 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
35963 }
35964 {
35965 PyThreadState* __tstate = wxPyBeginAllowThreads();
35966 result = (wxHitTest)((wxWindow const *)arg1)->HitTest((wxPoint const &)*arg2);
35967 wxPyEndAllowThreads(__tstate);
35968 if (PyErr_Occurred()) SWIG_fail;
35969 }
35970 resultobj = SWIG_From_int(static_cast< int >(result));
35971 return resultobj;
35972 fail:
35973 return NULL;
35974 }
35975
35976
35977 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
35978 PyObject *resultobj = 0;
35979 wxWindow *arg1 = (wxWindow *) 0 ;
35980 long arg2 ;
35981 wxBorder result;
35982 void *argp1 = 0 ;
35983 int res1 = 0 ;
35984 long val2 ;
35985 int ecode2 = 0 ;
35986
35987 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
35988 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
35989 if (!SWIG_IsOK(res1)) {
35990 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
35991 }
35992 arg1 = reinterpret_cast< wxWindow * >(argp1);
35993 ecode2 = SWIG_AsVal_long(swig_obj[1], &val2);
35994 if (!SWIG_IsOK(ecode2)) {
35995 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetBorder" "', expected argument " "2"" of type '" "long""'");
35996 }
35997 arg2 = static_cast< long >(val2);
35998 {
35999 PyThreadState* __tstate = wxPyBeginAllowThreads();
36000 result = (wxBorder)((wxWindow const *)arg1)->GetBorder(arg2);
36001 wxPyEndAllowThreads(__tstate);
36002 if (PyErr_Occurred()) SWIG_fail;
36003 }
36004 resultobj = SWIG_From_int(static_cast< int >(result));
36005 return resultobj;
36006 fail:
36007 return NULL;
36008 }
36009
36010
36011 SWIGINTERN PyObject *_wrap_Window_GetBorder__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
36012 PyObject *resultobj = 0;
36013 wxWindow *arg1 = (wxWindow *) 0 ;
36014 wxBorder result;
36015 void *argp1 = 0 ;
36016 int res1 = 0 ;
36017
36018 if ((nobjs < 1) || (nobjs > 1)) SWIG_fail;
36019 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36020 if (!SWIG_IsOK(res1)) {
36021 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetBorder" "', expected argument " "1"" of type '" "wxWindow const *""'");
36022 }
36023 arg1 = reinterpret_cast< wxWindow * >(argp1);
36024 {
36025 PyThreadState* __tstate = wxPyBeginAllowThreads();
36026 result = (wxBorder)((wxWindow const *)arg1)->GetBorder();
36027 wxPyEndAllowThreads(__tstate);
36028 if (PyErr_Occurred()) SWIG_fail;
36029 }
36030 resultobj = SWIG_From_int(static_cast< int >(result));
36031 return resultobj;
36032 fail:
36033 return NULL;
36034 }
36035
36036
36037 SWIGINTERN PyObject *_wrap_Window_GetBorder(PyObject *self, PyObject *args) {
36038 int argc;
36039 PyObject *argv[3];
36040
36041 if (!(argc = SWIG_Python_UnpackTuple(args,"Window_GetBorder",0,2,argv))) SWIG_fail;
36042 --argc;
36043 if (argc == 1) {
36044 return _wrap_Window_GetBorder__SWIG_1(self, argc, argv);
36045 }
36046 if (argc == 2) {
36047 return _wrap_Window_GetBorder__SWIG_0(self, argc, argv);
36048 }
36049
36050 fail:
36051 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'Window_GetBorder'");
36052 return NULL;
36053 }
36054
36055
36056 SWIGINTERN PyObject *_wrap_Window_UpdateWindowUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36057 PyObject *resultobj = 0;
36058 wxWindow *arg1 = (wxWindow *) 0 ;
36059 long arg2 = (long) wxUPDATE_UI_NONE ;
36060 void *argp1 = 0 ;
36061 int res1 = 0 ;
36062 long val2 ;
36063 int ecode2 = 0 ;
36064 PyObject * obj0 = 0 ;
36065 PyObject * obj1 = 0 ;
36066 char * kwnames[] = {
36067 (char *) "self",(char *) "flags", NULL
36068 };
36069
36070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Window_UpdateWindowUI",kwnames,&obj0,&obj1)) SWIG_fail;
36071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36072 if (!SWIG_IsOK(res1)) {
36073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_UpdateWindowUI" "', expected argument " "1"" of type '" "wxWindow *""'");
36074 }
36075 arg1 = reinterpret_cast< wxWindow * >(argp1);
36076 if (obj1) {
36077 ecode2 = SWIG_AsVal_long(obj1, &val2);
36078 if (!SWIG_IsOK(ecode2)) {
36079 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_UpdateWindowUI" "', expected argument " "2"" of type '" "long""'");
36080 }
36081 arg2 = static_cast< long >(val2);
36082 }
36083 {
36084 PyThreadState* __tstate = wxPyBeginAllowThreads();
36085 (arg1)->UpdateWindowUI(arg2);
36086 wxPyEndAllowThreads(__tstate);
36087 if (PyErr_Occurred()) SWIG_fail;
36088 }
36089 resultobj = SWIG_Py_Void();
36090 return resultobj;
36091 fail:
36092 return NULL;
36093 }
36094
36095
36096 SWIGINTERN PyObject *_wrap_Window_PopupMenuXY(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36097 PyObject *resultobj = 0;
36098 wxWindow *arg1 = (wxWindow *) 0 ;
36099 wxMenu *arg2 = (wxMenu *) 0 ;
36100 int arg3 = (int) -1 ;
36101 int arg4 = (int) -1 ;
36102 bool result;
36103 void *argp1 = 0 ;
36104 int res1 = 0 ;
36105 void *argp2 = 0 ;
36106 int res2 = 0 ;
36107 int val3 ;
36108 int ecode3 = 0 ;
36109 int val4 ;
36110 int ecode4 = 0 ;
36111 PyObject * obj0 = 0 ;
36112 PyObject * obj1 = 0 ;
36113 PyObject * obj2 = 0 ;
36114 PyObject * obj3 = 0 ;
36115 char * kwnames[] = {
36116 (char *) "self",(char *) "menu",(char *) "x",(char *) "y", NULL
36117 };
36118
36119 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Window_PopupMenuXY",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36120 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36121 if (!SWIG_IsOK(res1)) {
36122 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenuXY" "', expected argument " "1"" of type '" "wxWindow *""'");
36123 }
36124 arg1 = reinterpret_cast< wxWindow * >(argp1);
36125 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36126 if (!SWIG_IsOK(res2)) {
36127 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenuXY" "', expected argument " "2"" of type '" "wxMenu *""'");
36128 }
36129 arg2 = reinterpret_cast< wxMenu * >(argp2);
36130 if (obj2) {
36131 ecode3 = SWIG_AsVal_int(obj2, &val3);
36132 if (!SWIG_IsOK(ecode3)) {
36133 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_PopupMenuXY" "', expected argument " "3"" of type '" "int""'");
36134 }
36135 arg3 = static_cast< int >(val3);
36136 }
36137 if (obj3) {
36138 ecode4 = SWIG_AsVal_int(obj3, &val4);
36139 if (!SWIG_IsOK(ecode4)) {
36140 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_PopupMenuXY" "', expected argument " "4"" of type '" "int""'");
36141 }
36142 arg4 = static_cast< int >(val4);
36143 }
36144 {
36145 PyThreadState* __tstate = wxPyBeginAllowThreads();
36146 result = (bool)(arg1)->PopupMenu(arg2,arg3,arg4);
36147 wxPyEndAllowThreads(__tstate);
36148 if (PyErr_Occurred()) SWIG_fail;
36149 }
36150 {
36151 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36152 }
36153 return resultobj;
36154 fail:
36155 return NULL;
36156 }
36157
36158
36159 SWIGINTERN PyObject *_wrap_Window_PopupMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36160 PyObject *resultobj = 0;
36161 wxWindow *arg1 = (wxWindow *) 0 ;
36162 wxMenu *arg2 = (wxMenu *) 0 ;
36163 wxPoint const &arg3_defvalue = wxDefaultPosition ;
36164 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
36165 bool result;
36166 void *argp1 = 0 ;
36167 int res1 = 0 ;
36168 void *argp2 = 0 ;
36169 int res2 = 0 ;
36170 wxPoint temp3 ;
36171 PyObject * obj0 = 0 ;
36172 PyObject * obj1 = 0 ;
36173 PyObject * obj2 = 0 ;
36174 char * kwnames[] = {
36175 (char *) "self",(char *) "menu",(char *) "pos", NULL
36176 };
36177
36178 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_PopupMenu",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36179 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36180 if (!SWIG_IsOK(res1)) {
36181 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PopupMenu" "', expected argument " "1"" of type '" "wxWindow *""'");
36182 }
36183 arg1 = reinterpret_cast< wxWindow * >(argp1);
36184 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
36185 if (!SWIG_IsOK(res2)) {
36186 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_PopupMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
36187 }
36188 arg2 = reinterpret_cast< wxMenu * >(argp2);
36189 if (obj2) {
36190 {
36191 arg3 = &temp3;
36192 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
36193 }
36194 }
36195 {
36196 PyThreadState* __tstate = wxPyBeginAllowThreads();
36197 result = (bool)(arg1)->PopupMenu(arg2,(wxPoint const &)*arg3);
36198 wxPyEndAllowThreads(__tstate);
36199 if (PyErr_Occurred()) SWIG_fail;
36200 }
36201 {
36202 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36203 }
36204 return resultobj;
36205 fail:
36206 return NULL;
36207 }
36208
36209
36210 SWIGINTERN PyObject *_wrap_Window_HasMultiplePages(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36211 PyObject *resultobj = 0;
36212 wxWindow *arg1 = (wxWindow *) 0 ;
36213 bool result;
36214 void *argp1 = 0 ;
36215 int res1 = 0 ;
36216 PyObject *swig_obj[1] ;
36217
36218 if (!args) SWIG_fail;
36219 swig_obj[0] = args;
36220 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36221 if (!SWIG_IsOK(res1)) {
36222 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasMultiplePages" "', expected argument " "1"" of type '" "wxWindow const *""'");
36223 }
36224 arg1 = reinterpret_cast< wxWindow * >(argp1);
36225 {
36226 PyThreadState* __tstate = wxPyBeginAllowThreads();
36227 result = (bool)((wxWindow const *)arg1)->HasMultiplePages();
36228 wxPyEndAllowThreads(__tstate);
36229 if (PyErr_Occurred()) SWIG_fail;
36230 }
36231 {
36232 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36233 }
36234 return resultobj;
36235 fail:
36236 return NULL;
36237 }
36238
36239
36240 SWIGINTERN PyObject *_wrap_Window_GetHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36241 PyObject *resultobj = 0;
36242 wxWindow *arg1 = (wxWindow *) 0 ;
36243 long result;
36244 void *argp1 = 0 ;
36245 int res1 = 0 ;
36246 PyObject *swig_obj[1] ;
36247
36248 if (!args) SWIG_fail;
36249 swig_obj[0] = args;
36250 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36251 if (!SWIG_IsOK(res1)) {
36252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36253 }
36254 arg1 = reinterpret_cast< wxWindow * >(argp1);
36255 {
36256 PyThreadState* __tstate = wxPyBeginAllowThreads();
36257 result = (long)wxWindow_GetHandle(arg1);
36258 wxPyEndAllowThreads(__tstate);
36259 if (PyErr_Occurred()) SWIG_fail;
36260 }
36261 resultobj = SWIG_From_long(static_cast< long >(result));
36262 return resultobj;
36263 fail:
36264 return NULL;
36265 }
36266
36267
36268 SWIGINTERN PyObject *_wrap_Window_AssociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36269 PyObject *resultobj = 0;
36270 wxWindow *arg1 = (wxWindow *) 0 ;
36271 long arg2 ;
36272 void *argp1 = 0 ;
36273 int res1 = 0 ;
36274 long val2 ;
36275 int ecode2 = 0 ;
36276 PyObject * obj0 = 0 ;
36277 PyObject * obj1 = 0 ;
36278 char * kwnames[] = {
36279 (char *) "self",(char *) "handle", NULL
36280 };
36281
36282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_AssociateHandle",kwnames,&obj0,&obj1)) SWIG_fail;
36283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36284 if (!SWIG_IsOK(res1)) {
36285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_AssociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36286 }
36287 arg1 = reinterpret_cast< wxWindow * >(argp1);
36288 ecode2 = SWIG_AsVal_long(obj1, &val2);
36289 if (!SWIG_IsOK(ecode2)) {
36290 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_AssociateHandle" "', expected argument " "2"" of type '" "long""'");
36291 }
36292 arg2 = static_cast< long >(val2);
36293 {
36294 PyThreadState* __tstate = wxPyBeginAllowThreads();
36295 wxWindow_AssociateHandle(arg1,arg2);
36296 wxPyEndAllowThreads(__tstate);
36297 if (PyErr_Occurred()) SWIG_fail;
36298 }
36299 resultobj = SWIG_Py_Void();
36300 return resultobj;
36301 fail:
36302 return NULL;
36303 }
36304
36305
36306 SWIGINTERN PyObject *_wrap_Window_DissociateHandle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36307 PyObject *resultobj = 0;
36308 wxWindow *arg1 = (wxWindow *) 0 ;
36309 void *argp1 = 0 ;
36310 int res1 = 0 ;
36311 PyObject *swig_obj[1] ;
36312
36313 if (!args) SWIG_fail;
36314 swig_obj[0] = args;
36315 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36316 if (!SWIG_IsOK(res1)) {
36317 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DissociateHandle" "', expected argument " "1"" of type '" "wxWindow *""'");
36318 }
36319 arg1 = reinterpret_cast< wxWindow * >(argp1);
36320 {
36321 PyThreadState* __tstate = wxPyBeginAllowThreads();
36322 (arg1)->DissociateHandle();
36323 wxPyEndAllowThreads(__tstate);
36324 if (PyErr_Occurred()) SWIG_fail;
36325 }
36326 resultobj = SWIG_Py_Void();
36327 return resultobj;
36328 fail:
36329 return NULL;
36330 }
36331
36332
36333 SWIGINTERN PyObject *_wrap_Window_HasScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36334 PyObject *resultobj = 0;
36335 wxWindow *arg1 = (wxWindow *) 0 ;
36336 int arg2 ;
36337 bool result;
36338 void *argp1 = 0 ;
36339 int res1 = 0 ;
36340 int val2 ;
36341 int ecode2 = 0 ;
36342 PyObject * obj0 = 0 ;
36343 PyObject * obj1 = 0 ;
36344 char * kwnames[] = {
36345 (char *) "self",(char *) "orient", NULL
36346 };
36347
36348 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_HasScrollbar",kwnames,&obj0,&obj1)) SWIG_fail;
36349 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36350 if (!SWIG_IsOK(res1)) {
36351 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_HasScrollbar" "', expected argument " "1"" of type '" "wxWindow const *""'");
36352 }
36353 arg1 = reinterpret_cast< wxWindow * >(argp1);
36354 ecode2 = SWIG_AsVal_int(obj1, &val2);
36355 if (!SWIG_IsOK(ecode2)) {
36356 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_HasScrollbar" "', expected argument " "2"" of type '" "int""'");
36357 }
36358 arg2 = static_cast< int >(val2);
36359 {
36360 PyThreadState* __tstate = wxPyBeginAllowThreads();
36361 result = (bool)((wxWindow const *)arg1)->HasScrollbar(arg2);
36362 wxPyEndAllowThreads(__tstate);
36363 if (PyErr_Occurred()) SWIG_fail;
36364 }
36365 {
36366 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36367 }
36368 return resultobj;
36369 fail:
36370 return NULL;
36371 }
36372
36373
36374 SWIGINTERN PyObject *_wrap_Window_SetScrollbar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36375 PyObject *resultobj = 0;
36376 wxWindow *arg1 = (wxWindow *) 0 ;
36377 int arg2 ;
36378 int arg3 ;
36379 int arg4 ;
36380 int arg5 ;
36381 bool arg6 = (bool) true ;
36382 void *argp1 = 0 ;
36383 int res1 = 0 ;
36384 int val2 ;
36385 int ecode2 = 0 ;
36386 int val3 ;
36387 int ecode3 = 0 ;
36388 int val4 ;
36389 int ecode4 = 0 ;
36390 int val5 ;
36391 int ecode5 = 0 ;
36392 bool val6 ;
36393 int ecode6 = 0 ;
36394 PyObject * obj0 = 0 ;
36395 PyObject * obj1 = 0 ;
36396 PyObject * obj2 = 0 ;
36397 PyObject * obj3 = 0 ;
36398 PyObject * obj4 = 0 ;
36399 PyObject * obj5 = 0 ;
36400 char * kwnames[] = {
36401 (char *) "self",(char *) "orientation",(char *) "position",(char *) "thumbSize",(char *) "range",(char *) "refresh", NULL
36402 };
36403
36404 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Window_SetScrollbar",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
36405 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36406 if (!SWIG_IsOK(res1)) {
36407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollbar" "', expected argument " "1"" of type '" "wxWindow *""'");
36408 }
36409 arg1 = reinterpret_cast< wxWindow * >(argp1);
36410 ecode2 = SWIG_AsVal_int(obj1, &val2);
36411 if (!SWIG_IsOK(ecode2)) {
36412 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollbar" "', expected argument " "2"" of type '" "int""'");
36413 }
36414 arg2 = static_cast< int >(val2);
36415 ecode3 = SWIG_AsVal_int(obj2, &val3);
36416 if (!SWIG_IsOK(ecode3)) {
36417 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollbar" "', expected argument " "3"" of type '" "int""'");
36418 }
36419 arg3 = static_cast< int >(val3);
36420 ecode4 = SWIG_AsVal_int(obj3, &val4);
36421 if (!SWIG_IsOK(ecode4)) {
36422 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollbar" "', expected argument " "4"" of type '" "int""'");
36423 }
36424 arg4 = static_cast< int >(val4);
36425 ecode5 = SWIG_AsVal_int(obj4, &val5);
36426 if (!SWIG_IsOK(ecode5)) {
36427 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Window_SetScrollbar" "', expected argument " "5"" of type '" "int""'");
36428 }
36429 arg5 = static_cast< int >(val5);
36430 if (obj5) {
36431 ecode6 = SWIG_AsVal_bool(obj5, &val6);
36432 if (!SWIG_IsOK(ecode6)) {
36433 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Window_SetScrollbar" "', expected argument " "6"" of type '" "bool""'");
36434 }
36435 arg6 = static_cast< bool >(val6);
36436 }
36437 {
36438 PyThreadState* __tstate = wxPyBeginAllowThreads();
36439 (arg1)->SetScrollbar(arg2,arg3,arg4,arg5,arg6);
36440 wxPyEndAllowThreads(__tstate);
36441 if (PyErr_Occurred()) SWIG_fail;
36442 }
36443 resultobj = SWIG_Py_Void();
36444 return resultobj;
36445 fail:
36446 return NULL;
36447 }
36448
36449
36450 SWIGINTERN PyObject *_wrap_Window_SetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36451 PyObject *resultobj = 0;
36452 wxWindow *arg1 = (wxWindow *) 0 ;
36453 int arg2 ;
36454 int arg3 ;
36455 bool arg4 = (bool) true ;
36456 void *argp1 = 0 ;
36457 int res1 = 0 ;
36458 int val2 ;
36459 int ecode2 = 0 ;
36460 int val3 ;
36461 int ecode3 = 0 ;
36462 bool val4 ;
36463 int ecode4 = 0 ;
36464 PyObject * obj0 = 0 ;
36465 PyObject * obj1 = 0 ;
36466 PyObject * obj2 = 0 ;
36467 PyObject * obj3 = 0 ;
36468 char * kwnames[] = {
36469 (char *) "self",(char *) "orientation",(char *) "pos",(char *) "refresh", NULL
36470 };
36471
36472 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_SetScrollPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36473 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36474 if (!SWIG_IsOK(res1)) {
36475 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetScrollPos" "', expected argument " "1"" of type '" "wxWindow *""'");
36476 }
36477 arg1 = reinterpret_cast< wxWindow * >(argp1);
36478 ecode2 = SWIG_AsVal_int(obj1, &val2);
36479 if (!SWIG_IsOK(ecode2)) {
36480 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetScrollPos" "', expected argument " "2"" of type '" "int""'");
36481 }
36482 arg2 = static_cast< int >(val2);
36483 ecode3 = SWIG_AsVal_int(obj2, &val3);
36484 if (!SWIG_IsOK(ecode3)) {
36485 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetScrollPos" "', expected argument " "3"" of type '" "int""'");
36486 }
36487 arg3 = static_cast< int >(val3);
36488 if (obj3) {
36489 ecode4 = SWIG_AsVal_bool(obj3, &val4);
36490 if (!SWIG_IsOK(ecode4)) {
36491 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Window_SetScrollPos" "', expected argument " "4"" of type '" "bool""'");
36492 }
36493 arg4 = static_cast< bool >(val4);
36494 }
36495 {
36496 PyThreadState* __tstate = wxPyBeginAllowThreads();
36497 (arg1)->SetScrollPos(arg2,arg3,arg4);
36498 wxPyEndAllowThreads(__tstate);
36499 if (PyErr_Occurred()) SWIG_fail;
36500 }
36501 resultobj = SWIG_Py_Void();
36502 return resultobj;
36503 fail:
36504 return NULL;
36505 }
36506
36507
36508 SWIGINTERN PyObject *_wrap_Window_GetScrollPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36509 PyObject *resultobj = 0;
36510 wxWindow *arg1 = (wxWindow *) 0 ;
36511 int arg2 ;
36512 int result;
36513 void *argp1 = 0 ;
36514 int res1 = 0 ;
36515 int val2 ;
36516 int ecode2 = 0 ;
36517 PyObject * obj0 = 0 ;
36518 PyObject * obj1 = 0 ;
36519 char * kwnames[] = {
36520 (char *) "self",(char *) "orientation", NULL
36521 };
36522
36523 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollPos",kwnames,&obj0,&obj1)) SWIG_fail;
36524 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36525 if (!SWIG_IsOK(res1)) {
36526 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollPos" "', expected argument " "1"" of type '" "wxWindow const *""'");
36527 }
36528 arg1 = reinterpret_cast< wxWindow * >(argp1);
36529 ecode2 = SWIG_AsVal_int(obj1, &val2);
36530 if (!SWIG_IsOK(ecode2)) {
36531 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollPos" "', expected argument " "2"" of type '" "int""'");
36532 }
36533 arg2 = static_cast< int >(val2);
36534 {
36535 PyThreadState* __tstate = wxPyBeginAllowThreads();
36536 result = (int)((wxWindow const *)arg1)->GetScrollPos(arg2);
36537 wxPyEndAllowThreads(__tstate);
36538 if (PyErr_Occurred()) SWIG_fail;
36539 }
36540 resultobj = SWIG_From_int(static_cast< int >(result));
36541 return resultobj;
36542 fail:
36543 return NULL;
36544 }
36545
36546
36547 SWIGINTERN PyObject *_wrap_Window_GetScrollThumb(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36548 PyObject *resultobj = 0;
36549 wxWindow *arg1 = (wxWindow *) 0 ;
36550 int arg2 ;
36551 int result;
36552 void *argp1 = 0 ;
36553 int res1 = 0 ;
36554 int val2 ;
36555 int ecode2 = 0 ;
36556 PyObject * obj0 = 0 ;
36557 PyObject * obj1 = 0 ;
36558 char * kwnames[] = {
36559 (char *) "self",(char *) "orientation", NULL
36560 };
36561
36562 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollThumb",kwnames,&obj0,&obj1)) SWIG_fail;
36563 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36564 if (!SWIG_IsOK(res1)) {
36565 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollThumb" "', expected argument " "1"" of type '" "wxWindow const *""'");
36566 }
36567 arg1 = reinterpret_cast< wxWindow * >(argp1);
36568 ecode2 = SWIG_AsVal_int(obj1, &val2);
36569 if (!SWIG_IsOK(ecode2)) {
36570 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollThumb" "', expected argument " "2"" of type '" "int""'");
36571 }
36572 arg2 = static_cast< int >(val2);
36573 {
36574 PyThreadState* __tstate = wxPyBeginAllowThreads();
36575 result = (int)((wxWindow const *)arg1)->GetScrollThumb(arg2);
36576 wxPyEndAllowThreads(__tstate);
36577 if (PyErr_Occurred()) SWIG_fail;
36578 }
36579 resultobj = SWIG_From_int(static_cast< int >(result));
36580 return resultobj;
36581 fail:
36582 return NULL;
36583 }
36584
36585
36586 SWIGINTERN PyObject *_wrap_Window_GetScrollRange(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36587 PyObject *resultobj = 0;
36588 wxWindow *arg1 = (wxWindow *) 0 ;
36589 int arg2 ;
36590 int result;
36591 void *argp1 = 0 ;
36592 int res1 = 0 ;
36593 int val2 ;
36594 int ecode2 = 0 ;
36595 PyObject * obj0 = 0 ;
36596 PyObject * obj1 = 0 ;
36597 char * kwnames[] = {
36598 (char *) "self",(char *) "orientation", NULL
36599 };
36600
36601 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_GetScrollRange",kwnames,&obj0,&obj1)) SWIG_fail;
36602 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36603 if (!SWIG_IsOK(res1)) {
36604 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetScrollRange" "', expected argument " "1"" of type '" "wxWindow const *""'");
36605 }
36606 arg1 = reinterpret_cast< wxWindow * >(argp1);
36607 ecode2 = SWIG_AsVal_int(obj1, &val2);
36608 if (!SWIG_IsOK(ecode2)) {
36609 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_GetScrollRange" "', expected argument " "2"" of type '" "int""'");
36610 }
36611 arg2 = static_cast< int >(val2);
36612 {
36613 PyThreadState* __tstate = wxPyBeginAllowThreads();
36614 result = (int)((wxWindow const *)arg1)->GetScrollRange(arg2);
36615 wxPyEndAllowThreads(__tstate);
36616 if (PyErr_Occurred()) SWIG_fail;
36617 }
36618 resultobj = SWIG_From_int(static_cast< int >(result));
36619 return resultobj;
36620 fail:
36621 return NULL;
36622 }
36623
36624
36625 SWIGINTERN PyObject *_wrap_Window_ScrollWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36626 PyObject *resultobj = 0;
36627 wxWindow *arg1 = (wxWindow *) 0 ;
36628 int arg2 ;
36629 int arg3 ;
36630 wxRect *arg4 = (wxRect *) NULL ;
36631 void *argp1 = 0 ;
36632 int res1 = 0 ;
36633 int val2 ;
36634 int ecode2 = 0 ;
36635 int val3 ;
36636 int ecode3 = 0 ;
36637 void *argp4 = 0 ;
36638 int res4 = 0 ;
36639 PyObject * obj0 = 0 ;
36640 PyObject * obj1 = 0 ;
36641 PyObject * obj2 = 0 ;
36642 PyObject * obj3 = 0 ;
36643 char * kwnames[] = {
36644 (char *) "self",(char *) "dx",(char *) "dy",(char *) "rect", NULL
36645 };
36646
36647 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Window_ScrollWindow",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
36648 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36649 if (!SWIG_IsOK(res1)) {
36650 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
36651 }
36652 arg1 = reinterpret_cast< wxWindow * >(argp1);
36653 ecode2 = SWIG_AsVal_int(obj1, &val2);
36654 if (!SWIG_IsOK(ecode2)) {
36655 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollWindow" "', expected argument " "2"" of type '" "int""'");
36656 }
36657 arg2 = static_cast< int >(val2);
36658 ecode3 = SWIG_AsVal_int(obj2, &val3);
36659 if (!SWIG_IsOK(ecode3)) {
36660 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_ScrollWindow" "', expected argument " "3"" of type '" "int""'");
36661 }
36662 arg3 = static_cast< int >(val3);
36663 if (obj3) {
36664 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxRect, 0 | 0 );
36665 if (!SWIG_IsOK(res4)) {
36666 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Window_ScrollWindow" "', expected argument " "4"" of type '" "wxRect const *""'");
36667 }
36668 arg4 = reinterpret_cast< wxRect * >(argp4);
36669 }
36670 {
36671 PyThreadState* __tstate = wxPyBeginAllowThreads();
36672 (arg1)->ScrollWindow(arg2,arg3,(wxRect const *)arg4);
36673 wxPyEndAllowThreads(__tstate);
36674 if (PyErr_Occurred()) SWIG_fail;
36675 }
36676 resultobj = SWIG_Py_Void();
36677 return resultobj;
36678 fail:
36679 return NULL;
36680 }
36681
36682
36683 SWIGINTERN PyObject *_wrap_Window_ScrollLines(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36684 PyObject *resultobj = 0;
36685 wxWindow *arg1 = (wxWindow *) 0 ;
36686 int arg2 ;
36687 bool result;
36688 void *argp1 = 0 ;
36689 int res1 = 0 ;
36690 int val2 ;
36691 int ecode2 = 0 ;
36692 PyObject * obj0 = 0 ;
36693 PyObject * obj1 = 0 ;
36694 char * kwnames[] = {
36695 (char *) "self",(char *) "lines", NULL
36696 };
36697
36698 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollLines",kwnames,&obj0,&obj1)) SWIG_fail;
36699 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36700 if (!SWIG_IsOK(res1)) {
36701 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollLines" "', expected argument " "1"" of type '" "wxWindow *""'");
36702 }
36703 arg1 = reinterpret_cast< wxWindow * >(argp1);
36704 ecode2 = SWIG_AsVal_int(obj1, &val2);
36705 if (!SWIG_IsOK(ecode2)) {
36706 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollLines" "', expected argument " "2"" of type '" "int""'");
36707 }
36708 arg2 = static_cast< int >(val2);
36709 {
36710 PyThreadState* __tstate = wxPyBeginAllowThreads();
36711 result = (bool)(arg1)->ScrollLines(arg2);
36712 wxPyEndAllowThreads(__tstate);
36713 if (PyErr_Occurred()) SWIG_fail;
36714 }
36715 {
36716 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36717 }
36718 return resultobj;
36719 fail:
36720 return NULL;
36721 }
36722
36723
36724 SWIGINTERN PyObject *_wrap_Window_ScrollPages(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36725 PyObject *resultobj = 0;
36726 wxWindow *arg1 = (wxWindow *) 0 ;
36727 int arg2 ;
36728 bool result;
36729 void *argp1 = 0 ;
36730 int res1 = 0 ;
36731 int val2 ;
36732 int ecode2 = 0 ;
36733 PyObject * obj0 = 0 ;
36734 PyObject * obj1 = 0 ;
36735 char * kwnames[] = {
36736 (char *) "self",(char *) "pages", NULL
36737 };
36738
36739 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_ScrollPages",kwnames,&obj0,&obj1)) SWIG_fail;
36740 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36741 if (!SWIG_IsOK(res1)) {
36742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_ScrollPages" "', expected argument " "1"" of type '" "wxWindow *""'");
36743 }
36744 arg1 = reinterpret_cast< wxWindow * >(argp1);
36745 ecode2 = SWIG_AsVal_int(obj1, &val2);
36746 if (!SWIG_IsOK(ecode2)) {
36747 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_ScrollPages" "', expected argument " "2"" of type '" "int""'");
36748 }
36749 arg2 = static_cast< int >(val2);
36750 {
36751 PyThreadState* __tstate = wxPyBeginAllowThreads();
36752 result = (bool)(arg1)->ScrollPages(arg2);
36753 wxPyEndAllowThreads(__tstate);
36754 if (PyErr_Occurred()) SWIG_fail;
36755 }
36756 {
36757 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36758 }
36759 return resultobj;
36760 fail:
36761 return NULL;
36762 }
36763
36764
36765 SWIGINTERN PyObject *_wrap_Window_LineUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36766 PyObject *resultobj = 0;
36767 wxWindow *arg1 = (wxWindow *) 0 ;
36768 bool result;
36769 void *argp1 = 0 ;
36770 int res1 = 0 ;
36771 PyObject *swig_obj[1] ;
36772
36773 if (!args) SWIG_fail;
36774 swig_obj[0] = args;
36775 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36776 if (!SWIG_IsOK(res1)) {
36777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36778 }
36779 arg1 = reinterpret_cast< wxWindow * >(argp1);
36780 {
36781 PyThreadState* __tstate = wxPyBeginAllowThreads();
36782 result = (bool)(arg1)->LineUp();
36783 wxPyEndAllowThreads(__tstate);
36784 if (PyErr_Occurred()) SWIG_fail;
36785 }
36786 {
36787 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36788 }
36789 return resultobj;
36790 fail:
36791 return NULL;
36792 }
36793
36794
36795 SWIGINTERN PyObject *_wrap_Window_LineDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36796 PyObject *resultobj = 0;
36797 wxWindow *arg1 = (wxWindow *) 0 ;
36798 bool result;
36799 void *argp1 = 0 ;
36800 int res1 = 0 ;
36801 PyObject *swig_obj[1] ;
36802
36803 if (!args) SWIG_fail;
36804 swig_obj[0] = args;
36805 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36806 if (!SWIG_IsOK(res1)) {
36807 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_LineDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36808 }
36809 arg1 = reinterpret_cast< wxWindow * >(argp1);
36810 {
36811 PyThreadState* __tstate = wxPyBeginAllowThreads();
36812 result = (bool)(arg1)->LineDown();
36813 wxPyEndAllowThreads(__tstate);
36814 if (PyErr_Occurred()) SWIG_fail;
36815 }
36816 {
36817 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36818 }
36819 return resultobj;
36820 fail:
36821 return NULL;
36822 }
36823
36824
36825 SWIGINTERN PyObject *_wrap_Window_PageUp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36826 PyObject *resultobj = 0;
36827 wxWindow *arg1 = (wxWindow *) 0 ;
36828 bool result;
36829 void *argp1 = 0 ;
36830 int res1 = 0 ;
36831 PyObject *swig_obj[1] ;
36832
36833 if (!args) SWIG_fail;
36834 swig_obj[0] = args;
36835 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36836 if (!SWIG_IsOK(res1)) {
36837 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageUp" "', expected argument " "1"" of type '" "wxWindow *""'");
36838 }
36839 arg1 = reinterpret_cast< wxWindow * >(argp1);
36840 {
36841 PyThreadState* __tstate = wxPyBeginAllowThreads();
36842 result = (bool)(arg1)->PageUp();
36843 wxPyEndAllowThreads(__tstate);
36844 if (PyErr_Occurred()) SWIG_fail;
36845 }
36846 {
36847 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36848 }
36849 return resultobj;
36850 fail:
36851 return NULL;
36852 }
36853
36854
36855 SWIGINTERN PyObject *_wrap_Window_PageDown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
36856 PyObject *resultobj = 0;
36857 wxWindow *arg1 = (wxWindow *) 0 ;
36858 bool result;
36859 void *argp1 = 0 ;
36860 int res1 = 0 ;
36861 PyObject *swig_obj[1] ;
36862
36863 if (!args) SWIG_fail;
36864 swig_obj[0] = args;
36865 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36866 if (!SWIG_IsOK(res1)) {
36867 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_PageDown" "', expected argument " "1"" of type '" "wxWindow *""'");
36868 }
36869 arg1 = reinterpret_cast< wxWindow * >(argp1);
36870 {
36871 PyThreadState* __tstate = wxPyBeginAllowThreads();
36872 result = (bool)(arg1)->PageDown();
36873 wxPyEndAllowThreads(__tstate);
36874 if (PyErr_Occurred()) SWIG_fail;
36875 }
36876 {
36877 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
36878 }
36879 return resultobj;
36880 fail:
36881 return NULL;
36882 }
36883
36884
36885 SWIGINTERN PyObject *_wrap_Window_SetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36886 PyObject *resultobj = 0;
36887 wxWindow *arg1 = (wxWindow *) 0 ;
36888 wxString *arg2 = 0 ;
36889 void *argp1 = 0 ;
36890 int res1 = 0 ;
36891 bool temp2 = false ;
36892 PyObject * obj0 = 0 ;
36893 PyObject * obj1 = 0 ;
36894 char * kwnames[] = {
36895 (char *) "self",(char *) "text", NULL
36896 };
36897
36898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpText",kwnames,&obj0,&obj1)) SWIG_fail;
36899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36900 if (!SWIG_IsOK(res1)) {
36901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpText" "', expected argument " "1"" of type '" "wxWindow *""'");
36902 }
36903 arg1 = reinterpret_cast< wxWindow * >(argp1);
36904 {
36905 arg2 = wxString_in_helper(obj1);
36906 if (arg2 == NULL) SWIG_fail;
36907 temp2 = true;
36908 }
36909 {
36910 PyThreadState* __tstate = wxPyBeginAllowThreads();
36911 (arg1)->SetHelpText((wxString const &)*arg2);
36912 wxPyEndAllowThreads(__tstate);
36913 if (PyErr_Occurred()) SWIG_fail;
36914 }
36915 resultobj = SWIG_Py_Void();
36916 {
36917 if (temp2)
36918 delete arg2;
36919 }
36920 return resultobj;
36921 fail:
36922 {
36923 if (temp2)
36924 delete arg2;
36925 }
36926 return NULL;
36927 }
36928
36929
36930 SWIGINTERN PyObject *_wrap_Window_SetHelpTextForId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36931 PyObject *resultobj = 0;
36932 wxWindow *arg1 = (wxWindow *) 0 ;
36933 wxString *arg2 = 0 ;
36934 void *argp1 = 0 ;
36935 int res1 = 0 ;
36936 bool temp2 = false ;
36937 PyObject * obj0 = 0 ;
36938 PyObject * obj1 = 0 ;
36939 char * kwnames[] = {
36940 (char *) "self",(char *) "text", NULL
36941 };
36942
36943 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetHelpTextForId",kwnames,&obj0,&obj1)) SWIG_fail;
36944 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36945 if (!SWIG_IsOK(res1)) {
36946 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetHelpTextForId" "', expected argument " "1"" of type '" "wxWindow *""'");
36947 }
36948 arg1 = reinterpret_cast< wxWindow * >(argp1);
36949 {
36950 arg2 = wxString_in_helper(obj1);
36951 if (arg2 == NULL) SWIG_fail;
36952 temp2 = true;
36953 }
36954 {
36955 PyThreadState* __tstate = wxPyBeginAllowThreads();
36956 (arg1)->SetHelpTextForId((wxString const &)*arg2);
36957 wxPyEndAllowThreads(__tstate);
36958 if (PyErr_Occurred()) SWIG_fail;
36959 }
36960 resultobj = SWIG_Py_Void();
36961 {
36962 if (temp2)
36963 delete arg2;
36964 }
36965 return resultobj;
36966 fail:
36967 {
36968 if (temp2)
36969 delete arg2;
36970 }
36971 return NULL;
36972 }
36973
36974
36975 SWIGINTERN PyObject *_wrap_Window_GetHelpTextAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
36976 PyObject *resultobj = 0;
36977 wxWindow *arg1 = (wxWindow *) 0 ;
36978 wxPoint *arg2 = 0 ;
36979 wxHelpEvent::Origin arg3 ;
36980 wxString result;
36981 void *argp1 = 0 ;
36982 int res1 = 0 ;
36983 wxPoint temp2 ;
36984 void *argp3 ;
36985 int res3 = 0 ;
36986 PyObject * obj0 = 0 ;
36987 PyObject * obj1 = 0 ;
36988 PyObject * obj2 = 0 ;
36989 char * kwnames[] = {
36990 (char *) "self",(char *) "pt",(char *) "origin", NULL
36991 };
36992
36993 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Window_GetHelpTextAtPoint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
36994 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
36995 if (!SWIG_IsOK(res1)) {
36996 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "1"" of type '" "wxWindow const *""'");
36997 }
36998 arg1 = reinterpret_cast< wxWindow * >(argp1);
36999 {
37000 arg2 = &temp2;
37001 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
37002 }
37003 {
37004 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxHelpEvent__Origin, 0 | 0);
37005 if (!SWIG_IsOK(res3)) {
37006 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37007 }
37008 if (!argp3) {
37009 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Window_GetHelpTextAtPoint" "', expected argument " "3"" of type '" "wxHelpEvent::Origin""'");
37010 } else {
37011 wxHelpEvent::Origin * temp = reinterpret_cast< wxHelpEvent::Origin * >(argp3);
37012 arg3 = *temp;
37013 if (SWIG_IsNewObj(res3)) delete temp;
37014 }
37015 }
37016 {
37017 PyThreadState* __tstate = wxPyBeginAllowThreads();
37018 result = ((wxWindow const *)arg1)->GetHelpTextAtPoint((wxPoint const &)*arg2,arg3);
37019 wxPyEndAllowThreads(__tstate);
37020 if (PyErr_Occurred()) SWIG_fail;
37021 }
37022 {
37023 #if wxUSE_UNICODE
37024 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37025 #else
37026 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37027 #endif
37028 }
37029 return resultobj;
37030 fail:
37031 return NULL;
37032 }
37033
37034
37035 SWIGINTERN PyObject *_wrap_Window_GetHelpText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37036 PyObject *resultobj = 0;
37037 wxWindow *arg1 = (wxWindow *) 0 ;
37038 wxString result;
37039 void *argp1 = 0 ;
37040 int res1 = 0 ;
37041 PyObject *swig_obj[1] ;
37042
37043 if (!args) SWIG_fail;
37044 swig_obj[0] = args;
37045 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37046 if (!SWIG_IsOK(res1)) {
37047 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetHelpText" "', expected argument " "1"" of type '" "wxWindow const *""'");
37048 }
37049 arg1 = reinterpret_cast< wxWindow * >(argp1);
37050 {
37051 PyThreadState* __tstate = wxPyBeginAllowThreads();
37052 result = ((wxWindow const *)arg1)->GetHelpText();
37053 wxPyEndAllowThreads(__tstate);
37054 if (PyErr_Occurred()) SWIG_fail;
37055 }
37056 {
37057 #if wxUSE_UNICODE
37058 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
37059 #else
37060 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
37061 #endif
37062 }
37063 return resultobj;
37064 fail:
37065 return NULL;
37066 }
37067
37068
37069 SWIGINTERN PyObject *_wrap_Window_SetToolTipString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37070 PyObject *resultobj = 0;
37071 wxWindow *arg1 = (wxWindow *) 0 ;
37072 wxString *arg2 = 0 ;
37073 void *argp1 = 0 ;
37074 int res1 = 0 ;
37075 bool temp2 = false ;
37076 PyObject * obj0 = 0 ;
37077 PyObject * obj1 = 0 ;
37078 char * kwnames[] = {
37079 (char *) "self",(char *) "tip", NULL
37080 };
37081
37082 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTipString",kwnames,&obj0,&obj1)) SWIG_fail;
37083 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37084 if (!SWIG_IsOK(res1)) {
37085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTipString" "', expected argument " "1"" of type '" "wxWindow *""'");
37086 }
37087 arg1 = reinterpret_cast< wxWindow * >(argp1);
37088 {
37089 arg2 = wxString_in_helper(obj1);
37090 if (arg2 == NULL) SWIG_fail;
37091 temp2 = true;
37092 }
37093 {
37094 PyThreadState* __tstate = wxPyBeginAllowThreads();
37095 (arg1)->SetToolTip((wxString const &)*arg2);
37096 wxPyEndAllowThreads(__tstate);
37097 if (PyErr_Occurred()) SWIG_fail;
37098 }
37099 resultobj = SWIG_Py_Void();
37100 {
37101 if (temp2)
37102 delete arg2;
37103 }
37104 return resultobj;
37105 fail:
37106 {
37107 if (temp2)
37108 delete arg2;
37109 }
37110 return NULL;
37111 }
37112
37113
37114 SWIGINTERN PyObject *_wrap_Window_SetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37115 PyObject *resultobj = 0;
37116 wxWindow *arg1 = (wxWindow *) 0 ;
37117 wxToolTip *arg2 = (wxToolTip *) 0 ;
37118 void *argp1 = 0 ;
37119 int res1 = 0 ;
37120 int res2 = 0 ;
37121 PyObject * obj0 = 0 ;
37122 PyObject * obj1 = 0 ;
37123 char * kwnames[] = {
37124 (char *) "self",(char *) "tip", NULL
37125 };
37126
37127 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetToolTip",kwnames,&obj0,&obj1)) SWIG_fail;
37128 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37129 if (!SWIG_IsOK(res1)) {
37130 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetToolTip" "', expected argument " "1"" of type '" "wxWindow *""'");
37131 }
37132 arg1 = reinterpret_cast< wxWindow * >(argp1);
37133 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxToolTip, SWIG_POINTER_DISOWN | 0 );
37134 if (!SWIG_IsOK(res2)) {
37135 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetToolTip" "', expected argument " "2"" of type '" "wxToolTip *""'");
37136 }
37137 {
37138 PyThreadState* __tstate = wxPyBeginAllowThreads();
37139 (arg1)->SetToolTip(arg2);
37140 wxPyEndAllowThreads(__tstate);
37141 if (PyErr_Occurred()) SWIG_fail;
37142 }
37143 resultobj = SWIG_Py_Void();
37144 return resultobj;
37145 fail:
37146 return NULL;
37147 }
37148
37149
37150 SWIGINTERN PyObject *_wrap_Window_GetToolTip(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37151 PyObject *resultobj = 0;
37152 wxWindow *arg1 = (wxWindow *) 0 ;
37153 wxToolTip *result = 0 ;
37154 void *argp1 = 0 ;
37155 int res1 = 0 ;
37156 PyObject *swig_obj[1] ;
37157
37158 if (!args) SWIG_fail;
37159 swig_obj[0] = args;
37160 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37161 if (!SWIG_IsOK(res1)) {
37162 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetToolTip" "', expected argument " "1"" of type '" "wxWindow const *""'");
37163 }
37164 arg1 = reinterpret_cast< wxWindow * >(argp1);
37165 {
37166 PyThreadState* __tstate = wxPyBeginAllowThreads();
37167 result = (wxToolTip *)((wxWindow const *)arg1)->GetToolTip();
37168 wxPyEndAllowThreads(__tstate);
37169 if (PyErr_Occurred()) SWIG_fail;
37170 }
37171 {
37172 resultobj = wxPyMake_wxObject(result, (bool)0);
37173 }
37174 return resultobj;
37175 fail:
37176 return NULL;
37177 }
37178
37179
37180 SWIGINTERN PyObject *_wrap_Window_SetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37181 PyObject *resultobj = 0;
37182 wxWindow *arg1 = (wxWindow *) 0 ;
37183 wxPyDropTarget *arg2 = (wxPyDropTarget *) 0 ;
37184 void *argp1 = 0 ;
37185 int res1 = 0 ;
37186 int res2 = 0 ;
37187 PyObject * obj0 = 0 ;
37188 PyObject * obj1 = 0 ;
37189 char * kwnames[] = {
37190 (char *) "self",(char *) "dropTarget", NULL
37191 };
37192
37193 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetDropTarget",kwnames,&obj0,&obj1)) SWIG_fail;
37194 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37195 if (!SWIG_IsOK(res1)) {
37196 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetDropTarget" "', expected argument " "1"" of type '" "wxWindow *""'");
37197 }
37198 arg1 = reinterpret_cast< wxWindow * >(argp1);
37199 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxPyDropTarget, SWIG_POINTER_DISOWN | 0 );
37200 if (!SWIG_IsOK(res2)) {
37201 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetDropTarget" "', expected argument " "2"" of type '" "wxPyDropTarget *""'");
37202 }
37203 {
37204 PyThreadState* __tstate = wxPyBeginAllowThreads();
37205 (arg1)->SetDropTarget(arg2);
37206 wxPyEndAllowThreads(__tstate);
37207 if (PyErr_Occurred()) SWIG_fail;
37208 }
37209 resultobj = SWIG_Py_Void();
37210 return resultobj;
37211 fail:
37212 return NULL;
37213 }
37214
37215
37216 SWIGINTERN PyObject *_wrap_Window_GetDropTarget(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37217 PyObject *resultobj = 0;
37218 wxWindow *arg1 = (wxWindow *) 0 ;
37219 wxPyDropTarget *result = 0 ;
37220 void *argp1 = 0 ;
37221 int res1 = 0 ;
37222 PyObject *swig_obj[1] ;
37223
37224 if (!args) SWIG_fail;
37225 swig_obj[0] = args;
37226 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37227 if (!SWIG_IsOK(res1)) {
37228 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetDropTarget" "', expected argument " "1"" of type '" "wxWindow const *""'");
37229 }
37230 arg1 = reinterpret_cast< wxWindow * >(argp1);
37231 {
37232 PyThreadState* __tstate = wxPyBeginAllowThreads();
37233 result = (wxPyDropTarget *)((wxWindow const *)arg1)->GetDropTarget();
37234 wxPyEndAllowThreads(__tstate);
37235 if (PyErr_Occurred()) SWIG_fail;
37236 }
37237 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyDropTarget, 0 | 0 );
37238 return resultobj;
37239 fail:
37240 return NULL;
37241 }
37242
37243
37244 SWIGINTERN PyObject *_wrap_Window_DragAcceptFiles(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37245 PyObject *resultobj = 0;
37246 wxWindow *arg1 = (wxWindow *) 0 ;
37247 bool arg2 ;
37248 void *argp1 = 0 ;
37249 int res1 = 0 ;
37250 bool val2 ;
37251 int ecode2 = 0 ;
37252 PyObject * obj0 = 0 ;
37253 PyObject * obj1 = 0 ;
37254 char * kwnames[] = {
37255 (char *) "self",(char *) "accept", NULL
37256 };
37257
37258 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_DragAcceptFiles",kwnames,&obj0,&obj1)) SWIG_fail;
37259 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37260 if (!SWIG_IsOK(res1)) {
37261 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_DragAcceptFiles" "', expected argument " "1"" of type '" "wxWindow *""'");
37262 }
37263 arg1 = reinterpret_cast< wxWindow * >(argp1);
37264 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37265 if (!SWIG_IsOK(ecode2)) {
37266 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_DragAcceptFiles" "', expected argument " "2"" of type '" "bool""'");
37267 }
37268 arg2 = static_cast< bool >(val2);
37269 {
37270 PyThreadState* __tstate = wxPyBeginAllowThreads();
37271 wxWindow_DragAcceptFiles(arg1,arg2);
37272 wxPyEndAllowThreads(__tstate);
37273 if (PyErr_Occurred()) SWIG_fail;
37274 }
37275 resultobj = SWIG_Py_Void();
37276 return resultobj;
37277 fail:
37278 return NULL;
37279 }
37280
37281
37282 SWIGINTERN PyObject *_wrap_Window_SetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37283 PyObject *resultobj = 0;
37284 wxWindow *arg1 = (wxWindow *) 0 ;
37285 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
37286 void *argp1 = 0 ;
37287 int res1 = 0 ;
37288 int res2 = 0 ;
37289 PyObject * obj0 = 0 ;
37290 PyObject * obj1 = 0 ;
37291 char * kwnames[] = {
37292 (char *) "self",(char *) "constraints", NULL
37293 };
37294
37295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
37296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37297 if (!SWIG_IsOK(res1)) {
37298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetConstraints" "', expected argument " "1"" of type '" "wxWindow *""'");
37299 }
37300 arg1 = reinterpret_cast< wxWindow * >(argp1);
37301 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
37302 if (!SWIG_IsOK(res2)) {
37303 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetConstraints" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
37304 }
37305 {
37306 PyThreadState* __tstate = wxPyBeginAllowThreads();
37307 (arg1)->SetConstraints(arg2);
37308 wxPyEndAllowThreads(__tstate);
37309 if (PyErr_Occurred()) SWIG_fail;
37310 }
37311 resultobj = SWIG_Py_Void();
37312 return resultobj;
37313 fail:
37314 return NULL;
37315 }
37316
37317
37318 SWIGINTERN PyObject *_wrap_Window_GetConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37319 PyObject *resultobj = 0;
37320 wxWindow *arg1 = (wxWindow *) 0 ;
37321 wxLayoutConstraints *result = 0 ;
37322 void *argp1 = 0 ;
37323 int res1 = 0 ;
37324 PyObject *swig_obj[1] ;
37325
37326 if (!args) SWIG_fail;
37327 swig_obj[0] = args;
37328 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37329 if (!SWIG_IsOK(res1)) {
37330 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetConstraints" "', expected argument " "1"" of type '" "wxWindow const *""'");
37331 }
37332 arg1 = reinterpret_cast< wxWindow * >(argp1);
37333 {
37334 PyThreadState* __tstate = wxPyBeginAllowThreads();
37335 result = (wxLayoutConstraints *)((wxWindow const *)arg1)->GetConstraints();
37336 wxPyEndAllowThreads(__tstate);
37337 if (PyErr_Occurred()) SWIG_fail;
37338 }
37339 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
37340 return resultobj;
37341 fail:
37342 return NULL;
37343 }
37344
37345
37346 SWIGINTERN PyObject *_wrap_Window_SetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37347 PyObject *resultobj = 0;
37348 wxWindow *arg1 = (wxWindow *) 0 ;
37349 bool arg2 ;
37350 void *argp1 = 0 ;
37351 int res1 = 0 ;
37352 bool val2 ;
37353 int ecode2 = 0 ;
37354 PyObject * obj0 = 0 ;
37355 PyObject * obj1 = 0 ;
37356 char * kwnames[] = {
37357 (char *) "self",(char *) "autoLayout", NULL
37358 };
37359
37360 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetAutoLayout",kwnames,&obj0,&obj1)) SWIG_fail;
37361 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37362 if (!SWIG_IsOK(res1)) {
37363 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetAutoLayout" "', expected argument " "1"" of type '" "wxWindow *""'");
37364 }
37365 arg1 = reinterpret_cast< wxWindow * >(argp1);
37366 ecode2 = SWIG_AsVal_bool(obj1, &val2);
37367 if (!SWIG_IsOK(ecode2)) {
37368 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_SetAutoLayout" "', expected argument " "2"" of type '" "bool""'");
37369 }
37370 arg2 = static_cast< bool >(val2);
37371 {
37372 PyThreadState* __tstate = wxPyBeginAllowThreads();
37373 (arg1)->SetAutoLayout(arg2);
37374 wxPyEndAllowThreads(__tstate);
37375 if (PyErr_Occurred()) SWIG_fail;
37376 }
37377 resultobj = SWIG_Py_Void();
37378 return resultobj;
37379 fail:
37380 return NULL;
37381 }
37382
37383
37384 SWIGINTERN PyObject *_wrap_Window_GetAutoLayout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37385 PyObject *resultobj = 0;
37386 wxWindow *arg1 = (wxWindow *) 0 ;
37387 bool result;
37388 void *argp1 = 0 ;
37389 int res1 = 0 ;
37390 PyObject *swig_obj[1] ;
37391
37392 if (!args) SWIG_fail;
37393 swig_obj[0] = args;
37394 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37395 if (!SWIG_IsOK(res1)) {
37396 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetAutoLayout" "', expected argument " "1"" of type '" "wxWindow const *""'");
37397 }
37398 arg1 = reinterpret_cast< wxWindow * >(argp1);
37399 {
37400 PyThreadState* __tstate = wxPyBeginAllowThreads();
37401 result = (bool)((wxWindow const *)arg1)->GetAutoLayout();
37402 wxPyEndAllowThreads(__tstate);
37403 if (PyErr_Occurred()) SWIG_fail;
37404 }
37405 {
37406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37407 }
37408 return resultobj;
37409 fail:
37410 return NULL;
37411 }
37412
37413
37414 SWIGINTERN PyObject *_wrap_Window_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37415 PyObject *resultobj = 0;
37416 wxWindow *arg1 = (wxWindow *) 0 ;
37417 bool result;
37418 void *argp1 = 0 ;
37419 int res1 = 0 ;
37420 PyObject *swig_obj[1] ;
37421
37422 if (!args) SWIG_fail;
37423 swig_obj[0] = args;
37424 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37425 if (!SWIG_IsOK(res1)) {
37426 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_Layout" "', expected argument " "1"" of type '" "wxWindow *""'");
37427 }
37428 arg1 = reinterpret_cast< wxWindow * >(argp1);
37429 {
37430 PyThreadState* __tstate = wxPyBeginAllowThreads();
37431 result = (bool)(arg1)->Layout();
37432 wxPyEndAllowThreads(__tstate);
37433 if (PyErr_Occurred()) SWIG_fail;
37434 }
37435 {
37436 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37437 }
37438 return resultobj;
37439 fail:
37440 return NULL;
37441 }
37442
37443
37444 SWIGINTERN PyObject *_wrap_Window_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37445 PyObject *resultobj = 0;
37446 wxWindow *arg1 = (wxWindow *) 0 ;
37447 wxSizer *arg2 = (wxSizer *) 0 ;
37448 bool arg3 = (bool) true ;
37449 void *argp1 = 0 ;
37450 int res1 = 0 ;
37451 int res2 = 0 ;
37452 bool val3 ;
37453 int ecode3 = 0 ;
37454 PyObject * obj0 = 0 ;
37455 PyObject * obj1 = 0 ;
37456 PyObject * obj2 = 0 ;
37457 char * kwnames[] = {
37458 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37459 };
37460
37461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizer",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37463 if (!SWIG_IsOK(res1)) {
37464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37465 }
37466 arg1 = reinterpret_cast< wxWindow * >(argp1);
37467 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37468 if (!SWIG_IsOK(res2)) {
37469 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37470 }
37471 if (obj2) {
37472 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37473 if (!SWIG_IsOK(ecode3)) {
37474 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizer" "', expected argument " "3"" of type '" "bool""'");
37475 }
37476 arg3 = static_cast< bool >(val3);
37477 }
37478 {
37479 PyThreadState* __tstate = wxPyBeginAllowThreads();
37480 (arg1)->SetSizer(arg2,arg3);
37481 wxPyEndAllowThreads(__tstate);
37482 if (PyErr_Occurred()) SWIG_fail;
37483 }
37484 resultobj = SWIG_Py_Void();
37485 return resultobj;
37486 fail:
37487 return NULL;
37488 }
37489
37490
37491 SWIGINTERN PyObject *_wrap_Window_SetSizerAndFit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37492 PyObject *resultobj = 0;
37493 wxWindow *arg1 = (wxWindow *) 0 ;
37494 wxSizer *arg2 = (wxSizer *) 0 ;
37495 bool arg3 = (bool) true ;
37496 void *argp1 = 0 ;
37497 int res1 = 0 ;
37498 int res2 = 0 ;
37499 bool val3 ;
37500 int ecode3 = 0 ;
37501 PyObject * obj0 = 0 ;
37502 PyObject * obj1 = 0 ;
37503 PyObject * obj2 = 0 ;
37504 char * kwnames[] = {
37505 (char *) "self",(char *) "sizer",(char *) "deleteOld", NULL
37506 };
37507
37508 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:Window_SetSizerAndFit",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
37509 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37510 if (!SWIG_IsOK(res1)) {
37511 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetSizerAndFit" "', expected argument " "1"" of type '" "wxWindow *""'");
37512 }
37513 arg1 = reinterpret_cast< wxWindow * >(argp1);
37514 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
37515 if (!SWIG_IsOK(res2)) {
37516 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetSizerAndFit" "', expected argument " "2"" of type '" "wxSizer *""'");
37517 }
37518 if (obj2) {
37519 ecode3 = SWIG_AsVal_bool(obj2, &val3);
37520 if (!SWIG_IsOK(ecode3)) {
37521 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Window_SetSizerAndFit" "', expected argument " "3"" of type '" "bool""'");
37522 }
37523 arg3 = static_cast< bool >(val3);
37524 }
37525 {
37526 PyThreadState* __tstate = wxPyBeginAllowThreads();
37527 (arg1)->SetSizerAndFit(arg2,arg3);
37528 wxPyEndAllowThreads(__tstate);
37529 if (PyErr_Occurred()) SWIG_fail;
37530 }
37531 resultobj = SWIG_Py_Void();
37532 return resultobj;
37533 fail:
37534 return NULL;
37535 }
37536
37537
37538 SWIGINTERN PyObject *_wrap_Window_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37539 PyObject *resultobj = 0;
37540 wxWindow *arg1 = (wxWindow *) 0 ;
37541 wxSizer *result = 0 ;
37542 void *argp1 = 0 ;
37543 int res1 = 0 ;
37544 PyObject *swig_obj[1] ;
37545
37546 if (!args) SWIG_fail;
37547 swig_obj[0] = args;
37548 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37549 if (!SWIG_IsOK(res1)) {
37550 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37551 }
37552 arg1 = reinterpret_cast< wxWindow * >(argp1);
37553 {
37554 PyThreadState* __tstate = wxPyBeginAllowThreads();
37555 result = (wxSizer *)((wxWindow const *)arg1)->GetSizer();
37556 wxPyEndAllowThreads(__tstate);
37557 if (PyErr_Occurred()) SWIG_fail;
37558 }
37559 {
37560 resultobj = wxPyMake_wxObject(result, (bool)0);
37561 }
37562 return resultobj;
37563 fail:
37564 return NULL;
37565 }
37566
37567
37568 SWIGINTERN PyObject *_wrap_Window_SetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37569 PyObject *resultobj = 0;
37570 wxWindow *arg1 = (wxWindow *) 0 ;
37571 wxSizer *arg2 = (wxSizer *) 0 ;
37572 void *argp1 = 0 ;
37573 int res1 = 0 ;
37574 void *argp2 = 0 ;
37575 int res2 = 0 ;
37576 PyObject * obj0 = 0 ;
37577 PyObject * obj1 = 0 ;
37578 char * kwnames[] = {
37579 (char *) "self",(char *) "sizer", NULL
37580 };
37581
37582 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_SetContainingSizer",kwnames,&obj0,&obj1)) SWIG_fail;
37583 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37584 if (!SWIG_IsOK(res1)) {
37585 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_SetContainingSizer" "', expected argument " "1"" of type '" "wxWindow *""'");
37586 }
37587 arg1 = reinterpret_cast< wxWindow * >(argp1);
37588 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
37589 if (!SWIG_IsOK(res2)) {
37590 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Window_SetContainingSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
37591 }
37592 arg2 = reinterpret_cast< wxSizer * >(argp2);
37593 {
37594 PyThreadState* __tstate = wxPyBeginAllowThreads();
37595 (arg1)->SetContainingSizer(arg2);
37596 wxPyEndAllowThreads(__tstate);
37597 if (PyErr_Occurred()) SWIG_fail;
37598 }
37599 resultobj = SWIG_Py_Void();
37600 return resultobj;
37601 fail:
37602 return NULL;
37603 }
37604
37605
37606 SWIGINTERN PyObject *_wrap_Window_GetContainingSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37607 PyObject *resultobj = 0;
37608 wxWindow *arg1 = (wxWindow *) 0 ;
37609 wxSizer *result = 0 ;
37610 void *argp1 = 0 ;
37611 int res1 = 0 ;
37612 PyObject *swig_obj[1] ;
37613
37614 if (!args) SWIG_fail;
37615 swig_obj[0] = args;
37616 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37617 if (!SWIG_IsOK(res1)) {
37618 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_GetContainingSizer" "', expected argument " "1"" of type '" "wxWindow const *""'");
37619 }
37620 arg1 = reinterpret_cast< wxWindow * >(argp1);
37621 {
37622 PyThreadState* __tstate = wxPyBeginAllowThreads();
37623 result = (wxSizer *)((wxWindow const *)arg1)->GetContainingSizer();
37624 wxPyEndAllowThreads(__tstate);
37625 if (PyErr_Occurred()) SWIG_fail;
37626 }
37627 {
37628 resultobj = wxPyMake_wxObject(result, (bool)0);
37629 }
37630 return resultobj;
37631 fail:
37632 return NULL;
37633 }
37634
37635
37636 SWIGINTERN PyObject *_wrap_Window_InheritAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37637 PyObject *resultobj = 0;
37638 wxWindow *arg1 = (wxWindow *) 0 ;
37639 void *argp1 = 0 ;
37640 int res1 = 0 ;
37641 PyObject *swig_obj[1] ;
37642
37643 if (!args) SWIG_fail;
37644 swig_obj[0] = args;
37645 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37646 if (!SWIG_IsOK(res1)) {
37647 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_InheritAttributes" "', expected argument " "1"" of type '" "wxWindow *""'");
37648 }
37649 arg1 = reinterpret_cast< wxWindow * >(argp1);
37650 {
37651 PyThreadState* __tstate = wxPyBeginAllowThreads();
37652 (arg1)->InheritAttributes();
37653 wxPyEndAllowThreads(__tstate);
37654 if (PyErr_Occurred()) SWIG_fail;
37655 }
37656 resultobj = SWIG_Py_Void();
37657 return resultobj;
37658 fail:
37659 return NULL;
37660 }
37661
37662
37663 SWIGINTERN PyObject *_wrap_Window_ShouldInheritColours(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37664 PyObject *resultobj = 0;
37665 wxWindow *arg1 = (wxWindow *) 0 ;
37666 bool result;
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_ShouldInheritColours" "', expected argument " "1"" of type '" "wxWindow const *""'");
37676 }
37677 arg1 = reinterpret_cast< wxWindow * >(argp1);
37678 {
37679 PyThreadState* __tstate = wxPyBeginAllowThreads();
37680 result = (bool)((wxWindow const *)arg1)->ShouldInheritColours();
37681 wxPyEndAllowThreads(__tstate);
37682 if (PyErr_Occurred()) SWIG_fail;
37683 }
37684 {
37685 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37686 }
37687 return resultobj;
37688 fail:
37689 return NULL;
37690 }
37691
37692
37693 SWIGINTERN PyObject *Window_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37694 PyObject *obj;
37695 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
37696 SWIG_TypeNewClientData(SWIGTYPE_p_wxWindow, SWIG_NewClientData(obj));
37697 return SWIG_Py_Void();
37698 }
37699
37700 SWIGINTERN PyObject *Window_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37701 return SWIG_Python_InitShadowInstance(args);
37702 }
37703
37704 SWIGINTERN PyObject *_wrap_FindWindowById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37705 PyObject *resultobj = 0;
37706 long arg1 ;
37707 wxWindow *arg2 = (wxWindow *) NULL ;
37708 wxWindow *result = 0 ;
37709 long val1 ;
37710 int ecode1 = 0 ;
37711 void *argp2 = 0 ;
37712 int res2 = 0 ;
37713 PyObject * obj0 = 0 ;
37714 PyObject * obj1 = 0 ;
37715 char * kwnames[] = {
37716 (char *) "id",(char *) "parent", NULL
37717 };
37718
37719 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowById",kwnames,&obj0,&obj1)) SWIG_fail;
37720 ecode1 = SWIG_AsVal_long(obj0, &val1);
37721 if (!SWIG_IsOK(ecode1)) {
37722 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "FindWindowById" "', expected argument " "1"" of type '" "long""'");
37723 }
37724 arg1 = static_cast< long >(val1);
37725 if (obj1) {
37726 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37727 if (!SWIG_IsOK(res2)) {
37728 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowById" "', expected argument " "2"" of type '" "wxWindow const *""'");
37729 }
37730 arg2 = reinterpret_cast< wxWindow * >(argp2);
37731 }
37732 {
37733 if (!wxPyCheckForApp()) SWIG_fail;
37734 PyThreadState* __tstate = wxPyBeginAllowThreads();
37735 result = (wxWindow *)wxFindWindowById(arg1,(wxWindow const *)arg2);
37736 wxPyEndAllowThreads(__tstate);
37737 if (PyErr_Occurred()) SWIG_fail;
37738 }
37739 {
37740 resultobj = wxPyMake_wxObject(result, 0);
37741 }
37742 return resultobj;
37743 fail:
37744 return NULL;
37745 }
37746
37747
37748 SWIGINTERN PyObject *_wrap_FindWindowByName(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37749 PyObject *resultobj = 0;
37750 wxString *arg1 = 0 ;
37751 wxWindow *arg2 = (wxWindow *) NULL ;
37752 wxWindow *result = 0 ;
37753 bool temp1 = false ;
37754 void *argp2 = 0 ;
37755 int res2 = 0 ;
37756 PyObject * obj0 = 0 ;
37757 PyObject * obj1 = 0 ;
37758 char * kwnames[] = {
37759 (char *) "name",(char *) "parent", NULL
37760 };
37761
37762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByName",kwnames,&obj0,&obj1)) SWIG_fail;
37763 {
37764 arg1 = wxString_in_helper(obj0);
37765 if (arg1 == NULL) SWIG_fail;
37766 temp1 = true;
37767 }
37768 if (obj1) {
37769 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37770 if (!SWIG_IsOK(res2)) {
37771 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByName" "', expected argument " "2"" of type '" "wxWindow const *""'");
37772 }
37773 arg2 = reinterpret_cast< wxWindow * >(argp2);
37774 }
37775 {
37776 if (!wxPyCheckForApp()) SWIG_fail;
37777 PyThreadState* __tstate = wxPyBeginAllowThreads();
37778 result = (wxWindow *)wxFindWindowByName((wxString const &)*arg1,(wxWindow const *)arg2);
37779 wxPyEndAllowThreads(__tstate);
37780 if (PyErr_Occurred()) SWIG_fail;
37781 }
37782 {
37783 resultobj = wxPyMake_wxObject(result, 0);
37784 }
37785 {
37786 if (temp1)
37787 delete arg1;
37788 }
37789 return resultobj;
37790 fail:
37791 {
37792 if (temp1)
37793 delete arg1;
37794 }
37795 return NULL;
37796 }
37797
37798
37799 SWIGINTERN PyObject *_wrap_FindWindowByLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37800 PyObject *resultobj = 0;
37801 wxString *arg1 = 0 ;
37802 wxWindow *arg2 = (wxWindow *) NULL ;
37803 wxWindow *result = 0 ;
37804 bool temp1 = false ;
37805 void *argp2 = 0 ;
37806 int res2 = 0 ;
37807 PyObject * obj0 = 0 ;
37808 PyObject * obj1 = 0 ;
37809 char * kwnames[] = {
37810 (char *) "label",(char *) "parent", NULL
37811 };
37812
37813 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:FindWindowByLabel",kwnames,&obj0,&obj1)) SWIG_fail;
37814 {
37815 arg1 = wxString_in_helper(obj0);
37816 if (arg1 == NULL) SWIG_fail;
37817 temp1 = true;
37818 }
37819 if (obj1) {
37820 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37821 if (!SWIG_IsOK(res2)) {
37822 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "FindWindowByLabel" "', expected argument " "2"" of type '" "wxWindow const *""'");
37823 }
37824 arg2 = reinterpret_cast< wxWindow * >(argp2);
37825 }
37826 {
37827 if (!wxPyCheckForApp()) SWIG_fail;
37828 PyThreadState* __tstate = wxPyBeginAllowThreads();
37829 result = (wxWindow *)wxFindWindowByLabel((wxString const &)*arg1,(wxWindow const *)arg2);
37830 wxPyEndAllowThreads(__tstate);
37831 if (PyErr_Occurred()) SWIG_fail;
37832 }
37833 {
37834 resultobj = wxPyMake_wxObject(result, 0);
37835 }
37836 {
37837 if (temp1)
37838 delete arg1;
37839 }
37840 return resultobj;
37841 fail:
37842 {
37843 if (temp1)
37844 delete arg1;
37845 }
37846 return NULL;
37847 }
37848
37849
37850 SWIGINTERN PyObject *_wrap_Window_FromHWND(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37851 PyObject *resultobj = 0;
37852 wxWindow *arg1 = (wxWindow *) 0 ;
37853 unsigned long arg2 ;
37854 wxWindow *result = 0 ;
37855 void *argp1 = 0 ;
37856 int res1 = 0 ;
37857 unsigned long val2 ;
37858 int ecode2 = 0 ;
37859 PyObject * obj0 = 0 ;
37860 PyObject * obj1 = 0 ;
37861 char * kwnames[] = {
37862 (char *) "parent",(char *) "_hWnd", NULL
37863 };
37864
37865 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Window_FromHWND",kwnames,&obj0,&obj1)) SWIG_fail;
37866 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
37867 if (!SWIG_IsOK(res1)) {
37868 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Window_FromHWND" "', expected argument " "1"" of type '" "wxWindow *""'");
37869 }
37870 arg1 = reinterpret_cast< wxWindow * >(argp1);
37871 ecode2 = SWIG_AsVal_unsigned_SS_long(obj1, &val2);
37872 if (!SWIG_IsOK(ecode2)) {
37873 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Window_FromHWND" "', expected argument " "2"" of type '" "unsigned long""'");
37874 }
37875 arg2 = static_cast< unsigned long >(val2);
37876 {
37877 PyThreadState* __tstate = wxPyBeginAllowThreads();
37878 result = (wxWindow *)wxWindow_FromHWND(arg1,arg2);
37879 wxPyEndAllowThreads(__tstate);
37880 if (PyErr_Occurred()) SWIG_fail;
37881 }
37882 {
37883 resultobj = wxPyMake_wxObject(result, 0);
37884 }
37885 return resultobj;
37886 fail:
37887 return NULL;
37888 }
37889
37890
37891 SWIGINTERN PyObject *_wrap_GetTopLevelWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37892 PyObject *resultobj = 0;
37893 PyObject *result = 0 ;
37894
37895 if (!SWIG_Python_UnpackTuple(args,"GetTopLevelWindows",0,0,0)) SWIG_fail;
37896 {
37897 PyThreadState* __tstate = wxPyBeginAllowThreads();
37898 result = (PyObject *)GetTopLevelWindows();
37899 wxPyEndAllowThreads(__tstate);
37900 if (PyErr_Occurred()) SWIG_fail;
37901 }
37902 resultobj = result;
37903 return resultobj;
37904 fail:
37905 return NULL;
37906 }
37907
37908
37909 SWIGINTERN PyObject *_wrap_new_Validator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37910 PyObject *resultobj = 0;
37911 wxValidator *result = 0 ;
37912
37913 if (!SWIG_Python_UnpackTuple(args,"new_Validator",0,0,0)) SWIG_fail;
37914 {
37915 PyThreadState* __tstate = wxPyBeginAllowThreads();
37916 result = (wxValidator *)new wxValidator();
37917 wxPyEndAllowThreads(__tstate);
37918 if (PyErr_Occurred()) SWIG_fail;
37919 }
37920 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxValidator, SWIG_POINTER_NEW | 0 );
37921 return resultobj;
37922 fail:
37923 return NULL;
37924 }
37925
37926
37927 SWIGINTERN PyObject *_wrap_Validator_Clone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37928 PyObject *resultobj = 0;
37929 wxValidator *arg1 = (wxValidator *) 0 ;
37930 wxValidator *result = 0 ;
37931 void *argp1 = 0 ;
37932 int res1 = 0 ;
37933 PyObject *swig_obj[1] ;
37934
37935 if (!args) SWIG_fail;
37936 swig_obj[0] = args;
37937 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37938 if (!SWIG_IsOK(res1)) {
37939 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Clone" "', expected argument " "1"" of type '" "wxValidator *""'");
37940 }
37941 arg1 = reinterpret_cast< wxValidator * >(argp1);
37942 {
37943 PyThreadState* __tstate = wxPyBeginAllowThreads();
37944 result = (wxValidator *)(arg1)->Clone();
37945 wxPyEndAllowThreads(__tstate);
37946 if (PyErr_Occurred()) SWIG_fail;
37947 }
37948 {
37949 resultobj = wxPyMake_wxObject(result, 0);
37950 }
37951 return resultobj;
37952 fail:
37953 return NULL;
37954 }
37955
37956
37957 SWIGINTERN PyObject *_wrap_Validator_Validate(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
37958 PyObject *resultobj = 0;
37959 wxValidator *arg1 = (wxValidator *) 0 ;
37960 wxWindow *arg2 = (wxWindow *) 0 ;
37961 bool result;
37962 void *argp1 = 0 ;
37963 int res1 = 0 ;
37964 void *argp2 = 0 ;
37965 int res2 = 0 ;
37966 PyObject * obj0 = 0 ;
37967 PyObject * obj1 = 0 ;
37968 char * kwnames[] = {
37969 (char *) "self",(char *) "parent", NULL
37970 };
37971
37972 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_Validate",kwnames,&obj0,&obj1)) SWIG_fail;
37973 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
37974 if (!SWIG_IsOK(res1)) {
37975 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_Validate" "', expected argument " "1"" of type '" "wxValidator *""'");
37976 }
37977 arg1 = reinterpret_cast< wxValidator * >(argp1);
37978 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
37979 if (!SWIG_IsOK(res2)) {
37980 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_Validate" "', expected argument " "2"" of type '" "wxWindow *""'");
37981 }
37982 arg2 = reinterpret_cast< wxWindow * >(argp2);
37983 {
37984 PyThreadState* __tstate = wxPyBeginAllowThreads();
37985 result = (bool)(arg1)->Validate(arg2);
37986 wxPyEndAllowThreads(__tstate);
37987 if (PyErr_Occurred()) SWIG_fail;
37988 }
37989 {
37990 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
37991 }
37992 return resultobj;
37993 fail:
37994 return NULL;
37995 }
37996
37997
37998 SWIGINTERN PyObject *_wrap_Validator_TransferToWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
37999 PyObject *resultobj = 0;
38000 wxValidator *arg1 = (wxValidator *) 0 ;
38001 bool result;
38002 void *argp1 = 0 ;
38003 int res1 = 0 ;
38004 PyObject *swig_obj[1] ;
38005
38006 if (!args) SWIG_fail;
38007 swig_obj[0] = args;
38008 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38009 if (!SWIG_IsOK(res1)) {
38010 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferToWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38011 }
38012 arg1 = reinterpret_cast< wxValidator * >(argp1);
38013 {
38014 PyThreadState* __tstate = wxPyBeginAllowThreads();
38015 result = (bool)(arg1)->TransferToWindow();
38016 wxPyEndAllowThreads(__tstate);
38017 if (PyErr_Occurred()) SWIG_fail;
38018 }
38019 {
38020 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38021 }
38022 return resultobj;
38023 fail:
38024 return NULL;
38025 }
38026
38027
38028 SWIGINTERN PyObject *_wrap_Validator_TransferFromWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38029 PyObject *resultobj = 0;
38030 wxValidator *arg1 = (wxValidator *) 0 ;
38031 bool result;
38032 void *argp1 = 0 ;
38033 int res1 = 0 ;
38034 PyObject *swig_obj[1] ;
38035
38036 if (!args) SWIG_fail;
38037 swig_obj[0] = args;
38038 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38039 if (!SWIG_IsOK(res1)) {
38040 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_TransferFromWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38041 }
38042 arg1 = reinterpret_cast< wxValidator * >(argp1);
38043 {
38044 PyThreadState* __tstate = wxPyBeginAllowThreads();
38045 result = (bool)(arg1)->TransferFromWindow();
38046 wxPyEndAllowThreads(__tstate);
38047 if (PyErr_Occurred()) SWIG_fail;
38048 }
38049 {
38050 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38051 }
38052 return resultobj;
38053 fail:
38054 return NULL;
38055 }
38056
38057
38058 SWIGINTERN PyObject *_wrap_Validator_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38059 PyObject *resultobj = 0;
38060 wxValidator *arg1 = (wxValidator *) 0 ;
38061 wxWindow *result = 0 ;
38062 void *argp1 = 0 ;
38063 int res1 = 0 ;
38064 PyObject *swig_obj[1] ;
38065
38066 if (!args) SWIG_fail;
38067 swig_obj[0] = args;
38068 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38069 if (!SWIG_IsOK(res1)) {
38070 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_GetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38071 }
38072 arg1 = reinterpret_cast< wxValidator * >(argp1);
38073 {
38074 PyThreadState* __tstate = wxPyBeginAllowThreads();
38075 result = (wxWindow *)(arg1)->GetWindow();
38076 wxPyEndAllowThreads(__tstate);
38077 if (PyErr_Occurred()) SWIG_fail;
38078 }
38079 {
38080 resultobj = wxPyMake_wxObject(result, 0);
38081 }
38082 return resultobj;
38083 fail:
38084 return NULL;
38085 }
38086
38087
38088 SWIGINTERN PyObject *_wrap_Validator_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38089 PyObject *resultobj = 0;
38090 wxValidator *arg1 = (wxValidator *) 0 ;
38091 wxWindow *arg2 = (wxWindow *) 0 ;
38092 void *argp1 = 0 ;
38093 int res1 = 0 ;
38094 void *argp2 = 0 ;
38095 int res2 = 0 ;
38096 PyObject * obj0 = 0 ;
38097 PyObject * obj1 = 0 ;
38098 char * kwnames[] = {
38099 (char *) "self",(char *) "window", NULL
38100 };
38101
38102 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Validator_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
38103 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxValidator, 0 | 0 );
38104 if (!SWIG_IsOK(res1)) {
38105 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Validator_SetWindow" "', expected argument " "1"" of type '" "wxValidator *""'");
38106 }
38107 arg1 = reinterpret_cast< wxValidator * >(argp1);
38108 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
38109 if (!SWIG_IsOK(res2)) {
38110 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Validator_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
38111 }
38112 arg2 = reinterpret_cast< wxWindow * >(argp2);
38113 {
38114 PyThreadState* __tstate = wxPyBeginAllowThreads();
38115 (arg1)->SetWindow(arg2);
38116 wxPyEndAllowThreads(__tstate);
38117 if (PyErr_Occurred()) SWIG_fail;
38118 }
38119 resultobj = SWIG_Py_Void();
38120 return resultobj;
38121 fail:
38122 return NULL;
38123 }
38124
38125
38126 SWIGINTERN PyObject *_wrap_Validator_IsSilent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38127 PyObject *resultobj = 0;
38128 bool result;
38129
38130 if (!SWIG_Python_UnpackTuple(args,"Validator_IsSilent",0,0,0)) SWIG_fail;
38131 {
38132 PyThreadState* __tstate = wxPyBeginAllowThreads();
38133 result = (bool)wxValidator::IsSilent();
38134 wxPyEndAllowThreads(__tstate);
38135 if (PyErr_Occurred()) SWIG_fail;
38136 }
38137 {
38138 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
38139 }
38140 return resultobj;
38141 fail:
38142 return NULL;
38143 }
38144
38145
38146 SWIGINTERN PyObject *_wrap_Validator_SetBellOnError(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38147 PyObject *resultobj = 0;
38148 int arg1 = (int) true ;
38149 int val1 ;
38150 int ecode1 = 0 ;
38151 PyObject * obj0 = 0 ;
38152 char * kwnames[] = {
38153 (char *) "doIt", NULL
38154 };
38155
38156 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Validator_SetBellOnError",kwnames,&obj0)) SWIG_fail;
38157 if (obj0) {
38158 ecode1 = SWIG_AsVal_int(obj0, &val1);
38159 if (!SWIG_IsOK(ecode1)) {
38160 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Validator_SetBellOnError" "', expected argument " "1"" of type '" "int""'");
38161 }
38162 arg1 = static_cast< int >(val1);
38163 }
38164 {
38165 PyThreadState* __tstate = wxPyBeginAllowThreads();
38166 wxValidator::SetBellOnError(arg1);
38167 wxPyEndAllowThreads(__tstate);
38168 if (PyErr_Occurred()) SWIG_fail;
38169 }
38170 resultobj = SWIG_Py_Void();
38171 return resultobj;
38172 fail:
38173 return NULL;
38174 }
38175
38176
38177 SWIGINTERN PyObject *Validator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38178 PyObject *obj;
38179 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38180 SWIG_TypeNewClientData(SWIGTYPE_p_wxValidator, SWIG_NewClientData(obj));
38181 return SWIG_Py_Void();
38182 }
38183
38184 SWIGINTERN PyObject *Validator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38185 return SWIG_Python_InitShadowInstance(args);
38186 }
38187
38188 SWIGINTERN PyObject *_wrap_new_PyValidator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38189 PyObject *resultobj = 0;
38190 wxPyValidator *result = 0 ;
38191
38192 if (!SWIG_Python_UnpackTuple(args,"new_PyValidator",0,0,0)) SWIG_fail;
38193 {
38194 PyThreadState* __tstate = wxPyBeginAllowThreads();
38195 result = (wxPyValidator *)new wxPyValidator();
38196 wxPyEndAllowThreads(__tstate);
38197 if (PyErr_Occurred()) SWIG_fail;
38198 }
38199 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPyValidator, SWIG_POINTER_NEW | 0 );
38200 return resultobj;
38201 fail:
38202 return NULL;
38203 }
38204
38205
38206 SWIGINTERN PyObject *_wrap_PyValidator__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38207 PyObject *resultobj = 0;
38208 wxPyValidator *arg1 = (wxPyValidator *) 0 ;
38209 PyObject *arg2 = (PyObject *) 0 ;
38210 PyObject *arg3 = (PyObject *) 0 ;
38211 int arg4 = (int) true ;
38212 void *argp1 = 0 ;
38213 int res1 = 0 ;
38214 int val4 ;
38215 int ecode4 = 0 ;
38216 PyObject * obj0 = 0 ;
38217 PyObject * obj1 = 0 ;
38218 PyObject * obj2 = 0 ;
38219 PyObject * obj3 = 0 ;
38220 char * kwnames[] = {
38221 (char *) "self",(char *) "self",(char *) "_class",(char *) "incref", NULL
38222 };
38223
38224 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:PyValidator__setCallbackInfo",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38225 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPyValidator, 0 | 0 );
38226 if (!SWIG_IsOK(res1)) {
38227 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "1"" of type '" "wxPyValidator *""'");
38228 }
38229 arg1 = reinterpret_cast< wxPyValidator * >(argp1);
38230 arg2 = obj1;
38231 arg3 = obj2;
38232 if (obj3) {
38233 ecode4 = SWIG_AsVal_int(obj3, &val4);
38234 if (!SWIG_IsOK(ecode4)) {
38235 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "PyValidator__setCallbackInfo" "', expected argument " "4"" of type '" "int""'");
38236 }
38237 arg4 = static_cast< int >(val4);
38238 }
38239 {
38240 PyThreadState* __tstate = wxPyBeginAllowThreads();
38241 (arg1)->_setCallbackInfo(arg2,arg3,arg4);
38242 wxPyEndAllowThreads(__tstate);
38243 if (PyErr_Occurred()) SWIG_fail;
38244 }
38245 resultobj = SWIG_Py_Void();
38246 return resultobj;
38247 fail:
38248 return NULL;
38249 }
38250
38251
38252 SWIGINTERN PyObject *PyValidator_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38253 PyObject *obj;
38254 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
38255 SWIG_TypeNewClientData(SWIGTYPE_p_wxPyValidator, SWIG_NewClientData(obj));
38256 return SWIG_Py_Void();
38257 }
38258
38259 SWIGINTERN PyObject *PyValidator_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38260 return SWIG_Python_InitShadowInstance(args);
38261 }
38262
38263 SWIGINTERN int DefaultValidator_set(PyObject *) {
38264 SWIG_Error(SWIG_AttributeError,"Variable DefaultValidator is read-only.");
38265 return 1;
38266 }
38267
38268
38269 SWIGINTERN PyObject *DefaultValidator_get(void) {
38270 PyObject *pyobj = 0;
38271
38272 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultValidator), SWIGTYPE_p_wxValidator, 0 );
38273 return pyobj;
38274 }
38275
38276
38277 SWIGINTERN PyObject *_wrap_new_Menu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38278 PyObject *resultobj = 0;
38279 wxString const &arg1_defvalue = wxPyEmptyString ;
38280 wxString *arg1 = (wxString *) &arg1_defvalue ;
38281 long arg2 = (long) 0 ;
38282 wxMenu *result = 0 ;
38283 bool temp1 = false ;
38284 long val2 ;
38285 int ecode2 = 0 ;
38286 PyObject * obj0 = 0 ;
38287 PyObject * obj1 = 0 ;
38288 char * kwnames[] = {
38289 (char *) "title",(char *) "style", NULL
38290 };
38291
38292 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_Menu",kwnames,&obj0,&obj1)) SWIG_fail;
38293 if (obj0) {
38294 {
38295 arg1 = wxString_in_helper(obj0);
38296 if (arg1 == NULL) SWIG_fail;
38297 temp1 = true;
38298 }
38299 }
38300 if (obj1) {
38301 ecode2 = SWIG_AsVal_long(obj1, &val2);
38302 if (!SWIG_IsOK(ecode2)) {
38303 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Menu" "', expected argument " "2"" of type '" "long""'");
38304 }
38305 arg2 = static_cast< long >(val2);
38306 }
38307 {
38308 if (!wxPyCheckForApp()) SWIG_fail;
38309 PyThreadState* __tstate = wxPyBeginAllowThreads();
38310 result = (wxMenu *)new wxMenu((wxString const &)*arg1,arg2);
38311 wxPyEndAllowThreads(__tstate);
38312 if (PyErr_Occurred()) SWIG_fail;
38313 }
38314 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenu, SWIG_POINTER_NEW | 0 );
38315 {
38316 if (temp1)
38317 delete arg1;
38318 }
38319 return resultobj;
38320 fail:
38321 {
38322 if (temp1)
38323 delete arg1;
38324 }
38325 return NULL;
38326 }
38327
38328
38329 SWIGINTERN PyObject *_wrap_Menu_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38330 PyObject *resultobj = 0;
38331 wxMenu *arg1 = (wxMenu *) 0 ;
38332 int arg2 ;
38333 wxString *arg3 = 0 ;
38334 wxString const &arg4_defvalue = wxPyEmptyString ;
38335 wxString *arg4 = (wxString *) &arg4_defvalue ;
38336 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
38337 wxMenuItem *result = 0 ;
38338 void *argp1 = 0 ;
38339 int res1 = 0 ;
38340 int val2 ;
38341 int ecode2 = 0 ;
38342 bool temp3 = false ;
38343 bool temp4 = false ;
38344 int val5 ;
38345 int ecode5 = 0 ;
38346 PyObject * obj0 = 0 ;
38347 PyObject * obj1 = 0 ;
38348 PyObject * obj2 = 0 ;
38349 PyObject * obj3 = 0 ;
38350 PyObject * obj4 = 0 ;
38351 char * kwnames[] = {
38352 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38353 };
38354
38355 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Append",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38356 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38357 if (!SWIG_IsOK(res1)) {
38358 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Append" "', expected argument " "1"" of type '" "wxMenu *""'");
38359 }
38360 arg1 = reinterpret_cast< wxMenu * >(argp1);
38361 ecode2 = SWIG_AsVal_int(obj1, &val2);
38362 if (!SWIG_IsOK(ecode2)) {
38363 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Append" "', expected argument " "2"" of type '" "int""'");
38364 }
38365 arg2 = static_cast< int >(val2);
38366 {
38367 arg3 = wxString_in_helper(obj2);
38368 if (arg3 == NULL) SWIG_fail;
38369 temp3 = true;
38370 }
38371 if (obj3) {
38372 {
38373 arg4 = wxString_in_helper(obj3);
38374 if (arg4 == NULL) SWIG_fail;
38375 temp4 = true;
38376 }
38377 }
38378 if (obj4) {
38379 ecode5 = SWIG_AsVal_int(obj4, &val5);
38380 if (!SWIG_IsOK(ecode5)) {
38381 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Append" "', expected argument " "5"" of type '" "wxItemKind""'");
38382 }
38383 arg5 = static_cast< wxItemKind >(val5);
38384 }
38385 {
38386 PyThreadState* __tstate = wxPyBeginAllowThreads();
38387 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
38388 wxPyEndAllowThreads(__tstate);
38389 if (PyErr_Occurred()) SWIG_fail;
38390 }
38391 {
38392 resultobj = wxPyMake_wxObject(result, (bool)0);
38393 }
38394 {
38395 if (temp3)
38396 delete arg3;
38397 }
38398 {
38399 if (temp4)
38400 delete arg4;
38401 }
38402 return resultobj;
38403 fail:
38404 {
38405 if (temp3)
38406 delete arg3;
38407 }
38408 {
38409 if (temp4)
38410 delete arg4;
38411 }
38412 return NULL;
38413 }
38414
38415
38416 SWIGINTERN PyObject *_wrap_Menu_AppendSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38417 PyObject *resultobj = 0;
38418 wxMenu *arg1 = (wxMenu *) 0 ;
38419 wxMenuItem *result = 0 ;
38420 void *argp1 = 0 ;
38421 int res1 = 0 ;
38422 PyObject *swig_obj[1] ;
38423
38424 if (!args) SWIG_fail;
38425 swig_obj[0] = args;
38426 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38427 if (!SWIG_IsOK(res1)) {
38428 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
38429 }
38430 arg1 = reinterpret_cast< wxMenu * >(argp1);
38431 {
38432 PyThreadState* __tstate = wxPyBeginAllowThreads();
38433 result = (wxMenuItem *)(arg1)->AppendSeparator();
38434 wxPyEndAllowThreads(__tstate);
38435 if (PyErr_Occurred()) SWIG_fail;
38436 }
38437 {
38438 resultobj = wxPyMake_wxObject(result, (bool)0);
38439 }
38440 return resultobj;
38441 fail:
38442 return NULL;
38443 }
38444
38445
38446 SWIGINTERN PyObject *_wrap_Menu_AppendCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38447 PyObject *resultobj = 0;
38448 wxMenu *arg1 = (wxMenu *) 0 ;
38449 int arg2 ;
38450 wxString *arg3 = 0 ;
38451 wxString const &arg4_defvalue = wxPyEmptyString ;
38452 wxString *arg4 = (wxString *) &arg4_defvalue ;
38453 wxMenuItem *result = 0 ;
38454 void *argp1 = 0 ;
38455 int res1 = 0 ;
38456 int val2 ;
38457 int ecode2 = 0 ;
38458 bool temp3 = false ;
38459 bool temp4 = false ;
38460 PyObject * obj0 = 0 ;
38461 PyObject * obj1 = 0 ;
38462 PyObject * obj2 = 0 ;
38463 PyObject * obj3 = 0 ;
38464 char * kwnames[] = {
38465 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38466 };
38467
38468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38470 if (!SWIG_IsOK(res1)) {
38471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38472 }
38473 arg1 = reinterpret_cast< wxMenu * >(argp1);
38474 ecode2 = SWIG_AsVal_int(obj1, &val2);
38475 if (!SWIG_IsOK(ecode2)) {
38476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendCheckItem" "', expected argument " "2"" of type '" "int""'");
38477 }
38478 arg2 = static_cast< int >(val2);
38479 {
38480 arg3 = wxString_in_helper(obj2);
38481 if (arg3 == NULL) SWIG_fail;
38482 temp3 = true;
38483 }
38484 if (obj3) {
38485 {
38486 arg4 = wxString_in_helper(obj3);
38487 if (arg4 == NULL) SWIG_fail;
38488 temp4 = true;
38489 }
38490 }
38491 {
38492 PyThreadState* __tstate = wxPyBeginAllowThreads();
38493 result = (wxMenuItem *)(arg1)->AppendCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38494 wxPyEndAllowThreads(__tstate);
38495 if (PyErr_Occurred()) SWIG_fail;
38496 }
38497 {
38498 resultobj = wxPyMake_wxObject(result, (bool)0);
38499 }
38500 {
38501 if (temp3)
38502 delete arg3;
38503 }
38504 {
38505 if (temp4)
38506 delete arg4;
38507 }
38508 return resultobj;
38509 fail:
38510 {
38511 if (temp3)
38512 delete arg3;
38513 }
38514 {
38515 if (temp4)
38516 delete arg4;
38517 }
38518 return NULL;
38519 }
38520
38521
38522 SWIGINTERN PyObject *_wrap_Menu_AppendRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38523 PyObject *resultobj = 0;
38524 wxMenu *arg1 = (wxMenu *) 0 ;
38525 int arg2 ;
38526 wxString *arg3 = 0 ;
38527 wxString const &arg4_defvalue = wxPyEmptyString ;
38528 wxString *arg4 = (wxString *) &arg4_defvalue ;
38529 wxMenuItem *result = 0 ;
38530 void *argp1 = 0 ;
38531 int res1 = 0 ;
38532 int val2 ;
38533 int ecode2 = 0 ;
38534 bool temp3 = false ;
38535 bool temp4 = false ;
38536 PyObject * obj0 = 0 ;
38537 PyObject * obj1 = 0 ;
38538 PyObject * obj2 = 0 ;
38539 PyObject * obj3 = 0 ;
38540 char * kwnames[] = {
38541 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
38542 };
38543
38544 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38545 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38546 if (!SWIG_IsOK(res1)) {
38547 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38548 }
38549 arg1 = reinterpret_cast< wxMenu * >(argp1);
38550 ecode2 = SWIG_AsVal_int(obj1, &val2);
38551 if (!SWIG_IsOK(ecode2)) {
38552 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendRadioItem" "', expected argument " "2"" of type '" "int""'");
38553 }
38554 arg2 = static_cast< int >(val2);
38555 {
38556 arg3 = wxString_in_helper(obj2);
38557 if (arg3 == NULL) SWIG_fail;
38558 temp3 = true;
38559 }
38560 if (obj3) {
38561 {
38562 arg4 = wxString_in_helper(obj3);
38563 if (arg4 == NULL) SWIG_fail;
38564 temp4 = true;
38565 }
38566 }
38567 {
38568 PyThreadState* __tstate = wxPyBeginAllowThreads();
38569 result = (wxMenuItem *)(arg1)->AppendRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38570 wxPyEndAllowThreads(__tstate);
38571 if (PyErr_Occurred()) SWIG_fail;
38572 }
38573 {
38574 resultobj = wxPyMake_wxObject(result, (bool)0);
38575 }
38576 {
38577 if (temp3)
38578 delete arg3;
38579 }
38580 {
38581 if (temp4)
38582 delete arg4;
38583 }
38584 return resultobj;
38585 fail:
38586 {
38587 if (temp3)
38588 delete arg3;
38589 }
38590 {
38591 if (temp4)
38592 delete arg4;
38593 }
38594 return NULL;
38595 }
38596
38597
38598 SWIGINTERN PyObject *_wrap_Menu_AppendMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38599 PyObject *resultobj = 0;
38600 wxMenu *arg1 = (wxMenu *) 0 ;
38601 int arg2 ;
38602 wxString *arg3 = 0 ;
38603 wxMenu *arg4 = (wxMenu *) 0 ;
38604 wxString const &arg5_defvalue = wxPyEmptyString ;
38605 wxString *arg5 = (wxString *) &arg5_defvalue ;
38606 wxMenuItem *result = 0 ;
38607 void *argp1 = 0 ;
38608 int res1 = 0 ;
38609 int val2 ;
38610 int ecode2 = 0 ;
38611 bool temp3 = false ;
38612 void *argp4 = 0 ;
38613 int res4 = 0 ;
38614 bool temp5 = false ;
38615 PyObject * obj0 = 0 ;
38616 PyObject * obj1 = 0 ;
38617 PyObject * obj2 = 0 ;
38618 PyObject * obj3 = 0 ;
38619 PyObject * obj4 = 0 ;
38620 char * kwnames[] = {
38621 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
38622 };
38623
38624 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_AppendMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
38625 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38626 if (!SWIG_IsOK(res1)) {
38627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38628 }
38629 arg1 = reinterpret_cast< wxMenu * >(argp1);
38630 ecode2 = SWIG_AsVal_int(obj1, &val2);
38631 if (!SWIG_IsOK(ecode2)) {
38632 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_AppendMenu" "', expected argument " "2"" of type '" "int""'");
38633 }
38634 arg2 = static_cast< int >(val2);
38635 {
38636 arg3 = wxString_in_helper(obj2);
38637 if (arg3 == NULL) SWIG_fail;
38638 temp3 = true;
38639 }
38640 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
38641 if (!SWIG_IsOK(res4)) {
38642 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_AppendMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
38643 }
38644 arg4 = reinterpret_cast< wxMenu * >(argp4);
38645 if (obj4) {
38646 {
38647 arg5 = wxString_in_helper(obj4);
38648 if (arg5 == NULL) SWIG_fail;
38649 temp5 = true;
38650 }
38651 }
38652 {
38653 PyThreadState* __tstate = wxPyBeginAllowThreads();
38654 result = (wxMenuItem *)(arg1)->Append(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
38655 wxPyEndAllowThreads(__tstate);
38656 if (PyErr_Occurred()) SWIG_fail;
38657 }
38658 {
38659 resultobj = wxPyMake_wxObject(result, (bool)0);
38660 }
38661 {
38662 if (temp3)
38663 delete arg3;
38664 }
38665 {
38666 if (temp5)
38667 delete arg5;
38668 }
38669 return resultobj;
38670 fail:
38671 {
38672 if (temp3)
38673 delete arg3;
38674 }
38675 {
38676 if (temp5)
38677 delete arg5;
38678 }
38679 return NULL;
38680 }
38681
38682
38683 SWIGINTERN PyObject *_wrap_Menu_AppendSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38684 PyObject *resultobj = 0;
38685 wxMenu *arg1 = (wxMenu *) 0 ;
38686 wxMenu *arg2 = (wxMenu *) 0 ;
38687 wxString *arg3 = 0 ;
38688 wxString const &arg4_defvalue = wxPyEmptyString ;
38689 wxString *arg4 = (wxString *) &arg4_defvalue ;
38690 wxMenuItem *result = 0 ;
38691 void *argp1 = 0 ;
38692 int res1 = 0 ;
38693 void *argp2 = 0 ;
38694 int res2 = 0 ;
38695 bool temp3 = false ;
38696 bool temp4 = false ;
38697 PyObject * obj0 = 0 ;
38698 PyObject * obj1 = 0 ;
38699 PyObject * obj2 = 0 ;
38700 PyObject * obj3 = 0 ;
38701 char * kwnames[] = {
38702 (char *) "self",(char *) "submenu",(char *) "text",(char *) "help", NULL
38703 };
38704
38705 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_AppendSubMenu",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
38706 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38707 if (!SWIG_IsOK(res1)) {
38708 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendSubMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
38709 }
38710 arg1 = reinterpret_cast< wxMenu * >(argp1);
38711 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
38712 if (!SWIG_IsOK(res2)) {
38713 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
38714 }
38715 arg2 = reinterpret_cast< wxMenu * >(argp2);
38716 {
38717 arg3 = wxString_in_helper(obj2);
38718 if (arg3 == NULL) SWIG_fail;
38719 temp3 = true;
38720 }
38721 if (obj3) {
38722 {
38723 arg4 = wxString_in_helper(obj3);
38724 if (arg4 == NULL) SWIG_fail;
38725 temp4 = true;
38726 }
38727 }
38728 {
38729 PyThreadState* __tstate = wxPyBeginAllowThreads();
38730 result = (wxMenuItem *)(arg1)->AppendSubMenu(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
38731 wxPyEndAllowThreads(__tstate);
38732 if (PyErr_Occurred()) SWIG_fail;
38733 }
38734 {
38735 resultobj = wxPyMake_wxObject(result, (bool)0);
38736 }
38737 {
38738 if (temp3)
38739 delete arg3;
38740 }
38741 {
38742 if (temp4)
38743 delete arg4;
38744 }
38745 return resultobj;
38746 fail:
38747 {
38748 if (temp3)
38749 delete arg3;
38750 }
38751 {
38752 if (temp4)
38753 delete arg4;
38754 }
38755 return NULL;
38756 }
38757
38758
38759 SWIGINTERN PyObject *_wrap_Menu_AppendItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38760 PyObject *resultobj = 0;
38761 wxMenu *arg1 = (wxMenu *) 0 ;
38762 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38763 wxMenuItem *result = 0 ;
38764 void *argp1 = 0 ;
38765 int res1 = 0 ;
38766 int res2 = 0 ;
38767 PyObject * obj0 = 0 ;
38768 PyObject * obj1 = 0 ;
38769 char * kwnames[] = {
38770 (char *) "self",(char *) "item", NULL
38771 };
38772
38773 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_AppendItem",kwnames,&obj0,&obj1)) SWIG_fail;
38774 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38775 if (!SWIG_IsOK(res1)) {
38776 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_AppendItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38777 }
38778 arg1 = reinterpret_cast< wxMenu * >(argp1);
38779 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38780 if (!SWIG_IsOK(res2)) {
38781 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_AppendItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38782 }
38783 {
38784 PyThreadState* __tstate = wxPyBeginAllowThreads();
38785 result = (wxMenuItem *)(arg1)->Append(arg2);
38786 wxPyEndAllowThreads(__tstate);
38787 if (PyErr_Occurred()) SWIG_fail;
38788 }
38789 {
38790 resultobj = wxPyMake_wxObject(result, (bool)0);
38791 }
38792 return resultobj;
38793 fail:
38794 return NULL;
38795 }
38796
38797
38798 SWIGINTERN PyObject *_wrap_Menu_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38799 PyObject *resultobj = 0;
38800 wxMenu *arg1 = (wxMenu *) 0 ;
38801 size_t arg2 ;
38802 wxMenuItem *arg3 = (wxMenuItem *) 0 ;
38803 wxMenuItem *result = 0 ;
38804 void *argp1 = 0 ;
38805 int res1 = 0 ;
38806 size_t val2 ;
38807 int ecode2 = 0 ;
38808 int res3 = 0 ;
38809 PyObject * obj0 = 0 ;
38810 PyObject * obj1 = 0 ;
38811 PyObject * obj2 = 0 ;
38812 char * kwnames[] = {
38813 (char *) "self",(char *) "pos",(char *) "item", NULL
38814 };
38815
38816 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
38817 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38818 if (!SWIG_IsOK(res1)) {
38819 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38820 }
38821 arg1 = reinterpret_cast< wxMenu * >(argp1);
38822 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38823 if (!SWIG_IsOK(ecode2)) {
38824 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
38825 }
38826 arg2 = static_cast< size_t >(val2);
38827 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38828 if (!SWIG_IsOK(res3)) {
38829 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Menu_InsertItem" "', expected argument " "3"" of type '" "wxMenuItem *""'");
38830 }
38831 {
38832 PyThreadState* __tstate = wxPyBeginAllowThreads();
38833 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3);
38834 wxPyEndAllowThreads(__tstate);
38835 if (PyErr_Occurred()) SWIG_fail;
38836 }
38837 {
38838 resultobj = wxPyMake_wxObject(result, (bool)0);
38839 }
38840 return resultobj;
38841 fail:
38842 return NULL;
38843 }
38844
38845
38846 SWIGINTERN PyObject *_wrap_Menu_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38847 PyObject *resultobj = 0;
38848 wxMenu *arg1 = (wxMenu *) 0 ;
38849 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
38850 wxMenuItem *result = 0 ;
38851 void *argp1 = 0 ;
38852 int res1 = 0 ;
38853 int res2 = 0 ;
38854 PyObject * obj0 = 0 ;
38855 PyObject * obj1 = 0 ;
38856 char * kwnames[] = {
38857 (char *) "self",(char *) "item", NULL
38858 };
38859
38860 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
38861 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38862 if (!SWIG_IsOK(res1)) {
38863 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependItem" "', expected argument " "1"" of type '" "wxMenu *""'");
38864 }
38865 arg1 = reinterpret_cast< wxMenu * >(argp1);
38866 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
38867 if (!SWIG_IsOK(res2)) {
38868 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_PrependItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
38869 }
38870 {
38871 PyThreadState* __tstate = wxPyBeginAllowThreads();
38872 result = (wxMenuItem *)(arg1)->Prepend(arg2);
38873 wxPyEndAllowThreads(__tstate);
38874 if (PyErr_Occurred()) SWIG_fail;
38875 }
38876 {
38877 resultobj = wxPyMake_wxObject(result, (bool)0);
38878 }
38879 return resultobj;
38880 fail:
38881 return NULL;
38882 }
38883
38884
38885 SWIGINTERN PyObject *_wrap_Menu_Break(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
38886 PyObject *resultobj = 0;
38887 wxMenu *arg1 = (wxMenu *) 0 ;
38888 void *argp1 = 0 ;
38889 int res1 = 0 ;
38890 PyObject *swig_obj[1] ;
38891
38892 if (!args) SWIG_fail;
38893 swig_obj[0] = args;
38894 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38895 if (!SWIG_IsOK(res1)) {
38896 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Break" "', expected argument " "1"" of type '" "wxMenu *""'");
38897 }
38898 arg1 = reinterpret_cast< wxMenu * >(argp1);
38899 {
38900 PyThreadState* __tstate = wxPyBeginAllowThreads();
38901 (arg1)->Break();
38902 wxPyEndAllowThreads(__tstate);
38903 if (PyErr_Occurred()) SWIG_fail;
38904 }
38905 resultobj = SWIG_Py_Void();
38906 return resultobj;
38907 fail:
38908 return NULL;
38909 }
38910
38911
38912 SWIGINTERN PyObject *_wrap_Menu_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
38913 PyObject *resultobj = 0;
38914 wxMenu *arg1 = (wxMenu *) 0 ;
38915 size_t arg2 ;
38916 int arg3 ;
38917 wxString *arg4 = 0 ;
38918 wxString const &arg5_defvalue = wxPyEmptyString ;
38919 wxString *arg5 = (wxString *) &arg5_defvalue ;
38920 wxItemKind arg6 = (wxItemKind) wxITEM_NORMAL ;
38921 wxMenuItem *result = 0 ;
38922 void *argp1 = 0 ;
38923 int res1 = 0 ;
38924 size_t val2 ;
38925 int ecode2 = 0 ;
38926 int val3 ;
38927 int ecode3 = 0 ;
38928 bool temp4 = false ;
38929 bool temp5 = false ;
38930 int val6 ;
38931 int ecode6 = 0 ;
38932 PyObject * obj0 = 0 ;
38933 PyObject * obj1 = 0 ;
38934 PyObject * obj2 = 0 ;
38935 PyObject * obj3 = 0 ;
38936 PyObject * obj4 = 0 ;
38937 PyObject * obj5 = 0 ;
38938 char * kwnames[] = {
38939 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
38940 };
38941
38942 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:Menu_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
38943 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
38944 if (!SWIG_IsOK(res1)) {
38945 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Insert" "', expected argument " "1"" of type '" "wxMenu *""'");
38946 }
38947 arg1 = reinterpret_cast< wxMenu * >(argp1);
38948 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
38949 if (!SWIG_IsOK(ecode2)) {
38950 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Insert" "', expected argument " "2"" of type '" "size_t""'");
38951 }
38952 arg2 = static_cast< size_t >(val2);
38953 ecode3 = SWIG_AsVal_int(obj2, &val3);
38954 if (!SWIG_IsOK(ecode3)) {
38955 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Insert" "', expected argument " "3"" of type '" "int""'");
38956 }
38957 arg3 = static_cast< int >(val3);
38958 {
38959 arg4 = wxString_in_helper(obj3);
38960 if (arg4 == NULL) SWIG_fail;
38961 temp4 = true;
38962 }
38963 if (obj4) {
38964 {
38965 arg5 = wxString_in_helper(obj4);
38966 if (arg5 == NULL) SWIG_fail;
38967 temp5 = true;
38968 }
38969 }
38970 if (obj5) {
38971 ecode6 = SWIG_AsVal_int(obj5, &val6);
38972 if (!SWIG_IsOK(ecode6)) {
38973 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Menu_Insert" "', expected argument " "6"" of type '" "wxItemKind""'");
38974 }
38975 arg6 = static_cast< wxItemKind >(val6);
38976 }
38977 {
38978 PyThreadState* __tstate = wxPyBeginAllowThreads();
38979 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5,arg6);
38980 wxPyEndAllowThreads(__tstate);
38981 if (PyErr_Occurred()) SWIG_fail;
38982 }
38983 {
38984 resultobj = wxPyMake_wxObject(result, (bool)0);
38985 }
38986 {
38987 if (temp4)
38988 delete arg4;
38989 }
38990 {
38991 if (temp5)
38992 delete arg5;
38993 }
38994 return resultobj;
38995 fail:
38996 {
38997 if (temp4)
38998 delete arg4;
38999 }
39000 {
39001 if (temp5)
39002 delete arg5;
39003 }
39004 return NULL;
39005 }
39006
39007
39008 SWIGINTERN PyObject *_wrap_Menu_InsertSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39009 PyObject *resultobj = 0;
39010 wxMenu *arg1 = (wxMenu *) 0 ;
39011 size_t arg2 ;
39012 wxMenuItem *result = 0 ;
39013 void *argp1 = 0 ;
39014 int res1 = 0 ;
39015 size_t val2 ;
39016 int ecode2 = 0 ;
39017 PyObject * obj0 = 0 ;
39018 PyObject * obj1 = 0 ;
39019 char * kwnames[] = {
39020 (char *) "self",(char *) "pos", NULL
39021 };
39022
39023 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_InsertSeparator",kwnames,&obj0,&obj1)) SWIG_fail;
39024 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39025 if (!SWIG_IsOK(res1)) {
39026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39027 }
39028 arg1 = reinterpret_cast< wxMenu * >(argp1);
39029 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39030 if (!SWIG_IsOK(ecode2)) {
39031 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertSeparator" "', expected argument " "2"" of type '" "size_t""'");
39032 }
39033 arg2 = static_cast< size_t >(val2);
39034 {
39035 PyThreadState* __tstate = wxPyBeginAllowThreads();
39036 result = (wxMenuItem *)(arg1)->InsertSeparator(arg2);
39037 wxPyEndAllowThreads(__tstate);
39038 if (PyErr_Occurred()) SWIG_fail;
39039 }
39040 {
39041 resultobj = wxPyMake_wxObject(result, (bool)0);
39042 }
39043 return resultobj;
39044 fail:
39045 return NULL;
39046 }
39047
39048
39049 SWIGINTERN PyObject *_wrap_Menu_InsertCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39050 PyObject *resultobj = 0;
39051 wxMenu *arg1 = (wxMenu *) 0 ;
39052 size_t arg2 ;
39053 int arg3 ;
39054 wxString *arg4 = 0 ;
39055 wxString const &arg5_defvalue = wxPyEmptyString ;
39056 wxString *arg5 = (wxString *) &arg5_defvalue ;
39057 wxMenuItem *result = 0 ;
39058 void *argp1 = 0 ;
39059 int res1 = 0 ;
39060 size_t val2 ;
39061 int ecode2 = 0 ;
39062 int val3 ;
39063 int ecode3 = 0 ;
39064 bool temp4 = false ;
39065 bool temp5 = false ;
39066 PyObject * obj0 = 0 ;
39067 PyObject * obj1 = 0 ;
39068 PyObject * obj2 = 0 ;
39069 PyObject * obj3 = 0 ;
39070 PyObject * obj4 = 0 ;
39071 char * kwnames[] = {
39072 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39073 };
39074
39075 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39076 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39077 if (!SWIG_IsOK(res1)) {
39078 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39079 }
39080 arg1 = reinterpret_cast< wxMenu * >(argp1);
39081 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39082 if (!SWIG_IsOK(ecode2)) {
39083 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertCheckItem" "', expected argument " "2"" of type '" "size_t""'");
39084 }
39085 arg2 = static_cast< size_t >(val2);
39086 ecode3 = SWIG_AsVal_int(obj2, &val3);
39087 if (!SWIG_IsOK(ecode3)) {
39088 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertCheckItem" "', expected argument " "3"" of type '" "int""'");
39089 }
39090 arg3 = static_cast< int >(val3);
39091 {
39092 arg4 = wxString_in_helper(obj3);
39093 if (arg4 == NULL) SWIG_fail;
39094 temp4 = true;
39095 }
39096 if (obj4) {
39097 {
39098 arg5 = wxString_in_helper(obj4);
39099 if (arg5 == NULL) SWIG_fail;
39100 temp5 = true;
39101 }
39102 }
39103 {
39104 PyThreadState* __tstate = wxPyBeginAllowThreads();
39105 result = (wxMenuItem *)(arg1)->InsertCheckItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39106 wxPyEndAllowThreads(__tstate);
39107 if (PyErr_Occurred()) SWIG_fail;
39108 }
39109 {
39110 resultobj = wxPyMake_wxObject(result, (bool)0);
39111 }
39112 {
39113 if (temp4)
39114 delete arg4;
39115 }
39116 {
39117 if (temp5)
39118 delete arg5;
39119 }
39120 return resultobj;
39121 fail:
39122 {
39123 if (temp4)
39124 delete arg4;
39125 }
39126 {
39127 if (temp5)
39128 delete arg5;
39129 }
39130 return NULL;
39131 }
39132
39133
39134 SWIGINTERN PyObject *_wrap_Menu_InsertRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39135 PyObject *resultobj = 0;
39136 wxMenu *arg1 = (wxMenu *) 0 ;
39137 size_t arg2 ;
39138 int arg3 ;
39139 wxString *arg4 = 0 ;
39140 wxString const &arg5_defvalue = wxPyEmptyString ;
39141 wxString *arg5 = (wxString *) &arg5_defvalue ;
39142 wxMenuItem *result = 0 ;
39143 void *argp1 = 0 ;
39144 int res1 = 0 ;
39145 size_t val2 ;
39146 int ecode2 = 0 ;
39147 int val3 ;
39148 int ecode3 = 0 ;
39149 bool temp4 = false ;
39150 bool temp5 = false ;
39151 PyObject * obj0 = 0 ;
39152 PyObject * obj1 = 0 ;
39153 PyObject * obj2 = 0 ;
39154 PyObject * obj3 = 0 ;
39155 PyObject * obj4 = 0 ;
39156 char * kwnames[] = {
39157 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "help", NULL
39158 };
39159
39160 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_InsertRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39161 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39162 if (!SWIG_IsOK(res1)) {
39163 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39164 }
39165 arg1 = reinterpret_cast< wxMenu * >(argp1);
39166 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39167 if (!SWIG_IsOK(ecode2)) {
39168 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertRadioItem" "', expected argument " "2"" of type '" "size_t""'");
39169 }
39170 arg2 = static_cast< size_t >(val2);
39171 ecode3 = SWIG_AsVal_int(obj2, &val3);
39172 if (!SWIG_IsOK(ecode3)) {
39173 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertRadioItem" "', expected argument " "3"" of type '" "int""'");
39174 }
39175 arg3 = static_cast< int >(val3);
39176 {
39177 arg4 = wxString_in_helper(obj3);
39178 if (arg4 == NULL) SWIG_fail;
39179 temp4 = true;
39180 }
39181 if (obj4) {
39182 {
39183 arg5 = wxString_in_helper(obj4);
39184 if (arg5 == NULL) SWIG_fail;
39185 temp5 = true;
39186 }
39187 }
39188 {
39189 PyThreadState* __tstate = wxPyBeginAllowThreads();
39190 result = (wxMenuItem *)(arg1)->InsertRadioItem(arg2,arg3,(wxString const &)*arg4,(wxString const &)*arg5);
39191 wxPyEndAllowThreads(__tstate);
39192 if (PyErr_Occurred()) SWIG_fail;
39193 }
39194 {
39195 resultobj = wxPyMake_wxObject(result, (bool)0);
39196 }
39197 {
39198 if (temp4)
39199 delete arg4;
39200 }
39201 {
39202 if (temp5)
39203 delete arg5;
39204 }
39205 return resultobj;
39206 fail:
39207 {
39208 if (temp4)
39209 delete arg4;
39210 }
39211 {
39212 if (temp5)
39213 delete arg5;
39214 }
39215 return NULL;
39216 }
39217
39218
39219 SWIGINTERN PyObject *_wrap_Menu_InsertMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39220 PyObject *resultobj = 0;
39221 wxMenu *arg1 = (wxMenu *) 0 ;
39222 size_t arg2 ;
39223 int arg3 ;
39224 wxString *arg4 = 0 ;
39225 wxMenu *arg5 = (wxMenu *) 0 ;
39226 wxString const &arg6_defvalue = wxPyEmptyString ;
39227 wxString *arg6 = (wxString *) &arg6_defvalue ;
39228 wxMenuItem *result = 0 ;
39229 void *argp1 = 0 ;
39230 int res1 = 0 ;
39231 size_t val2 ;
39232 int ecode2 = 0 ;
39233 int val3 ;
39234 int ecode3 = 0 ;
39235 bool temp4 = false ;
39236 void *argp5 = 0 ;
39237 int res5 = 0 ;
39238 bool temp6 = false ;
39239 PyObject * obj0 = 0 ;
39240 PyObject * obj1 = 0 ;
39241 PyObject * obj2 = 0 ;
39242 PyObject * obj3 = 0 ;
39243 PyObject * obj4 = 0 ;
39244 PyObject * obj5 = 0 ;
39245 char * kwnames[] = {
39246 (char *) "self",(char *) "pos",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39247 };
39248
39249 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:Menu_InsertMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
39250 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39251 if (!SWIG_IsOK(res1)) {
39252 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_InsertMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39253 }
39254 arg1 = reinterpret_cast< wxMenu * >(argp1);
39255 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
39256 if (!SWIG_IsOK(ecode2)) {
39257 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_InsertMenu" "', expected argument " "2"" of type '" "size_t""'");
39258 }
39259 arg2 = static_cast< size_t >(val2);
39260 ecode3 = SWIG_AsVal_int(obj2, &val3);
39261 if (!SWIG_IsOK(ecode3)) {
39262 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_InsertMenu" "', expected argument " "3"" of type '" "int""'");
39263 }
39264 arg3 = static_cast< int >(val3);
39265 {
39266 arg4 = wxString_in_helper(obj3);
39267 if (arg4 == NULL) SWIG_fail;
39268 temp4 = true;
39269 }
39270 res5 = SWIG_ConvertPtr(obj4, &argp5,SWIGTYPE_p_wxMenu, 0 | 0 );
39271 if (!SWIG_IsOK(res5)) {
39272 SWIG_exception_fail(SWIG_ArgError(res5), "in method '" "Menu_InsertMenu" "', expected argument " "5"" of type '" "wxMenu *""'");
39273 }
39274 arg5 = reinterpret_cast< wxMenu * >(argp5);
39275 if (obj5) {
39276 {
39277 arg6 = wxString_in_helper(obj5);
39278 if (arg6 == NULL) SWIG_fail;
39279 temp6 = true;
39280 }
39281 }
39282 {
39283 PyThreadState* __tstate = wxPyBeginAllowThreads();
39284 result = (wxMenuItem *)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4,arg5,(wxString const &)*arg6);
39285 wxPyEndAllowThreads(__tstate);
39286 if (PyErr_Occurred()) SWIG_fail;
39287 }
39288 {
39289 resultobj = wxPyMake_wxObject(result, (bool)0);
39290 }
39291 {
39292 if (temp4)
39293 delete arg4;
39294 }
39295 {
39296 if (temp6)
39297 delete arg6;
39298 }
39299 return resultobj;
39300 fail:
39301 {
39302 if (temp4)
39303 delete arg4;
39304 }
39305 {
39306 if (temp6)
39307 delete arg6;
39308 }
39309 return NULL;
39310 }
39311
39312
39313 SWIGINTERN PyObject *_wrap_Menu_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39314 PyObject *resultobj = 0;
39315 wxMenu *arg1 = (wxMenu *) 0 ;
39316 int arg2 ;
39317 wxString *arg3 = 0 ;
39318 wxString const &arg4_defvalue = wxPyEmptyString ;
39319 wxString *arg4 = (wxString *) &arg4_defvalue ;
39320 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
39321 wxMenuItem *result = 0 ;
39322 void *argp1 = 0 ;
39323 int res1 = 0 ;
39324 int val2 ;
39325 int ecode2 = 0 ;
39326 bool temp3 = false ;
39327 bool temp4 = false ;
39328 int val5 ;
39329 int ecode5 = 0 ;
39330 PyObject * obj0 = 0 ;
39331 PyObject * obj1 = 0 ;
39332 PyObject * obj2 = 0 ;
39333 PyObject * obj3 = 0 ;
39334 PyObject * obj4 = 0 ;
39335 char * kwnames[] = {
39336 (char *) "self",(char *) "id",(char *) "text",(char *) "help",(char *) "kind", NULL
39337 };
39338
39339 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OO:Menu_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39340 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39341 if (!SWIG_IsOK(res1)) {
39342 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Prepend" "', expected argument " "1"" of type '" "wxMenu *""'");
39343 }
39344 arg1 = reinterpret_cast< wxMenu * >(argp1);
39345 ecode2 = SWIG_AsVal_int(obj1, &val2);
39346 if (!SWIG_IsOK(ecode2)) {
39347 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Prepend" "', expected argument " "2"" of type '" "int""'");
39348 }
39349 arg2 = static_cast< int >(val2);
39350 {
39351 arg3 = wxString_in_helper(obj2);
39352 if (arg3 == NULL) SWIG_fail;
39353 temp3 = true;
39354 }
39355 if (obj3) {
39356 {
39357 arg4 = wxString_in_helper(obj3);
39358 if (arg4 == NULL) SWIG_fail;
39359 temp4 = true;
39360 }
39361 }
39362 if (obj4) {
39363 ecode5 = SWIG_AsVal_int(obj4, &val5);
39364 if (!SWIG_IsOK(ecode5)) {
39365 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Menu_Prepend" "', expected argument " "5"" of type '" "wxItemKind""'");
39366 }
39367 arg5 = static_cast< wxItemKind >(val5);
39368 }
39369 {
39370 PyThreadState* __tstate = wxPyBeginAllowThreads();
39371 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5);
39372 wxPyEndAllowThreads(__tstate);
39373 if (PyErr_Occurred()) SWIG_fail;
39374 }
39375 {
39376 resultobj = wxPyMake_wxObject(result, (bool)0);
39377 }
39378 {
39379 if (temp3)
39380 delete arg3;
39381 }
39382 {
39383 if (temp4)
39384 delete arg4;
39385 }
39386 return resultobj;
39387 fail:
39388 {
39389 if (temp3)
39390 delete arg3;
39391 }
39392 {
39393 if (temp4)
39394 delete arg4;
39395 }
39396 return NULL;
39397 }
39398
39399
39400 SWIGINTERN PyObject *_wrap_Menu_PrependSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39401 PyObject *resultobj = 0;
39402 wxMenu *arg1 = (wxMenu *) 0 ;
39403 wxMenuItem *result = 0 ;
39404 void *argp1 = 0 ;
39405 int res1 = 0 ;
39406 PyObject *swig_obj[1] ;
39407
39408 if (!args) SWIG_fail;
39409 swig_obj[0] = args;
39410 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39411 if (!SWIG_IsOK(res1)) {
39412 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependSeparator" "', expected argument " "1"" of type '" "wxMenu *""'");
39413 }
39414 arg1 = reinterpret_cast< wxMenu * >(argp1);
39415 {
39416 PyThreadState* __tstate = wxPyBeginAllowThreads();
39417 result = (wxMenuItem *)(arg1)->PrependSeparator();
39418 wxPyEndAllowThreads(__tstate);
39419 if (PyErr_Occurred()) SWIG_fail;
39420 }
39421 {
39422 resultobj = wxPyMake_wxObject(result, (bool)0);
39423 }
39424 return resultobj;
39425 fail:
39426 return NULL;
39427 }
39428
39429
39430 SWIGINTERN PyObject *_wrap_Menu_PrependCheckItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39431 PyObject *resultobj = 0;
39432 wxMenu *arg1 = (wxMenu *) 0 ;
39433 int arg2 ;
39434 wxString *arg3 = 0 ;
39435 wxString const &arg4_defvalue = wxPyEmptyString ;
39436 wxString *arg4 = (wxString *) &arg4_defvalue ;
39437 wxMenuItem *result = 0 ;
39438 void *argp1 = 0 ;
39439 int res1 = 0 ;
39440 int val2 ;
39441 int ecode2 = 0 ;
39442 bool temp3 = false ;
39443 bool temp4 = false ;
39444 PyObject * obj0 = 0 ;
39445 PyObject * obj1 = 0 ;
39446 PyObject * obj2 = 0 ;
39447 PyObject * obj3 = 0 ;
39448 char * kwnames[] = {
39449 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39450 };
39451
39452 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependCheckItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39453 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39454 if (!SWIG_IsOK(res1)) {
39455 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependCheckItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39456 }
39457 arg1 = reinterpret_cast< wxMenu * >(argp1);
39458 ecode2 = SWIG_AsVal_int(obj1, &val2);
39459 if (!SWIG_IsOK(ecode2)) {
39460 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependCheckItem" "', expected argument " "2"" of type '" "int""'");
39461 }
39462 arg2 = static_cast< int >(val2);
39463 {
39464 arg3 = wxString_in_helper(obj2);
39465 if (arg3 == NULL) SWIG_fail;
39466 temp3 = true;
39467 }
39468 if (obj3) {
39469 {
39470 arg4 = wxString_in_helper(obj3);
39471 if (arg4 == NULL) SWIG_fail;
39472 temp4 = true;
39473 }
39474 }
39475 {
39476 PyThreadState* __tstate = wxPyBeginAllowThreads();
39477 result = (wxMenuItem *)(arg1)->PrependCheckItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39478 wxPyEndAllowThreads(__tstate);
39479 if (PyErr_Occurred()) SWIG_fail;
39480 }
39481 {
39482 resultobj = wxPyMake_wxObject(result, (bool)0);
39483 }
39484 {
39485 if (temp3)
39486 delete arg3;
39487 }
39488 {
39489 if (temp4)
39490 delete arg4;
39491 }
39492 return resultobj;
39493 fail:
39494 {
39495 if (temp3)
39496 delete arg3;
39497 }
39498 {
39499 if (temp4)
39500 delete arg4;
39501 }
39502 return NULL;
39503 }
39504
39505
39506 SWIGINTERN PyObject *_wrap_Menu_PrependRadioItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39507 PyObject *resultobj = 0;
39508 wxMenu *arg1 = (wxMenu *) 0 ;
39509 int arg2 ;
39510 wxString *arg3 = 0 ;
39511 wxString const &arg4_defvalue = wxPyEmptyString ;
39512 wxString *arg4 = (wxString *) &arg4_defvalue ;
39513 wxMenuItem *result = 0 ;
39514 void *argp1 = 0 ;
39515 int res1 = 0 ;
39516 int val2 ;
39517 int ecode2 = 0 ;
39518 bool temp3 = false ;
39519 bool temp4 = false ;
39520 PyObject * obj0 = 0 ;
39521 PyObject * obj1 = 0 ;
39522 PyObject * obj2 = 0 ;
39523 PyObject * obj3 = 0 ;
39524 char * kwnames[] = {
39525 (char *) "self",(char *) "id",(char *) "text",(char *) "help", NULL
39526 };
39527
39528 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:Menu_PrependRadioItem",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
39529 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39530 if (!SWIG_IsOK(res1)) {
39531 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependRadioItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39532 }
39533 arg1 = reinterpret_cast< wxMenu * >(argp1);
39534 ecode2 = SWIG_AsVal_int(obj1, &val2);
39535 if (!SWIG_IsOK(ecode2)) {
39536 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependRadioItem" "', expected argument " "2"" of type '" "int""'");
39537 }
39538 arg2 = static_cast< int >(val2);
39539 {
39540 arg3 = wxString_in_helper(obj2);
39541 if (arg3 == NULL) SWIG_fail;
39542 temp3 = true;
39543 }
39544 if (obj3) {
39545 {
39546 arg4 = wxString_in_helper(obj3);
39547 if (arg4 == NULL) SWIG_fail;
39548 temp4 = true;
39549 }
39550 }
39551 {
39552 PyThreadState* __tstate = wxPyBeginAllowThreads();
39553 result = (wxMenuItem *)(arg1)->PrependRadioItem(arg2,(wxString const &)*arg3,(wxString const &)*arg4);
39554 wxPyEndAllowThreads(__tstate);
39555 if (PyErr_Occurred()) SWIG_fail;
39556 }
39557 {
39558 resultobj = wxPyMake_wxObject(result, (bool)0);
39559 }
39560 {
39561 if (temp3)
39562 delete arg3;
39563 }
39564 {
39565 if (temp4)
39566 delete arg4;
39567 }
39568 return resultobj;
39569 fail:
39570 {
39571 if (temp3)
39572 delete arg3;
39573 }
39574 {
39575 if (temp4)
39576 delete arg4;
39577 }
39578 return NULL;
39579 }
39580
39581
39582 SWIGINTERN PyObject *_wrap_Menu_PrependMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39583 PyObject *resultobj = 0;
39584 wxMenu *arg1 = (wxMenu *) 0 ;
39585 int arg2 ;
39586 wxString *arg3 = 0 ;
39587 wxMenu *arg4 = (wxMenu *) 0 ;
39588 wxString const &arg5_defvalue = wxPyEmptyString ;
39589 wxString *arg5 = (wxString *) &arg5_defvalue ;
39590 wxMenuItem *result = 0 ;
39591 void *argp1 = 0 ;
39592 int res1 = 0 ;
39593 int val2 ;
39594 int ecode2 = 0 ;
39595 bool temp3 = false ;
39596 void *argp4 = 0 ;
39597 int res4 = 0 ;
39598 bool temp5 = false ;
39599 PyObject * obj0 = 0 ;
39600 PyObject * obj1 = 0 ;
39601 PyObject * obj2 = 0 ;
39602 PyObject * obj3 = 0 ;
39603 PyObject * obj4 = 0 ;
39604 char * kwnames[] = {
39605 (char *) "self",(char *) "id",(char *) "text",(char *) "submenu",(char *) "help", NULL
39606 };
39607
39608 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:Menu_PrependMenu",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
39609 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39610 if (!SWIG_IsOK(res1)) {
39611 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_PrependMenu" "', expected argument " "1"" of type '" "wxMenu *""'");
39612 }
39613 arg1 = reinterpret_cast< wxMenu * >(argp1);
39614 ecode2 = SWIG_AsVal_int(obj1, &val2);
39615 if (!SWIG_IsOK(ecode2)) {
39616 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_PrependMenu" "', expected argument " "2"" of type '" "int""'");
39617 }
39618 arg2 = static_cast< int >(val2);
39619 {
39620 arg3 = wxString_in_helper(obj2);
39621 if (arg3 == NULL) SWIG_fail;
39622 temp3 = true;
39623 }
39624 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxMenu, 0 | 0 );
39625 if (!SWIG_IsOK(res4)) {
39626 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "Menu_PrependMenu" "', expected argument " "4"" of type '" "wxMenu *""'");
39627 }
39628 arg4 = reinterpret_cast< wxMenu * >(argp4);
39629 if (obj4) {
39630 {
39631 arg5 = wxString_in_helper(obj4);
39632 if (arg5 == NULL) SWIG_fail;
39633 temp5 = true;
39634 }
39635 }
39636 {
39637 PyThreadState* __tstate = wxPyBeginAllowThreads();
39638 result = (wxMenuItem *)(arg1)->Prepend(arg2,(wxString const &)*arg3,arg4,(wxString const &)*arg5);
39639 wxPyEndAllowThreads(__tstate);
39640 if (PyErr_Occurred()) SWIG_fail;
39641 }
39642 {
39643 resultobj = wxPyMake_wxObject(result, (bool)0);
39644 }
39645 {
39646 if (temp3)
39647 delete arg3;
39648 }
39649 {
39650 if (temp5)
39651 delete arg5;
39652 }
39653 return resultobj;
39654 fail:
39655 {
39656 if (temp3)
39657 delete arg3;
39658 }
39659 {
39660 if (temp5)
39661 delete arg5;
39662 }
39663 return NULL;
39664 }
39665
39666
39667 SWIGINTERN PyObject *_wrap_Menu_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39668 PyObject *resultobj = 0;
39669 wxMenu *arg1 = (wxMenu *) 0 ;
39670 int arg2 ;
39671 wxMenuItem *result = 0 ;
39672 void *argp1 = 0 ;
39673 int res1 = 0 ;
39674 int val2 ;
39675 int ecode2 = 0 ;
39676 PyObject * obj0 = 0 ;
39677 PyObject * obj1 = 0 ;
39678 char * kwnames[] = {
39679 (char *) "self",(char *) "id", NULL
39680 };
39681
39682 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
39683 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39684 if (!SWIG_IsOK(res1)) {
39685 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Remove" "', expected argument " "1"" of type '" "wxMenu *""'");
39686 }
39687 arg1 = reinterpret_cast< wxMenu * >(argp1);
39688 ecode2 = SWIG_AsVal_int(obj1, &val2);
39689 if (!SWIG_IsOK(ecode2)) {
39690 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Remove" "', expected argument " "2"" of type '" "int""'");
39691 }
39692 arg2 = static_cast< int >(val2);
39693 {
39694 PyThreadState* __tstate = wxPyBeginAllowThreads();
39695 result = (wxMenuItem *)(arg1)->Remove(arg2);
39696 wxPyEndAllowThreads(__tstate);
39697 if (PyErr_Occurred()) SWIG_fail;
39698 }
39699 {
39700 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39701 }
39702 return resultobj;
39703 fail:
39704 return NULL;
39705 }
39706
39707
39708 SWIGINTERN PyObject *_wrap_Menu_RemoveItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39709 PyObject *resultobj = 0;
39710 wxMenu *arg1 = (wxMenu *) 0 ;
39711 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39712 wxMenuItem *result = 0 ;
39713 void *argp1 = 0 ;
39714 int res1 = 0 ;
39715 void *argp2 = 0 ;
39716 int res2 = 0 ;
39717 PyObject * obj0 = 0 ;
39718 PyObject * obj1 = 0 ;
39719 char * kwnames[] = {
39720 (char *) "self",(char *) "item", NULL
39721 };
39722
39723 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_RemoveItem",kwnames,&obj0,&obj1)) SWIG_fail;
39724 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39725 if (!SWIG_IsOK(res1)) {
39726 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_RemoveItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39727 }
39728 arg1 = reinterpret_cast< wxMenu * >(argp1);
39729 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39730 if (!SWIG_IsOK(res2)) {
39731 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_RemoveItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39732 }
39733 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39734 {
39735 PyThreadState* __tstate = wxPyBeginAllowThreads();
39736 result = (wxMenuItem *)(arg1)->Remove(arg2);
39737 wxPyEndAllowThreads(__tstate);
39738 if (PyErr_Occurred()) SWIG_fail;
39739 }
39740 {
39741 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_OWN);
39742 }
39743 return resultobj;
39744 fail:
39745 return NULL;
39746 }
39747
39748
39749 SWIGINTERN PyObject *_wrap_Menu_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39750 PyObject *resultobj = 0;
39751 wxMenu *arg1 = (wxMenu *) 0 ;
39752 int arg2 ;
39753 bool result;
39754 void *argp1 = 0 ;
39755 int res1 = 0 ;
39756 int val2 ;
39757 int ecode2 = 0 ;
39758 PyObject * obj0 = 0 ;
39759 PyObject * obj1 = 0 ;
39760 char * kwnames[] = {
39761 (char *) "self",(char *) "id", NULL
39762 };
39763
39764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
39765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39766 if (!SWIG_IsOK(res1)) {
39767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Delete" "', expected argument " "1"" of type '" "wxMenu *""'");
39768 }
39769 arg1 = reinterpret_cast< wxMenu * >(argp1);
39770 ecode2 = SWIG_AsVal_int(obj1, &val2);
39771 if (!SWIG_IsOK(ecode2)) {
39772 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Delete" "', expected argument " "2"" of type '" "int""'");
39773 }
39774 arg2 = static_cast< int >(val2);
39775 {
39776 PyThreadState* __tstate = wxPyBeginAllowThreads();
39777 result = (bool)(arg1)->Delete(arg2);
39778 wxPyEndAllowThreads(__tstate);
39779 if (PyErr_Occurred()) SWIG_fail;
39780 }
39781 {
39782 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39783 }
39784 return resultobj;
39785 fail:
39786 return NULL;
39787 }
39788
39789
39790 SWIGINTERN PyObject *_wrap_Menu_DeleteItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39791 PyObject *resultobj = 0;
39792 wxMenu *arg1 = (wxMenu *) 0 ;
39793 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39794 bool result;
39795 void *argp1 = 0 ;
39796 int res1 = 0 ;
39797 void *argp2 = 0 ;
39798 int res2 = 0 ;
39799 PyObject * obj0 = 0 ;
39800 PyObject * obj1 = 0 ;
39801 char * kwnames[] = {
39802 (char *) "self",(char *) "item", NULL
39803 };
39804
39805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DeleteItem",kwnames,&obj0,&obj1)) SWIG_fail;
39806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39807 if (!SWIG_IsOK(res1)) {
39808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DeleteItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39809 }
39810 arg1 = reinterpret_cast< wxMenu * >(argp1);
39811 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39812 if (!SWIG_IsOK(res2)) {
39813 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DeleteItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39814 }
39815 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39816 {
39817 PyThreadState* __tstate = wxPyBeginAllowThreads();
39818 result = (bool)(arg1)->Delete(arg2);
39819 wxPyEndAllowThreads(__tstate);
39820 if (PyErr_Occurred()) SWIG_fail;
39821 }
39822 {
39823 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39824 }
39825 return resultobj;
39826 fail:
39827 return NULL;
39828 }
39829
39830
39831 SWIGINTERN PyObject *_wrap_Menu_Destroy(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39832 PyObject *resultobj = 0;
39833 wxMenu *arg1 = (wxMenu *) 0 ;
39834 void *argp1 = 0 ;
39835 int res1 = 0 ;
39836 PyObject *swig_obj[1] ;
39837
39838 if (!args) SWIG_fail;
39839 swig_obj[0] = args;
39840 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39841 if (!SWIG_IsOK(res1)) {
39842 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Destroy" "', expected argument " "1"" of type '" "wxMenu *""'");
39843 }
39844 arg1 = reinterpret_cast< wxMenu * >(argp1);
39845 {
39846 PyThreadState* __tstate = wxPyBeginAllowThreads();
39847 wxMenu_Destroy(arg1);
39848 wxPyEndAllowThreads(__tstate);
39849 if (PyErr_Occurred()) SWIG_fail;
39850 }
39851 resultobj = SWIG_Py_Void();
39852 return resultobj;
39853 fail:
39854 return NULL;
39855 }
39856
39857
39858 SWIGINTERN PyObject *_wrap_Menu_DestroyId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39859 PyObject *resultobj = 0;
39860 wxMenu *arg1 = (wxMenu *) 0 ;
39861 int arg2 ;
39862 bool result;
39863 void *argp1 = 0 ;
39864 int res1 = 0 ;
39865 int val2 ;
39866 int ecode2 = 0 ;
39867 PyObject * obj0 = 0 ;
39868 PyObject * obj1 = 0 ;
39869 char * kwnames[] = {
39870 (char *) "self",(char *) "id", NULL
39871 };
39872
39873 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyId",kwnames,&obj0,&obj1)) SWIG_fail;
39874 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39875 if (!SWIG_IsOK(res1)) {
39876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyId" "', expected argument " "1"" of type '" "wxMenu *""'");
39877 }
39878 arg1 = reinterpret_cast< wxMenu * >(argp1);
39879 ecode2 = SWIG_AsVal_int(obj1, &val2);
39880 if (!SWIG_IsOK(ecode2)) {
39881 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_DestroyId" "', expected argument " "2"" of type '" "int""'");
39882 }
39883 arg2 = static_cast< int >(val2);
39884 {
39885 PyThreadState* __tstate = wxPyBeginAllowThreads();
39886 result = (bool)(arg1)->Destroy(arg2);
39887 wxPyEndAllowThreads(__tstate);
39888 if (PyErr_Occurred()) SWIG_fail;
39889 }
39890 {
39891 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39892 }
39893 return resultobj;
39894 fail:
39895 return NULL;
39896 }
39897
39898
39899 SWIGINTERN PyObject *_wrap_Menu_DestroyItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39900 PyObject *resultobj = 0;
39901 wxMenu *arg1 = (wxMenu *) 0 ;
39902 wxMenuItem *arg2 = (wxMenuItem *) 0 ;
39903 bool result;
39904 void *argp1 = 0 ;
39905 int res1 = 0 ;
39906 void *argp2 = 0 ;
39907 int res2 = 0 ;
39908 PyObject * obj0 = 0 ;
39909 PyObject * obj1 = 0 ;
39910 char * kwnames[] = {
39911 (char *) "self",(char *) "item", NULL
39912 };
39913
39914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_DestroyItem",kwnames,&obj0,&obj1)) SWIG_fail;
39915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39916 if (!SWIG_IsOK(res1)) {
39917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_DestroyItem" "', expected argument " "1"" of type '" "wxMenu *""'");
39918 }
39919 arg1 = reinterpret_cast< wxMenu * >(argp1);
39920 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuItem, 0 | 0 );
39921 if (!SWIG_IsOK(res2)) {
39922 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_DestroyItem" "', expected argument " "2"" of type '" "wxMenuItem *""'");
39923 }
39924 arg2 = reinterpret_cast< wxMenuItem * >(argp2);
39925 {
39926 PyThreadState* __tstate = wxPyBeginAllowThreads();
39927 result = (bool)(arg1)->Destroy(arg2);
39928 wxPyEndAllowThreads(__tstate);
39929 if (PyErr_Occurred()) SWIG_fail;
39930 }
39931 {
39932 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
39933 }
39934 return resultobj;
39935 fail:
39936 return NULL;
39937 }
39938
39939
39940 SWIGINTERN PyObject *_wrap_Menu_GetMenuItemCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39941 PyObject *resultobj = 0;
39942 wxMenu *arg1 = (wxMenu *) 0 ;
39943 size_t result;
39944 void *argp1 = 0 ;
39945 int res1 = 0 ;
39946 PyObject *swig_obj[1] ;
39947
39948 if (!args) SWIG_fail;
39949 swig_obj[0] = args;
39950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39951 if (!SWIG_IsOK(res1)) {
39952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItemCount" "', expected argument " "1"" of type '" "wxMenu const *""'");
39953 }
39954 arg1 = reinterpret_cast< wxMenu * >(argp1);
39955 {
39956 PyThreadState* __tstate = wxPyBeginAllowThreads();
39957 result = (size_t)((wxMenu const *)arg1)->GetMenuItemCount();
39958 wxPyEndAllowThreads(__tstate);
39959 if (PyErr_Occurred()) SWIG_fail;
39960 }
39961 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
39962 return resultobj;
39963 fail:
39964 return NULL;
39965 }
39966
39967
39968 SWIGINTERN PyObject *_wrap_Menu_GetMenuItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
39969 PyObject *resultobj = 0;
39970 wxMenu *arg1 = (wxMenu *) 0 ;
39971 PyObject *result = 0 ;
39972 void *argp1 = 0 ;
39973 int res1 = 0 ;
39974 PyObject *swig_obj[1] ;
39975
39976 if (!args) SWIG_fail;
39977 swig_obj[0] = args;
39978 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
39979 if (!SWIG_IsOK(res1)) {
39980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuItems" "', expected argument " "1"" of type '" "wxMenu *""'");
39981 }
39982 arg1 = reinterpret_cast< wxMenu * >(argp1);
39983 {
39984 PyThreadState* __tstate = wxPyBeginAllowThreads();
39985 result = (PyObject *)wxMenu_GetMenuItems(arg1);
39986 wxPyEndAllowThreads(__tstate);
39987 if (PyErr_Occurred()) SWIG_fail;
39988 }
39989 resultobj = result;
39990 return resultobj;
39991 fail:
39992 return NULL;
39993 }
39994
39995
39996 SWIGINTERN PyObject *_wrap_Menu_FindItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
39997 PyObject *resultobj = 0;
39998 wxMenu *arg1 = (wxMenu *) 0 ;
39999 wxString *arg2 = 0 ;
40000 int result;
40001 void *argp1 = 0 ;
40002 int res1 = 0 ;
40003 bool temp2 = false ;
40004 PyObject * obj0 = 0 ;
40005 PyObject * obj1 = 0 ;
40006 char * kwnames[] = {
40007 (char *) "self",(char *) "item", NULL
40008 };
40009
40010 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItem",kwnames,&obj0,&obj1)) SWIG_fail;
40011 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40012 if (!SWIG_IsOK(res1)) {
40013 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItem" "', expected argument " "1"" of type '" "wxMenu const *""'");
40014 }
40015 arg1 = reinterpret_cast< wxMenu * >(argp1);
40016 {
40017 arg2 = wxString_in_helper(obj1);
40018 if (arg2 == NULL) SWIG_fail;
40019 temp2 = true;
40020 }
40021 {
40022 PyThreadState* __tstate = wxPyBeginAllowThreads();
40023 result = (int)((wxMenu const *)arg1)->FindItem((wxString const &)*arg2);
40024 wxPyEndAllowThreads(__tstate);
40025 if (PyErr_Occurred()) SWIG_fail;
40026 }
40027 resultobj = SWIG_From_int(static_cast< int >(result));
40028 {
40029 if (temp2)
40030 delete arg2;
40031 }
40032 return resultobj;
40033 fail:
40034 {
40035 if (temp2)
40036 delete arg2;
40037 }
40038 return NULL;
40039 }
40040
40041
40042 SWIGINTERN PyObject *_wrap_Menu_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40043 PyObject *resultobj = 0;
40044 wxMenu *arg1 = (wxMenu *) 0 ;
40045 int arg2 ;
40046 wxMenuItem *result = 0 ;
40047 void *argp1 = 0 ;
40048 int res1 = 0 ;
40049 int val2 ;
40050 int ecode2 = 0 ;
40051 PyObject * obj0 = 0 ;
40052 PyObject * obj1 = 0 ;
40053 char * kwnames[] = {
40054 (char *) "self",(char *) "id", NULL
40055 };
40056
40057 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
40058 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40059 if (!SWIG_IsOK(res1)) {
40060 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemById" "', expected argument " "1"" of type '" "wxMenu const *""'");
40061 }
40062 arg1 = reinterpret_cast< wxMenu * >(argp1);
40063 ecode2 = SWIG_AsVal_int(obj1, &val2);
40064 if (!SWIG_IsOK(ecode2)) {
40065 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemById" "', expected argument " "2"" of type '" "int""'");
40066 }
40067 arg2 = static_cast< int >(val2);
40068 {
40069 PyThreadState* __tstate = wxPyBeginAllowThreads();
40070 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItem(arg2);
40071 wxPyEndAllowThreads(__tstate);
40072 if (PyErr_Occurred()) SWIG_fail;
40073 }
40074 {
40075 resultobj = wxPyMake_wxObject(result, (bool)0);
40076 }
40077 return resultobj;
40078 fail:
40079 return NULL;
40080 }
40081
40082
40083 SWIGINTERN PyObject *_wrap_Menu_FindItemByPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40084 PyObject *resultobj = 0;
40085 wxMenu *arg1 = (wxMenu *) 0 ;
40086 size_t arg2 ;
40087 wxMenuItem *result = 0 ;
40088 void *argp1 = 0 ;
40089 int res1 = 0 ;
40090 size_t val2 ;
40091 int ecode2 = 0 ;
40092 PyObject * obj0 = 0 ;
40093 PyObject * obj1 = 0 ;
40094 char * kwnames[] = {
40095 (char *) "self",(char *) "position", NULL
40096 };
40097
40098 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_FindItemByPosition",kwnames,&obj0,&obj1)) SWIG_fail;
40099 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40100 if (!SWIG_IsOK(res1)) {
40101 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_FindItemByPosition" "', expected argument " "1"" of type '" "wxMenu const *""'");
40102 }
40103 arg1 = reinterpret_cast< wxMenu * >(argp1);
40104 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
40105 if (!SWIG_IsOK(ecode2)) {
40106 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_FindItemByPosition" "', expected argument " "2"" of type '" "size_t""'");
40107 }
40108 arg2 = static_cast< size_t >(val2);
40109 {
40110 PyThreadState* __tstate = wxPyBeginAllowThreads();
40111 result = (wxMenuItem *)((wxMenu const *)arg1)->FindItemByPosition(arg2);
40112 wxPyEndAllowThreads(__tstate);
40113 if (PyErr_Occurred()) SWIG_fail;
40114 }
40115 {
40116 resultobj = wxPyMake_wxObject(result, (bool)0);
40117 }
40118 return resultobj;
40119 fail:
40120 return NULL;
40121 }
40122
40123
40124 SWIGINTERN PyObject *_wrap_Menu_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40125 PyObject *resultobj = 0;
40126 wxMenu *arg1 = (wxMenu *) 0 ;
40127 int arg2 ;
40128 bool arg3 ;
40129 void *argp1 = 0 ;
40130 int res1 = 0 ;
40131 int val2 ;
40132 int ecode2 = 0 ;
40133 bool val3 ;
40134 int ecode3 = 0 ;
40135 PyObject * obj0 = 0 ;
40136 PyObject * obj1 = 0 ;
40137 PyObject * obj2 = 0 ;
40138 char * kwnames[] = {
40139 (char *) "self",(char *) "id",(char *) "enable", NULL
40140 };
40141
40142 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40143 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40144 if (!SWIG_IsOK(res1)) {
40145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Enable" "', expected argument " "1"" of type '" "wxMenu *""'");
40146 }
40147 arg1 = reinterpret_cast< wxMenu * >(argp1);
40148 ecode2 = SWIG_AsVal_int(obj1, &val2);
40149 if (!SWIG_IsOK(ecode2)) {
40150 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Enable" "', expected argument " "2"" of type '" "int""'");
40151 }
40152 arg2 = static_cast< int >(val2);
40153 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40154 if (!SWIG_IsOK(ecode3)) {
40155 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Enable" "', expected argument " "3"" of type '" "bool""'");
40156 }
40157 arg3 = static_cast< bool >(val3);
40158 {
40159 PyThreadState* __tstate = wxPyBeginAllowThreads();
40160 (arg1)->Enable(arg2,arg3);
40161 wxPyEndAllowThreads(__tstate);
40162 if (PyErr_Occurred()) SWIG_fail;
40163 }
40164 resultobj = SWIG_Py_Void();
40165 return resultobj;
40166 fail:
40167 return NULL;
40168 }
40169
40170
40171 SWIGINTERN PyObject *_wrap_Menu_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40172 PyObject *resultobj = 0;
40173 wxMenu *arg1 = (wxMenu *) 0 ;
40174 int arg2 ;
40175 bool result;
40176 void *argp1 = 0 ;
40177 int res1 = 0 ;
40178 int val2 ;
40179 int ecode2 = 0 ;
40180 PyObject * obj0 = 0 ;
40181 PyObject * obj1 = 0 ;
40182 char * kwnames[] = {
40183 (char *) "self",(char *) "id", NULL
40184 };
40185
40186 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
40187 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40188 if (!SWIG_IsOK(res1)) {
40189 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsEnabled" "', expected argument " "1"" of type '" "wxMenu const *""'");
40190 }
40191 arg1 = reinterpret_cast< wxMenu * >(argp1);
40192 ecode2 = SWIG_AsVal_int(obj1, &val2);
40193 if (!SWIG_IsOK(ecode2)) {
40194 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsEnabled" "', expected argument " "2"" of type '" "int""'");
40195 }
40196 arg2 = static_cast< int >(val2);
40197 {
40198 PyThreadState* __tstate = wxPyBeginAllowThreads();
40199 result = (bool)((wxMenu const *)arg1)->IsEnabled(arg2);
40200 wxPyEndAllowThreads(__tstate);
40201 if (PyErr_Occurred()) SWIG_fail;
40202 }
40203 {
40204 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40205 }
40206 return resultobj;
40207 fail:
40208 return NULL;
40209 }
40210
40211
40212 SWIGINTERN PyObject *_wrap_Menu_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40213 PyObject *resultobj = 0;
40214 wxMenu *arg1 = (wxMenu *) 0 ;
40215 int arg2 ;
40216 bool arg3 ;
40217 void *argp1 = 0 ;
40218 int res1 = 0 ;
40219 int val2 ;
40220 int ecode2 = 0 ;
40221 bool val3 ;
40222 int ecode3 = 0 ;
40223 PyObject * obj0 = 0 ;
40224 PyObject * obj1 = 0 ;
40225 PyObject * obj2 = 0 ;
40226 char * kwnames[] = {
40227 (char *) "self",(char *) "id",(char *) "check", NULL
40228 };
40229
40230 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40231 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40232 if (!SWIG_IsOK(res1)) {
40233 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Check" "', expected argument " "1"" of type '" "wxMenu *""'");
40234 }
40235 arg1 = reinterpret_cast< wxMenu * >(argp1);
40236 ecode2 = SWIG_AsVal_int(obj1, &val2);
40237 if (!SWIG_IsOK(ecode2)) {
40238 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_Check" "', expected argument " "2"" of type '" "int""'");
40239 }
40240 arg2 = static_cast< int >(val2);
40241 ecode3 = SWIG_AsVal_bool(obj2, &val3);
40242 if (!SWIG_IsOK(ecode3)) {
40243 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Menu_Check" "', expected argument " "3"" of type '" "bool""'");
40244 }
40245 arg3 = static_cast< bool >(val3);
40246 {
40247 PyThreadState* __tstate = wxPyBeginAllowThreads();
40248 (arg1)->Check(arg2,arg3);
40249 wxPyEndAllowThreads(__tstate);
40250 if (PyErr_Occurred()) SWIG_fail;
40251 }
40252 resultobj = SWIG_Py_Void();
40253 return resultobj;
40254 fail:
40255 return NULL;
40256 }
40257
40258
40259 SWIGINTERN PyObject *_wrap_Menu_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40260 PyObject *resultobj = 0;
40261 wxMenu *arg1 = (wxMenu *) 0 ;
40262 int arg2 ;
40263 bool result;
40264 void *argp1 = 0 ;
40265 int res1 = 0 ;
40266 int val2 ;
40267 int ecode2 = 0 ;
40268 PyObject * obj0 = 0 ;
40269 PyObject * obj1 = 0 ;
40270 char * kwnames[] = {
40271 (char *) "self",(char *) "id", NULL
40272 };
40273
40274 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
40275 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40276 if (!SWIG_IsOK(res1)) {
40277 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsChecked" "', expected argument " "1"" of type '" "wxMenu const *""'");
40278 }
40279 arg1 = reinterpret_cast< wxMenu * >(argp1);
40280 ecode2 = SWIG_AsVal_int(obj1, &val2);
40281 if (!SWIG_IsOK(ecode2)) {
40282 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_IsChecked" "', expected argument " "2"" of type '" "int""'");
40283 }
40284 arg2 = static_cast< int >(val2);
40285 {
40286 PyThreadState* __tstate = wxPyBeginAllowThreads();
40287 result = (bool)((wxMenu const *)arg1)->IsChecked(arg2);
40288 wxPyEndAllowThreads(__tstate);
40289 if (PyErr_Occurred()) SWIG_fail;
40290 }
40291 {
40292 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40293 }
40294 return resultobj;
40295 fail:
40296 return NULL;
40297 }
40298
40299
40300 SWIGINTERN PyObject *_wrap_Menu_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40301 PyObject *resultobj = 0;
40302 wxMenu *arg1 = (wxMenu *) 0 ;
40303 int arg2 ;
40304 wxString *arg3 = 0 ;
40305 void *argp1 = 0 ;
40306 int res1 = 0 ;
40307 int val2 ;
40308 int ecode2 = 0 ;
40309 bool temp3 = false ;
40310 PyObject * obj0 = 0 ;
40311 PyObject * obj1 = 0 ;
40312 PyObject * obj2 = 0 ;
40313 char * kwnames[] = {
40314 (char *) "self",(char *) "id",(char *) "label", NULL
40315 };
40316
40317 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40318 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40319 if (!SWIG_IsOK(res1)) {
40320 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetLabel" "', expected argument " "1"" of type '" "wxMenu *""'");
40321 }
40322 arg1 = reinterpret_cast< wxMenu * >(argp1);
40323 ecode2 = SWIG_AsVal_int(obj1, &val2);
40324 if (!SWIG_IsOK(ecode2)) {
40325 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetLabel" "', expected argument " "2"" of type '" "int""'");
40326 }
40327 arg2 = static_cast< int >(val2);
40328 {
40329 arg3 = wxString_in_helper(obj2);
40330 if (arg3 == NULL) SWIG_fail;
40331 temp3 = true;
40332 }
40333 {
40334 PyThreadState* __tstate = wxPyBeginAllowThreads();
40335 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
40336 wxPyEndAllowThreads(__tstate);
40337 if (PyErr_Occurred()) SWIG_fail;
40338 }
40339 resultobj = SWIG_Py_Void();
40340 {
40341 if (temp3)
40342 delete arg3;
40343 }
40344 return resultobj;
40345 fail:
40346 {
40347 if (temp3)
40348 delete arg3;
40349 }
40350 return NULL;
40351 }
40352
40353
40354 SWIGINTERN PyObject *_wrap_Menu_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40355 PyObject *resultobj = 0;
40356 wxMenu *arg1 = (wxMenu *) 0 ;
40357 int arg2 ;
40358 wxString result;
40359 void *argp1 = 0 ;
40360 int res1 = 0 ;
40361 int val2 ;
40362 int ecode2 = 0 ;
40363 PyObject * obj0 = 0 ;
40364 PyObject * obj1 = 0 ;
40365 char * kwnames[] = {
40366 (char *) "self",(char *) "id", NULL
40367 };
40368
40369 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
40370 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40371 if (!SWIG_IsOK(res1)) {
40372 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetLabel" "', expected argument " "1"" of type '" "wxMenu const *""'");
40373 }
40374 arg1 = reinterpret_cast< wxMenu * >(argp1);
40375 ecode2 = SWIG_AsVal_int(obj1, &val2);
40376 if (!SWIG_IsOK(ecode2)) {
40377 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetLabel" "', expected argument " "2"" of type '" "int""'");
40378 }
40379 arg2 = static_cast< int >(val2);
40380 {
40381 PyThreadState* __tstate = wxPyBeginAllowThreads();
40382 result = ((wxMenu const *)arg1)->GetLabel(arg2);
40383 wxPyEndAllowThreads(__tstate);
40384 if (PyErr_Occurred()) SWIG_fail;
40385 }
40386 {
40387 #if wxUSE_UNICODE
40388 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40389 #else
40390 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40391 #endif
40392 }
40393 return resultobj;
40394 fail:
40395 return NULL;
40396 }
40397
40398
40399 SWIGINTERN PyObject *_wrap_Menu_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40400 PyObject *resultobj = 0;
40401 wxMenu *arg1 = (wxMenu *) 0 ;
40402 int arg2 ;
40403 wxString *arg3 = 0 ;
40404 void *argp1 = 0 ;
40405 int res1 = 0 ;
40406 int val2 ;
40407 int ecode2 = 0 ;
40408 bool temp3 = false ;
40409 PyObject * obj0 = 0 ;
40410 PyObject * obj1 = 0 ;
40411 PyObject * obj2 = 0 ;
40412 char * kwnames[] = {
40413 (char *) "self",(char *) "id",(char *) "helpString", NULL
40414 };
40415
40416 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Menu_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
40417 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40418 if (!SWIG_IsOK(res1)) {
40419 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetHelpString" "', expected argument " "1"" of type '" "wxMenu *""'");
40420 }
40421 arg1 = reinterpret_cast< wxMenu * >(argp1);
40422 ecode2 = SWIG_AsVal_int(obj1, &val2);
40423 if (!SWIG_IsOK(ecode2)) {
40424 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_SetHelpString" "', expected argument " "2"" of type '" "int""'");
40425 }
40426 arg2 = static_cast< int >(val2);
40427 {
40428 arg3 = wxString_in_helper(obj2);
40429 if (arg3 == NULL) SWIG_fail;
40430 temp3 = true;
40431 }
40432 {
40433 PyThreadState* __tstate = wxPyBeginAllowThreads();
40434 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
40435 wxPyEndAllowThreads(__tstate);
40436 if (PyErr_Occurred()) SWIG_fail;
40437 }
40438 resultobj = SWIG_Py_Void();
40439 {
40440 if (temp3)
40441 delete arg3;
40442 }
40443 return resultobj;
40444 fail:
40445 {
40446 if (temp3)
40447 delete arg3;
40448 }
40449 return NULL;
40450 }
40451
40452
40453 SWIGINTERN PyObject *_wrap_Menu_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40454 PyObject *resultobj = 0;
40455 wxMenu *arg1 = (wxMenu *) 0 ;
40456 int arg2 ;
40457 wxString result;
40458 void *argp1 = 0 ;
40459 int res1 = 0 ;
40460 int val2 ;
40461 int ecode2 = 0 ;
40462 PyObject * obj0 = 0 ;
40463 PyObject * obj1 = 0 ;
40464 char * kwnames[] = {
40465 (char *) "self",(char *) "id", NULL
40466 };
40467
40468 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
40469 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40470 if (!SWIG_IsOK(res1)) {
40471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetHelpString" "', expected argument " "1"" of type '" "wxMenu const *""'");
40472 }
40473 arg1 = reinterpret_cast< wxMenu * >(argp1);
40474 ecode2 = SWIG_AsVal_int(obj1, &val2);
40475 if (!SWIG_IsOK(ecode2)) {
40476 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Menu_GetHelpString" "', expected argument " "2"" of type '" "int""'");
40477 }
40478 arg2 = static_cast< int >(val2);
40479 {
40480 PyThreadState* __tstate = wxPyBeginAllowThreads();
40481 result = ((wxMenu const *)arg1)->GetHelpString(arg2);
40482 wxPyEndAllowThreads(__tstate);
40483 if (PyErr_Occurred()) SWIG_fail;
40484 }
40485 {
40486 #if wxUSE_UNICODE
40487 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40488 #else
40489 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40490 #endif
40491 }
40492 return resultobj;
40493 fail:
40494 return NULL;
40495 }
40496
40497
40498 SWIGINTERN PyObject *_wrap_Menu_SetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40499 PyObject *resultobj = 0;
40500 wxMenu *arg1 = (wxMenu *) 0 ;
40501 wxString *arg2 = 0 ;
40502 void *argp1 = 0 ;
40503 int res1 = 0 ;
40504 bool temp2 = false ;
40505 PyObject * obj0 = 0 ;
40506 PyObject * obj1 = 0 ;
40507 char * kwnames[] = {
40508 (char *) "self",(char *) "title", NULL
40509 };
40510
40511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetTitle",kwnames,&obj0,&obj1)) SWIG_fail;
40512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40513 if (!SWIG_IsOK(res1)) {
40514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetTitle" "', expected argument " "1"" of type '" "wxMenu *""'");
40515 }
40516 arg1 = reinterpret_cast< wxMenu * >(argp1);
40517 {
40518 arg2 = wxString_in_helper(obj1);
40519 if (arg2 == NULL) SWIG_fail;
40520 temp2 = true;
40521 }
40522 {
40523 PyThreadState* __tstate = wxPyBeginAllowThreads();
40524 (arg1)->SetTitle((wxString const &)*arg2);
40525 wxPyEndAllowThreads(__tstate);
40526 if (PyErr_Occurred()) SWIG_fail;
40527 }
40528 resultobj = SWIG_Py_Void();
40529 {
40530 if (temp2)
40531 delete arg2;
40532 }
40533 return resultobj;
40534 fail:
40535 {
40536 if (temp2)
40537 delete arg2;
40538 }
40539 return NULL;
40540 }
40541
40542
40543 SWIGINTERN PyObject *_wrap_Menu_GetTitle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40544 PyObject *resultobj = 0;
40545 wxMenu *arg1 = (wxMenu *) 0 ;
40546 wxString result;
40547 void *argp1 = 0 ;
40548 int res1 = 0 ;
40549 PyObject *swig_obj[1] ;
40550
40551 if (!args) SWIG_fail;
40552 swig_obj[0] = args;
40553 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40554 if (!SWIG_IsOK(res1)) {
40555 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetTitle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40556 }
40557 arg1 = reinterpret_cast< wxMenu * >(argp1);
40558 {
40559 PyThreadState* __tstate = wxPyBeginAllowThreads();
40560 result = ((wxMenu const *)arg1)->GetTitle();
40561 wxPyEndAllowThreads(__tstate);
40562 if (PyErr_Occurred()) SWIG_fail;
40563 }
40564 {
40565 #if wxUSE_UNICODE
40566 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
40567 #else
40568 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
40569 #endif
40570 }
40571 return resultobj;
40572 fail:
40573 return NULL;
40574 }
40575
40576
40577 SWIGINTERN PyObject *_wrap_Menu_SetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40578 PyObject *resultobj = 0;
40579 wxMenu *arg1 = (wxMenu *) 0 ;
40580 wxEvtHandler *arg2 = (wxEvtHandler *) 0 ;
40581 void *argp1 = 0 ;
40582 int res1 = 0 ;
40583 void *argp2 = 0 ;
40584 int res2 = 0 ;
40585 PyObject * obj0 = 0 ;
40586 PyObject * obj1 = 0 ;
40587 char * kwnames[] = {
40588 (char *) "self",(char *) "handler", NULL
40589 };
40590
40591 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetEventHandler",kwnames,&obj0,&obj1)) SWIG_fail;
40592 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40593 if (!SWIG_IsOK(res1)) {
40594 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetEventHandler" "', expected argument " "1"" of type '" "wxMenu *""'");
40595 }
40596 arg1 = reinterpret_cast< wxMenu * >(argp1);
40597 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40598 if (!SWIG_IsOK(res2)) {
40599 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetEventHandler" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40600 }
40601 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40602 {
40603 PyThreadState* __tstate = wxPyBeginAllowThreads();
40604 (arg1)->SetEventHandler(arg2);
40605 wxPyEndAllowThreads(__tstate);
40606 if (PyErr_Occurred()) SWIG_fail;
40607 }
40608 resultobj = SWIG_Py_Void();
40609 return resultobj;
40610 fail:
40611 return NULL;
40612 }
40613
40614
40615 SWIGINTERN PyObject *_wrap_Menu_GetEventHandler(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40616 PyObject *resultobj = 0;
40617 wxMenu *arg1 = (wxMenu *) 0 ;
40618 wxEvtHandler *result = 0 ;
40619 void *argp1 = 0 ;
40620 int res1 = 0 ;
40621 PyObject *swig_obj[1] ;
40622
40623 if (!args) SWIG_fail;
40624 swig_obj[0] = args;
40625 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40626 if (!SWIG_IsOK(res1)) {
40627 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetEventHandler" "', expected argument " "1"" of type '" "wxMenu const *""'");
40628 }
40629 arg1 = reinterpret_cast< wxMenu * >(argp1);
40630 {
40631 PyThreadState* __tstate = wxPyBeginAllowThreads();
40632 result = (wxEvtHandler *)((wxMenu const *)arg1)->GetEventHandler();
40633 wxPyEndAllowThreads(__tstate);
40634 if (PyErr_Occurred()) SWIG_fail;
40635 }
40636 {
40637 resultobj = wxPyMake_wxObject(result, 0);
40638 }
40639 return resultobj;
40640 fail:
40641 return NULL;
40642 }
40643
40644
40645 SWIGINTERN PyObject *_wrap_Menu_SetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40646 PyObject *resultobj = 0;
40647 wxMenu *arg1 = (wxMenu *) 0 ;
40648 wxWindow *arg2 = (wxWindow *) 0 ;
40649 void *argp1 = 0 ;
40650 int res1 = 0 ;
40651 void *argp2 = 0 ;
40652 int res2 = 0 ;
40653 PyObject * obj0 = 0 ;
40654 PyObject * obj1 = 0 ;
40655 char * kwnames[] = {
40656 (char *) "self",(char *) "win", NULL
40657 };
40658
40659 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetInvokingWindow",kwnames,&obj0,&obj1)) SWIG_fail;
40660 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40661 if (!SWIG_IsOK(res1)) {
40662 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu *""'");
40663 }
40664 arg1 = reinterpret_cast< wxMenu * >(argp1);
40665 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
40666 if (!SWIG_IsOK(res2)) {
40667 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetInvokingWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
40668 }
40669 arg2 = reinterpret_cast< wxWindow * >(argp2);
40670 {
40671 PyThreadState* __tstate = wxPyBeginAllowThreads();
40672 (arg1)->SetInvokingWindow(arg2);
40673 wxPyEndAllowThreads(__tstate);
40674 if (PyErr_Occurred()) SWIG_fail;
40675 }
40676 resultobj = SWIG_Py_Void();
40677 return resultobj;
40678 fail:
40679 return NULL;
40680 }
40681
40682
40683 SWIGINTERN PyObject *_wrap_Menu_GetInvokingWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40684 PyObject *resultobj = 0;
40685 wxMenu *arg1 = (wxMenu *) 0 ;
40686 wxWindow *result = 0 ;
40687 void *argp1 = 0 ;
40688 int res1 = 0 ;
40689 PyObject *swig_obj[1] ;
40690
40691 if (!args) SWIG_fail;
40692 swig_obj[0] = args;
40693 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40694 if (!SWIG_IsOK(res1)) {
40695 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetInvokingWindow" "', expected argument " "1"" of type '" "wxMenu const *""'");
40696 }
40697 arg1 = reinterpret_cast< wxMenu * >(argp1);
40698 {
40699 PyThreadState* __tstate = wxPyBeginAllowThreads();
40700 result = (wxWindow *)((wxMenu const *)arg1)->GetInvokingWindow();
40701 wxPyEndAllowThreads(__tstate);
40702 if (PyErr_Occurred()) SWIG_fail;
40703 }
40704 {
40705 resultobj = wxPyMake_wxObject(result, 0);
40706 }
40707 return resultobj;
40708 fail:
40709 return NULL;
40710 }
40711
40712
40713 SWIGINTERN PyObject *_wrap_Menu_GetStyle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40714 PyObject *resultobj = 0;
40715 wxMenu *arg1 = (wxMenu *) 0 ;
40716 long result;
40717 void *argp1 = 0 ;
40718 int res1 = 0 ;
40719 PyObject *swig_obj[1] ;
40720
40721 if (!args) SWIG_fail;
40722 swig_obj[0] = args;
40723 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40724 if (!SWIG_IsOK(res1)) {
40725 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetStyle" "', expected argument " "1"" of type '" "wxMenu const *""'");
40726 }
40727 arg1 = reinterpret_cast< wxMenu * >(argp1);
40728 {
40729 PyThreadState* __tstate = wxPyBeginAllowThreads();
40730 result = (long)((wxMenu const *)arg1)->GetStyle();
40731 wxPyEndAllowThreads(__tstate);
40732 if (PyErr_Occurred()) SWIG_fail;
40733 }
40734 resultobj = SWIG_From_long(static_cast< long >(result));
40735 return resultobj;
40736 fail:
40737 return NULL;
40738 }
40739
40740
40741 SWIGINTERN PyObject *_wrap_Menu_UpdateUI(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40742 PyObject *resultobj = 0;
40743 wxMenu *arg1 = (wxMenu *) 0 ;
40744 wxEvtHandler *arg2 = (wxEvtHandler *) NULL ;
40745 void *argp1 = 0 ;
40746 int res1 = 0 ;
40747 void *argp2 = 0 ;
40748 int res2 = 0 ;
40749 PyObject * obj0 = 0 ;
40750 PyObject * obj1 = 0 ;
40751 char * kwnames[] = {
40752 (char *) "self",(char *) "source", NULL
40753 };
40754
40755 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Menu_UpdateUI",kwnames,&obj0,&obj1)) SWIG_fail;
40756 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40757 if (!SWIG_IsOK(res1)) {
40758 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_UpdateUI" "', expected argument " "1"" of type '" "wxMenu *""'");
40759 }
40760 arg1 = reinterpret_cast< wxMenu * >(argp1);
40761 if (obj1) {
40762 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxEvtHandler, 0 | 0 );
40763 if (!SWIG_IsOK(res2)) {
40764 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_UpdateUI" "', expected argument " "2"" of type '" "wxEvtHandler *""'");
40765 }
40766 arg2 = reinterpret_cast< wxEvtHandler * >(argp2);
40767 }
40768 {
40769 PyThreadState* __tstate = wxPyBeginAllowThreads();
40770 (arg1)->UpdateUI(arg2);
40771 wxPyEndAllowThreads(__tstate);
40772 if (PyErr_Occurred()) SWIG_fail;
40773 }
40774 resultobj = SWIG_Py_Void();
40775 return resultobj;
40776 fail:
40777 return NULL;
40778 }
40779
40780
40781 SWIGINTERN PyObject *_wrap_Menu_GetMenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40782 PyObject *resultobj = 0;
40783 wxMenu *arg1 = (wxMenu *) 0 ;
40784 wxMenuBar *result = 0 ;
40785 void *argp1 = 0 ;
40786 int res1 = 0 ;
40787 PyObject *swig_obj[1] ;
40788
40789 if (!args) SWIG_fail;
40790 swig_obj[0] = args;
40791 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40792 if (!SWIG_IsOK(res1)) {
40793 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetMenuBar" "', expected argument " "1"" of type '" "wxMenu const *""'");
40794 }
40795 arg1 = reinterpret_cast< wxMenu * >(argp1);
40796 {
40797 PyThreadState* __tstate = wxPyBeginAllowThreads();
40798 result = (wxMenuBar *)((wxMenu const *)arg1)->GetMenuBar();
40799 wxPyEndAllowThreads(__tstate);
40800 if (PyErr_Occurred()) SWIG_fail;
40801 }
40802 {
40803 resultobj = wxPyMake_wxObject(result, (bool)0);
40804 }
40805 return resultobj;
40806 fail:
40807 return NULL;
40808 }
40809
40810
40811 SWIGINTERN PyObject *_wrap_Menu_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40812 PyObject *resultobj = 0;
40813 wxMenu *arg1 = (wxMenu *) 0 ;
40814 wxMenuBarBase *arg2 = (wxMenuBarBase *) 0 ;
40815 void *argp1 = 0 ;
40816 int res1 = 0 ;
40817 void *argp2 = 0 ;
40818 int res2 = 0 ;
40819 PyObject * obj0 = 0 ;
40820 PyObject * obj1 = 0 ;
40821 char * kwnames[] = {
40822 (char *) "self",(char *) "menubar", NULL
40823 };
40824
40825 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
40826 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40827 if (!SWIG_IsOK(res1)) {
40828 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Attach" "', expected argument " "1"" of type '" "wxMenu *""'");
40829 }
40830 arg1 = reinterpret_cast< wxMenu * >(argp1);
40831 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenuBarBase, 0 | 0 );
40832 if (!SWIG_IsOK(res2)) {
40833 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_Attach" "', expected argument " "2"" of type '" "wxMenuBarBase *""'");
40834 }
40835 arg2 = reinterpret_cast< wxMenuBarBase * >(argp2);
40836 {
40837 PyThreadState* __tstate = wxPyBeginAllowThreads();
40838 (arg1)->Attach(arg2);
40839 wxPyEndAllowThreads(__tstate);
40840 if (PyErr_Occurred()) SWIG_fail;
40841 }
40842 resultobj = SWIG_Py_Void();
40843 return resultobj;
40844 fail:
40845 return NULL;
40846 }
40847
40848
40849 SWIGINTERN PyObject *_wrap_Menu_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40850 PyObject *resultobj = 0;
40851 wxMenu *arg1 = (wxMenu *) 0 ;
40852 void *argp1 = 0 ;
40853 int res1 = 0 ;
40854 PyObject *swig_obj[1] ;
40855
40856 if (!args) SWIG_fail;
40857 swig_obj[0] = args;
40858 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40859 if (!SWIG_IsOK(res1)) {
40860 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_Detach" "', expected argument " "1"" of type '" "wxMenu *""'");
40861 }
40862 arg1 = reinterpret_cast< wxMenu * >(argp1);
40863 {
40864 PyThreadState* __tstate = wxPyBeginAllowThreads();
40865 (arg1)->Detach();
40866 wxPyEndAllowThreads(__tstate);
40867 if (PyErr_Occurred()) SWIG_fail;
40868 }
40869 resultobj = SWIG_Py_Void();
40870 return resultobj;
40871 fail:
40872 return NULL;
40873 }
40874
40875
40876 SWIGINTERN PyObject *_wrap_Menu_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40877 PyObject *resultobj = 0;
40878 wxMenu *arg1 = (wxMenu *) 0 ;
40879 bool result;
40880 void *argp1 = 0 ;
40881 int res1 = 0 ;
40882 PyObject *swig_obj[1] ;
40883
40884 if (!args) SWIG_fail;
40885 swig_obj[0] = args;
40886 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40887 if (!SWIG_IsOK(res1)) {
40888 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_IsAttached" "', expected argument " "1"" of type '" "wxMenu const *""'");
40889 }
40890 arg1 = reinterpret_cast< wxMenu * >(argp1);
40891 {
40892 PyThreadState* __tstate = wxPyBeginAllowThreads();
40893 result = (bool)((wxMenu const *)arg1)->IsAttached();
40894 wxPyEndAllowThreads(__tstate);
40895 if (PyErr_Occurred()) SWIG_fail;
40896 }
40897 {
40898 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
40899 }
40900 return resultobj;
40901 fail:
40902 return NULL;
40903 }
40904
40905
40906 SWIGINTERN PyObject *_wrap_Menu_SetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40907 PyObject *resultobj = 0;
40908 wxMenu *arg1 = (wxMenu *) 0 ;
40909 wxMenu *arg2 = (wxMenu *) 0 ;
40910 void *argp1 = 0 ;
40911 int res1 = 0 ;
40912 void *argp2 = 0 ;
40913 int res2 = 0 ;
40914 PyObject * obj0 = 0 ;
40915 PyObject * obj1 = 0 ;
40916 char * kwnames[] = {
40917 (char *) "self",(char *) "parent", NULL
40918 };
40919
40920 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Menu_SetParent",kwnames,&obj0,&obj1)) SWIG_fail;
40921 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40922 if (!SWIG_IsOK(res1)) {
40923 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_SetParent" "', expected argument " "1"" of type '" "wxMenu *""'");
40924 }
40925 arg1 = reinterpret_cast< wxMenu * >(argp1);
40926 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
40927 if (!SWIG_IsOK(res2)) {
40928 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Menu_SetParent" "', expected argument " "2"" of type '" "wxMenu *""'");
40929 }
40930 arg2 = reinterpret_cast< wxMenu * >(argp2);
40931 {
40932 PyThreadState* __tstate = wxPyBeginAllowThreads();
40933 (arg1)->SetParent(arg2);
40934 wxPyEndAllowThreads(__tstate);
40935 if (PyErr_Occurred()) SWIG_fail;
40936 }
40937 resultobj = SWIG_Py_Void();
40938 return resultobj;
40939 fail:
40940 return NULL;
40941 }
40942
40943
40944 SWIGINTERN PyObject *_wrap_Menu_GetParent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40945 PyObject *resultobj = 0;
40946 wxMenu *arg1 = (wxMenu *) 0 ;
40947 wxMenu *result = 0 ;
40948 void *argp1 = 0 ;
40949 int res1 = 0 ;
40950 PyObject *swig_obj[1] ;
40951
40952 if (!args) SWIG_fail;
40953 swig_obj[0] = args;
40954 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
40955 if (!SWIG_IsOK(res1)) {
40956 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Menu_GetParent" "', expected argument " "1"" of type '" "wxMenu const *""'");
40957 }
40958 arg1 = reinterpret_cast< wxMenu * >(argp1);
40959 {
40960 PyThreadState* __tstate = wxPyBeginAllowThreads();
40961 result = (wxMenu *)((wxMenu const *)arg1)->GetParent();
40962 wxPyEndAllowThreads(__tstate);
40963 if (PyErr_Occurred()) SWIG_fail;
40964 }
40965 {
40966 resultobj = wxPyMake_wxObject(result, 0);
40967 }
40968 return resultobj;
40969 fail:
40970 return NULL;
40971 }
40972
40973
40974 SWIGINTERN PyObject *Menu_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40975 PyObject *obj;
40976 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
40977 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenu, SWIG_NewClientData(obj));
40978 return SWIG_Py_Void();
40979 }
40980
40981 SWIGINTERN PyObject *Menu_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
40982 return SWIG_Python_InitShadowInstance(args);
40983 }
40984
40985 SWIGINTERN PyObject *_wrap_new_MenuBar(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
40986 PyObject *resultobj = 0;
40987 long arg1 = (long) 0 ;
40988 wxMenuBar *result = 0 ;
40989 long val1 ;
40990 int ecode1 = 0 ;
40991 PyObject * obj0 = 0 ;
40992 char * kwnames[] = {
40993 (char *) "style", NULL
40994 };
40995
40996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_MenuBar",kwnames,&obj0)) SWIG_fail;
40997 if (obj0) {
40998 ecode1 = SWIG_AsVal_long(obj0, &val1);
40999 if (!SWIG_IsOK(ecode1)) {
41000 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_MenuBar" "', expected argument " "1"" of type '" "long""'");
41001 }
41002 arg1 = static_cast< long >(val1);
41003 }
41004 {
41005 if (!wxPyCheckForApp()) SWIG_fail;
41006 PyThreadState* __tstate = wxPyBeginAllowThreads();
41007 result = (wxMenuBar *)new wxMenuBar(arg1);
41008 wxPyEndAllowThreads(__tstate);
41009 if (PyErr_Occurred()) SWIG_fail;
41010 }
41011 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxMenuBar, SWIG_POINTER_NEW | 0 );
41012 return resultobj;
41013 fail:
41014 return NULL;
41015 }
41016
41017
41018 SWIGINTERN PyObject *_wrap_MenuBar_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41019 PyObject *resultobj = 0;
41020 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41021 wxMenu *arg2 = (wxMenu *) 0 ;
41022 wxString *arg3 = 0 ;
41023 bool result;
41024 void *argp1 = 0 ;
41025 int res1 = 0 ;
41026 void *argp2 = 0 ;
41027 int res2 = 0 ;
41028 bool temp3 = false ;
41029 PyObject * obj0 = 0 ;
41030 PyObject * obj1 = 0 ;
41031 PyObject * obj2 = 0 ;
41032 char * kwnames[] = {
41033 (char *) "self",(char *) "menu",(char *) "title", NULL
41034 };
41035
41036 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41037 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41038 if (!SWIG_IsOK(res1)) {
41039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Append" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41040 }
41041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41042 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
41043 if (!SWIG_IsOK(res2)) {
41044 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Append" "', expected argument " "2"" of type '" "wxMenu *""'");
41045 }
41046 arg2 = reinterpret_cast< wxMenu * >(argp2);
41047 {
41048 arg3 = wxString_in_helper(obj2);
41049 if (arg3 == NULL) SWIG_fail;
41050 temp3 = true;
41051 }
41052 {
41053 PyThreadState* __tstate = wxPyBeginAllowThreads();
41054 result = (bool)(arg1)->Append(arg2,(wxString const &)*arg3);
41055 wxPyEndAllowThreads(__tstate);
41056 if (PyErr_Occurred()) SWIG_fail;
41057 }
41058 {
41059 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41060 }
41061 {
41062 if (temp3)
41063 delete arg3;
41064 }
41065 return resultobj;
41066 fail:
41067 {
41068 if (temp3)
41069 delete arg3;
41070 }
41071 return NULL;
41072 }
41073
41074
41075 SWIGINTERN PyObject *_wrap_MenuBar_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41076 PyObject *resultobj = 0;
41077 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41078 size_t arg2 ;
41079 wxMenu *arg3 = (wxMenu *) 0 ;
41080 wxString *arg4 = 0 ;
41081 bool result;
41082 void *argp1 = 0 ;
41083 int res1 = 0 ;
41084 size_t val2 ;
41085 int ecode2 = 0 ;
41086 void *argp3 = 0 ;
41087 int res3 = 0 ;
41088 bool temp4 = false ;
41089 PyObject * obj0 = 0 ;
41090 PyObject * obj1 = 0 ;
41091 PyObject * obj2 = 0 ;
41092 PyObject * obj3 = 0 ;
41093 char * kwnames[] = {
41094 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41095 };
41096
41097 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41098 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41099 if (!SWIG_IsOK(res1)) {
41100 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Insert" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41101 }
41102 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41103 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41104 if (!SWIG_IsOK(ecode2)) {
41105 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Insert" "', expected argument " "2"" of type '" "size_t""'");
41106 }
41107 arg2 = static_cast< size_t >(val2);
41108 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41109 if (!SWIG_IsOK(res3)) {
41110 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Insert" "', expected argument " "3"" of type '" "wxMenu *""'");
41111 }
41112 arg3 = reinterpret_cast< wxMenu * >(argp3);
41113 {
41114 arg4 = wxString_in_helper(obj3);
41115 if (arg4 == NULL) SWIG_fail;
41116 temp4 = true;
41117 }
41118 {
41119 PyThreadState* __tstate = wxPyBeginAllowThreads();
41120 result = (bool)(arg1)->Insert(arg2,arg3,(wxString const &)*arg4);
41121 wxPyEndAllowThreads(__tstate);
41122 if (PyErr_Occurred()) SWIG_fail;
41123 }
41124 {
41125 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41126 }
41127 {
41128 if (temp4)
41129 delete arg4;
41130 }
41131 return resultobj;
41132 fail:
41133 {
41134 if (temp4)
41135 delete arg4;
41136 }
41137 return NULL;
41138 }
41139
41140
41141 SWIGINTERN PyObject *_wrap_MenuBar_GetMenuCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
41142 PyObject *resultobj = 0;
41143 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41144 size_t result;
41145 void *argp1 = 0 ;
41146 int res1 = 0 ;
41147 PyObject *swig_obj[1] ;
41148
41149 if (!args) SWIG_fail;
41150 swig_obj[0] = args;
41151 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41152 if (!SWIG_IsOK(res1)) {
41153 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenuCount" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41154 }
41155 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41156 {
41157 PyThreadState* __tstate = wxPyBeginAllowThreads();
41158 result = (size_t)((wxMenuBar const *)arg1)->GetMenuCount();
41159 wxPyEndAllowThreads(__tstate);
41160 if (PyErr_Occurred()) SWIG_fail;
41161 }
41162 resultobj = SWIG_From_size_t(static_cast< size_t >(result));
41163 return resultobj;
41164 fail:
41165 return NULL;
41166 }
41167
41168
41169 SWIGINTERN PyObject *_wrap_MenuBar_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41170 PyObject *resultobj = 0;
41171 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41172 size_t arg2 ;
41173 wxMenu *result = 0 ;
41174 void *argp1 = 0 ;
41175 int res1 = 0 ;
41176 size_t val2 ;
41177 int ecode2 = 0 ;
41178 PyObject * obj0 = 0 ;
41179 PyObject * obj1 = 0 ;
41180 char * kwnames[] = {
41181 (char *) "self",(char *) "pos", NULL
41182 };
41183
41184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41186 if (!SWIG_IsOK(res1)) {
41187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetMenu" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41188 }
41189 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41190 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41191 if (!SWIG_IsOK(ecode2)) {
41192 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetMenu" "', expected argument " "2"" of type '" "size_t""'");
41193 }
41194 arg2 = static_cast< size_t >(val2);
41195 {
41196 PyThreadState* __tstate = wxPyBeginAllowThreads();
41197 result = (wxMenu *)((wxMenuBar const *)arg1)->GetMenu(arg2);
41198 wxPyEndAllowThreads(__tstate);
41199 if (PyErr_Occurred()) SWIG_fail;
41200 }
41201 {
41202 resultobj = wxPyMake_wxObject(result, 0);
41203 }
41204 return resultobj;
41205 fail:
41206 return NULL;
41207 }
41208
41209
41210 SWIGINTERN PyObject *_wrap_MenuBar_Replace(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41211 PyObject *resultobj = 0;
41212 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41213 size_t arg2 ;
41214 wxMenu *arg3 = (wxMenu *) 0 ;
41215 wxString *arg4 = 0 ;
41216 wxMenu *result = 0 ;
41217 void *argp1 = 0 ;
41218 int res1 = 0 ;
41219 size_t val2 ;
41220 int ecode2 = 0 ;
41221 void *argp3 = 0 ;
41222 int res3 = 0 ;
41223 bool temp4 = false ;
41224 PyObject * obj0 = 0 ;
41225 PyObject * obj1 = 0 ;
41226 PyObject * obj2 = 0 ;
41227 PyObject * obj3 = 0 ;
41228 char * kwnames[] = {
41229 (char *) "self",(char *) "pos",(char *) "menu",(char *) "title", NULL
41230 };
41231
41232 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:MenuBar_Replace",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
41233 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41234 if (!SWIG_IsOK(res1)) {
41235 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Replace" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41236 }
41237 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41238 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41239 if (!SWIG_IsOK(ecode2)) {
41240 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Replace" "', expected argument " "2"" of type '" "size_t""'");
41241 }
41242 arg2 = static_cast< size_t >(val2);
41243 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxMenu, 0 | 0 );
41244 if (!SWIG_IsOK(res3)) {
41245 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuBar_Replace" "', expected argument " "3"" of type '" "wxMenu *""'");
41246 }
41247 arg3 = reinterpret_cast< wxMenu * >(argp3);
41248 {
41249 arg4 = wxString_in_helper(obj3);
41250 if (arg4 == NULL) SWIG_fail;
41251 temp4 = true;
41252 }
41253 {
41254 PyThreadState* __tstate = wxPyBeginAllowThreads();
41255 result = (wxMenu *)(arg1)->Replace(arg2,arg3,(wxString const &)*arg4);
41256 wxPyEndAllowThreads(__tstate);
41257 if (PyErr_Occurred()) SWIG_fail;
41258 }
41259 {
41260 resultobj = wxPyMake_wxObject(result, 0);
41261 }
41262 {
41263 if (temp4)
41264 delete arg4;
41265 }
41266 return resultobj;
41267 fail:
41268 {
41269 if (temp4)
41270 delete arg4;
41271 }
41272 return NULL;
41273 }
41274
41275
41276 SWIGINTERN PyObject *_wrap_MenuBar_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41277 PyObject *resultobj = 0;
41278 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41279 size_t arg2 ;
41280 wxMenu *result = 0 ;
41281 void *argp1 = 0 ;
41282 int res1 = 0 ;
41283 size_t val2 ;
41284 int ecode2 = 0 ;
41285 PyObject * obj0 = 0 ;
41286 PyObject * obj1 = 0 ;
41287 char * kwnames[] = {
41288 (char *) "self",(char *) "pos", NULL
41289 };
41290
41291 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
41292 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41293 if (!SWIG_IsOK(res1)) {
41294 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Remove" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41295 }
41296 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41297 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41298 if (!SWIG_IsOK(ecode2)) {
41299 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Remove" "', expected argument " "2"" of type '" "size_t""'");
41300 }
41301 arg2 = static_cast< size_t >(val2);
41302 {
41303 PyThreadState* __tstate = wxPyBeginAllowThreads();
41304 result = (wxMenu *)(arg1)->Remove(arg2);
41305 wxPyEndAllowThreads(__tstate);
41306 if (PyErr_Occurred()) SWIG_fail;
41307 }
41308 {
41309 resultobj = wxPyMake_wxObject(result, 0);
41310 }
41311 return resultobj;
41312 fail:
41313 return NULL;
41314 }
41315
41316
41317 SWIGINTERN PyObject *_wrap_MenuBar_EnableTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41318 PyObject *resultobj = 0;
41319 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41320 size_t arg2 ;
41321 bool arg3 ;
41322 void *argp1 = 0 ;
41323 int res1 = 0 ;
41324 size_t val2 ;
41325 int ecode2 = 0 ;
41326 bool val3 ;
41327 int ecode3 = 0 ;
41328 PyObject * obj0 = 0 ;
41329 PyObject * obj1 = 0 ;
41330 PyObject * obj2 = 0 ;
41331 char * kwnames[] = {
41332 (char *) "self",(char *) "pos",(char *) "enable", NULL
41333 };
41334
41335 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_EnableTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41336 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41337 if (!SWIG_IsOK(res1)) {
41338 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_EnableTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41339 }
41340 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41341 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41342 if (!SWIG_IsOK(ecode2)) {
41343 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_EnableTop" "', expected argument " "2"" of type '" "size_t""'");
41344 }
41345 arg2 = static_cast< size_t >(val2);
41346 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41347 if (!SWIG_IsOK(ecode3)) {
41348 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_EnableTop" "', expected argument " "3"" of type '" "bool""'");
41349 }
41350 arg3 = static_cast< bool >(val3);
41351 {
41352 PyThreadState* __tstate = wxPyBeginAllowThreads();
41353 (arg1)->EnableTop(arg2,arg3);
41354 wxPyEndAllowThreads(__tstate);
41355 if (PyErr_Occurred()) SWIG_fail;
41356 }
41357 resultobj = SWIG_Py_Void();
41358 return resultobj;
41359 fail:
41360 return NULL;
41361 }
41362
41363
41364 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabledTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41365 PyObject *resultobj = 0;
41366 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41367 size_t arg2 ;
41368 bool result;
41369 void *argp1 = 0 ;
41370 int res1 = 0 ;
41371 size_t val2 ;
41372 int ecode2 = 0 ;
41373 PyObject * obj0 = 0 ;
41374 PyObject * obj1 = 0 ;
41375 char * kwnames[] = {
41376 (char *) "self",(char *) "pos", NULL
41377 };
41378
41379 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabledTop",kwnames,&obj0,&obj1)) SWIG_fail;
41380 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41381 if (!SWIG_IsOK(res1)) {
41382 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41383 }
41384 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41385 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41386 if (!SWIG_IsOK(ecode2)) {
41387 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabledTop" "', expected argument " "2"" of type '" "size_t""'");
41388 }
41389 arg2 = static_cast< size_t >(val2);
41390 {
41391 PyThreadState* __tstate = wxPyBeginAllowThreads();
41392 result = (bool)((wxMenuBar const *)arg1)->IsEnabledTop(arg2);
41393 wxPyEndAllowThreads(__tstate);
41394 if (PyErr_Occurred()) SWIG_fail;
41395 }
41396 {
41397 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41398 }
41399 return resultobj;
41400 fail:
41401 return NULL;
41402 }
41403
41404
41405 SWIGINTERN PyObject *_wrap_MenuBar_SetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41406 PyObject *resultobj = 0;
41407 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41408 size_t arg2 ;
41409 wxString *arg3 = 0 ;
41410 void *argp1 = 0 ;
41411 int res1 = 0 ;
41412 size_t val2 ;
41413 int ecode2 = 0 ;
41414 bool temp3 = false ;
41415 PyObject * obj0 = 0 ;
41416 PyObject * obj1 = 0 ;
41417 PyObject * obj2 = 0 ;
41418 char * kwnames[] = {
41419 (char *) "self",(char *) "pos",(char *) "label", NULL
41420 };
41421
41422 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabelTop",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41423 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41424 if (!SWIG_IsOK(res1)) {
41425 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41426 }
41427 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41428 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41429 if (!SWIG_IsOK(ecode2)) {
41430 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41431 }
41432 arg2 = static_cast< size_t >(val2);
41433 {
41434 arg3 = wxString_in_helper(obj2);
41435 if (arg3 == NULL) SWIG_fail;
41436 temp3 = true;
41437 }
41438 {
41439 PyThreadState* __tstate = wxPyBeginAllowThreads();
41440 (arg1)->SetLabelTop(arg2,(wxString const &)*arg3);
41441 wxPyEndAllowThreads(__tstate);
41442 if (PyErr_Occurred()) SWIG_fail;
41443 }
41444 resultobj = SWIG_Py_Void();
41445 {
41446 if (temp3)
41447 delete arg3;
41448 }
41449 return resultobj;
41450 fail:
41451 {
41452 if (temp3)
41453 delete arg3;
41454 }
41455 return NULL;
41456 }
41457
41458
41459 SWIGINTERN PyObject *_wrap_MenuBar_GetLabelTop(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41460 PyObject *resultobj = 0;
41461 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41462 size_t arg2 ;
41463 wxString result;
41464 void *argp1 = 0 ;
41465 int res1 = 0 ;
41466 size_t val2 ;
41467 int ecode2 = 0 ;
41468 PyObject * obj0 = 0 ;
41469 PyObject * obj1 = 0 ;
41470 char * kwnames[] = {
41471 (char *) "self",(char *) "pos", NULL
41472 };
41473
41474 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabelTop",kwnames,&obj0,&obj1)) SWIG_fail;
41475 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41476 if (!SWIG_IsOK(res1)) {
41477 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabelTop" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41478 }
41479 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41480 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
41481 if (!SWIG_IsOK(ecode2)) {
41482 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabelTop" "', expected argument " "2"" of type '" "size_t""'");
41483 }
41484 arg2 = static_cast< size_t >(val2);
41485 {
41486 PyThreadState* __tstate = wxPyBeginAllowThreads();
41487 result = ((wxMenuBar const *)arg1)->GetLabelTop(arg2);
41488 wxPyEndAllowThreads(__tstate);
41489 if (PyErr_Occurred()) SWIG_fail;
41490 }
41491 {
41492 #if wxUSE_UNICODE
41493 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41494 #else
41495 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41496 #endif
41497 }
41498 return resultobj;
41499 fail:
41500 return NULL;
41501 }
41502
41503
41504 SWIGINTERN PyObject *_wrap_MenuBar_FindMenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41505 PyObject *resultobj = 0;
41506 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41507 wxString *arg2 = 0 ;
41508 wxString *arg3 = 0 ;
41509 int result;
41510 void *argp1 = 0 ;
41511 int res1 = 0 ;
41512 bool temp2 = false ;
41513 bool temp3 = false ;
41514 PyObject * obj0 = 0 ;
41515 PyObject * obj1 = 0 ;
41516 PyObject * obj2 = 0 ;
41517 char * kwnames[] = {
41518 (char *) "self",(char *) "menu",(char *) "item", NULL
41519 };
41520
41521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_FindMenuItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41523 if (!SWIG_IsOK(res1)) {
41524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenuItem" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41525 }
41526 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41527 {
41528 arg2 = wxString_in_helper(obj1);
41529 if (arg2 == NULL) SWIG_fail;
41530 temp2 = true;
41531 }
41532 {
41533 arg3 = wxString_in_helper(obj2);
41534 if (arg3 == NULL) SWIG_fail;
41535 temp3 = true;
41536 }
41537 {
41538 PyThreadState* __tstate = wxPyBeginAllowThreads();
41539 result = (int)((wxMenuBar const *)arg1)->FindMenuItem((wxString const &)*arg2,(wxString const &)*arg3);
41540 wxPyEndAllowThreads(__tstate);
41541 if (PyErr_Occurred()) SWIG_fail;
41542 }
41543 resultobj = SWIG_From_int(static_cast< int >(result));
41544 {
41545 if (temp2)
41546 delete arg2;
41547 }
41548 {
41549 if (temp3)
41550 delete arg3;
41551 }
41552 return resultobj;
41553 fail:
41554 {
41555 if (temp2)
41556 delete arg2;
41557 }
41558 {
41559 if (temp3)
41560 delete arg3;
41561 }
41562 return NULL;
41563 }
41564
41565
41566 SWIGINTERN PyObject *_wrap_MenuBar_FindItemById(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41567 PyObject *resultobj = 0;
41568 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41569 int arg2 ;
41570 wxMenuItem *result = 0 ;
41571 void *argp1 = 0 ;
41572 int res1 = 0 ;
41573 int val2 ;
41574 int ecode2 = 0 ;
41575 PyObject * obj0 = 0 ;
41576 PyObject * obj1 = 0 ;
41577 char * kwnames[] = {
41578 (char *) "self",(char *) "id", NULL
41579 };
41580
41581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindItemById",kwnames,&obj0,&obj1)) SWIG_fail;
41582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41583 if (!SWIG_IsOK(res1)) {
41584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindItemById" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41585 }
41586 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41587 ecode2 = SWIG_AsVal_int(obj1, &val2);
41588 if (!SWIG_IsOK(ecode2)) {
41589 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_FindItemById" "', expected argument " "2"" of type '" "int""'");
41590 }
41591 arg2 = static_cast< int >(val2);
41592 {
41593 PyThreadState* __tstate = wxPyBeginAllowThreads();
41594 result = (wxMenuItem *)((wxMenuBar const *)arg1)->FindItem(arg2);
41595 wxPyEndAllowThreads(__tstate);
41596 if (PyErr_Occurred()) SWIG_fail;
41597 }
41598 {
41599 resultobj = wxPyMake_wxObject(result, (bool)0);
41600 }
41601 return resultobj;
41602 fail:
41603 return NULL;
41604 }
41605
41606
41607 SWIGINTERN PyObject *_wrap_MenuBar_FindMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41608 PyObject *resultobj = 0;
41609 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41610 wxString *arg2 = 0 ;
41611 int result;
41612 void *argp1 = 0 ;
41613 int res1 = 0 ;
41614 bool temp2 = false ;
41615 PyObject * obj0 = 0 ;
41616 PyObject * obj1 = 0 ;
41617 char * kwnames[] = {
41618 (char *) "self",(char *) "title", NULL
41619 };
41620
41621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_FindMenu",kwnames,&obj0,&obj1)) SWIG_fail;
41622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41623 if (!SWIG_IsOK(res1)) {
41624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_FindMenu" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41625 }
41626 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41627 {
41628 arg2 = wxString_in_helper(obj1);
41629 if (arg2 == NULL) SWIG_fail;
41630 temp2 = true;
41631 }
41632 {
41633 PyThreadState* __tstate = wxPyBeginAllowThreads();
41634 result = (int)(arg1)->FindMenu((wxString const &)*arg2);
41635 wxPyEndAllowThreads(__tstate);
41636 if (PyErr_Occurred()) SWIG_fail;
41637 }
41638 resultobj = SWIG_From_int(static_cast< int >(result));
41639 {
41640 if (temp2)
41641 delete arg2;
41642 }
41643 return resultobj;
41644 fail:
41645 {
41646 if (temp2)
41647 delete arg2;
41648 }
41649 return NULL;
41650 }
41651
41652
41653 SWIGINTERN PyObject *_wrap_MenuBar_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41654 PyObject *resultobj = 0;
41655 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41656 int arg2 ;
41657 bool arg3 ;
41658 void *argp1 = 0 ;
41659 int res1 = 0 ;
41660 int val2 ;
41661 int ecode2 = 0 ;
41662 bool val3 ;
41663 int ecode3 = 0 ;
41664 PyObject * obj0 = 0 ;
41665 PyObject * obj1 = 0 ;
41666 PyObject * obj2 = 0 ;
41667 char * kwnames[] = {
41668 (char *) "self",(char *) "id",(char *) "enable", NULL
41669 };
41670
41671 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Enable",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41672 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41673 if (!SWIG_IsOK(res1)) {
41674 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Enable" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41675 }
41676 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41677 ecode2 = SWIG_AsVal_int(obj1, &val2);
41678 if (!SWIG_IsOK(ecode2)) {
41679 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Enable" "', expected argument " "2"" of type '" "int""'");
41680 }
41681 arg2 = static_cast< int >(val2);
41682 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41683 if (!SWIG_IsOK(ecode3)) {
41684 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Enable" "', expected argument " "3"" of type '" "bool""'");
41685 }
41686 arg3 = static_cast< bool >(val3);
41687 {
41688 PyThreadState* __tstate = wxPyBeginAllowThreads();
41689 (arg1)->Enable(arg2,arg3);
41690 wxPyEndAllowThreads(__tstate);
41691 if (PyErr_Occurred()) SWIG_fail;
41692 }
41693 resultobj = SWIG_Py_Void();
41694 return resultobj;
41695 fail:
41696 return NULL;
41697 }
41698
41699
41700 SWIGINTERN PyObject *_wrap_MenuBar_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41701 PyObject *resultobj = 0;
41702 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41703 int arg2 ;
41704 bool arg3 ;
41705 void *argp1 = 0 ;
41706 int res1 = 0 ;
41707 int val2 ;
41708 int ecode2 = 0 ;
41709 bool val3 ;
41710 int ecode3 = 0 ;
41711 PyObject * obj0 = 0 ;
41712 PyObject * obj1 = 0 ;
41713 PyObject * obj2 = 0 ;
41714 char * kwnames[] = {
41715 (char *) "self",(char *) "id",(char *) "check", NULL
41716 };
41717
41718 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_Check",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41719 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41720 if (!SWIG_IsOK(res1)) {
41721 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Check" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41722 }
41723 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41724 ecode2 = SWIG_AsVal_int(obj1, &val2);
41725 if (!SWIG_IsOK(ecode2)) {
41726 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_Check" "', expected argument " "2"" of type '" "int""'");
41727 }
41728 arg2 = static_cast< int >(val2);
41729 ecode3 = SWIG_AsVal_bool(obj2, &val3);
41730 if (!SWIG_IsOK(ecode3)) {
41731 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "MenuBar_Check" "', expected argument " "3"" of type '" "bool""'");
41732 }
41733 arg3 = static_cast< bool >(val3);
41734 {
41735 PyThreadState* __tstate = wxPyBeginAllowThreads();
41736 (arg1)->Check(arg2,arg3);
41737 wxPyEndAllowThreads(__tstate);
41738 if (PyErr_Occurred()) SWIG_fail;
41739 }
41740 resultobj = SWIG_Py_Void();
41741 return resultobj;
41742 fail:
41743 return NULL;
41744 }
41745
41746
41747 SWIGINTERN PyObject *_wrap_MenuBar_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41748 PyObject *resultobj = 0;
41749 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41750 int arg2 ;
41751 bool result;
41752 void *argp1 = 0 ;
41753 int res1 = 0 ;
41754 int val2 ;
41755 int ecode2 = 0 ;
41756 PyObject * obj0 = 0 ;
41757 PyObject * obj1 = 0 ;
41758 char * kwnames[] = {
41759 (char *) "self",(char *) "id", NULL
41760 };
41761
41762 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsChecked",kwnames,&obj0,&obj1)) SWIG_fail;
41763 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41764 if (!SWIG_IsOK(res1)) {
41765 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsChecked" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41766 }
41767 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41768 ecode2 = SWIG_AsVal_int(obj1, &val2);
41769 if (!SWIG_IsOK(ecode2)) {
41770 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsChecked" "', expected argument " "2"" of type '" "int""'");
41771 }
41772 arg2 = static_cast< int >(val2);
41773 {
41774 PyThreadState* __tstate = wxPyBeginAllowThreads();
41775 result = (bool)((wxMenuBar const *)arg1)->IsChecked(arg2);
41776 wxPyEndAllowThreads(__tstate);
41777 if (PyErr_Occurred()) SWIG_fail;
41778 }
41779 {
41780 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41781 }
41782 return resultobj;
41783 fail:
41784 return NULL;
41785 }
41786
41787
41788 SWIGINTERN PyObject *_wrap_MenuBar_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41789 PyObject *resultobj = 0;
41790 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41791 int arg2 ;
41792 bool result;
41793 void *argp1 = 0 ;
41794 int res1 = 0 ;
41795 int val2 ;
41796 int ecode2 = 0 ;
41797 PyObject * obj0 = 0 ;
41798 PyObject * obj1 = 0 ;
41799 char * kwnames[] = {
41800 (char *) "self",(char *) "id", NULL
41801 };
41802
41803 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_IsEnabled",kwnames,&obj0,&obj1)) SWIG_fail;
41804 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41805 if (!SWIG_IsOK(res1)) {
41806 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsEnabled" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41807 }
41808 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41809 ecode2 = SWIG_AsVal_int(obj1, &val2);
41810 if (!SWIG_IsOK(ecode2)) {
41811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_IsEnabled" "', expected argument " "2"" of type '" "int""'");
41812 }
41813 arg2 = static_cast< int >(val2);
41814 {
41815 PyThreadState* __tstate = wxPyBeginAllowThreads();
41816 result = (bool)((wxMenuBar const *)arg1)->IsEnabled(arg2);
41817 wxPyEndAllowThreads(__tstate);
41818 if (PyErr_Occurred()) SWIG_fail;
41819 }
41820 {
41821 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
41822 }
41823 return resultobj;
41824 fail:
41825 return NULL;
41826 }
41827
41828
41829 SWIGINTERN PyObject *_wrap_MenuBar_SetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41830 PyObject *resultobj = 0;
41831 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41832 int arg2 ;
41833 wxString *arg3 = 0 ;
41834 void *argp1 = 0 ;
41835 int res1 = 0 ;
41836 int val2 ;
41837 int ecode2 = 0 ;
41838 bool temp3 = false ;
41839 PyObject * obj0 = 0 ;
41840 PyObject * obj1 = 0 ;
41841 PyObject * obj2 = 0 ;
41842 char * kwnames[] = {
41843 (char *) "self",(char *) "id",(char *) "label", NULL
41844 };
41845
41846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetLabel",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41848 if (!SWIG_IsOK(res1)) {
41849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetLabel" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41850 }
41851 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41852 ecode2 = SWIG_AsVal_int(obj1, &val2);
41853 if (!SWIG_IsOK(ecode2)) {
41854 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetLabel" "', expected argument " "2"" of type '" "int""'");
41855 }
41856 arg2 = static_cast< int >(val2);
41857 {
41858 arg3 = wxString_in_helper(obj2);
41859 if (arg3 == NULL) SWIG_fail;
41860 temp3 = true;
41861 }
41862 {
41863 PyThreadState* __tstate = wxPyBeginAllowThreads();
41864 (arg1)->SetLabel(arg2,(wxString const &)*arg3);
41865 wxPyEndAllowThreads(__tstate);
41866 if (PyErr_Occurred()) SWIG_fail;
41867 }
41868 resultobj = SWIG_Py_Void();
41869 {
41870 if (temp3)
41871 delete arg3;
41872 }
41873 return resultobj;
41874 fail:
41875 {
41876 if (temp3)
41877 delete arg3;
41878 }
41879 return NULL;
41880 }
41881
41882
41883 SWIGINTERN PyObject *_wrap_MenuBar_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41884 PyObject *resultobj = 0;
41885 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41886 int arg2 ;
41887 wxString result;
41888 void *argp1 = 0 ;
41889 int res1 = 0 ;
41890 int val2 ;
41891 int ecode2 = 0 ;
41892 PyObject * obj0 = 0 ;
41893 PyObject * obj1 = 0 ;
41894 char * kwnames[] = {
41895 (char *) "self",(char *) "id", NULL
41896 };
41897
41898 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetLabel",kwnames,&obj0,&obj1)) SWIG_fail;
41899 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41900 if (!SWIG_IsOK(res1)) {
41901 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetLabel" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
41902 }
41903 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41904 ecode2 = SWIG_AsVal_int(obj1, &val2);
41905 if (!SWIG_IsOK(ecode2)) {
41906 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetLabel" "', expected argument " "2"" of type '" "int""'");
41907 }
41908 arg2 = static_cast< int >(val2);
41909 {
41910 PyThreadState* __tstate = wxPyBeginAllowThreads();
41911 result = ((wxMenuBar const *)arg1)->GetLabel(arg2);
41912 wxPyEndAllowThreads(__tstate);
41913 if (PyErr_Occurred()) SWIG_fail;
41914 }
41915 {
41916 #if wxUSE_UNICODE
41917 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
41918 #else
41919 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
41920 #endif
41921 }
41922 return resultobj;
41923 fail:
41924 return NULL;
41925 }
41926
41927
41928 SWIGINTERN PyObject *_wrap_MenuBar_SetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41929 PyObject *resultobj = 0;
41930 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41931 int arg2 ;
41932 wxString *arg3 = 0 ;
41933 void *argp1 = 0 ;
41934 int res1 = 0 ;
41935 int val2 ;
41936 int ecode2 = 0 ;
41937 bool temp3 = false ;
41938 PyObject * obj0 = 0 ;
41939 PyObject * obj1 = 0 ;
41940 PyObject * obj2 = 0 ;
41941 char * kwnames[] = {
41942 (char *) "self",(char *) "id",(char *) "helpString", NULL
41943 };
41944
41945 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:MenuBar_SetHelpString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
41946 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41947 if (!SWIG_IsOK(res1)) {
41948 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_SetHelpString" "', expected argument " "1"" of type '" "wxMenuBar *""'");
41949 }
41950 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
41951 ecode2 = SWIG_AsVal_int(obj1, &val2);
41952 if (!SWIG_IsOK(ecode2)) {
41953 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_SetHelpString" "', expected argument " "2"" of type '" "int""'");
41954 }
41955 arg2 = static_cast< int >(val2);
41956 {
41957 arg3 = wxString_in_helper(obj2);
41958 if (arg3 == NULL) SWIG_fail;
41959 temp3 = true;
41960 }
41961 {
41962 PyThreadState* __tstate = wxPyBeginAllowThreads();
41963 (arg1)->SetHelpString(arg2,(wxString const &)*arg3);
41964 wxPyEndAllowThreads(__tstate);
41965 if (PyErr_Occurred()) SWIG_fail;
41966 }
41967 resultobj = SWIG_Py_Void();
41968 {
41969 if (temp3)
41970 delete arg3;
41971 }
41972 return resultobj;
41973 fail:
41974 {
41975 if (temp3)
41976 delete arg3;
41977 }
41978 return NULL;
41979 }
41980
41981
41982 SWIGINTERN PyObject *_wrap_MenuBar_GetHelpString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
41983 PyObject *resultobj = 0;
41984 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
41985 int arg2 ;
41986 wxString result;
41987 void *argp1 = 0 ;
41988 int res1 = 0 ;
41989 int val2 ;
41990 int ecode2 = 0 ;
41991 PyObject * obj0 = 0 ;
41992 PyObject * obj1 = 0 ;
41993 char * kwnames[] = {
41994 (char *) "self",(char *) "id", NULL
41995 };
41996
41997 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_GetHelpString",kwnames,&obj0,&obj1)) SWIG_fail;
41998 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
41999 if (!SWIG_IsOK(res1)) {
42000 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetHelpString" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42001 }
42002 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42003 ecode2 = SWIG_AsVal_int(obj1, &val2);
42004 if (!SWIG_IsOK(ecode2)) {
42005 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuBar_GetHelpString" "', expected argument " "2"" of type '" "int""'");
42006 }
42007 arg2 = static_cast< int >(val2);
42008 {
42009 PyThreadState* __tstate = wxPyBeginAllowThreads();
42010 result = ((wxMenuBar const *)arg1)->GetHelpString(arg2);
42011 wxPyEndAllowThreads(__tstate);
42012 if (PyErr_Occurred()) SWIG_fail;
42013 }
42014 {
42015 #if wxUSE_UNICODE
42016 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42017 #else
42018 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42019 #endif
42020 }
42021 return resultobj;
42022 fail:
42023 return NULL;
42024 }
42025
42026
42027 SWIGINTERN PyObject *_wrap_MenuBar_GetFrame(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42028 PyObject *resultobj = 0;
42029 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42030 wxFrame *result = 0 ;
42031 void *argp1 = 0 ;
42032 int res1 = 0 ;
42033 PyObject *swig_obj[1] ;
42034
42035 if (!args) SWIG_fail;
42036 swig_obj[0] = args;
42037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42038 if (!SWIG_IsOK(res1)) {
42039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_GetFrame" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42040 }
42041 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42042 {
42043 PyThreadState* __tstate = wxPyBeginAllowThreads();
42044 result = (wxFrame *)((wxMenuBar const *)arg1)->GetFrame();
42045 wxPyEndAllowThreads(__tstate);
42046 if (PyErr_Occurred()) SWIG_fail;
42047 }
42048 {
42049 resultobj = wxPyMake_wxObject(result, (bool)0);
42050 }
42051 return resultobj;
42052 fail:
42053 return NULL;
42054 }
42055
42056
42057 SWIGINTERN PyObject *_wrap_MenuBar_IsAttached(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42058 PyObject *resultobj = 0;
42059 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42060 bool result;
42061 void *argp1 = 0 ;
42062 int res1 = 0 ;
42063 PyObject *swig_obj[1] ;
42064
42065 if (!args) SWIG_fail;
42066 swig_obj[0] = args;
42067 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42068 if (!SWIG_IsOK(res1)) {
42069 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_IsAttached" "', expected argument " "1"" of type '" "wxMenuBar const *""'");
42070 }
42071 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42072 {
42073 PyThreadState* __tstate = wxPyBeginAllowThreads();
42074 result = (bool)((wxMenuBar const *)arg1)->IsAttached();
42075 wxPyEndAllowThreads(__tstate);
42076 if (PyErr_Occurred()) SWIG_fail;
42077 }
42078 {
42079 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42080 }
42081 return resultobj;
42082 fail:
42083 return NULL;
42084 }
42085
42086
42087 SWIGINTERN PyObject *_wrap_MenuBar_Attach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42088 PyObject *resultobj = 0;
42089 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42090 wxFrame *arg2 = (wxFrame *) 0 ;
42091 void *argp1 = 0 ;
42092 int res1 = 0 ;
42093 void *argp2 = 0 ;
42094 int res2 = 0 ;
42095 PyObject * obj0 = 0 ;
42096 PyObject * obj1 = 0 ;
42097 char * kwnames[] = {
42098 (char *) "self",(char *) "frame", NULL
42099 };
42100
42101 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuBar_Attach",kwnames,&obj0,&obj1)) SWIG_fail;
42102 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42103 if (!SWIG_IsOK(res1)) {
42104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Attach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42105 }
42106 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42107 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxFrame, 0 | 0 );
42108 if (!SWIG_IsOK(res2)) {
42109 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuBar_Attach" "', expected argument " "2"" of type '" "wxFrame *""'");
42110 }
42111 arg2 = reinterpret_cast< wxFrame * >(argp2);
42112 {
42113 PyThreadState* __tstate = wxPyBeginAllowThreads();
42114 (arg1)->Attach(arg2);
42115 wxPyEndAllowThreads(__tstate);
42116 if (PyErr_Occurred()) SWIG_fail;
42117 }
42118 resultobj = SWIG_Py_Void();
42119 return resultobj;
42120 fail:
42121 return NULL;
42122 }
42123
42124
42125 SWIGINTERN PyObject *_wrap_MenuBar_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42126 PyObject *resultobj = 0;
42127 wxMenuBar *arg1 = (wxMenuBar *) 0 ;
42128 void *argp1 = 0 ;
42129 int res1 = 0 ;
42130 PyObject *swig_obj[1] ;
42131
42132 if (!args) SWIG_fail;
42133 swig_obj[0] = args;
42134 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuBar, 0 | 0 );
42135 if (!SWIG_IsOK(res1)) {
42136 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuBar_Detach" "', expected argument " "1"" of type '" "wxMenuBar *""'");
42137 }
42138 arg1 = reinterpret_cast< wxMenuBar * >(argp1);
42139 {
42140 PyThreadState* __tstate = wxPyBeginAllowThreads();
42141 (arg1)->Detach();
42142 wxPyEndAllowThreads(__tstate);
42143 if (PyErr_Occurred()) SWIG_fail;
42144 }
42145 resultobj = SWIG_Py_Void();
42146 return resultobj;
42147 fail:
42148 return NULL;
42149 }
42150
42151
42152 SWIGINTERN PyObject *_wrap_MenuBar_SetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42153 PyObject *resultobj = 0;
42154 bool arg1 ;
42155 bool val1 ;
42156 int ecode1 = 0 ;
42157 PyObject * obj0 = 0 ;
42158 char * kwnames[] = {
42159 (char *) "enable", NULL
42160 };
42161
42162 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuBar_SetAutoWindowMenu",kwnames,&obj0)) SWIG_fail;
42163 ecode1 = SWIG_AsVal_bool(obj0, &val1);
42164 if (!SWIG_IsOK(ecode1)) {
42165 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "MenuBar_SetAutoWindowMenu" "', expected argument " "1"" of type '" "bool""'");
42166 }
42167 arg1 = static_cast< bool >(val1);
42168 {
42169 PyThreadState* __tstate = wxPyBeginAllowThreads();
42170 wxMenuBar::SetAutoWindowMenu(arg1);
42171 wxPyEndAllowThreads(__tstate);
42172 if (PyErr_Occurred()) SWIG_fail;
42173 }
42174 resultobj = SWIG_Py_Void();
42175 return resultobj;
42176 fail:
42177 return NULL;
42178 }
42179
42180
42181 SWIGINTERN PyObject *_wrap_MenuBar_GetAutoWindowMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42182 PyObject *resultobj = 0;
42183 bool result;
42184
42185 if (!SWIG_Python_UnpackTuple(args,"MenuBar_GetAutoWindowMenu",0,0,0)) SWIG_fail;
42186 {
42187 PyThreadState* __tstate = wxPyBeginAllowThreads();
42188 result = (bool)wxMenuBar::GetAutoWindowMenu();
42189 wxPyEndAllowThreads(__tstate);
42190 if (PyErr_Occurred()) SWIG_fail;
42191 }
42192 {
42193 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42194 }
42195 return resultobj;
42196 fail:
42197 return NULL;
42198 }
42199
42200
42201 SWIGINTERN PyObject *MenuBar_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42202 PyObject *obj;
42203 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
42204 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuBar, SWIG_NewClientData(obj));
42205 return SWIG_Py_Void();
42206 }
42207
42208 SWIGINTERN PyObject *MenuBar_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42209 return SWIG_Python_InitShadowInstance(args);
42210 }
42211
42212 SWIGINTERN PyObject *_wrap_new_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42213 PyObject *resultobj = 0;
42214 wxMenu *arg1 = (wxMenu *) NULL ;
42215 int arg2 = (int) wxID_ANY ;
42216 wxString const &arg3_defvalue = wxPyEmptyString ;
42217 wxString *arg3 = (wxString *) &arg3_defvalue ;
42218 wxString const &arg4_defvalue = wxPyEmptyString ;
42219 wxString *arg4 = (wxString *) &arg4_defvalue ;
42220 wxItemKind arg5 = (wxItemKind) wxITEM_NORMAL ;
42221 wxMenu *arg6 = (wxMenu *) NULL ;
42222 wxMenuItem *result = 0 ;
42223 void *argp1 = 0 ;
42224 int res1 = 0 ;
42225 int val2 ;
42226 int ecode2 = 0 ;
42227 bool temp3 = false ;
42228 bool temp4 = false ;
42229 int val5 ;
42230 int ecode5 = 0 ;
42231 void *argp6 = 0 ;
42232 int res6 = 0 ;
42233 PyObject * obj0 = 0 ;
42234 PyObject * obj1 = 0 ;
42235 PyObject * obj2 = 0 ;
42236 PyObject * obj3 = 0 ;
42237 PyObject * obj4 = 0 ;
42238 PyObject * obj5 = 0 ;
42239 char * kwnames[] = {
42240 (char *) "parentMenu",(char *) "id",(char *) "text",(char *) "help",(char *) "kind",(char *) "subMenu", NULL
42241 };
42242
42243 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOOOO:new_MenuItem",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
42244 if (obj0) {
42245 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenu, 0 | 0 );
42246 if (!SWIG_IsOK(res1)) {
42247 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_MenuItem" "', expected argument " "1"" of type '" "wxMenu *""'");
42248 }
42249 arg1 = reinterpret_cast< wxMenu * >(argp1);
42250 }
42251 if (obj1) {
42252 ecode2 = SWIG_AsVal_int(obj1, &val2);
42253 if (!SWIG_IsOK(ecode2)) {
42254 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_MenuItem" "', expected argument " "2"" of type '" "int""'");
42255 }
42256 arg2 = static_cast< int >(val2);
42257 }
42258 if (obj2) {
42259 {
42260 arg3 = wxString_in_helper(obj2);
42261 if (arg3 == NULL) SWIG_fail;
42262 temp3 = true;
42263 }
42264 }
42265 if (obj3) {
42266 {
42267 arg4 = wxString_in_helper(obj3);
42268 if (arg4 == NULL) SWIG_fail;
42269 temp4 = true;
42270 }
42271 }
42272 if (obj4) {
42273 ecode5 = SWIG_AsVal_int(obj4, &val5);
42274 if (!SWIG_IsOK(ecode5)) {
42275 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_MenuItem" "', expected argument " "5"" of type '" "wxItemKind""'");
42276 }
42277 arg5 = static_cast< wxItemKind >(val5);
42278 }
42279 if (obj5) {
42280 res6 = SWIG_ConvertPtr(obj5, &argp6,SWIGTYPE_p_wxMenu, 0 | 0 );
42281 if (!SWIG_IsOK(res6)) {
42282 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_MenuItem" "', expected argument " "6"" of type '" "wxMenu *""'");
42283 }
42284 arg6 = reinterpret_cast< wxMenu * >(argp6);
42285 }
42286 {
42287 PyThreadState* __tstate = wxPyBeginAllowThreads();
42288 result = (wxMenuItem *)new wxMenuItem(arg1,arg2,(wxString const &)*arg3,(wxString const &)*arg4,arg5,arg6);
42289 wxPyEndAllowThreads(__tstate);
42290 if (PyErr_Occurred()) SWIG_fail;
42291 }
42292 {
42293 resultobj = wxPyMake_wxObject(result, (bool)SWIG_POINTER_NEW);
42294 }
42295 {
42296 if (temp3)
42297 delete arg3;
42298 }
42299 {
42300 if (temp4)
42301 delete arg4;
42302 }
42303 return resultobj;
42304 fail:
42305 {
42306 if (temp3)
42307 delete arg3;
42308 }
42309 {
42310 if (temp4)
42311 delete arg4;
42312 }
42313 return NULL;
42314 }
42315
42316
42317 SWIGINTERN PyObject *_wrap_delete_MenuItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42318 PyObject *resultobj = 0;
42319 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42320 void *argp1 = 0 ;
42321 int res1 = 0 ;
42322 PyObject *swig_obj[1] ;
42323
42324 if (!args) SWIG_fail;
42325 swig_obj[0] = args;
42326 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, SWIG_POINTER_DISOWN | 0 );
42327 if (!SWIG_IsOK(res1)) {
42328 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_MenuItem" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42329 }
42330 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42331 {
42332 PyThreadState* __tstate = wxPyBeginAllowThreads();
42333 delete arg1;
42334
42335 wxPyEndAllowThreads(__tstate);
42336 if (PyErr_Occurred()) SWIG_fail;
42337 }
42338 resultobj = SWIG_Py_Void();
42339 return resultobj;
42340 fail:
42341 return NULL;
42342 }
42343
42344
42345 SWIGINTERN PyObject *_wrap_MenuItem_GetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42346 PyObject *resultobj = 0;
42347 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42348 wxMenu *result = 0 ;
42349 void *argp1 = 0 ;
42350 int res1 = 0 ;
42351 PyObject *swig_obj[1] ;
42352
42353 if (!args) SWIG_fail;
42354 swig_obj[0] = args;
42355 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42356 if (!SWIG_IsOK(res1)) {
42357 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42358 }
42359 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42360 {
42361 PyThreadState* __tstate = wxPyBeginAllowThreads();
42362 result = (wxMenu *)((wxMenuItem const *)arg1)->GetMenu();
42363 wxPyEndAllowThreads(__tstate);
42364 if (PyErr_Occurred()) SWIG_fail;
42365 }
42366 {
42367 resultobj = wxPyMake_wxObject(result, 0);
42368 }
42369 return resultobj;
42370 fail:
42371 return NULL;
42372 }
42373
42374
42375 SWIGINTERN PyObject *_wrap_MenuItem_SetMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42376 PyObject *resultobj = 0;
42377 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42378 wxMenu *arg2 = (wxMenu *) 0 ;
42379 void *argp1 = 0 ;
42380 int res1 = 0 ;
42381 void *argp2 = 0 ;
42382 int res2 = 0 ;
42383 PyObject * obj0 = 0 ;
42384 PyObject * obj1 = 0 ;
42385 char * kwnames[] = {
42386 (char *) "self",(char *) "menu", NULL
42387 };
42388
42389 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42390 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42391 if (!SWIG_IsOK(res1)) {
42392 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42393 }
42394 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42395 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42396 if (!SWIG_IsOK(res2)) {
42397 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42398 }
42399 arg2 = reinterpret_cast< wxMenu * >(argp2);
42400 {
42401 PyThreadState* __tstate = wxPyBeginAllowThreads();
42402 (arg1)->SetMenu(arg2);
42403 wxPyEndAllowThreads(__tstate);
42404 if (PyErr_Occurred()) SWIG_fail;
42405 }
42406 resultobj = SWIG_Py_Void();
42407 return resultobj;
42408 fail:
42409 return NULL;
42410 }
42411
42412
42413 SWIGINTERN PyObject *_wrap_MenuItem_SetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42414 PyObject *resultobj = 0;
42415 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42416 int arg2 ;
42417 void *argp1 = 0 ;
42418 int res1 = 0 ;
42419 int val2 ;
42420 int ecode2 = 0 ;
42421 PyObject * obj0 = 0 ;
42422 PyObject * obj1 = 0 ;
42423 char * kwnames[] = {
42424 (char *) "self",(char *) "id", NULL
42425 };
42426
42427 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetId",kwnames,&obj0,&obj1)) SWIG_fail;
42428 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42429 if (!SWIG_IsOK(res1)) {
42430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetId" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42431 }
42432 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42433 ecode2 = SWIG_AsVal_int(obj1, &val2);
42434 if (!SWIG_IsOK(ecode2)) {
42435 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetId" "', expected argument " "2"" of type '" "int""'");
42436 }
42437 arg2 = static_cast< int >(val2);
42438 {
42439 PyThreadState* __tstate = wxPyBeginAllowThreads();
42440 (arg1)->SetId(arg2);
42441 wxPyEndAllowThreads(__tstate);
42442 if (PyErr_Occurred()) SWIG_fail;
42443 }
42444 resultobj = SWIG_Py_Void();
42445 return resultobj;
42446 fail:
42447 return NULL;
42448 }
42449
42450
42451 SWIGINTERN PyObject *_wrap_MenuItem_GetId(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42452 PyObject *resultobj = 0;
42453 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42454 int result;
42455 void *argp1 = 0 ;
42456 int res1 = 0 ;
42457 PyObject *swig_obj[1] ;
42458
42459 if (!args) SWIG_fail;
42460 swig_obj[0] = args;
42461 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42462 if (!SWIG_IsOK(res1)) {
42463 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetId" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42464 }
42465 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42466 {
42467 PyThreadState* __tstate = wxPyBeginAllowThreads();
42468 result = (int)((wxMenuItem const *)arg1)->GetId();
42469 wxPyEndAllowThreads(__tstate);
42470 if (PyErr_Occurred()) SWIG_fail;
42471 }
42472 resultobj = SWIG_From_int(static_cast< int >(result));
42473 return resultobj;
42474 fail:
42475 return NULL;
42476 }
42477
42478
42479 SWIGINTERN PyObject *_wrap_MenuItem_IsSeparator(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42480 PyObject *resultobj = 0;
42481 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42482 bool result;
42483 void *argp1 = 0 ;
42484 int res1 = 0 ;
42485 PyObject *swig_obj[1] ;
42486
42487 if (!args) SWIG_fail;
42488 swig_obj[0] = args;
42489 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42490 if (!SWIG_IsOK(res1)) {
42491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSeparator" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42492 }
42493 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42494 {
42495 PyThreadState* __tstate = wxPyBeginAllowThreads();
42496 result = (bool)((wxMenuItem const *)arg1)->IsSeparator();
42497 wxPyEndAllowThreads(__tstate);
42498 if (PyErr_Occurred()) SWIG_fail;
42499 }
42500 {
42501 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42502 }
42503 return resultobj;
42504 fail:
42505 return NULL;
42506 }
42507
42508
42509 SWIGINTERN PyObject *_wrap_MenuItem_SetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42510 PyObject *resultobj = 0;
42511 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42512 wxString *arg2 = 0 ;
42513 void *argp1 = 0 ;
42514 int res1 = 0 ;
42515 bool temp2 = false ;
42516 PyObject * obj0 = 0 ;
42517 PyObject * obj1 = 0 ;
42518 char * kwnames[] = {
42519 (char *) "self",(char *) "str", NULL
42520 };
42521
42522 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetText",kwnames,&obj0,&obj1)) SWIG_fail;
42523 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42524 if (!SWIG_IsOK(res1)) {
42525 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetText" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42526 }
42527 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42528 {
42529 arg2 = wxString_in_helper(obj1);
42530 if (arg2 == NULL) SWIG_fail;
42531 temp2 = true;
42532 }
42533 {
42534 PyThreadState* __tstate = wxPyBeginAllowThreads();
42535 (arg1)->SetText((wxString const &)*arg2);
42536 wxPyEndAllowThreads(__tstate);
42537 if (PyErr_Occurred()) SWIG_fail;
42538 }
42539 resultobj = SWIG_Py_Void();
42540 {
42541 if (temp2)
42542 delete arg2;
42543 }
42544 return resultobj;
42545 fail:
42546 {
42547 if (temp2)
42548 delete arg2;
42549 }
42550 return NULL;
42551 }
42552
42553
42554 SWIGINTERN PyObject *_wrap_MenuItem_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42555 PyObject *resultobj = 0;
42556 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42557 wxString result;
42558 void *argp1 = 0 ;
42559 int res1 = 0 ;
42560 PyObject *swig_obj[1] ;
42561
42562 if (!args) SWIG_fail;
42563 swig_obj[0] = args;
42564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42565 if (!SWIG_IsOK(res1)) {
42566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetLabel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42567 }
42568 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42569 {
42570 PyThreadState* __tstate = wxPyBeginAllowThreads();
42571 result = ((wxMenuItem const *)arg1)->GetLabel();
42572 wxPyEndAllowThreads(__tstate);
42573 if (PyErr_Occurred()) SWIG_fail;
42574 }
42575 {
42576 #if wxUSE_UNICODE
42577 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42578 #else
42579 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42580 #endif
42581 }
42582 return resultobj;
42583 fail:
42584 return NULL;
42585 }
42586
42587
42588 SWIGINTERN PyObject *_wrap_MenuItem_GetText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42589 PyObject *resultobj = 0;
42590 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42591 wxString *result = 0 ;
42592 void *argp1 = 0 ;
42593 int res1 = 0 ;
42594 PyObject *swig_obj[1] ;
42595
42596 if (!args) SWIG_fail;
42597 swig_obj[0] = args;
42598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42599 if (!SWIG_IsOK(res1)) {
42600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetText" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42601 }
42602 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42603 {
42604 PyThreadState* __tstate = wxPyBeginAllowThreads();
42605 {
42606 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetText();
42607 result = (wxString *) &_result_ref;
42608 }
42609 wxPyEndAllowThreads(__tstate);
42610 if (PyErr_Occurred()) SWIG_fail;
42611 }
42612 {
42613 #if wxUSE_UNICODE
42614 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
42615 #else
42616 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
42617 #endif
42618 }
42619 return resultobj;
42620 fail:
42621 return NULL;
42622 }
42623
42624
42625 SWIGINTERN PyObject *_wrap_MenuItem_GetLabelFromText(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42626 PyObject *resultobj = 0;
42627 wxString *arg1 = 0 ;
42628 wxString result;
42629 bool temp1 = false ;
42630 PyObject * obj0 = 0 ;
42631 char * kwnames[] = {
42632 (char *) "text", NULL
42633 };
42634
42635 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O:MenuItem_GetLabelFromText",kwnames,&obj0)) SWIG_fail;
42636 {
42637 arg1 = wxString_in_helper(obj0);
42638 if (arg1 == NULL) SWIG_fail;
42639 temp1 = true;
42640 }
42641 {
42642 PyThreadState* __tstate = wxPyBeginAllowThreads();
42643 result = wxMenuItem::GetLabelFromText((wxString const &)*arg1);
42644 wxPyEndAllowThreads(__tstate);
42645 if (PyErr_Occurred()) SWIG_fail;
42646 }
42647 {
42648 #if wxUSE_UNICODE
42649 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
42650 #else
42651 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
42652 #endif
42653 }
42654 {
42655 if (temp1)
42656 delete arg1;
42657 }
42658 return resultobj;
42659 fail:
42660 {
42661 if (temp1)
42662 delete arg1;
42663 }
42664 return NULL;
42665 }
42666
42667
42668 SWIGINTERN PyObject *_wrap_MenuItem_GetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42669 PyObject *resultobj = 0;
42670 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42671 wxItemKind result;
42672 void *argp1 = 0 ;
42673 int res1 = 0 ;
42674 PyObject *swig_obj[1] ;
42675
42676 if (!args) SWIG_fail;
42677 swig_obj[0] = args;
42678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42679 if (!SWIG_IsOK(res1)) {
42680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetKind" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42681 }
42682 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42683 {
42684 PyThreadState* __tstate = wxPyBeginAllowThreads();
42685 result = (wxItemKind)((wxMenuItem const *)arg1)->GetKind();
42686 wxPyEndAllowThreads(__tstate);
42687 if (PyErr_Occurred()) SWIG_fail;
42688 }
42689 resultobj = SWIG_From_int(static_cast< int >(result));
42690 return resultobj;
42691 fail:
42692 return NULL;
42693 }
42694
42695
42696 SWIGINTERN PyObject *_wrap_MenuItem_SetKind(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42697 PyObject *resultobj = 0;
42698 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42699 wxItemKind arg2 ;
42700 void *argp1 = 0 ;
42701 int res1 = 0 ;
42702 int val2 ;
42703 int ecode2 = 0 ;
42704 PyObject * obj0 = 0 ;
42705 PyObject * obj1 = 0 ;
42706 char * kwnames[] = {
42707 (char *) "self",(char *) "kind", NULL
42708 };
42709
42710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetKind",kwnames,&obj0,&obj1)) SWIG_fail;
42711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42712 if (!SWIG_IsOK(res1)) {
42713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetKind" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42714 }
42715 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42716 ecode2 = SWIG_AsVal_int(obj1, &val2);
42717 if (!SWIG_IsOK(ecode2)) {
42718 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetKind" "', expected argument " "2"" of type '" "wxItemKind""'");
42719 }
42720 arg2 = static_cast< wxItemKind >(val2);
42721 {
42722 PyThreadState* __tstate = wxPyBeginAllowThreads();
42723 (arg1)->SetKind(arg2);
42724 wxPyEndAllowThreads(__tstate);
42725 if (PyErr_Occurred()) SWIG_fail;
42726 }
42727 resultobj = SWIG_Py_Void();
42728 return resultobj;
42729 fail:
42730 return NULL;
42731 }
42732
42733
42734 SWIGINTERN PyObject *_wrap_MenuItem_SetCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42735 PyObject *resultobj = 0;
42736 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42737 bool arg2 ;
42738 void *argp1 = 0 ;
42739 int res1 = 0 ;
42740 bool val2 ;
42741 int ecode2 = 0 ;
42742 PyObject * obj0 = 0 ;
42743 PyObject * obj1 = 0 ;
42744 char * kwnames[] = {
42745 (char *) "self",(char *) "checkable", NULL
42746 };
42747
42748 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetCheckable",kwnames,&obj0,&obj1)) SWIG_fail;
42749 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42750 if (!SWIG_IsOK(res1)) {
42751 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetCheckable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42752 }
42753 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42754 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42755 if (!SWIG_IsOK(ecode2)) {
42756 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetCheckable" "', expected argument " "2"" of type '" "bool""'");
42757 }
42758 arg2 = static_cast< bool >(val2);
42759 {
42760 PyThreadState* __tstate = wxPyBeginAllowThreads();
42761 (arg1)->SetCheckable(arg2);
42762 wxPyEndAllowThreads(__tstate);
42763 if (PyErr_Occurred()) SWIG_fail;
42764 }
42765 resultobj = SWIG_Py_Void();
42766 return resultobj;
42767 fail:
42768 return NULL;
42769 }
42770
42771
42772 SWIGINTERN PyObject *_wrap_MenuItem_IsCheckable(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42773 PyObject *resultobj = 0;
42774 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42775 bool result;
42776 void *argp1 = 0 ;
42777 int res1 = 0 ;
42778 PyObject *swig_obj[1] ;
42779
42780 if (!args) SWIG_fail;
42781 swig_obj[0] = args;
42782 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42783 if (!SWIG_IsOK(res1)) {
42784 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsCheckable" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42785 }
42786 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42787 {
42788 PyThreadState* __tstate = wxPyBeginAllowThreads();
42789 result = (bool)((wxMenuItem const *)arg1)->IsCheckable();
42790 wxPyEndAllowThreads(__tstate);
42791 if (PyErr_Occurred()) SWIG_fail;
42792 }
42793 {
42794 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42795 }
42796 return resultobj;
42797 fail:
42798 return NULL;
42799 }
42800
42801
42802 SWIGINTERN PyObject *_wrap_MenuItem_IsSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42803 PyObject *resultobj = 0;
42804 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42805 bool result;
42806 void *argp1 = 0 ;
42807 int res1 = 0 ;
42808 PyObject *swig_obj[1] ;
42809
42810 if (!args) SWIG_fail;
42811 swig_obj[0] = args;
42812 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42813 if (!SWIG_IsOK(res1)) {
42814 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42815 }
42816 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42817 {
42818 PyThreadState* __tstate = wxPyBeginAllowThreads();
42819 result = (bool)((wxMenuItem const *)arg1)->IsSubMenu();
42820 wxPyEndAllowThreads(__tstate);
42821 if (PyErr_Occurred()) SWIG_fail;
42822 }
42823 {
42824 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42825 }
42826 return resultobj;
42827 fail:
42828 return NULL;
42829 }
42830
42831
42832 SWIGINTERN PyObject *_wrap_MenuItem_SetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42833 PyObject *resultobj = 0;
42834 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42835 wxMenu *arg2 = (wxMenu *) 0 ;
42836 void *argp1 = 0 ;
42837 int res1 = 0 ;
42838 void *argp2 = 0 ;
42839 int res2 = 0 ;
42840 PyObject * obj0 = 0 ;
42841 PyObject * obj1 = 0 ;
42842 char * kwnames[] = {
42843 (char *) "self",(char *) "menu", NULL
42844 };
42845
42846 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetSubMenu",kwnames,&obj0,&obj1)) SWIG_fail;
42847 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42848 if (!SWIG_IsOK(res1)) {
42849 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42850 }
42851 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42852 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxMenu, 0 | 0 );
42853 if (!SWIG_IsOK(res2)) {
42854 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetSubMenu" "', expected argument " "2"" of type '" "wxMenu *""'");
42855 }
42856 arg2 = reinterpret_cast< wxMenu * >(argp2);
42857 {
42858 PyThreadState* __tstate = wxPyBeginAllowThreads();
42859 (arg1)->SetSubMenu(arg2);
42860 wxPyEndAllowThreads(__tstate);
42861 if (PyErr_Occurred()) SWIG_fail;
42862 }
42863 resultobj = SWIG_Py_Void();
42864 return resultobj;
42865 fail:
42866 return NULL;
42867 }
42868
42869
42870 SWIGINTERN PyObject *_wrap_MenuItem_GetSubMenu(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42871 PyObject *resultobj = 0;
42872 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42873 wxMenu *result = 0 ;
42874 void *argp1 = 0 ;
42875 int res1 = 0 ;
42876 PyObject *swig_obj[1] ;
42877
42878 if (!args) SWIG_fail;
42879 swig_obj[0] = args;
42880 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42881 if (!SWIG_IsOK(res1)) {
42882 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetSubMenu" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42883 }
42884 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42885 {
42886 PyThreadState* __tstate = wxPyBeginAllowThreads();
42887 result = (wxMenu *)((wxMenuItem const *)arg1)->GetSubMenu();
42888 wxPyEndAllowThreads(__tstate);
42889 if (PyErr_Occurred()) SWIG_fail;
42890 }
42891 {
42892 resultobj = wxPyMake_wxObject(result, 0);
42893 }
42894 return resultobj;
42895 fail:
42896 return NULL;
42897 }
42898
42899
42900 SWIGINTERN PyObject *_wrap_MenuItem_Enable(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42901 PyObject *resultobj = 0;
42902 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42903 bool arg2 = (bool) true ;
42904 void *argp1 = 0 ;
42905 int res1 = 0 ;
42906 bool val2 ;
42907 int ecode2 = 0 ;
42908 PyObject * obj0 = 0 ;
42909 PyObject * obj1 = 0 ;
42910 char * kwnames[] = {
42911 (char *) "self",(char *) "enable", NULL
42912 };
42913
42914 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Enable",kwnames,&obj0,&obj1)) SWIG_fail;
42915 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42916 if (!SWIG_IsOK(res1)) {
42917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Enable" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42918 }
42919 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42920 if (obj1) {
42921 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42922 if (!SWIG_IsOK(ecode2)) {
42923 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Enable" "', expected argument " "2"" of type '" "bool""'");
42924 }
42925 arg2 = static_cast< bool >(val2);
42926 }
42927 {
42928 PyThreadState* __tstate = wxPyBeginAllowThreads();
42929 (arg1)->Enable(arg2);
42930 wxPyEndAllowThreads(__tstate);
42931 if (PyErr_Occurred()) SWIG_fail;
42932 }
42933 resultobj = SWIG_Py_Void();
42934 return resultobj;
42935 fail:
42936 return NULL;
42937 }
42938
42939
42940 SWIGINTERN PyObject *_wrap_MenuItem_IsEnabled(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
42941 PyObject *resultobj = 0;
42942 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42943 bool result;
42944 void *argp1 = 0 ;
42945 int res1 = 0 ;
42946 PyObject *swig_obj[1] ;
42947
42948 if (!args) SWIG_fail;
42949 swig_obj[0] = args;
42950 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42951 if (!SWIG_IsOK(res1)) {
42952 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsEnabled" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
42953 }
42954 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42955 {
42956 PyThreadState* __tstate = wxPyBeginAllowThreads();
42957 result = (bool)((wxMenuItem const *)arg1)->IsEnabled();
42958 wxPyEndAllowThreads(__tstate);
42959 if (PyErr_Occurred()) SWIG_fail;
42960 }
42961 {
42962 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
42963 }
42964 return resultobj;
42965 fail:
42966 return NULL;
42967 }
42968
42969
42970 SWIGINTERN PyObject *_wrap_MenuItem_Check(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
42971 PyObject *resultobj = 0;
42972 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
42973 bool arg2 = (bool) true ;
42974 void *argp1 = 0 ;
42975 int res1 = 0 ;
42976 bool val2 ;
42977 int ecode2 = 0 ;
42978 PyObject * obj0 = 0 ;
42979 PyObject * obj1 = 0 ;
42980 char * kwnames[] = {
42981 (char *) "self",(char *) "check", NULL
42982 };
42983
42984 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_Check",kwnames,&obj0,&obj1)) SWIG_fail;
42985 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
42986 if (!SWIG_IsOK(res1)) {
42987 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Check" "', expected argument " "1"" of type '" "wxMenuItem *""'");
42988 }
42989 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
42990 if (obj1) {
42991 ecode2 = SWIG_AsVal_bool(obj1, &val2);
42992 if (!SWIG_IsOK(ecode2)) {
42993 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_Check" "', expected argument " "2"" of type '" "bool""'");
42994 }
42995 arg2 = static_cast< bool >(val2);
42996 }
42997 {
42998 PyThreadState* __tstate = wxPyBeginAllowThreads();
42999 (arg1)->Check(arg2);
43000 wxPyEndAllowThreads(__tstate);
43001 if (PyErr_Occurred()) SWIG_fail;
43002 }
43003 resultobj = SWIG_Py_Void();
43004 return resultobj;
43005 fail:
43006 return NULL;
43007 }
43008
43009
43010 SWIGINTERN PyObject *_wrap_MenuItem_IsChecked(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43011 PyObject *resultobj = 0;
43012 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43013 bool result;
43014 void *argp1 = 0 ;
43015 int res1 = 0 ;
43016 PyObject *swig_obj[1] ;
43017
43018 if (!args) SWIG_fail;
43019 swig_obj[0] = args;
43020 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43021 if (!SWIG_IsOK(res1)) {
43022 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsChecked" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43023 }
43024 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43025 {
43026 PyThreadState* __tstate = wxPyBeginAllowThreads();
43027 result = (bool)((wxMenuItem const *)arg1)->IsChecked();
43028 wxPyEndAllowThreads(__tstate);
43029 if (PyErr_Occurred()) SWIG_fail;
43030 }
43031 {
43032 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43033 }
43034 return resultobj;
43035 fail:
43036 return NULL;
43037 }
43038
43039
43040 SWIGINTERN PyObject *_wrap_MenuItem_Toggle(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43041 PyObject *resultobj = 0;
43042 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43043 void *argp1 = 0 ;
43044 int res1 = 0 ;
43045 PyObject *swig_obj[1] ;
43046
43047 if (!args) SWIG_fail;
43048 swig_obj[0] = args;
43049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43050 if (!SWIG_IsOK(res1)) {
43051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_Toggle" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43052 }
43053 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43054 {
43055 PyThreadState* __tstate = wxPyBeginAllowThreads();
43056 (arg1)->Toggle();
43057 wxPyEndAllowThreads(__tstate);
43058 if (PyErr_Occurred()) SWIG_fail;
43059 }
43060 resultobj = SWIG_Py_Void();
43061 return resultobj;
43062 fail:
43063 return NULL;
43064 }
43065
43066
43067 SWIGINTERN PyObject *_wrap_MenuItem_SetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43068 PyObject *resultobj = 0;
43069 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43070 wxString *arg2 = 0 ;
43071 void *argp1 = 0 ;
43072 int res1 = 0 ;
43073 bool temp2 = false ;
43074 PyObject * obj0 = 0 ;
43075 PyObject * obj1 = 0 ;
43076 char * kwnames[] = {
43077 (char *) "self",(char *) "str", NULL
43078 };
43079
43080 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetHelp",kwnames,&obj0,&obj1)) SWIG_fail;
43081 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43082 if (!SWIG_IsOK(res1)) {
43083 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetHelp" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43084 }
43085 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43086 {
43087 arg2 = wxString_in_helper(obj1);
43088 if (arg2 == NULL) SWIG_fail;
43089 temp2 = true;
43090 }
43091 {
43092 PyThreadState* __tstate = wxPyBeginAllowThreads();
43093 (arg1)->SetHelp((wxString const &)*arg2);
43094 wxPyEndAllowThreads(__tstate);
43095 if (PyErr_Occurred()) SWIG_fail;
43096 }
43097 resultobj = SWIG_Py_Void();
43098 {
43099 if (temp2)
43100 delete arg2;
43101 }
43102 return resultobj;
43103 fail:
43104 {
43105 if (temp2)
43106 delete arg2;
43107 }
43108 return NULL;
43109 }
43110
43111
43112 SWIGINTERN PyObject *_wrap_MenuItem_GetHelp(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43113 PyObject *resultobj = 0;
43114 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43115 wxString *result = 0 ;
43116 void *argp1 = 0 ;
43117 int res1 = 0 ;
43118 PyObject *swig_obj[1] ;
43119
43120 if (!args) SWIG_fail;
43121 swig_obj[0] = args;
43122 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43123 if (!SWIG_IsOK(res1)) {
43124 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetHelp" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43125 }
43126 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43127 {
43128 PyThreadState* __tstate = wxPyBeginAllowThreads();
43129 {
43130 wxString const &_result_ref = ((wxMenuItem const *)arg1)->GetHelp();
43131 result = (wxString *) &_result_ref;
43132 }
43133 wxPyEndAllowThreads(__tstate);
43134 if (PyErr_Occurred()) SWIG_fail;
43135 }
43136 {
43137 #if wxUSE_UNICODE
43138 resultobj = PyUnicode_FromWideChar(result->c_str(), result->Len());
43139 #else
43140 resultobj = PyString_FromStringAndSize(result->c_str(), result->Len());
43141 #endif
43142 }
43143 return resultobj;
43144 fail:
43145 return NULL;
43146 }
43147
43148
43149 SWIGINTERN PyObject *_wrap_MenuItem_GetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43150 PyObject *resultobj = 0;
43151 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43152 wxAcceleratorEntry *result = 0 ;
43153 void *argp1 = 0 ;
43154 int res1 = 0 ;
43155 PyObject *swig_obj[1] ;
43156
43157 if (!args) SWIG_fail;
43158 swig_obj[0] = args;
43159 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43160 if (!SWIG_IsOK(res1)) {
43161 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetAccel" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43162 }
43163 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43164 {
43165 PyThreadState* __tstate = wxPyBeginAllowThreads();
43166 result = (wxAcceleratorEntry *)((wxMenuItem const *)arg1)->GetAccel();
43167 wxPyEndAllowThreads(__tstate);
43168 if (PyErr_Occurred()) SWIG_fail;
43169 }
43170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43171 return resultobj;
43172 fail:
43173 return NULL;
43174 }
43175
43176
43177 SWIGINTERN PyObject *_wrap_MenuItem_SetAccel(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43178 PyObject *resultobj = 0;
43179 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43180 wxAcceleratorEntry *arg2 = (wxAcceleratorEntry *) 0 ;
43181 void *argp1 = 0 ;
43182 int res1 = 0 ;
43183 void *argp2 = 0 ;
43184 int res2 = 0 ;
43185 PyObject * obj0 = 0 ;
43186 PyObject * obj1 = 0 ;
43187 char * kwnames[] = {
43188 (char *) "self",(char *) "accel", NULL
43189 };
43190
43191 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetAccel",kwnames,&obj0,&obj1)) SWIG_fail;
43192 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43193 if (!SWIG_IsOK(res1)) {
43194 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetAccel" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43195 }
43196 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43197 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxAcceleratorEntry, 0 | 0 );
43198 if (!SWIG_IsOK(res2)) {
43199 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetAccel" "', expected argument " "2"" of type '" "wxAcceleratorEntry *""'");
43200 }
43201 arg2 = reinterpret_cast< wxAcceleratorEntry * >(argp2);
43202 {
43203 PyThreadState* __tstate = wxPyBeginAllowThreads();
43204 (arg1)->SetAccel(arg2);
43205 wxPyEndAllowThreads(__tstate);
43206 if (PyErr_Occurred()) SWIG_fail;
43207 }
43208 resultobj = SWIG_Py_Void();
43209 return resultobj;
43210 fail:
43211 return NULL;
43212 }
43213
43214
43215 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43216 PyObject *resultobj = 0;
43217 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43218 wxBitmap *arg2 = 0 ;
43219 void *argp1 = 0 ;
43220 int res1 = 0 ;
43221 void *argp2 = 0 ;
43222 int res2 = 0 ;
43223 PyObject * obj0 = 0 ;
43224 PyObject * obj1 = 0 ;
43225 char * kwnames[] = {
43226 (char *) "self",(char *) "bitmap", NULL
43227 };
43228
43229 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43230 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43231 if (!SWIG_IsOK(res1)) {
43232 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43233 }
43234 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43235 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43236 if (!SWIG_IsOK(res2)) {
43237 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43238 }
43239 if (!argp2) {
43240 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43241 }
43242 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43243 {
43244 PyThreadState* __tstate = wxPyBeginAllowThreads();
43245 (arg1)->SetBitmap((wxBitmap const &)*arg2);
43246 wxPyEndAllowThreads(__tstate);
43247 if (PyErr_Occurred()) SWIG_fail;
43248 }
43249 resultobj = SWIG_Py_Void();
43250 return resultobj;
43251 fail:
43252 return NULL;
43253 }
43254
43255
43256 SWIGINTERN PyObject *_wrap_MenuItem_GetBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43257 PyObject *resultobj = 0;
43258 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43259 wxBitmap *result = 0 ;
43260 void *argp1 = 0 ;
43261 int res1 = 0 ;
43262 PyObject *swig_obj[1] ;
43263
43264 if (!args) SWIG_fail;
43265 swig_obj[0] = args;
43266 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43267 if (!SWIG_IsOK(res1)) {
43268 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43269 }
43270 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43271 {
43272 PyThreadState* __tstate = wxPyBeginAllowThreads();
43273 {
43274 wxBitmap const &_result_ref = (arg1)->GetBitmap();
43275 result = (wxBitmap *) &_result_ref;
43276 }
43277 wxPyEndAllowThreads(__tstate);
43278 if (PyErr_Occurred()) SWIG_fail;
43279 }
43280 {
43281 wxBitmap* resultptr = new wxBitmap(*result);
43282 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43283 }
43284 return resultobj;
43285 fail:
43286 return NULL;
43287 }
43288
43289
43290 SWIGINTERN PyObject *_wrap_MenuItem_SetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43291 PyObject *resultobj = 0;
43292 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43293 wxFont *arg2 = 0 ;
43294 void *argp1 = 0 ;
43295 int res1 = 0 ;
43296 void *argp2 = 0 ;
43297 int res2 = 0 ;
43298 PyObject * obj0 = 0 ;
43299 PyObject * obj1 = 0 ;
43300 char * kwnames[] = {
43301 (char *) "self",(char *) "font", NULL
43302 };
43303
43304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetFont",kwnames,&obj0,&obj1)) SWIG_fail;
43305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43306 if (!SWIG_IsOK(res1)) {
43307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43308 }
43309 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43310 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxFont, 0 | 0);
43311 if (!SWIG_IsOK(res2)) {
43312 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43313 }
43314 if (!argp2) {
43315 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetFont" "', expected argument " "2"" of type '" "wxFont const &""'");
43316 }
43317 arg2 = reinterpret_cast< wxFont * >(argp2);
43318 {
43319 PyThreadState* __tstate = wxPyBeginAllowThreads();
43320 wxMenuItem_SetFont(arg1,(wxFont const &)*arg2);
43321 wxPyEndAllowThreads(__tstate);
43322 if (PyErr_Occurred()) SWIG_fail;
43323 }
43324 resultobj = SWIG_Py_Void();
43325 return resultobj;
43326 fail:
43327 return NULL;
43328 }
43329
43330
43331 SWIGINTERN PyObject *_wrap_MenuItem_GetFont(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43332 PyObject *resultobj = 0;
43333 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43334 wxFont result;
43335 void *argp1 = 0 ;
43336 int res1 = 0 ;
43337 PyObject *swig_obj[1] ;
43338
43339 if (!args) SWIG_fail;
43340 swig_obj[0] = args;
43341 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43342 if (!SWIG_IsOK(res1)) {
43343 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetFont" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43344 }
43345 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43346 {
43347 PyThreadState* __tstate = wxPyBeginAllowThreads();
43348 result = wxMenuItem_GetFont(arg1);
43349 wxPyEndAllowThreads(__tstate);
43350 if (PyErr_Occurred()) SWIG_fail;
43351 }
43352 resultobj = SWIG_NewPointerObj((new wxFont(static_cast< const wxFont& >(result))), SWIGTYPE_p_wxFont, SWIG_POINTER_OWN | 0 );
43353 return resultobj;
43354 fail:
43355 return NULL;
43356 }
43357
43358
43359 SWIGINTERN PyObject *_wrap_MenuItem_SetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43360 PyObject *resultobj = 0;
43361 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43362 wxColour *arg2 = 0 ;
43363 void *argp1 = 0 ;
43364 int res1 = 0 ;
43365 wxColour temp2 ;
43366 PyObject * obj0 = 0 ;
43367 PyObject * obj1 = 0 ;
43368 char * kwnames[] = {
43369 (char *) "self",(char *) "colText", NULL
43370 };
43371
43372 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetTextColour",kwnames,&obj0,&obj1)) SWIG_fail;
43373 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43374 if (!SWIG_IsOK(res1)) {
43375 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43376 }
43377 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43378 {
43379 arg2 = &temp2;
43380 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43381 }
43382 {
43383 PyThreadState* __tstate = wxPyBeginAllowThreads();
43384 wxMenuItem_SetTextColour(arg1,(wxColour const &)*arg2);
43385 wxPyEndAllowThreads(__tstate);
43386 if (PyErr_Occurred()) SWIG_fail;
43387 }
43388 resultobj = SWIG_Py_Void();
43389 return resultobj;
43390 fail:
43391 return NULL;
43392 }
43393
43394
43395 SWIGINTERN PyObject *_wrap_MenuItem_GetTextColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43396 PyObject *resultobj = 0;
43397 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43398 wxColour result;
43399 void *argp1 = 0 ;
43400 int res1 = 0 ;
43401 PyObject *swig_obj[1] ;
43402
43403 if (!args) SWIG_fail;
43404 swig_obj[0] = args;
43405 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43406 if (!SWIG_IsOK(res1)) {
43407 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetTextColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43408 }
43409 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43410 {
43411 PyThreadState* __tstate = wxPyBeginAllowThreads();
43412 result = wxMenuItem_GetTextColour(arg1);
43413 wxPyEndAllowThreads(__tstate);
43414 if (PyErr_Occurred()) SWIG_fail;
43415 }
43416 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43417 return resultobj;
43418 fail:
43419 return NULL;
43420 }
43421
43422
43423 SWIGINTERN PyObject *_wrap_MenuItem_SetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43424 PyObject *resultobj = 0;
43425 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43426 wxColour *arg2 = 0 ;
43427 void *argp1 = 0 ;
43428 int res1 = 0 ;
43429 wxColour temp2 ;
43430 PyObject * obj0 = 0 ;
43431 PyObject * obj1 = 0 ;
43432 char * kwnames[] = {
43433 (char *) "self",(char *) "colBack", NULL
43434 };
43435
43436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetBackgroundColour",kwnames,&obj0,&obj1)) SWIG_fail;
43437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43438 if (!SWIG_IsOK(res1)) {
43439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43440 }
43441 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43442 {
43443 arg2 = &temp2;
43444 if ( ! wxColour_helper(obj1, &arg2)) SWIG_fail;
43445 }
43446 {
43447 PyThreadState* __tstate = wxPyBeginAllowThreads();
43448 wxMenuItem_SetBackgroundColour(arg1,(wxColour const &)*arg2);
43449 wxPyEndAllowThreads(__tstate);
43450 if (PyErr_Occurred()) SWIG_fail;
43451 }
43452 resultobj = SWIG_Py_Void();
43453 return resultobj;
43454 fail:
43455 return NULL;
43456 }
43457
43458
43459 SWIGINTERN PyObject *_wrap_MenuItem_GetBackgroundColour(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43460 PyObject *resultobj = 0;
43461 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43462 wxColour result;
43463 void *argp1 = 0 ;
43464 int res1 = 0 ;
43465 PyObject *swig_obj[1] ;
43466
43467 if (!args) SWIG_fail;
43468 swig_obj[0] = args;
43469 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43470 if (!SWIG_IsOK(res1)) {
43471 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetBackgroundColour" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43472 }
43473 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43474 {
43475 PyThreadState* __tstate = wxPyBeginAllowThreads();
43476 result = wxMenuItem_GetBackgroundColour(arg1);
43477 wxPyEndAllowThreads(__tstate);
43478 if (PyErr_Occurred()) SWIG_fail;
43479 }
43480 resultobj = SWIG_NewPointerObj((new wxColour(static_cast< const wxColour& >(result))), SWIGTYPE_p_wxColour, SWIG_POINTER_OWN | 0 );
43481 return resultobj;
43482 fail:
43483 return NULL;
43484 }
43485
43486
43487 SWIGINTERN PyObject *_wrap_MenuItem_SetBitmaps(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43488 PyObject *resultobj = 0;
43489 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43490 wxBitmap *arg2 = 0 ;
43491 wxBitmap const &arg3_defvalue = wxNullBitmap ;
43492 wxBitmap *arg3 = (wxBitmap *) &arg3_defvalue ;
43493 void *argp1 = 0 ;
43494 int res1 = 0 ;
43495 void *argp2 = 0 ;
43496 int res2 = 0 ;
43497 void *argp3 = 0 ;
43498 int res3 = 0 ;
43499 PyObject * obj0 = 0 ;
43500 PyObject * obj1 = 0 ;
43501 PyObject * obj2 = 0 ;
43502 char * kwnames[] = {
43503 (char *) "self",(char *) "bmpChecked",(char *) "bmpUnchecked", NULL
43504 };
43505
43506 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:MenuItem_SetBitmaps",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
43507 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43508 if (!SWIG_IsOK(res1)) {
43509 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetBitmaps" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43510 }
43511 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43512 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43513 if (!SWIG_IsOK(res2)) {
43514 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43515 }
43516 if (!argp2) {
43517 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43518 }
43519 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43520 if (obj2) {
43521 res3 = SWIG_ConvertPtr(obj2, &argp3, SWIGTYPE_p_wxBitmap, 0 | 0);
43522 if (!SWIG_IsOK(res3)) {
43523 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43524 }
43525 if (!argp3) {
43526 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetBitmaps" "', expected argument " "3"" of type '" "wxBitmap const &""'");
43527 }
43528 arg3 = reinterpret_cast< wxBitmap * >(argp3);
43529 }
43530 {
43531 PyThreadState* __tstate = wxPyBeginAllowThreads();
43532 wxMenuItem_SetBitmaps(arg1,(wxBitmap const &)*arg2,(wxBitmap const &)*arg3);
43533 wxPyEndAllowThreads(__tstate);
43534 if (PyErr_Occurred()) SWIG_fail;
43535 }
43536 resultobj = SWIG_Py_Void();
43537 return resultobj;
43538 fail:
43539 return NULL;
43540 }
43541
43542
43543 SWIGINTERN PyObject *_wrap_MenuItem_SetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43544 PyObject *resultobj = 0;
43545 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43546 wxBitmap *arg2 = 0 ;
43547 void *argp1 = 0 ;
43548 int res1 = 0 ;
43549 void *argp2 = 0 ;
43550 int res2 = 0 ;
43551 PyObject * obj0 = 0 ;
43552 PyObject * obj1 = 0 ;
43553 char * kwnames[] = {
43554 (char *) "self",(char *) "bmpDisabled", NULL
43555 };
43556
43557 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetDisabledBitmap",kwnames,&obj0,&obj1)) SWIG_fail;
43558 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43559 if (!SWIG_IsOK(res1)) {
43560 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43561 }
43562 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43563 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxBitmap, 0 | 0);
43564 if (!SWIG_IsOK(res2)) {
43565 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43566 }
43567 if (!argp2) {
43568 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "MenuItem_SetDisabledBitmap" "', expected argument " "2"" of type '" "wxBitmap const &""'");
43569 }
43570 arg2 = reinterpret_cast< wxBitmap * >(argp2);
43571 {
43572 PyThreadState* __tstate = wxPyBeginAllowThreads();
43573 wxMenuItem_SetDisabledBitmap(arg1,(wxBitmap const &)*arg2);
43574 wxPyEndAllowThreads(__tstate);
43575 if (PyErr_Occurred()) SWIG_fail;
43576 }
43577 resultobj = SWIG_Py_Void();
43578 return resultobj;
43579 fail:
43580 return NULL;
43581 }
43582
43583
43584 SWIGINTERN PyObject *_wrap_MenuItem_GetDisabledBitmap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43585 PyObject *resultobj = 0;
43586 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43587 wxBitmap *result = 0 ;
43588 void *argp1 = 0 ;
43589 int res1 = 0 ;
43590 PyObject *swig_obj[1] ;
43591
43592 if (!args) SWIG_fail;
43593 swig_obj[0] = args;
43594 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43595 if (!SWIG_IsOK(res1)) {
43596 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetDisabledBitmap" "', expected argument " "1"" of type '" "wxMenuItem const *""'");
43597 }
43598 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43599 {
43600 PyThreadState* __tstate = wxPyBeginAllowThreads();
43601 {
43602 wxBitmap const &_result_ref = wxMenuItem_GetDisabledBitmap((wxMenuItem const *)arg1);
43603 result = (wxBitmap *) &_result_ref;
43604 }
43605 wxPyEndAllowThreads(__tstate);
43606 if (PyErr_Occurred()) SWIG_fail;
43607 }
43608 {
43609 wxBitmap* resultptr = new wxBitmap(*result);
43610 resultobj = SWIG_NewPointerObj((void*)(resultptr), SWIGTYPE_p_wxBitmap, 1);
43611 }
43612 return resultobj;
43613 fail:
43614 return NULL;
43615 }
43616
43617
43618 SWIGINTERN PyObject *_wrap_MenuItem_SetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43619 PyObject *resultobj = 0;
43620 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43621 int arg2 ;
43622 void *argp1 = 0 ;
43623 int res1 = 0 ;
43624 int val2 ;
43625 int ecode2 = 0 ;
43626 PyObject * obj0 = 0 ;
43627 PyObject * obj1 = 0 ;
43628 char * kwnames[] = {
43629 (char *) "self",(char *) "nWidth", NULL
43630 };
43631
43632 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:MenuItem_SetMarginWidth",kwnames,&obj0,&obj1)) SWIG_fail;
43633 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43634 if (!SWIG_IsOK(res1)) {
43635 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43636 }
43637 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43638 ecode2 = SWIG_AsVal_int(obj1, &val2);
43639 if (!SWIG_IsOK(ecode2)) {
43640 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetMarginWidth" "', expected argument " "2"" of type '" "int""'");
43641 }
43642 arg2 = static_cast< int >(val2);
43643 {
43644 PyThreadState* __tstate = wxPyBeginAllowThreads();
43645 wxMenuItem_SetMarginWidth(arg1,arg2);
43646 wxPyEndAllowThreads(__tstate);
43647 if (PyErr_Occurred()) SWIG_fail;
43648 }
43649 resultobj = SWIG_Py_Void();
43650 return resultobj;
43651 fail:
43652 return NULL;
43653 }
43654
43655
43656 SWIGINTERN PyObject *_wrap_MenuItem_GetMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43657 PyObject *resultobj = 0;
43658 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43659 int result;
43660 void *argp1 = 0 ;
43661 int res1 = 0 ;
43662 PyObject *swig_obj[1] ;
43663
43664 if (!args) SWIG_fail;
43665 swig_obj[0] = args;
43666 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43667 if (!SWIG_IsOK(res1)) {
43668 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_GetMarginWidth" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43669 }
43670 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43671 {
43672 PyThreadState* __tstate = wxPyBeginAllowThreads();
43673 result = (int)wxMenuItem_GetMarginWidth(arg1);
43674 wxPyEndAllowThreads(__tstate);
43675 if (PyErr_Occurred()) SWIG_fail;
43676 }
43677 resultobj = SWIG_From_int(static_cast< int >(result));
43678 return resultobj;
43679 fail:
43680 return NULL;
43681 }
43682
43683
43684 SWIGINTERN PyObject *_wrap_MenuItem_GetDefaultMarginWidth(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43685 PyObject *resultobj = 0;
43686 int result;
43687
43688 if (!SWIG_Python_UnpackTuple(args,"MenuItem_GetDefaultMarginWidth",0,0,0)) SWIG_fail;
43689 {
43690 PyThreadState* __tstate = wxPyBeginAllowThreads();
43691 result = (int)wxMenuItem_GetDefaultMarginWidth();
43692 wxPyEndAllowThreads(__tstate);
43693 if (PyErr_Occurred()) SWIG_fail;
43694 }
43695 resultobj = SWIG_From_int(static_cast< int >(result));
43696 return resultobj;
43697 fail:
43698 return NULL;
43699 }
43700
43701
43702 SWIGINTERN PyObject *_wrap_MenuItem_IsOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43703 PyObject *resultobj = 0;
43704 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43705 bool result;
43706 void *argp1 = 0 ;
43707 int res1 = 0 ;
43708 PyObject *swig_obj[1] ;
43709
43710 if (!args) SWIG_fail;
43711 swig_obj[0] = args;
43712 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43713 if (!SWIG_IsOK(res1)) {
43714 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_IsOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43715 }
43716 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43717 {
43718 PyThreadState* __tstate = wxPyBeginAllowThreads();
43719 result = (bool)wxMenuItem_IsOwnerDrawn(arg1);
43720 wxPyEndAllowThreads(__tstate);
43721 if (PyErr_Occurred()) SWIG_fail;
43722 }
43723 {
43724 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
43725 }
43726 return resultobj;
43727 fail:
43728 return NULL;
43729 }
43730
43731
43732 SWIGINTERN PyObject *_wrap_MenuItem_SetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43733 PyObject *resultobj = 0;
43734 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43735 bool arg2 = (bool) true ;
43736 void *argp1 = 0 ;
43737 int res1 = 0 ;
43738 bool val2 ;
43739 int ecode2 = 0 ;
43740 PyObject * obj0 = 0 ;
43741 PyObject * obj1 = 0 ;
43742 char * kwnames[] = {
43743 (char *) "self",(char *) "ownerDrawn", NULL
43744 };
43745
43746 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:MenuItem_SetOwnerDrawn",kwnames,&obj0,&obj1)) SWIG_fail;
43747 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43748 if (!SWIG_IsOK(res1)) {
43749 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43750 }
43751 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43752 if (obj1) {
43753 ecode2 = SWIG_AsVal_bool(obj1, &val2);
43754 if (!SWIG_IsOK(ecode2)) {
43755 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "MenuItem_SetOwnerDrawn" "', expected argument " "2"" of type '" "bool""'");
43756 }
43757 arg2 = static_cast< bool >(val2);
43758 }
43759 {
43760 PyThreadState* __tstate = wxPyBeginAllowThreads();
43761 wxMenuItem_SetOwnerDrawn(arg1,arg2);
43762 wxPyEndAllowThreads(__tstate);
43763 if (PyErr_Occurred()) SWIG_fail;
43764 }
43765 resultobj = SWIG_Py_Void();
43766 return resultobj;
43767 fail:
43768 return NULL;
43769 }
43770
43771
43772 SWIGINTERN PyObject *_wrap_MenuItem_ResetOwnerDrawn(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43773 PyObject *resultobj = 0;
43774 wxMenuItem *arg1 = (wxMenuItem *) 0 ;
43775 void *argp1 = 0 ;
43776 int res1 = 0 ;
43777 PyObject *swig_obj[1] ;
43778
43779 if (!args) SWIG_fail;
43780 swig_obj[0] = args;
43781 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxMenuItem, 0 | 0 );
43782 if (!SWIG_IsOK(res1)) {
43783 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "MenuItem_ResetOwnerDrawn" "', expected argument " "1"" of type '" "wxMenuItem *""'");
43784 }
43785 arg1 = reinterpret_cast< wxMenuItem * >(argp1);
43786 {
43787 PyThreadState* __tstate = wxPyBeginAllowThreads();
43788 wxMenuItem_ResetOwnerDrawn(arg1);
43789 wxPyEndAllowThreads(__tstate);
43790 if (PyErr_Occurred()) SWIG_fail;
43791 }
43792 resultobj = SWIG_Py_Void();
43793 return resultobj;
43794 fail:
43795 return NULL;
43796 }
43797
43798
43799 SWIGINTERN PyObject *MenuItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43800 PyObject *obj;
43801 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
43802 SWIG_TypeNewClientData(SWIGTYPE_p_wxMenuItem, SWIG_NewClientData(obj));
43803 return SWIG_Py_Void();
43804 }
43805
43806 SWIGINTERN PyObject *MenuItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43807 return SWIG_Python_InitShadowInstance(args);
43808 }
43809
43810 SWIGINTERN int ControlNameStr_set(PyObject *) {
43811 SWIG_Error(SWIG_AttributeError,"Variable ControlNameStr is read-only.");
43812 return 1;
43813 }
43814
43815
43816 SWIGINTERN PyObject *ControlNameStr_get(void) {
43817 PyObject *pyobj = 0;
43818
43819 {
43820 #if wxUSE_UNICODE
43821 pyobj = PyUnicode_FromWideChar((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43822 #else
43823 pyobj = PyString_FromStringAndSize((&wxPyControlNameStr)->c_str(), (&wxPyControlNameStr)->Len());
43824 #endif
43825 }
43826 return pyobj;
43827 }
43828
43829
43830 SWIGINTERN PyObject *_wrap_new_Control(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43831 PyObject *resultobj = 0;
43832 wxWindow *arg1 = (wxWindow *) 0 ;
43833 int arg2 = (int) -1 ;
43834 wxPoint const &arg3_defvalue = wxDefaultPosition ;
43835 wxPoint *arg3 = (wxPoint *) &arg3_defvalue ;
43836 wxSize const &arg4_defvalue = wxDefaultSize ;
43837 wxSize *arg4 = (wxSize *) &arg4_defvalue ;
43838 long arg5 = (long) 0 ;
43839 wxValidator const &arg6_defvalue = wxDefaultValidator ;
43840 wxValidator *arg6 = (wxValidator *) &arg6_defvalue ;
43841 wxString const &arg7_defvalue = wxPyControlNameStr ;
43842 wxString *arg7 = (wxString *) &arg7_defvalue ;
43843 wxControl *result = 0 ;
43844 void *argp1 = 0 ;
43845 int res1 = 0 ;
43846 int val2 ;
43847 int ecode2 = 0 ;
43848 wxPoint temp3 ;
43849 wxSize temp4 ;
43850 long val5 ;
43851 int ecode5 = 0 ;
43852 void *argp6 = 0 ;
43853 int res6 = 0 ;
43854 bool temp7 = false ;
43855 PyObject * obj0 = 0 ;
43856 PyObject * obj1 = 0 ;
43857 PyObject * obj2 = 0 ;
43858 PyObject * obj3 = 0 ;
43859 PyObject * obj4 = 0 ;
43860 PyObject * obj5 = 0 ;
43861 PyObject * obj6 = 0 ;
43862 char * kwnames[] = {
43863 (char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43864 };
43865
43866 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OOOOOO:new_Control",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
43867 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
43868 if (!SWIG_IsOK(res1)) {
43869 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_Control" "', expected argument " "1"" of type '" "wxWindow *""'");
43870 }
43871 arg1 = reinterpret_cast< wxWindow * >(argp1);
43872 if (obj1) {
43873 ecode2 = SWIG_AsVal_int(obj1, &val2);
43874 if (!SWIG_IsOK(ecode2)) {
43875 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_Control" "', expected argument " "2"" of type '" "int""'");
43876 }
43877 arg2 = static_cast< int >(val2);
43878 }
43879 if (obj2) {
43880 {
43881 arg3 = &temp3;
43882 if ( ! wxPoint_helper(obj2, &arg3)) SWIG_fail;
43883 }
43884 }
43885 if (obj3) {
43886 {
43887 arg4 = &temp4;
43888 if ( ! wxSize_helper(obj3, &arg4)) SWIG_fail;
43889 }
43890 }
43891 if (obj4) {
43892 ecode5 = SWIG_AsVal_long(obj4, &val5);
43893 if (!SWIG_IsOK(ecode5)) {
43894 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_Control" "', expected argument " "5"" of type '" "long""'");
43895 }
43896 arg5 = static_cast< long >(val5);
43897 }
43898 if (obj5) {
43899 res6 = SWIG_ConvertPtr(obj5, &argp6, SWIGTYPE_p_wxValidator, 0 | 0);
43900 if (!SWIG_IsOK(res6)) {
43901 SWIG_exception_fail(SWIG_ArgError(res6), "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43902 }
43903 if (!argp6) {
43904 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "new_Control" "', expected argument " "6"" of type '" "wxValidator const &""'");
43905 }
43906 arg6 = reinterpret_cast< wxValidator * >(argp6);
43907 }
43908 if (obj6) {
43909 {
43910 arg7 = wxString_in_helper(obj6);
43911 if (arg7 == NULL) SWIG_fail;
43912 temp7 = true;
43913 }
43914 }
43915 {
43916 if (!wxPyCheckForApp()) SWIG_fail;
43917 PyThreadState* __tstate = wxPyBeginAllowThreads();
43918 result = (wxControl *)new wxControl(arg1,arg2,(wxPoint const &)*arg3,(wxSize const &)*arg4,arg5,(wxValidator const &)*arg6,(wxString const &)*arg7);
43919 wxPyEndAllowThreads(__tstate);
43920 if (PyErr_Occurred()) SWIG_fail;
43921 }
43922 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_NEW | 0 );
43923 {
43924 if (temp7)
43925 delete arg7;
43926 }
43927 return resultobj;
43928 fail:
43929 {
43930 if (temp7)
43931 delete arg7;
43932 }
43933 return NULL;
43934 }
43935
43936
43937 SWIGINTERN PyObject *_wrap_new_PreControl(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
43938 PyObject *resultobj = 0;
43939 wxControl *result = 0 ;
43940
43941 if (!SWIG_Python_UnpackTuple(args,"new_PreControl",0,0,0)) SWIG_fail;
43942 {
43943 if (!wxPyCheckForApp()) SWIG_fail;
43944 PyThreadState* __tstate = wxPyBeginAllowThreads();
43945 result = (wxControl *)new wxControl();
43946 wxPyEndAllowThreads(__tstate);
43947 if (PyErr_Occurred()) SWIG_fail;
43948 }
43949 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxControl, SWIG_POINTER_OWN | 0 );
43950 return resultobj;
43951 fail:
43952 return NULL;
43953 }
43954
43955
43956 SWIGINTERN PyObject *_wrap_Control_Create(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
43957 PyObject *resultobj = 0;
43958 wxControl *arg1 = (wxControl *) 0 ;
43959 wxWindow *arg2 = (wxWindow *) 0 ;
43960 int arg3 = (int) -1 ;
43961 wxPoint const &arg4_defvalue = wxDefaultPosition ;
43962 wxPoint *arg4 = (wxPoint *) &arg4_defvalue ;
43963 wxSize const &arg5_defvalue = wxDefaultSize ;
43964 wxSize *arg5 = (wxSize *) &arg5_defvalue ;
43965 long arg6 = (long) 0 ;
43966 wxValidator const &arg7_defvalue = wxDefaultValidator ;
43967 wxValidator *arg7 = (wxValidator *) &arg7_defvalue ;
43968 wxString const &arg8_defvalue = wxPyControlNameStr ;
43969 wxString *arg8 = (wxString *) &arg8_defvalue ;
43970 bool result;
43971 void *argp1 = 0 ;
43972 int res1 = 0 ;
43973 void *argp2 = 0 ;
43974 int res2 = 0 ;
43975 int val3 ;
43976 int ecode3 = 0 ;
43977 wxPoint temp4 ;
43978 wxSize temp5 ;
43979 long val6 ;
43980 int ecode6 = 0 ;
43981 void *argp7 = 0 ;
43982 int res7 = 0 ;
43983 bool temp8 = false ;
43984 PyObject * obj0 = 0 ;
43985 PyObject * obj1 = 0 ;
43986 PyObject * obj2 = 0 ;
43987 PyObject * obj3 = 0 ;
43988 PyObject * obj4 = 0 ;
43989 PyObject * obj5 = 0 ;
43990 PyObject * obj6 = 0 ;
43991 PyObject * obj7 = 0 ;
43992 char * kwnames[] = {
43993 (char *) "self",(char *) "parent",(char *) "id",(char *) "pos",(char *) "size",(char *) "style",(char *) "validator",(char *) "name", NULL
43994 };
43995
43996 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOOOO:Control_Create",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6,&obj7)) SWIG_fail;
43997 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
43998 if (!SWIG_IsOK(res1)) {
43999 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Create" "', expected argument " "1"" of type '" "wxControl *""'");
44000 }
44001 arg1 = reinterpret_cast< wxControl * >(argp1);
44002 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
44003 if (!SWIG_IsOK(res2)) {
44004 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Create" "', expected argument " "2"" of type '" "wxWindow *""'");
44005 }
44006 arg2 = reinterpret_cast< wxWindow * >(argp2);
44007 if (obj2) {
44008 ecode3 = SWIG_AsVal_int(obj2, &val3);
44009 if (!SWIG_IsOK(ecode3)) {
44010 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Control_Create" "', expected argument " "3"" of type '" "int""'");
44011 }
44012 arg3 = static_cast< int >(val3);
44013 }
44014 if (obj3) {
44015 {
44016 arg4 = &temp4;
44017 if ( ! wxPoint_helper(obj3, &arg4)) SWIG_fail;
44018 }
44019 }
44020 if (obj4) {
44021 {
44022 arg5 = &temp5;
44023 if ( ! wxSize_helper(obj4, &arg5)) SWIG_fail;
44024 }
44025 }
44026 if (obj5) {
44027 ecode6 = SWIG_AsVal_long(obj5, &val6);
44028 if (!SWIG_IsOK(ecode6)) {
44029 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Control_Create" "', expected argument " "6"" of type '" "long""'");
44030 }
44031 arg6 = static_cast< long >(val6);
44032 }
44033 if (obj6) {
44034 res7 = SWIG_ConvertPtr(obj6, &argp7, SWIGTYPE_p_wxValidator, 0 | 0);
44035 if (!SWIG_IsOK(res7)) {
44036 SWIG_exception_fail(SWIG_ArgError(res7), "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44037 }
44038 if (!argp7) {
44039 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Create" "', expected argument " "7"" of type '" "wxValidator const &""'");
44040 }
44041 arg7 = reinterpret_cast< wxValidator * >(argp7);
44042 }
44043 if (obj7) {
44044 {
44045 arg8 = wxString_in_helper(obj7);
44046 if (arg8 == NULL) SWIG_fail;
44047 temp8 = true;
44048 }
44049 }
44050 {
44051 PyThreadState* __tstate = wxPyBeginAllowThreads();
44052 result = (bool)(arg1)->Create(arg2,arg3,(wxPoint const &)*arg4,(wxSize const &)*arg5,arg6,(wxValidator const &)*arg7,(wxString const &)*arg8);
44053 wxPyEndAllowThreads(__tstate);
44054 if (PyErr_Occurred()) SWIG_fail;
44055 }
44056 {
44057 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44058 }
44059 {
44060 if (temp8)
44061 delete arg8;
44062 }
44063 return resultobj;
44064 fail:
44065 {
44066 if (temp8)
44067 delete arg8;
44068 }
44069 return NULL;
44070 }
44071
44072
44073 SWIGINTERN PyObject *_wrap_Control_GetAlignment(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44074 PyObject *resultobj = 0;
44075 wxControl *arg1 = (wxControl *) 0 ;
44076 int result;
44077 void *argp1 = 0 ;
44078 int res1 = 0 ;
44079 PyObject *swig_obj[1] ;
44080
44081 if (!args) SWIG_fail;
44082 swig_obj[0] = args;
44083 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44084 if (!SWIG_IsOK(res1)) {
44085 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetAlignment" "', expected argument " "1"" of type '" "wxControl const *""'");
44086 }
44087 arg1 = reinterpret_cast< wxControl * >(argp1);
44088 {
44089 PyThreadState* __tstate = wxPyBeginAllowThreads();
44090 result = (int)((wxControl const *)arg1)->GetAlignment();
44091 wxPyEndAllowThreads(__tstate);
44092 if (PyErr_Occurred()) SWIG_fail;
44093 }
44094 resultobj = SWIG_From_int(static_cast< int >(result));
44095 return resultobj;
44096 fail:
44097 return NULL;
44098 }
44099
44100
44101 SWIGINTERN PyObject *_wrap_Control_GetLabelText(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44102 PyObject *resultobj = 0;
44103 wxControl *arg1 = (wxControl *) 0 ;
44104 wxString result;
44105 void *argp1 = 0 ;
44106 int res1 = 0 ;
44107 PyObject *swig_obj[1] ;
44108
44109 if (!args) SWIG_fail;
44110 swig_obj[0] = args;
44111 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44112 if (!SWIG_IsOK(res1)) {
44113 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabelText" "', expected argument " "1"" of type '" "wxControl const *""'");
44114 }
44115 arg1 = reinterpret_cast< wxControl * >(argp1);
44116 {
44117 PyThreadState* __tstate = wxPyBeginAllowThreads();
44118 result = ((wxControl const *)arg1)->GetLabelText();
44119 wxPyEndAllowThreads(__tstate);
44120 if (PyErr_Occurred()) SWIG_fail;
44121 }
44122 {
44123 #if wxUSE_UNICODE
44124 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44125 #else
44126 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44127 #endif
44128 }
44129 return resultobj;
44130 fail:
44131 return NULL;
44132 }
44133
44134
44135 SWIGINTERN PyObject *_wrap_Control_Command(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44136 PyObject *resultobj = 0;
44137 wxControl *arg1 = (wxControl *) 0 ;
44138 wxCommandEvent *arg2 = 0 ;
44139 void *argp1 = 0 ;
44140 int res1 = 0 ;
44141 void *argp2 = 0 ;
44142 int res2 = 0 ;
44143 PyObject * obj0 = 0 ;
44144 PyObject * obj1 = 0 ;
44145 char * kwnames[] = {
44146 (char *) "self",(char *) "event", NULL
44147 };
44148
44149 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Control_Command",kwnames,&obj0,&obj1)) SWIG_fail;
44150 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44151 if (!SWIG_IsOK(res1)) {
44152 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_Command" "', expected argument " "1"" of type '" "wxControl *""'");
44153 }
44154 arg1 = reinterpret_cast< wxControl * >(argp1);
44155 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxCommandEvent, 0 );
44156 if (!SWIG_IsOK(res2)) {
44157 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44158 }
44159 if (!argp2) {
44160 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "Control_Command" "', expected argument " "2"" of type '" "wxCommandEvent &""'");
44161 }
44162 arg2 = reinterpret_cast< wxCommandEvent * >(argp2);
44163 {
44164 PyThreadState* __tstate = wxPyBeginAllowThreads();
44165 (arg1)->Command(*arg2);
44166 wxPyEndAllowThreads(__tstate);
44167 if (PyErr_Occurred()) SWIG_fail;
44168 }
44169 resultobj = SWIG_Py_Void();
44170 return resultobj;
44171 fail:
44172 return NULL;
44173 }
44174
44175
44176 SWIGINTERN PyObject *_wrap_Control_GetLabel(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44177 PyObject *resultobj = 0;
44178 wxControl *arg1 = (wxControl *) 0 ;
44179 wxString result;
44180 void *argp1 = 0 ;
44181 int res1 = 0 ;
44182 PyObject *swig_obj[1] ;
44183
44184 if (!args) SWIG_fail;
44185 swig_obj[0] = args;
44186 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxControl, 0 | 0 );
44187 if (!SWIG_IsOK(res1)) {
44188 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Control_GetLabel" "', expected argument " "1"" of type '" "wxControl *""'");
44189 }
44190 arg1 = reinterpret_cast< wxControl * >(argp1);
44191 {
44192 PyThreadState* __tstate = wxPyBeginAllowThreads();
44193 result = (arg1)->GetLabel();
44194 wxPyEndAllowThreads(__tstate);
44195 if (PyErr_Occurred()) SWIG_fail;
44196 }
44197 {
44198 #if wxUSE_UNICODE
44199 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44200 #else
44201 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44202 #endif
44203 }
44204 return resultobj;
44205 fail:
44206 return NULL;
44207 }
44208
44209
44210 SWIGINTERN PyObject *_wrap_Control_GetClassDefaultAttributes(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44211 PyObject *resultobj = 0;
44212 wxWindowVariant arg1 = (wxWindowVariant) wxWINDOW_VARIANT_NORMAL ;
44213 SwigValueWrapper<wxVisualAttributes > result;
44214 int val1 ;
44215 int ecode1 = 0 ;
44216 PyObject * obj0 = 0 ;
44217 char * kwnames[] = {
44218 (char *) "variant", NULL
44219 };
44220
44221 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:Control_GetClassDefaultAttributes",kwnames,&obj0)) SWIG_fail;
44222 if (obj0) {
44223 ecode1 = SWIG_AsVal_int(obj0, &val1);
44224 if (!SWIG_IsOK(ecode1)) {
44225 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "Control_GetClassDefaultAttributes" "', expected argument " "1"" of type '" "wxWindowVariant""'");
44226 }
44227 arg1 = static_cast< wxWindowVariant >(val1);
44228 }
44229 {
44230 if (!wxPyCheckForApp()) SWIG_fail;
44231 PyThreadState* __tstate = wxPyBeginAllowThreads();
44232 result = wxControl::GetClassDefaultAttributes(arg1);
44233 wxPyEndAllowThreads(__tstate);
44234 if (PyErr_Occurred()) SWIG_fail;
44235 }
44236 resultobj = SWIG_NewPointerObj((new wxVisualAttributes(static_cast< const wxVisualAttributes& >(result))), SWIGTYPE_p_wxVisualAttributes, SWIG_POINTER_OWN | 0 );
44237 return resultobj;
44238 fail:
44239 return NULL;
44240 }
44241
44242
44243 SWIGINTERN PyObject *Control_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44244 PyObject *obj;
44245 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44246 SWIG_TypeNewClientData(SWIGTYPE_p_wxControl, SWIG_NewClientData(obj));
44247 return SWIG_Py_Void();
44248 }
44249
44250 SWIGINTERN PyObject *Control_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44251 return SWIG_Python_InitShadowInstance(args);
44252 }
44253
44254 SWIGINTERN PyObject *_wrap_ItemContainer_Append(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44255 PyObject *resultobj = 0;
44256 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44257 wxString *arg2 = 0 ;
44258 PyObject *arg3 = (PyObject *) NULL ;
44259 int result;
44260 void *argp1 = 0 ;
44261 int res1 = 0 ;
44262 bool temp2 = false ;
44263 PyObject * obj0 = 0 ;
44264 PyObject * obj1 = 0 ;
44265 PyObject * obj2 = 0 ;
44266 char * kwnames[] = {
44267 (char *) "self",(char *) "item",(char *) "clientData", NULL
44268 };
44269
44270 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:ItemContainer_Append",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44271 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44272 if (!SWIG_IsOK(res1)) {
44273 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Append" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44274 }
44275 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44276 {
44277 arg2 = wxString_in_helper(obj1);
44278 if (arg2 == NULL) SWIG_fail;
44279 temp2 = true;
44280 }
44281 if (obj2) {
44282 arg3 = obj2;
44283 }
44284 {
44285 PyThreadState* __tstate = wxPyBeginAllowThreads();
44286 result = (int)wxItemContainer_Append(arg1,(wxString const &)*arg2,arg3);
44287 wxPyEndAllowThreads(__tstate);
44288 if (PyErr_Occurred()) SWIG_fail;
44289 }
44290 resultobj = SWIG_From_int(static_cast< int >(result));
44291 {
44292 if (temp2)
44293 delete arg2;
44294 }
44295 return resultobj;
44296 fail:
44297 {
44298 if (temp2)
44299 delete arg2;
44300 }
44301 return NULL;
44302 }
44303
44304
44305 SWIGINTERN PyObject *_wrap_ItemContainer_AppendItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44306 PyObject *resultobj = 0;
44307 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44308 wxArrayString *arg2 = 0 ;
44309 void *argp1 = 0 ;
44310 int res1 = 0 ;
44311 bool temp2 = false ;
44312 PyObject * obj0 = 0 ;
44313 PyObject * obj1 = 0 ;
44314 char * kwnames[] = {
44315 (char *) "self",(char *) "strings", NULL
44316 };
44317
44318 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_AppendItems",kwnames,&obj0,&obj1)) SWIG_fail;
44319 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44320 if (!SWIG_IsOK(res1)) {
44321 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_AppendItems" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44322 }
44323 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44324 {
44325 if (! PySequence_Check(obj1)) {
44326 PyErr_SetString(PyExc_TypeError, "Sequence of strings expected.");
44327 SWIG_fail;
44328 }
44329 arg2 = new wxArrayString;
44330 temp2 = true;
44331 int i, len=PySequence_Length(obj1);
44332 for (i=0; i<len; i++) {
44333 PyObject* item = PySequence_GetItem(obj1, i);
44334 wxString* s = wxString_in_helper(item);
44335 if (PyErr_Occurred()) SWIG_fail;
44336 arg2->Add(*s);
44337 delete s;
44338 Py_DECREF(item);
44339 }
44340 }
44341 {
44342 PyThreadState* __tstate = wxPyBeginAllowThreads();
44343 (arg1)->Append((wxArrayString const &)*arg2);
44344 wxPyEndAllowThreads(__tstate);
44345 if (PyErr_Occurred()) SWIG_fail;
44346 }
44347 resultobj = SWIG_Py_Void();
44348 {
44349 if (temp2) delete arg2;
44350 }
44351 return resultobj;
44352 fail:
44353 {
44354 if (temp2) delete arg2;
44355 }
44356 return NULL;
44357 }
44358
44359
44360 SWIGINTERN PyObject *_wrap_ItemContainer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44361 PyObject *resultobj = 0;
44362 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44363 wxString *arg2 = 0 ;
44364 unsigned int arg3 ;
44365 PyObject *arg4 = (PyObject *) NULL ;
44366 int result;
44367 void *argp1 = 0 ;
44368 int res1 = 0 ;
44369 bool temp2 = false ;
44370 unsigned int val3 ;
44371 int ecode3 = 0 ;
44372 PyObject * obj0 = 0 ;
44373 PyObject * obj1 = 0 ;
44374 PyObject * obj2 = 0 ;
44375 PyObject * obj3 = 0 ;
44376 char * kwnames[] = {
44377 (char *) "self",(char *) "item",(char *) "pos",(char *) "clientData", NULL
44378 };
44379
44380 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:ItemContainer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
44381 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44382 if (!SWIG_IsOK(res1)) {
44383 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Insert" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44384 }
44385 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44386 {
44387 arg2 = wxString_in_helper(obj1);
44388 if (arg2 == NULL) SWIG_fail;
44389 temp2 = true;
44390 }
44391 ecode3 = SWIG_AsVal_unsigned_SS_int(obj2, &val3);
44392 if (!SWIG_IsOK(ecode3)) {
44393 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "ItemContainer_Insert" "', expected argument " "3"" of type '" "unsigned int""'");
44394 }
44395 arg3 = static_cast< unsigned int >(val3);
44396 if (obj3) {
44397 arg4 = obj3;
44398 }
44399 {
44400 PyThreadState* __tstate = wxPyBeginAllowThreads();
44401 result = (int)wxItemContainer_Insert(arg1,(wxString const &)*arg2,arg3,arg4);
44402 wxPyEndAllowThreads(__tstate);
44403 if (PyErr_Occurred()) SWIG_fail;
44404 }
44405 resultobj = SWIG_From_int(static_cast< int >(result));
44406 {
44407 if (temp2)
44408 delete arg2;
44409 }
44410 return resultobj;
44411 fail:
44412 {
44413 if (temp2)
44414 delete arg2;
44415 }
44416 return NULL;
44417 }
44418
44419
44420 SWIGINTERN PyObject *_wrap_ItemContainer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44421 PyObject *resultobj = 0;
44422 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44423 void *argp1 = 0 ;
44424 int res1 = 0 ;
44425 PyObject *swig_obj[1] ;
44426
44427 if (!args) SWIG_fail;
44428 swig_obj[0] = args;
44429 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44430 if (!SWIG_IsOK(res1)) {
44431 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Clear" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44432 }
44433 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44434 {
44435 PyThreadState* __tstate = wxPyBeginAllowThreads();
44436 (arg1)->Clear();
44437 wxPyEndAllowThreads(__tstate);
44438 if (PyErr_Occurred()) SWIG_fail;
44439 }
44440 resultobj = SWIG_Py_Void();
44441 return resultobj;
44442 fail:
44443 return NULL;
44444 }
44445
44446
44447 SWIGINTERN PyObject *_wrap_ItemContainer_Delete(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44448 PyObject *resultobj = 0;
44449 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44450 unsigned int arg2 ;
44451 void *argp1 = 0 ;
44452 int res1 = 0 ;
44453 unsigned int val2 ;
44454 int ecode2 = 0 ;
44455 PyObject * obj0 = 0 ;
44456 PyObject * obj1 = 0 ;
44457 char * kwnames[] = {
44458 (char *) "self",(char *) "n", NULL
44459 };
44460
44461 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Delete",kwnames,&obj0,&obj1)) SWIG_fail;
44462 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44463 if (!SWIG_IsOK(res1)) {
44464 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Delete" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44465 }
44466 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44467 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44468 if (!SWIG_IsOK(ecode2)) {
44469 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Delete" "', expected argument " "2"" of type '" "unsigned int""'");
44470 }
44471 arg2 = static_cast< unsigned int >(val2);
44472 {
44473 PyThreadState* __tstate = wxPyBeginAllowThreads();
44474 (arg1)->Delete(arg2);
44475 wxPyEndAllowThreads(__tstate);
44476 if (PyErr_Occurred()) SWIG_fail;
44477 }
44478 resultobj = SWIG_Py_Void();
44479 return resultobj;
44480 fail:
44481 return NULL;
44482 }
44483
44484
44485 SWIGINTERN PyObject *_wrap_ItemContainer_GetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44486 PyObject *resultobj = 0;
44487 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44488 unsigned int arg2 ;
44489 PyObject *result = 0 ;
44490 void *argp1 = 0 ;
44491 int res1 = 0 ;
44492 unsigned int val2 ;
44493 int ecode2 = 0 ;
44494 PyObject * obj0 = 0 ;
44495 PyObject * obj1 = 0 ;
44496 char * kwnames[] = {
44497 (char *) "self",(char *) "n", NULL
44498 };
44499
44500 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetClientData",kwnames,&obj0,&obj1)) SWIG_fail;
44501 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44502 if (!SWIG_IsOK(res1)) {
44503 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44504 }
44505 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44506 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44507 if (!SWIG_IsOK(ecode2)) {
44508 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44509 }
44510 arg2 = static_cast< unsigned int >(val2);
44511 {
44512 PyThreadState* __tstate = wxPyBeginAllowThreads();
44513 result = (PyObject *)wxItemContainer_GetClientData(arg1,arg2);
44514 wxPyEndAllowThreads(__tstate);
44515 if (PyErr_Occurred()) SWIG_fail;
44516 }
44517 resultobj = result;
44518 return resultobj;
44519 fail:
44520 return NULL;
44521 }
44522
44523
44524 SWIGINTERN PyObject *_wrap_ItemContainer_SetClientData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44525 PyObject *resultobj = 0;
44526 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44527 unsigned int arg2 ;
44528 PyObject *arg3 = (PyObject *) 0 ;
44529 void *argp1 = 0 ;
44530 int res1 = 0 ;
44531 unsigned int val2 ;
44532 int ecode2 = 0 ;
44533 PyObject * obj0 = 0 ;
44534 PyObject * obj1 = 0 ;
44535 PyObject * obj2 = 0 ;
44536 char * kwnames[] = {
44537 (char *) "self",(char *) "n",(char *) "clientData", NULL
44538 };
44539
44540 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetClientData",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44541 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44542 if (!SWIG_IsOK(res1)) {
44543 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetClientData" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44544 }
44545 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44546 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44547 if (!SWIG_IsOK(ecode2)) {
44548 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetClientData" "', expected argument " "2"" of type '" "unsigned int""'");
44549 }
44550 arg2 = static_cast< unsigned int >(val2);
44551 arg3 = obj2;
44552 {
44553 PyThreadState* __tstate = wxPyBeginAllowThreads();
44554 wxItemContainer_SetClientData(arg1,arg2,arg3);
44555 wxPyEndAllowThreads(__tstate);
44556 if (PyErr_Occurred()) SWIG_fail;
44557 }
44558 resultobj = SWIG_Py_Void();
44559 return resultobj;
44560 fail:
44561 return NULL;
44562 }
44563
44564
44565 SWIGINTERN PyObject *_wrap_ItemContainer_GetCount(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44566 PyObject *resultobj = 0;
44567 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44568 unsigned int result;
44569 void *argp1 = 0 ;
44570 int res1 = 0 ;
44571 PyObject *swig_obj[1] ;
44572
44573 if (!args) SWIG_fail;
44574 swig_obj[0] = args;
44575 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44576 if (!SWIG_IsOK(res1)) {
44577 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetCount" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44578 }
44579 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44580 {
44581 PyThreadState* __tstate = wxPyBeginAllowThreads();
44582 result = (unsigned int)((wxItemContainer const *)arg1)->GetCount();
44583 wxPyEndAllowThreads(__tstate);
44584 if (PyErr_Occurred()) SWIG_fail;
44585 }
44586 resultobj = SWIG_From_unsigned_SS_int(static_cast< unsigned int >(result));
44587 return resultobj;
44588 fail:
44589 return NULL;
44590 }
44591
44592
44593 SWIGINTERN PyObject *_wrap_ItemContainer_IsEmpty(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44594 PyObject *resultobj = 0;
44595 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44596 bool result;
44597 void *argp1 = 0 ;
44598 int res1 = 0 ;
44599 PyObject *swig_obj[1] ;
44600
44601 if (!args) SWIG_fail;
44602 swig_obj[0] = args;
44603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44604 if (!SWIG_IsOK(res1)) {
44605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_IsEmpty" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44606 }
44607 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44608 {
44609 PyThreadState* __tstate = wxPyBeginAllowThreads();
44610 result = (bool)((wxItemContainer const *)arg1)->IsEmpty();
44611 wxPyEndAllowThreads(__tstate);
44612 if (PyErr_Occurred()) SWIG_fail;
44613 }
44614 {
44615 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44616 }
44617 return resultobj;
44618 fail:
44619 return NULL;
44620 }
44621
44622
44623 SWIGINTERN PyObject *_wrap_ItemContainer_GetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44624 PyObject *resultobj = 0;
44625 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44626 unsigned int arg2 ;
44627 wxString result;
44628 void *argp1 = 0 ;
44629 int res1 = 0 ;
44630 unsigned int val2 ;
44631 int ecode2 = 0 ;
44632 PyObject * obj0 = 0 ;
44633 PyObject * obj1 = 0 ;
44634 char * kwnames[] = {
44635 (char *) "self",(char *) "n", NULL
44636 };
44637
44638 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_GetString",kwnames,&obj0,&obj1)) SWIG_fail;
44639 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44640 if (!SWIG_IsOK(res1)) {
44641 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44642 }
44643 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44644 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44645 if (!SWIG_IsOK(ecode2)) {
44646 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_GetString" "', expected argument " "2"" of type '" "unsigned int""'");
44647 }
44648 arg2 = static_cast< unsigned int >(val2);
44649 {
44650 PyThreadState* __tstate = wxPyBeginAllowThreads();
44651 result = ((wxItemContainer const *)arg1)->GetString(arg2);
44652 wxPyEndAllowThreads(__tstate);
44653 if (PyErr_Occurred()) SWIG_fail;
44654 }
44655 {
44656 #if wxUSE_UNICODE
44657 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44658 #else
44659 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44660 #endif
44661 }
44662 return resultobj;
44663 fail:
44664 return NULL;
44665 }
44666
44667
44668 SWIGINTERN PyObject *_wrap_ItemContainer_GetStrings(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44669 PyObject *resultobj = 0;
44670 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44671 wxArrayString result;
44672 void *argp1 = 0 ;
44673 int res1 = 0 ;
44674 PyObject *swig_obj[1] ;
44675
44676 if (!args) SWIG_fail;
44677 swig_obj[0] = args;
44678 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44679 if (!SWIG_IsOK(res1)) {
44680 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStrings" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44681 }
44682 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44683 {
44684 PyThreadState* __tstate = wxPyBeginAllowThreads();
44685 result = ((wxItemContainer const *)arg1)->GetStrings();
44686 wxPyEndAllowThreads(__tstate);
44687 if (PyErr_Occurred()) SWIG_fail;
44688 }
44689 {
44690 resultobj = wxArrayString2PyList_helper(result);
44691 }
44692 return resultobj;
44693 fail:
44694 return NULL;
44695 }
44696
44697
44698 SWIGINTERN PyObject *_wrap_ItemContainer_SetString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44699 PyObject *resultobj = 0;
44700 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44701 unsigned int arg2 ;
44702 wxString *arg3 = 0 ;
44703 void *argp1 = 0 ;
44704 int res1 = 0 ;
44705 unsigned int val2 ;
44706 int ecode2 = 0 ;
44707 bool temp3 = false ;
44708 PyObject * obj0 = 0 ;
44709 PyObject * obj1 = 0 ;
44710 PyObject * obj2 = 0 ;
44711 char * kwnames[] = {
44712 (char *) "self",(char *) "n",(char *) "s", NULL
44713 };
44714
44715 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:ItemContainer_SetString",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
44716 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44717 if (!SWIG_IsOK(res1)) {
44718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetString" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44719 }
44720 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44721 ecode2 = SWIG_AsVal_unsigned_SS_int(obj1, &val2);
44722 if (!SWIG_IsOK(ecode2)) {
44723 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetString" "', expected argument " "2"" of type '" "unsigned int""'");
44724 }
44725 arg2 = static_cast< unsigned int >(val2);
44726 {
44727 arg3 = wxString_in_helper(obj2);
44728 if (arg3 == NULL) SWIG_fail;
44729 temp3 = true;
44730 }
44731 {
44732 PyThreadState* __tstate = wxPyBeginAllowThreads();
44733 (arg1)->SetString(arg2,(wxString const &)*arg3);
44734 wxPyEndAllowThreads(__tstate);
44735 if (PyErr_Occurred()) SWIG_fail;
44736 }
44737 resultobj = SWIG_Py_Void();
44738 {
44739 if (temp3)
44740 delete arg3;
44741 }
44742 return resultobj;
44743 fail:
44744 {
44745 if (temp3)
44746 delete arg3;
44747 }
44748 return NULL;
44749 }
44750
44751
44752 SWIGINTERN PyObject *_wrap_ItemContainer_FindString(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44753 PyObject *resultobj = 0;
44754 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44755 wxString *arg2 = 0 ;
44756 int result;
44757 void *argp1 = 0 ;
44758 int res1 = 0 ;
44759 bool temp2 = false ;
44760 PyObject * obj0 = 0 ;
44761 PyObject * obj1 = 0 ;
44762 char * kwnames[] = {
44763 (char *) "self",(char *) "s", NULL
44764 };
44765
44766 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_FindString",kwnames,&obj0,&obj1)) SWIG_fail;
44767 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44768 if (!SWIG_IsOK(res1)) {
44769 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_FindString" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44770 }
44771 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44772 {
44773 arg2 = wxString_in_helper(obj1);
44774 if (arg2 == NULL) SWIG_fail;
44775 temp2 = true;
44776 }
44777 {
44778 PyThreadState* __tstate = wxPyBeginAllowThreads();
44779 result = (int)((wxItemContainer const *)arg1)->FindString((wxString const &)*arg2);
44780 wxPyEndAllowThreads(__tstate);
44781 if (PyErr_Occurred()) SWIG_fail;
44782 }
44783 resultobj = SWIG_From_int(static_cast< int >(result));
44784 {
44785 if (temp2)
44786 delete arg2;
44787 }
44788 return resultobj;
44789 fail:
44790 {
44791 if (temp2)
44792 delete arg2;
44793 }
44794 return NULL;
44795 }
44796
44797
44798 SWIGINTERN PyObject *_wrap_ItemContainer_SetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44799 PyObject *resultobj = 0;
44800 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44801 int arg2 ;
44802 void *argp1 = 0 ;
44803 int res1 = 0 ;
44804 int val2 ;
44805 int ecode2 = 0 ;
44806 PyObject * obj0 = 0 ;
44807 PyObject * obj1 = 0 ;
44808 char * kwnames[] = {
44809 (char *) "self",(char *) "n", NULL
44810 };
44811
44812 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44813 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44814 if (!SWIG_IsOK(res1)) {
44815 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44816 }
44817 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44818 ecode2 = SWIG_AsVal_int(obj1, &val2);
44819 if (!SWIG_IsOK(ecode2)) {
44820 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_SetSelection" "', expected argument " "2"" of type '" "int""'");
44821 }
44822 arg2 = static_cast< int >(val2);
44823 {
44824 PyThreadState* __tstate = wxPyBeginAllowThreads();
44825 (arg1)->SetSelection(arg2);
44826 wxPyEndAllowThreads(__tstate);
44827 if (PyErr_Occurred()) SWIG_fail;
44828 }
44829 resultobj = SWIG_Py_Void();
44830 return resultobj;
44831 fail:
44832 return NULL;
44833 }
44834
44835
44836 SWIGINTERN PyObject *_wrap_ItemContainer_GetSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44837 PyObject *resultobj = 0;
44838 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44839 int result;
44840 void *argp1 = 0 ;
44841 int res1 = 0 ;
44842 PyObject *swig_obj[1] ;
44843
44844 if (!args) SWIG_fail;
44845 swig_obj[0] = args;
44846 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44847 if (!SWIG_IsOK(res1)) {
44848 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44849 }
44850 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44851 {
44852 PyThreadState* __tstate = wxPyBeginAllowThreads();
44853 result = (int)((wxItemContainer const *)arg1)->GetSelection();
44854 wxPyEndAllowThreads(__tstate);
44855 if (PyErr_Occurred()) SWIG_fail;
44856 }
44857 resultobj = SWIG_From_int(static_cast< int >(result));
44858 return resultobj;
44859 fail:
44860 return NULL;
44861 }
44862
44863
44864 SWIGINTERN PyObject *_wrap_ItemContainer_SetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44865 PyObject *resultobj = 0;
44866 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44867 wxString *arg2 = 0 ;
44868 bool result;
44869 void *argp1 = 0 ;
44870 int res1 = 0 ;
44871 bool temp2 = false ;
44872 PyObject * obj0 = 0 ;
44873 PyObject * obj1 = 0 ;
44874 char * kwnames[] = {
44875 (char *) "self",(char *) "s", NULL
44876 };
44877
44878 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_SetStringSelection",kwnames,&obj0,&obj1)) SWIG_fail;
44879 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44880 if (!SWIG_IsOK(res1)) {
44881 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_SetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44882 }
44883 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44884 {
44885 arg2 = wxString_in_helper(obj1);
44886 if (arg2 == NULL) SWIG_fail;
44887 temp2 = true;
44888 }
44889 {
44890 PyThreadState* __tstate = wxPyBeginAllowThreads();
44891 result = (bool)(arg1)->SetStringSelection((wxString const &)*arg2);
44892 wxPyEndAllowThreads(__tstate);
44893 if (PyErr_Occurred()) SWIG_fail;
44894 }
44895 {
44896 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
44897 }
44898 {
44899 if (temp2)
44900 delete arg2;
44901 }
44902 return resultobj;
44903 fail:
44904 {
44905 if (temp2)
44906 delete arg2;
44907 }
44908 return NULL;
44909 }
44910
44911
44912 SWIGINTERN PyObject *_wrap_ItemContainer_GetStringSelection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44913 PyObject *resultobj = 0;
44914 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44915 wxString result;
44916 void *argp1 = 0 ;
44917 int res1 = 0 ;
44918 PyObject *swig_obj[1] ;
44919
44920 if (!args) SWIG_fail;
44921 swig_obj[0] = args;
44922 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44923 if (!SWIG_IsOK(res1)) {
44924 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_GetStringSelection" "', expected argument " "1"" of type '" "wxItemContainer const *""'");
44925 }
44926 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44927 {
44928 PyThreadState* __tstate = wxPyBeginAllowThreads();
44929 result = ((wxItemContainer const *)arg1)->GetStringSelection();
44930 wxPyEndAllowThreads(__tstate);
44931 if (PyErr_Occurred()) SWIG_fail;
44932 }
44933 {
44934 #if wxUSE_UNICODE
44935 resultobj = PyUnicode_FromWideChar((&result)->c_str(), (&result)->Len());
44936 #else
44937 resultobj = PyString_FromStringAndSize((&result)->c_str(), (&result)->Len());
44938 #endif
44939 }
44940 return resultobj;
44941 fail:
44942 return NULL;
44943 }
44944
44945
44946 SWIGINTERN PyObject *_wrap_ItemContainer_Select(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
44947 PyObject *resultobj = 0;
44948 wxItemContainer *arg1 = (wxItemContainer *) 0 ;
44949 int arg2 ;
44950 void *argp1 = 0 ;
44951 int res1 = 0 ;
44952 int val2 ;
44953 int ecode2 = 0 ;
44954 PyObject * obj0 = 0 ;
44955 PyObject * obj1 = 0 ;
44956 char * kwnames[] = {
44957 (char *) "self",(char *) "n", NULL
44958 };
44959
44960 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:ItemContainer_Select",kwnames,&obj0,&obj1)) SWIG_fail;
44961 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxItemContainer, 0 | 0 );
44962 if (!SWIG_IsOK(res1)) {
44963 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "ItemContainer_Select" "', expected argument " "1"" of type '" "wxItemContainer *""'");
44964 }
44965 arg1 = reinterpret_cast< wxItemContainer * >(argp1);
44966 ecode2 = SWIG_AsVal_int(obj1, &val2);
44967 if (!SWIG_IsOK(ecode2)) {
44968 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "ItemContainer_Select" "', expected argument " "2"" of type '" "int""'");
44969 }
44970 arg2 = static_cast< int >(val2);
44971 {
44972 PyThreadState* __tstate = wxPyBeginAllowThreads();
44973 (arg1)->Select(arg2);
44974 wxPyEndAllowThreads(__tstate);
44975 if (PyErr_Occurred()) SWIG_fail;
44976 }
44977 resultobj = SWIG_Py_Void();
44978 return resultobj;
44979 fail:
44980 return NULL;
44981 }
44982
44983
44984 SWIGINTERN PyObject *ItemContainer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44985 PyObject *obj;
44986 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44987 SWIG_TypeNewClientData(SWIGTYPE_p_wxItemContainer, SWIG_NewClientData(obj));
44988 return SWIG_Py_Void();
44989 }
44990
44991 SWIGINTERN PyObject *ControlWithItems_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44992 PyObject *obj;
44993 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
44994 SWIG_TypeNewClientData(SWIGTYPE_p_wxControlWithItems, SWIG_NewClientData(obj));
44995 return SWIG_Py_Void();
44996 }
44997
44998 SWIGINTERN PyObject *_wrap_new_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
44999 PyObject *resultobj = 0;
45000 wxSizerItem *result = 0 ;
45001
45002 if (!SWIG_Python_UnpackTuple(args,"new_SizerItem",0,0,0)) SWIG_fail;
45003 {
45004 PyThreadState* __tstate = wxPyBeginAllowThreads();
45005 result = (wxSizerItem *)new wxSizerItem();
45006 wxPyEndAllowThreads(__tstate);
45007 if (PyErr_Occurred()) SWIG_fail;
45008 }
45009 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_NEW | 0 );
45010 return resultobj;
45011 fail:
45012 return NULL;
45013 }
45014
45015
45016 SWIGINTERN PyObject *_wrap_delete_SizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45017 PyObject *resultobj = 0;
45018 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45019 void *argp1 = 0 ;
45020 int res1 = 0 ;
45021 PyObject *swig_obj[1] ;
45022
45023 if (!args) SWIG_fail;
45024 swig_obj[0] = args;
45025 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
45026 if (!SWIG_IsOK(res1)) {
45027 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_SizerItem" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45028 }
45029 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45030 {
45031 PyThreadState* __tstate = wxPyBeginAllowThreads();
45032 delete arg1;
45033
45034 wxPyEndAllowThreads(__tstate);
45035 if (PyErr_Occurred()) SWIG_fail;
45036 }
45037 resultobj = SWIG_Py_Void();
45038 return resultobj;
45039 fail:
45040 return NULL;
45041 }
45042
45043
45044 SWIGINTERN PyObject *_wrap_new_SizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45045 PyObject *resultobj = 0;
45046 wxWindow *arg1 = (wxWindow *) 0 ;
45047 int arg2 ;
45048 int arg3 ;
45049 int arg4 ;
45050 PyObject *arg5 = (PyObject *) NULL ;
45051 wxSizerItem *result = 0 ;
45052 void *argp1 = 0 ;
45053 int res1 = 0 ;
45054 int val2 ;
45055 int ecode2 = 0 ;
45056 int val3 ;
45057 int ecode3 = 0 ;
45058 int val4 ;
45059 int ecode4 = 0 ;
45060 PyObject * obj0 = 0 ;
45061 PyObject * obj1 = 0 ;
45062 PyObject * obj2 = 0 ;
45063 PyObject * obj3 = 0 ;
45064 PyObject * obj4 = 0 ;
45065 char * kwnames[] = {
45066 (char *) "window",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45067 };
45068
45069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
45071 if (!SWIG_IsOK(res1)) {
45072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
45073 }
45074 arg1 = reinterpret_cast< wxWindow * >(argp1);
45075 ecode2 = SWIG_AsVal_int(obj1, &val2);
45076 if (!SWIG_IsOK(ecode2)) {
45077 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemWindow" "', expected argument " "2"" of type '" "int""'");
45078 }
45079 arg2 = static_cast< int >(val2);
45080 ecode3 = SWIG_AsVal_int(obj2, &val3);
45081 if (!SWIG_IsOK(ecode3)) {
45082 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemWindow" "', expected argument " "3"" of type '" "int""'");
45083 }
45084 arg3 = static_cast< int >(val3);
45085 ecode4 = SWIG_AsVal_int(obj3, &val4);
45086 if (!SWIG_IsOK(ecode4)) {
45087 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemWindow" "', expected argument " "4"" of type '" "int""'");
45088 }
45089 arg4 = static_cast< int >(val4);
45090 if (obj4) {
45091 arg5 = obj4;
45092 }
45093 {
45094 PyThreadState* __tstate = wxPyBeginAllowThreads();
45095 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45096 wxPyEndAllowThreads(__tstate);
45097 if (PyErr_Occurred()) SWIG_fail;
45098 }
45099 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45100 return resultobj;
45101 fail:
45102 return NULL;
45103 }
45104
45105
45106 SWIGINTERN PyObject *_wrap_new_SizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45107 PyObject *resultobj = 0;
45108 int arg1 ;
45109 int arg2 ;
45110 int arg3 ;
45111 int arg4 ;
45112 int arg5 ;
45113 PyObject *arg6 = (PyObject *) NULL ;
45114 wxSizerItem *result = 0 ;
45115 int val1 ;
45116 int ecode1 = 0 ;
45117 int val2 ;
45118 int ecode2 = 0 ;
45119 int val3 ;
45120 int ecode3 = 0 ;
45121 int val4 ;
45122 int ecode4 = 0 ;
45123 int val5 ;
45124 int ecode5 = 0 ;
45125 PyObject * obj0 = 0 ;
45126 PyObject * obj1 = 0 ;
45127 PyObject * obj2 = 0 ;
45128 PyObject * obj3 = 0 ;
45129 PyObject * obj4 = 0 ;
45130 PyObject * obj5 = 0 ;
45131 char * kwnames[] = {
45132 (char *) "width",(char *) "height",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45133 };
45134
45135 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_SizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
45136 ecode1 = SWIG_AsVal_int(obj0, &val1);
45137 if (!SWIG_IsOK(ecode1)) {
45138 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_SizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
45139 }
45140 arg1 = static_cast< int >(val1);
45141 ecode2 = SWIG_AsVal_int(obj1, &val2);
45142 if (!SWIG_IsOK(ecode2)) {
45143 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
45144 }
45145 arg2 = static_cast< int >(val2);
45146 ecode3 = SWIG_AsVal_int(obj2, &val3);
45147 if (!SWIG_IsOK(ecode3)) {
45148 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSpacer" "', expected argument " "3"" of type '" "int""'");
45149 }
45150 arg3 = static_cast< int >(val3);
45151 ecode4 = SWIG_AsVal_int(obj3, &val4);
45152 if (!SWIG_IsOK(ecode4)) {
45153 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSpacer" "', expected argument " "4"" of type '" "int""'");
45154 }
45155 arg4 = static_cast< int >(val4);
45156 ecode5 = SWIG_AsVal_int(obj4, &val5);
45157 if (!SWIG_IsOK(ecode5)) {
45158 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_SizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
45159 }
45160 arg5 = static_cast< int >(val5);
45161 if (obj5) {
45162 arg6 = obj5;
45163 }
45164 {
45165 PyThreadState* __tstate = wxPyBeginAllowThreads();
45166 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5,arg6);
45167 wxPyEndAllowThreads(__tstate);
45168 if (PyErr_Occurred()) SWIG_fail;
45169 }
45170 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45171 return resultobj;
45172 fail:
45173 return NULL;
45174 }
45175
45176
45177 SWIGINTERN PyObject *_wrap_new_SizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45178 PyObject *resultobj = 0;
45179 wxSizer *arg1 = (wxSizer *) 0 ;
45180 int arg2 ;
45181 int arg3 ;
45182 int arg4 ;
45183 PyObject *arg5 = (PyObject *) NULL ;
45184 wxSizerItem *result = 0 ;
45185 int res1 = 0 ;
45186 int val2 ;
45187 int ecode2 = 0 ;
45188 int val3 ;
45189 int ecode3 = 0 ;
45190 int val4 ;
45191 int ecode4 = 0 ;
45192 PyObject * obj0 = 0 ;
45193 PyObject * obj1 = 0 ;
45194 PyObject * obj2 = 0 ;
45195 PyObject * obj3 = 0 ;
45196 PyObject * obj4 = 0 ;
45197 char * kwnames[] = {
45198 (char *) "sizer",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
45199 };
45200
45201 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|O:new_SizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
45202 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
45203 if (!SWIG_IsOK(res1)) {
45204 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_SizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
45205 }
45206 ecode2 = SWIG_AsVal_int(obj1, &val2);
45207 if (!SWIG_IsOK(ecode2)) {
45208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_SizerItemSizer" "', expected argument " "2"" of type '" "int""'");
45209 }
45210 arg2 = static_cast< int >(val2);
45211 ecode3 = SWIG_AsVal_int(obj2, &val3);
45212 if (!SWIG_IsOK(ecode3)) {
45213 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_SizerItemSizer" "', expected argument " "3"" of type '" "int""'");
45214 }
45215 arg3 = static_cast< int >(val3);
45216 ecode4 = SWIG_AsVal_int(obj3, &val4);
45217 if (!SWIG_IsOK(ecode4)) {
45218 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_SizerItemSizer" "', expected argument " "4"" of type '" "int""'");
45219 }
45220 arg4 = static_cast< int >(val4);
45221 if (obj4) {
45222 arg5 = obj4;
45223 }
45224 {
45225 PyThreadState* __tstate = wxPyBeginAllowThreads();
45226 result = (wxSizerItem *)new_wxSizerItem(arg1,arg2,arg3,arg4,arg5);
45227 wxPyEndAllowThreads(__tstate);
45228 if (PyErr_Occurred()) SWIG_fail;
45229 }
45230 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_OWN | 0 );
45231 return resultobj;
45232 fail:
45233 return NULL;
45234 }
45235
45236
45237 SWIGINTERN PyObject *_wrap_SizerItem_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45238 PyObject *resultobj = 0;
45239 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45240 void *argp1 = 0 ;
45241 int res1 = 0 ;
45242 PyObject *swig_obj[1] ;
45243
45244 if (!args) SWIG_fail;
45245 swig_obj[0] = args;
45246 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45247 if (!SWIG_IsOK(res1)) {
45248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DeleteWindows" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45249 }
45250 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45251 {
45252 PyThreadState* __tstate = wxPyBeginAllowThreads();
45253 (arg1)->DeleteWindows();
45254 wxPyEndAllowThreads(__tstate);
45255 if (PyErr_Occurred()) SWIG_fail;
45256 }
45257 resultobj = SWIG_Py_Void();
45258 return resultobj;
45259 fail:
45260 return NULL;
45261 }
45262
45263
45264 SWIGINTERN PyObject *_wrap_SizerItem_DetachSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45265 PyObject *resultobj = 0;
45266 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45267 void *argp1 = 0 ;
45268 int res1 = 0 ;
45269 PyObject *swig_obj[1] ;
45270
45271 if (!args) SWIG_fail;
45272 swig_obj[0] = args;
45273 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45274 if (!SWIG_IsOK(res1)) {
45275 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_DetachSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45276 }
45277 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45278 {
45279 PyThreadState* __tstate = wxPyBeginAllowThreads();
45280 (arg1)->DetachSizer();
45281 wxPyEndAllowThreads(__tstate);
45282 if (PyErr_Occurred()) SWIG_fail;
45283 }
45284 resultobj = SWIG_Py_Void();
45285 return resultobj;
45286 fail:
45287 return NULL;
45288 }
45289
45290
45291 SWIGINTERN PyObject *_wrap_SizerItem_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45292 PyObject *resultobj = 0;
45293 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45294 wxSize result;
45295 void *argp1 = 0 ;
45296 int res1 = 0 ;
45297 PyObject *swig_obj[1] ;
45298
45299 if (!args) SWIG_fail;
45300 swig_obj[0] = args;
45301 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45302 if (!SWIG_IsOK(res1)) {
45303 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45304 }
45305 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45306 {
45307 PyThreadState* __tstate = wxPyBeginAllowThreads();
45308 result = (arg1)->GetSize();
45309 wxPyEndAllowThreads(__tstate);
45310 if (PyErr_Occurred()) SWIG_fail;
45311 }
45312 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45313 return resultobj;
45314 fail:
45315 return NULL;
45316 }
45317
45318
45319 SWIGINTERN PyObject *_wrap_SizerItem_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45320 PyObject *resultobj = 0;
45321 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45322 wxSize result;
45323 void *argp1 = 0 ;
45324 int res1 = 0 ;
45325 PyObject *swig_obj[1] ;
45326
45327 if (!args) SWIG_fail;
45328 swig_obj[0] = args;
45329 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45330 if (!SWIG_IsOK(res1)) {
45331 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_CalcMin" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45332 }
45333 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45334 {
45335 PyThreadState* __tstate = wxPyBeginAllowThreads();
45336 result = (arg1)->CalcMin();
45337 wxPyEndAllowThreads(__tstate);
45338 if (PyErr_Occurred()) SWIG_fail;
45339 }
45340 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45341 return resultobj;
45342 fail:
45343 return NULL;
45344 }
45345
45346
45347 SWIGINTERN PyObject *_wrap_SizerItem_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45348 PyObject *resultobj = 0;
45349 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45350 wxPoint *arg2 = 0 ;
45351 wxSize *arg3 = 0 ;
45352 void *argp1 = 0 ;
45353 int res1 = 0 ;
45354 wxPoint temp2 ;
45355 wxSize temp3 ;
45356 PyObject * obj0 = 0 ;
45357 PyObject * obj1 = 0 ;
45358 PyObject * obj2 = 0 ;
45359 char * kwnames[] = {
45360 (char *) "self",(char *) "pos",(char *) "size", NULL
45361 };
45362
45363 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetDimension",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45364 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45365 if (!SWIG_IsOK(res1)) {
45366 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetDimension" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45367 }
45368 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45369 {
45370 arg2 = &temp2;
45371 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
45372 }
45373 {
45374 arg3 = &temp3;
45375 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
45376 }
45377 {
45378 PyThreadState* __tstate = wxPyBeginAllowThreads();
45379 (arg1)->SetDimension((wxPoint const &)*arg2,(wxSize const &)*arg3);
45380 wxPyEndAllowThreads(__tstate);
45381 if (PyErr_Occurred()) SWIG_fail;
45382 }
45383 resultobj = SWIG_Py_Void();
45384 return resultobj;
45385 fail:
45386 return NULL;
45387 }
45388
45389
45390 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45391 PyObject *resultobj = 0;
45392 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45393 wxSize result;
45394 void *argp1 = 0 ;
45395 int res1 = 0 ;
45396 PyObject *swig_obj[1] ;
45397
45398 if (!args) SWIG_fail;
45399 swig_obj[0] = args;
45400 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45401 if (!SWIG_IsOK(res1)) {
45402 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45403 }
45404 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45405 {
45406 PyThreadState* __tstate = wxPyBeginAllowThreads();
45407 result = (arg1)->GetMinSize();
45408 wxPyEndAllowThreads(__tstate);
45409 if (PyErr_Occurred()) SWIG_fail;
45410 }
45411 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45412 return resultobj;
45413 fail:
45414 return NULL;
45415 }
45416
45417
45418 SWIGINTERN PyObject *_wrap_SizerItem_GetMinSizeWithBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45419 PyObject *resultobj = 0;
45420 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45421 wxSize result;
45422 void *argp1 = 0 ;
45423 int res1 = 0 ;
45424 PyObject *swig_obj[1] ;
45425
45426 if (!args) SWIG_fail;
45427 swig_obj[0] = args;
45428 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45429 if (!SWIG_IsOK(res1)) {
45430 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetMinSizeWithBorder" "', expected argument " "1"" of type '" "wxSizerItem const *""'");
45431 }
45432 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45433 {
45434 PyThreadState* __tstate = wxPyBeginAllowThreads();
45435 result = ((wxSizerItem const *)arg1)->GetMinSizeWithBorder();
45436 wxPyEndAllowThreads(__tstate);
45437 if (PyErr_Occurred()) SWIG_fail;
45438 }
45439 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
45440 return resultobj;
45441 fail:
45442 return NULL;
45443 }
45444
45445
45446 SWIGINTERN PyObject *_wrap_SizerItem_SetInitSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45447 PyObject *resultobj = 0;
45448 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45449 int arg2 ;
45450 int arg3 ;
45451 void *argp1 = 0 ;
45452 int res1 = 0 ;
45453 int val2 ;
45454 int ecode2 = 0 ;
45455 int val3 ;
45456 int ecode3 = 0 ;
45457 PyObject * obj0 = 0 ;
45458 PyObject * obj1 = 0 ;
45459 PyObject * obj2 = 0 ;
45460 char * kwnames[] = {
45461 (char *) "self",(char *) "x",(char *) "y", NULL
45462 };
45463
45464 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetInitSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45465 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45466 if (!SWIG_IsOK(res1)) {
45467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetInitSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45468 }
45469 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45470 ecode2 = SWIG_AsVal_int(obj1, &val2);
45471 if (!SWIG_IsOK(ecode2)) {
45472 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetInitSize" "', expected argument " "2"" of type '" "int""'");
45473 }
45474 arg2 = static_cast< int >(val2);
45475 ecode3 = SWIG_AsVal_int(obj2, &val3);
45476 if (!SWIG_IsOK(ecode3)) {
45477 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetInitSize" "', expected argument " "3"" of type '" "int""'");
45478 }
45479 arg3 = static_cast< int >(val3);
45480 {
45481 PyThreadState* __tstate = wxPyBeginAllowThreads();
45482 (arg1)->SetInitSize(arg2,arg3);
45483 wxPyEndAllowThreads(__tstate);
45484 if (PyErr_Occurred()) SWIG_fail;
45485 }
45486 resultobj = SWIG_Py_Void();
45487 return resultobj;
45488 fail:
45489 return NULL;
45490 }
45491
45492
45493 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioWH(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45494 PyObject *resultobj = 0;
45495 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45496 int arg2 ;
45497 int arg3 ;
45498 void *argp1 = 0 ;
45499 int res1 = 0 ;
45500 int val2 ;
45501 int ecode2 = 0 ;
45502 int val3 ;
45503 int ecode3 = 0 ;
45504 PyObject * obj0 = 0 ;
45505 PyObject * obj1 = 0 ;
45506 PyObject * obj2 = 0 ;
45507 char * kwnames[] = {
45508 (char *) "self",(char *) "width",(char *) "height", NULL
45509 };
45510
45511 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:SizerItem_SetRatioWH",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
45512 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45513 if (!SWIG_IsOK(res1)) {
45514 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioWH" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45515 }
45516 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45517 ecode2 = SWIG_AsVal_int(obj1, &val2);
45518 if (!SWIG_IsOK(ecode2)) {
45519 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatioWH" "', expected argument " "2"" of type '" "int""'");
45520 }
45521 arg2 = static_cast< int >(val2);
45522 ecode3 = SWIG_AsVal_int(obj2, &val3);
45523 if (!SWIG_IsOK(ecode3)) {
45524 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "SizerItem_SetRatioWH" "', expected argument " "3"" of type '" "int""'");
45525 }
45526 arg3 = static_cast< int >(val3);
45527 {
45528 PyThreadState* __tstate = wxPyBeginAllowThreads();
45529 (arg1)->SetRatio(arg2,arg3);
45530 wxPyEndAllowThreads(__tstate);
45531 if (PyErr_Occurred()) SWIG_fail;
45532 }
45533 resultobj = SWIG_Py_Void();
45534 return resultobj;
45535 fail:
45536 return NULL;
45537 }
45538
45539
45540 SWIGINTERN PyObject *_wrap_SizerItem_SetRatioSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45541 PyObject *resultobj = 0;
45542 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45543 wxSize *arg2 = 0 ;
45544 void *argp1 = 0 ;
45545 int res1 = 0 ;
45546 wxSize temp2 ;
45547 PyObject * obj0 = 0 ;
45548 PyObject * obj1 = 0 ;
45549 char * kwnames[] = {
45550 (char *) "self",(char *) "size", NULL
45551 };
45552
45553 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatioSize",kwnames,&obj0,&obj1)) SWIG_fail;
45554 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45555 if (!SWIG_IsOK(res1)) {
45556 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatioSize" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45557 }
45558 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45559 {
45560 arg2 = &temp2;
45561 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
45562 }
45563 {
45564 PyThreadState* __tstate = wxPyBeginAllowThreads();
45565 (arg1)->SetRatio((wxSize const &)*arg2);
45566 wxPyEndAllowThreads(__tstate);
45567 if (PyErr_Occurred()) SWIG_fail;
45568 }
45569 resultobj = SWIG_Py_Void();
45570 return resultobj;
45571 fail:
45572 return NULL;
45573 }
45574
45575
45576 SWIGINTERN PyObject *_wrap_SizerItem_SetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45577 PyObject *resultobj = 0;
45578 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45579 float arg2 ;
45580 void *argp1 = 0 ;
45581 int res1 = 0 ;
45582 float val2 ;
45583 int ecode2 = 0 ;
45584 PyObject * obj0 = 0 ;
45585 PyObject * obj1 = 0 ;
45586 char * kwnames[] = {
45587 (char *) "self",(char *) "ratio", NULL
45588 };
45589
45590 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetRatio",kwnames,&obj0,&obj1)) SWIG_fail;
45591 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45592 if (!SWIG_IsOK(res1)) {
45593 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45594 }
45595 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45596 ecode2 = SWIG_AsVal_float(obj1, &val2);
45597 if (!SWIG_IsOK(ecode2)) {
45598 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetRatio" "', expected argument " "2"" of type '" "float""'");
45599 }
45600 arg2 = static_cast< float >(val2);
45601 {
45602 PyThreadState* __tstate = wxPyBeginAllowThreads();
45603 (arg1)->SetRatio(arg2);
45604 wxPyEndAllowThreads(__tstate);
45605 if (PyErr_Occurred()) SWIG_fail;
45606 }
45607 resultobj = SWIG_Py_Void();
45608 return resultobj;
45609 fail:
45610 return NULL;
45611 }
45612
45613
45614 SWIGINTERN PyObject *_wrap_SizerItem_GetRatio(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45615 PyObject *resultobj = 0;
45616 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45617 float result;
45618 void *argp1 = 0 ;
45619 int res1 = 0 ;
45620 PyObject *swig_obj[1] ;
45621
45622 if (!args) SWIG_fail;
45623 swig_obj[0] = args;
45624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45625 if (!SWIG_IsOK(res1)) {
45626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRatio" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45627 }
45628 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45629 {
45630 PyThreadState* __tstate = wxPyBeginAllowThreads();
45631 result = (float)(arg1)->GetRatio();
45632 wxPyEndAllowThreads(__tstate);
45633 if (PyErr_Occurred()) SWIG_fail;
45634 }
45635 resultobj = SWIG_From_float(static_cast< float >(result));
45636 return resultobj;
45637 fail:
45638 return NULL;
45639 }
45640
45641
45642 SWIGINTERN PyObject *_wrap_SizerItem_GetRect(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45643 PyObject *resultobj = 0;
45644 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45645 wxRect result;
45646 void *argp1 = 0 ;
45647 int res1 = 0 ;
45648 PyObject *swig_obj[1] ;
45649
45650 if (!args) SWIG_fail;
45651 swig_obj[0] = args;
45652 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45653 if (!SWIG_IsOK(res1)) {
45654 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetRect" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45655 }
45656 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45657 {
45658 PyThreadState* __tstate = wxPyBeginAllowThreads();
45659 result = (arg1)->GetRect();
45660 wxPyEndAllowThreads(__tstate);
45661 if (PyErr_Occurred()) SWIG_fail;
45662 }
45663 resultobj = SWIG_NewPointerObj((new wxRect(static_cast< const wxRect& >(result))), SWIGTYPE_p_wxRect, SWIG_POINTER_OWN | 0 );
45664 return resultobj;
45665 fail:
45666 return NULL;
45667 }
45668
45669
45670 SWIGINTERN PyObject *_wrap_SizerItem_IsWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45671 PyObject *resultobj = 0;
45672 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45673 bool result;
45674 void *argp1 = 0 ;
45675 int res1 = 0 ;
45676 PyObject *swig_obj[1] ;
45677
45678 if (!args) SWIG_fail;
45679 swig_obj[0] = args;
45680 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45681 if (!SWIG_IsOK(res1)) {
45682 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45683 }
45684 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45685 {
45686 PyThreadState* __tstate = wxPyBeginAllowThreads();
45687 result = (bool)(arg1)->IsWindow();
45688 wxPyEndAllowThreads(__tstate);
45689 if (PyErr_Occurred()) SWIG_fail;
45690 }
45691 {
45692 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45693 }
45694 return resultobj;
45695 fail:
45696 return NULL;
45697 }
45698
45699
45700 SWIGINTERN PyObject *_wrap_SizerItem_IsSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45701 PyObject *resultobj = 0;
45702 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45703 bool result;
45704 void *argp1 = 0 ;
45705 int res1 = 0 ;
45706 PyObject *swig_obj[1] ;
45707
45708 if (!args) SWIG_fail;
45709 swig_obj[0] = args;
45710 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45711 if (!SWIG_IsOK(res1)) {
45712 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45713 }
45714 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45715 {
45716 PyThreadState* __tstate = wxPyBeginAllowThreads();
45717 result = (bool)(arg1)->IsSizer();
45718 wxPyEndAllowThreads(__tstate);
45719 if (PyErr_Occurred()) SWIG_fail;
45720 }
45721 {
45722 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45723 }
45724 return resultobj;
45725 fail:
45726 return NULL;
45727 }
45728
45729
45730 SWIGINTERN PyObject *_wrap_SizerItem_IsSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45731 PyObject *resultobj = 0;
45732 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45733 bool result;
45734 void *argp1 = 0 ;
45735 int res1 = 0 ;
45736 PyObject *swig_obj[1] ;
45737
45738 if (!args) SWIG_fail;
45739 swig_obj[0] = args;
45740 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45741 if (!SWIG_IsOK(res1)) {
45742 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45743 }
45744 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45745 {
45746 PyThreadState* __tstate = wxPyBeginAllowThreads();
45747 result = (bool)(arg1)->IsSpacer();
45748 wxPyEndAllowThreads(__tstate);
45749 if (PyErr_Occurred()) SWIG_fail;
45750 }
45751 {
45752 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
45753 }
45754 return resultobj;
45755 fail:
45756 return NULL;
45757 }
45758
45759
45760 SWIGINTERN PyObject *_wrap_SizerItem_SetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45761 PyObject *resultobj = 0;
45762 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45763 int arg2 ;
45764 void *argp1 = 0 ;
45765 int res1 = 0 ;
45766 int val2 ;
45767 int ecode2 = 0 ;
45768 PyObject * obj0 = 0 ;
45769 PyObject * obj1 = 0 ;
45770 char * kwnames[] = {
45771 (char *) "self",(char *) "proportion", NULL
45772 };
45773
45774 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetProportion",kwnames,&obj0,&obj1)) SWIG_fail;
45775 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45776 if (!SWIG_IsOK(res1)) {
45777 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45778 }
45779 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45780 ecode2 = SWIG_AsVal_int(obj1, &val2);
45781 if (!SWIG_IsOK(ecode2)) {
45782 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetProportion" "', expected argument " "2"" of type '" "int""'");
45783 }
45784 arg2 = static_cast< int >(val2);
45785 {
45786 PyThreadState* __tstate = wxPyBeginAllowThreads();
45787 (arg1)->SetProportion(arg2);
45788 wxPyEndAllowThreads(__tstate);
45789 if (PyErr_Occurred()) SWIG_fail;
45790 }
45791 resultobj = SWIG_Py_Void();
45792 return resultobj;
45793 fail:
45794 return NULL;
45795 }
45796
45797
45798 SWIGINTERN PyObject *_wrap_SizerItem_GetProportion(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45799 PyObject *resultobj = 0;
45800 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45801 int result;
45802 void *argp1 = 0 ;
45803 int res1 = 0 ;
45804 PyObject *swig_obj[1] ;
45805
45806 if (!args) SWIG_fail;
45807 swig_obj[0] = args;
45808 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45809 if (!SWIG_IsOK(res1)) {
45810 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetProportion" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45811 }
45812 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45813 {
45814 PyThreadState* __tstate = wxPyBeginAllowThreads();
45815 result = (int)(arg1)->GetProportion();
45816 wxPyEndAllowThreads(__tstate);
45817 if (PyErr_Occurred()) SWIG_fail;
45818 }
45819 resultobj = SWIG_From_int(static_cast< int >(result));
45820 return resultobj;
45821 fail:
45822 return NULL;
45823 }
45824
45825
45826 SWIGINTERN PyObject *_wrap_SizerItem_SetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45827 PyObject *resultobj = 0;
45828 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45829 int arg2 ;
45830 void *argp1 = 0 ;
45831 int res1 = 0 ;
45832 int val2 ;
45833 int ecode2 = 0 ;
45834 PyObject * obj0 = 0 ;
45835 PyObject * obj1 = 0 ;
45836 char * kwnames[] = {
45837 (char *) "self",(char *) "flag", NULL
45838 };
45839
45840 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetFlag",kwnames,&obj0,&obj1)) SWIG_fail;
45841 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45842 if (!SWIG_IsOK(res1)) {
45843 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45844 }
45845 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45846 ecode2 = SWIG_AsVal_int(obj1, &val2);
45847 if (!SWIG_IsOK(ecode2)) {
45848 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetFlag" "', expected argument " "2"" of type '" "int""'");
45849 }
45850 arg2 = static_cast< int >(val2);
45851 {
45852 PyThreadState* __tstate = wxPyBeginAllowThreads();
45853 (arg1)->SetFlag(arg2);
45854 wxPyEndAllowThreads(__tstate);
45855 if (PyErr_Occurred()) SWIG_fail;
45856 }
45857 resultobj = SWIG_Py_Void();
45858 return resultobj;
45859 fail:
45860 return NULL;
45861 }
45862
45863
45864 SWIGINTERN PyObject *_wrap_SizerItem_GetFlag(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45865 PyObject *resultobj = 0;
45866 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45867 int result;
45868 void *argp1 = 0 ;
45869 int res1 = 0 ;
45870 PyObject *swig_obj[1] ;
45871
45872 if (!args) SWIG_fail;
45873 swig_obj[0] = args;
45874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45875 if (!SWIG_IsOK(res1)) {
45876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetFlag" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45877 }
45878 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45879 {
45880 PyThreadState* __tstate = wxPyBeginAllowThreads();
45881 result = (int)(arg1)->GetFlag();
45882 wxPyEndAllowThreads(__tstate);
45883 if (PyErr_Occurred()) SWIG_fail;
45884 }
45885 resultobj = SWIG_From_int(static_cast< int >(result));
45886 return resultobj;
45887 fail:
45888 return NULL;
45889 }
45890
45891
45892 SWIGINTERN PyObject *_wrap_SizerItem_SetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45893 PyObject *resultobj = 0;
45894 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45895 int arg2 ;
45896 void *argp1 = 0 ;
45897 int res1 = 0 ;
45898 int val2 ;
45899 int ecode2 = 0 ;
45900 PyObject * obj0 = 0 ;
45901 PyObject * obj1 = 0 ;
45902 char * kwnames[] = {
45903 (char *) "self",(char *) "border", NULL
45904 };
45905
45906 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetBorder",kwnames,&obj0,&obj1)) SWIG_fail;
45907 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45908 if (!SWIG_IsOK(res1)) {
45909 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45910 }
45911 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45912 ecode2 = SWIG_AsVal_int(obj1, &val2);
45913 if (!SWIG_IsOK(ecode2)) {
45914 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_SetBorder" "', expected argument " "2"" of type '" "int""'");
45915 }
45916 arg2 = static_cast< int >(val2);
45917 {
45918 PyThreadState* __tstate = wxPyBeginAllowThreads();
45919 (arg1)->SetBorder(arg2);
45920 wxPyEndAllowThreads(__tstate);
45921 if (PyErr_Occurred()) SWIG_fail;
45922 }
45923 resultobj = SWIG_Py_Void();
45924 return resultobj;
45925 fail:
45926 return NULL;
45927 }
45928
45929
45930 SWIGINTERN PyObject *_wrap_SizerItem_GetBorder(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45931 PyObject *resultobj = 0;
45932 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45933 int result;
45934 void *argp1 = 0 ;
45935 int res1 = 0 ;
45936 PyObject *swig_obj[1] ;
45937
45938 if (!args) SWIG_fail;
45939 swig_obj[0] = args;
45940 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45941 if (!SWIG_IsOK(res1)) {
45942 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetBorder" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45943 }
45944 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45945 {
45946 PyThreadState* __tstate = wxPyBeginAllowThreads();
45947 result = (int)(arg1)->GetBorder();
45948 wxPyEndAllowThreads(__tstate);
45949 if (PyErr_Occurred()) SWIG_fail;
45950 }
45951 resultobj = SWIG_From_int(static_cast< int >(result));
45952 return resultobj;
45953 fail:
45954 return NULL;
45955 }
45956
45957
45958 SWIGINTERN PyObject *_wrap_SizerItem_GetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
45959 PyObject *resultobj = 0;
45960 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45961 wxWindow *result = 0 ;
45962 void *argp1 = 0 ;
45963 int res1 = 0 ;
45964 PyObject *swig_obj[1] ;
45965
45966 if (!args) SWIG_fail;
45967 swig_obj[0] = args;
45968 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
45969 if (!SWIG_IsOK(res1)) {
45970 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
45971 }
45972 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
45973 {
45974 PyThreadState* __tstate = wxPyBeginAllowThreads();
45975 result = (wxWindow *)(arg1)->GetWindow();
45976 wxPyEndAllowThreads(__tstate);
45977 if (PyErr_Occurred()) SWIG_fail;
45978 }
45979 {
45980 resultobj = wxPyMake_wxObject(result, 0);
45981 }
45982 return resultobj;
45983 fail:
45984 return NULL;
45985 }
45986
45987
45988 SWIGINTERN PyObject *_wrap_SizerItem_SetWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
45989 PyObject *resultobj = 0;
45990 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
45991 wxWindow *arg2 = (wxWindow *) 0 ;
45992 void *argp1 = 0 ;
45993 int res1 = 0 ;
45994 void *argp2 = 0 ;
45995 int res2 = 0 ;
45996 PyObject * obj0 = 0 ;
45997 PyObject * obj1 = 0 ;
45998 char * kwnames[] = {
45999 (char *) "self",(char *) "window", NULL
46000 };
46001
46002 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetWindow",kwnames,&obj0,&obj1)) SWIG_fail;
46003 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46004 if (!SWIG_IsOK(res1)) {
46005 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetWindow" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46006 }
46007 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46008 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
46009 if (!SWIG_IsOK(res2)) {
46010 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetWindow" "', expected argument " "2"" of type '" "wxWindow *""'");
46011 }
46012 arg2 = reinterpret_cast< wxWindow * >(argp2);
46013 {
46014 PyThreadState* __tstate = wxPyBeginAllowThreads();
46015 (arg1)->SetWindow(arg2);
46016 wxPyEndAllowThreads(__tstate);
46017 if (PyErr_Occurred()) SWIG_fail;
46018 }
46019 resultobj = SWIG_Py_Void();
46020 return resultobj;
46021 fail:
46022 return NULL;
46023 }
46024
46025
46026 SWIGINTERN PyObject *_wrap_SizerItem_GetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46027 PyObject *resultobj = 0;
46028 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46029 wxSizer *result = 0 ;
46030 void *argp1 = 0 ;
46031 int res1 = 0 ;
46032 PyObject *swig_obj[1] ;
46033
46034 if (!args) SWIG_fail;
46035 swig_obj[0] = args;
46036 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46037 if (!SWIG_IsOK(res1)) {
46038 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46039 }
46040 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46041 {
46042 PyThreadState* __tstate = wxPyBeginAllowThreads();
46043 result = (wxSizer *)(arg1)->GetSizer();
46044 wxPyEndAllowThreads(__tstate);
46045 if (PyErr_Occurred()) SWIG_fail;
46046 }
46047 {
46048 resultobj = wxPyMake_wxObject(result, (bool)0);
46049 }
46050 return resultobj;
46051 fail:
46052 return NULL;
46053 }
46054
46055
46056 SWIGINTERN PyObject *_wrap_SizerItem_SetSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46057 PyObject *resultobj = 0;
46058 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46059 wxSizer *arg2 = (wxSizer *) 0 ;
46060 void *argp1 = 0 ;
46061 int res1 = 0 ;
46062 int res2 = 0 ;
46063 PyObject * obj0 = 0 ;
46064 PyObject * obj1 = 0 ;
46065 char * kwnames[] = {
46066 (char *) "self",(char *) "sizer", NULL
46067 };
46068
46069 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSizer",kwnames,&obj0,&obj1)) SWIG_fail;
46070 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46071 if (!SWIG_IsOK(res1)) {
46072 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSizer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46073 }
46074 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46075 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46076 if (!SWIG_IsOK(res2)) {
46077 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "SizerItem_SetSizer" "', expected argument " "2"" of type '" "wxSizer *""'");
46078 }
46079 {
46080 PyThreadState* __tstate = wxPyBeginAllowThreads();
46081 (arg1)->SetSizer(arg2);
46082 wxPyEndAllowThreads(__tstate);
46083 if (PyErr_Occurred()) SWIG_fail;
46084 }
46085 resultobj = SWIG_Py_Void();
46086 return resultobj;
46087 fail:
46088 return NULL;
46089 }
46090
46091
46092 SWIGINTERN PyObject *_wrap_SizerItem_GetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46093 PyObject *resultobj = 0;
46094 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46095 wxSize *result = 0 ;
46096 void *argp1 = 0 ;
46097 int res1 = 0 ;
46098 PyObject *swig_obj[1] ;
46099
46100 if (!args) SWIG_fail;
46101 swig_obj[0] = args;
46102 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46103 if (!SWIG_IsOK(res1)) {
46104 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46105 }
46106 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46107 {
46108 PyThreadState* __tstate = wxPyBeginAllowThreads();
46109 {
46110 wxSize const &_result_ref = (arg1)->GetSpacer();
46111 result = (wxSize *) &_result_ref;
46112 }
46113 wxPyEndAllowThreads(__tstate);
46114 if (PyErr_Occurred()) SWIG_fail;
46115 }
46116 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSize, 0 | 0 );
46117 return resultobj;
46118 fail:
46119 return NULL;
46120 }
46121
46122
46123 SWIGINTERN PyObject *_wrap_SizerItem_SetSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46124 PyObject *resultobj = 0;
46125 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46126 wxSize *arg2 = 0 ;
46127 void *argp1 = 0 ;
46128 int res1 = 0 ;
46129 wxSize temp2 ;
46130 PyObject * obj0 = 0 ;
46131 PyObject * obj1 = 0 ;
46132 char * kwnames[] = {
46133 (char *) "self",(char *) "size", NULL
46134 };
46135
46136 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetSpacer",kwnames,&obj0,&obj1)) SWIG_fail;
46137 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46138 if (!SWIG_IsOK(res1)) {
46139 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetSpacer" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46140 }
46141 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46142 {
46143 arg2 = &temp2;
46144 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46145 }
46146 {
46147 PyThreadState* __tstate = wxPyBeginAllowThreads();
46148 (arg1)->SetSpacer((wxSize const &)*arg2);
46149 wxPyEndAllowThreads(__tstate);
46150 if (PyErr_Occurred()) SWIG_fail;
46151 }
46152 resultobj = SWIG_Py_Void();
46153 return resultobj;
46154 fail:
46155 return NULL;
46156 }
46157
46158
46159 SWIGINTERN PyObject *_wrap_SizerItem_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46160 PyObject *resultobj = 0;
46161 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46162 bool arg2 ;
46163 void *argp1 = 0 ;
46164 int res1 = 0 ;
46165 bool val2 ;
46166 int ecode2 = 0 ;
46167 PyObject * obj0 = 0 ;
46168 PyObject * obj1 = 0 ;
46169 char * kwnames[] = {
46170 (char *) "self",(char *) "show", NULL
46171 };
46172
46173 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_Show",kwnames,&obj0,&obj1)) SWIG_fail;
46174 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46175 if (!SWIG_IsOK(res1)) {
46176 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_Show" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46177 }
46178 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46179 ecode2 = SWIG_AsVal_bool(obj1, &val2);
46180 if (!SWIG_IsOK(ecode2)) {
46181 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "SizerItem_Show" "', expected argument " "2"" of type '" "bool""'");
46182 }
46183 arg2 = static_cast< bool >(val2);
46184 {
46185 PyThreadState* __tstate = wxPyBeginAllowThreads();
46186 (arg1)->Show(arg2);
46187 wxPyEndAllowThreads(__tstate);
46188 if (PyErr_Occurred()) SWIG_fail;
46189 }
46190 resultobj = SWIG_Py_Void();
46191 return resultobj;
46192 fail:
46193 return NULL;
46194 }
46195
46196
46197 SWIGINTERN PyObject *_wrap_SizerItem_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46198 PyObject *resultobj = 0;
46199 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46200 bool result;
46201 void *argp1 = 0 ;
46202 int res1 = 0 ;
46203 PyObject *swig_obj[1] ;
46204
46205 if (!args) SWIG_fail;
46206 swig_obj[0] = args;
46207 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46208 if (!SWIG_IsOK(res1)) {
46209 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_IsShown" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46210 }
46211 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46212 {
46213 PyThreadState* __tstate = wxPyBeginAllowThreads();
46214 result = (bool)(arg1)->IsShown();
46215 wxPyEndAllowThreads(__tstate);
46216 if (PyErr_Occurred()) SWIG_fail;
46217 }
46218 {
46219 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46220 }
46221 return resultobj;
46222 fail:
46223 return NULL;
46224 }
46225
46226
46227 SWIGINTERN PyObject *_wrap_SizerItem_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46228 PyObject *resultobj = 0;
46229 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46230 wxPoint result;
46231 void *argp1 = 0 ;
46232 int res1 = 0 ;
46233 PyObject *swig_obj[1] ;
46234
46235 if (!args) SWIG_fail;
46236 swig_obj[0] = args;
46237 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46238 if (!SWIG_IsOK(res1)) {
46239 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetPosition" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46240 }
46241 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46242 {
46243 PyThreadState* __tstate = wxPyBeginAllowThreads();
46244 result = (arg1)->GetPosition();
46245 wxPyEndAllowThreads(__tstate);
46246 if (PyErr_Occurred()) SWIG_fail;
46247 }
46248 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
46249 return resultobj;
46250 fail:
46251 return NULL;
46252 }
46253
46254
46255 SWIGINTERN PyObject *_wrap_SizerItem_GetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46256 PyObject *resultobj = 0;
46257 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46258 PyObject *result = 0 ;
46259 void *argp1 = 0 ;
46260 int res1 = 0 ;
46261 PyObject *swig_obj[1] ;
46262
46263 if (!args) SWIG_fail;
46264 swig_obj[0] = args;
46265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46266 if (!SWIG_IsOK(res1)) {
46267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_GetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46268 }
46269 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46270 {
46271 PyThreadState* __tstate = wxPyBeginAllowThreads();
46272 result = (PyObject *)wxSizerItem_GetUserData(arg1);
46273 wxPyEndAllowThreads(__tstate);
46274 if (PyErr_Occurred()) SWIG_fail;
46275 }
46276 resultobj = result;
46277 return resultobj;
46278 fail:
46279 return NULL;
46280 }
46281
46282
46283 SWIGINTERN PyObject *_wrap_SizerItem_SetUserData(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46284 PyObject *resultobj = 0;
46285 wxSizerItem *arg1 = (wxSizerItem *) 0 ;
46286 PyObject *arg2 = (PyObject *) 0 ;
46287 void *argp1 = 0 ;
46288 int res1 = 0 ;
46289 PyObject * obj0 = 0 ;
46290 PyObject * obj1 = 0 ;
46291 char * kwnames[] = {
46292 (char *) "self",(char *) "userData", NULL
46293 };
46294
46295 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:SizerItem_SetUserData",kwnames,&obj0,&obj1)) SWIG_fail;
46296 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizerItem, 0 | 0 );
46297 if (!SWIG_IsOK(res1)) {
46298 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "SizerItem_SetUserData" "', expected argument " "1"" of type '" "wxSizerItem *""'");
46299 }
46300 arg1 = reinterpret_cast< wxSizerItem * >(argp1);
46301 arg2 = obj1;
46302 {
46303 PyThreadState* __tstate = wxPyBeginAllowThreads();
46304 wxSizerItem_SetUserData(arg1,arg2);
46305 wxPyEndAllowThreads(__tstate);
46306 if (PyErr_Occurred()) SWIG_fail;
46307 }
46308 resultobj = SWIG_Py_Void();
46309 return resultobj;
46310 fail:
46311 return NULL;
46312 }
46313
46314
46315 SWIGINTERN PyObject *SizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46316 PyObject *obj;
46317 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
46318 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizerItem, SWIG_NewClientData(obj));
46319 return SWIG_Py_Void();
46320 }
46321
46322 SWIGINTERN PyObject *SizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46323 return SWIG_Python_InitShadowInstance(args);
46324 }
46325
46326 SWIGINTERN PyObject *_wrap_delete_Sizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46327 PyObject *resultobj = 0;
46328 wxSizer *arg1 = (wxSizer *) 0 ;
46329 void *argp1 = 0 ;
46330 int res1 = 0 ;
46331 PyObject *swig_obj[1] ;
46332
46333 if (!args) SWIG_fail;
46334 swig_obj[0] = args;
46335 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
46336 if (!SWIG_IsOK(res1)) {
46337 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_Sizer" "', expected argument " "1"" of type '" "wxSizer *""'");
46338 }
46339 arg1 = reinterpret_cast< wxSizer * >(argp1);
46340 {
46341 PyThreadState* __tstate = wxPyBeginAllowThreads();
46342 delete arg1;
46343
46344 wxPyEndAllowThreads(__tstate);
46345 if (PyErr_Occurred()) SWIG_fail;
46346 }
46347 resultobj = SWIG_Py_Void();
46348 return resultobj;
46349 fail:
46350 return NULL;
46351 }
46352
46353
46354 SWIGINTERN PyObject *_wrap_Sizer__setOORInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46355 PyObject *resultobj = 0;
46356 wxSizer *arg1 = (wxSizer *) 0 ;
46357 PyObject *arg2 = (PyObject *) 0 ;
46358 void *argp1 = 0 ;
46359 int res1 = 0 ;
46360 PyObject * obj0 = 0 ;
46361 PyObject * obj1 = 0 ;
46362 char * kwnames[] = {
46363 (char *) "self",(char *) "_self", NULL
46364 };
46365
46366 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer__setOORInfo",kwnames,&obj0,&obj1)) SWIG_fail;
46367 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46368 if (!SWIG_IsOK(res1)) {
46369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__setOORInfo" "', expected argument " "1"" of type '" "wxSizer *""'");
46370 }
46371 arg1 = reinterpret_cast< wxSizer * >(argp1);
46372 arg2 = obj1;
46373 {
46374 PyThreadState* __tstate = wxPyBeginAllowThreads();
46375 wxSizer__setOORInfo(arg1,arg2);
46376 wxPyEndAllowThreads(__tstate);
46377 if (PyErr_Occurred()) SWIG_fail;
46378 }
46379 resultobj = SWIG_Py_Void();
46380 return resultobj;
46381 fail:
46382 return NULL;
46383 }
46384
46385
46386 SWIGINTERN PyObject *_wrap_Sizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46387 PyObject *resultobj = 0;
46388 wxSizer *arg1 = (wxSizer *) 0 ;
46389 PyObject *arg2 = (PyObject *) 0 ;
46390 int arg3 = (int) 0 ;
46391 int arg4 = (int) 0 ;
46392 int arg5 = (int) 0 ;
46393 PyObject *arg6 = (PyObject *) NULL ;
46394 wxSizerItem *result = 0 ;
46395 void *argp1 = 0 ;
46396 int res1 = 0 ;
46397 int val3 ;
46398 int ecode3 = 0 ;
46399 int val4 ;
46400 int ecode4 = 0 ;
46401 int val5 ;
46402 int ecode5 = 0 ;
46403 PyObject * obj0 = 0 ;
46404 PyObject * obj1 = 0 ;
46405 PyObject * obj2 = 0 ;
46406 PyObject * obj3 = 0 ;
46407 PyObject * obj4 = 0 ;
46408 PyObject * obj5 = 0 ;
46409 char * kwnames[] = {
46410 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46411 };
46412
46413 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46414 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46415 if (!SWIG_IsOK(res1)) {
46416 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Add" "', expected argument " "1"" of type '" "wxSizer *""'");
46417 }
46418 arg1 = reinterpret_cast< wxSizer * >(argp1);
46419 arg2 = obj1;
46420 if (obj2) {
46421 ecode3 = SWIG_AsVal_int(obj2, &val3);
46422 if (!SWIG_IsOK(ecode3)) {
46423 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Add" "', expected argument " "3"" of type '" "int""'");
46424 }
46425 arg3 = static_cast< int >(val3);
46426 }
46427 if (obj3) {
46428 ecode4 = SWIG_AsVal_int(obj3, &val4);
46429 if (!SWIG_IsOK(ecode4)) {
46430 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Add" "', expected argument " "4"" of type '" "int""'");
46431 }
46432 arg4 = static_cast< int >(val4);
46433 }
46434 if (obj4) {
46435 ecode5 = SWIG_AsVal_int(obj4, &val5);
46436 if (!SWIG_IsOK(ecode5)) {
46437 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Add" "', expected argument " "5"" of type '" "int""'");
46438 }
46439 arg5 = static_cast< int >(val5);
46440 }
46441 if (obj5) {
46442 arg6 = obj5;
46443 }
46444 {
46445 PyThreadState* __tstate = wxPyBeginAllowThreads();
46446 result = (wxSizerItem *)wxSizer_Add(arg1,arg2,arg3,arg4,arg5,arg6);
46447 wxPyEndAllowThreads(__tstate);
46448 if (PyErr_Occurred()) SWIG_fail;
46449 }
46450 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46451 return resultobj;
46452 fail:
46453 return NULL;
46454 }
46455
46456
46457 SWIGINTERN PyObject *_wrap_Sizer_Insert(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46458 PyObject *resultobj = 0;
46459 wxSizer *arg1 = (wxSizer *) 0 ;
46460 int arg2 ;
46461 PyObject *arg3 = (PyObject *) 0 ;
46462 int arg4 = (int) 0 ;
46463 int arg5 = (int) 0 ;
46464 int arg6 = (int) 0 ;
46465 PyObject *arg7 = (PyObject *) NULL ;
46466 wxSizerItem *result = 0 ;
46467 void *argp1 = 0 ;
46468 int res1 = 0 ;
46469 int val2 ;
46470 int ecode2 = 0 ;
46471 int val4 ;
46472 int ecode4 = 0 ;
46473 int val5 ;
46474 int ecode5 = 0 ;
46475 int val6 ;
46476 int ecode6 = 0 ;
46477 PyObject * obj0 = 0 ;
46478 PyObject * obj1 = 0 ;
46479 PyObject * obj2 = 0 ;
46480 PyObject * obj3 = 0 ;
46481 PyObject * obj4 = 0 ;
46482 PyObject * obj5 = 0 ;
46483 PyObject * obj6 = 0 ;
46484 char * kwnames[] = {
46485 (char *) "self",(char *) "before",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46486 };
46487
46488 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:Sizer_Insert",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
46489 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46490 if (!SWIG_IsOK(res1)) {
46491 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Insert" "', expected argument " "1"" of type '" "wxSizer *""'");
46492 }
46493 arg1 = reinterpret_cast< wxSizer * >(argp1);
46494 ecode2 = SWIG_AsVal_int(obj1, &val2);
46495 if (!SWIG_IsOK(ecode2)) {
46496 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Insert" "', expected argument " "2"" of type '" "int""'");
46497 }
46498 arg2 = static_cast< int >(val2);
46499 arg3 = obj2;
46500 if (obj3) {
46501 ecode4 = SWIG_AsVal_int(obj3, &val4);
46502 if (!SWIG_IsOK(ecode4)) {
46503 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Insert" "', expected argument " "4"" of type '" "int""'");
46504 }
46505 arg4 = static_cast< int >(val4);
46506 }
46507 if (obj4) {
46508 ecode5 = SWIG_AsVal_int(obj4, &val5);
46509 if (!SWIG_IsOK(ecode5)) {
46510 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Insert" "', expected argument " "5"" of type '" "int""'");
46511 }
46512 arg5 = static_cast< int >(val5);
46513 }
46514 if (obj5) {
46515 ecode6 = SWIG_AsVal_int(obj5, &val6);
46516 if (!SWIG_IsOK(ecode6)) {
46517 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "Sizer_Insert" "', expected argument " "6"" of type '" "int""'");
46518 }
46519 arg6 = static_cast< int >(val6);
46520 }
46521 if (obj6) {
46522 arg7 = obj6;
46523 }
46524 {
46525 PyThreadState* __tstate = wxPyBeginAllowThreads();
46526 result = (wxSizerItem *)wxSizer_Insert(arg1,arg2,arg3,arg4,arg5,arg6,arg7);
46527 wxPyEndAllowThreads(__tstate);
46528 if (PyErr_Occurred()) SWIG_fail;
46529 }
46530 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46531 return resultobj;
46532 fail:
46533 return NULL;
46534 }
46535
46536
46537 SWIGINTERN PyObject *_wrap_Sizer_Prepend(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46538 PyObject *resultobj = 0;
46539 wxSizer *arg1 = (wxSizer *) 0 ;
46540 PyObject *arg2 = (PyObject *) 0 ;
46541 int arg3 = (int) 0 ;
46542 int arg4 = (int) 0 ;
46543 int arg5 = (int) 0 ;
46544 PyObject *arg6 = (PyObject *) NULL ;
46545 wxSizerItem *result = 0 ;
46546 void *argp1 = 0 ;
46547 int res1 = 0 ;
46548 int val3 ;
46549 int ecode3 = 0 ;
46550 int val4 ;
46551 int ecode4 = 0 ;
46552 int val5 ;
46553 int ecode5 = 0 ;
46554 PyObject * obj0 = 0 ;
46555 PyObject * obj1 = 0 ;
46556 PyObject * obj2 = 0 ;
46557 PyObject * obj3 = 0 ;
46558 PyObject * obj4 = 0 ;
46559 PyObject * obj5 = 0 ;
46560 char * kwnames[] = {
46561 (char *) "self",(char *) "item",(char *) "proportion",(char *) "flag",(char *) "border",(char *) "userData", NULL
46562 };
46563
46564 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OOOO:Sizer_Prepend",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
46565 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46566 if (!SWIG_IsOK(res1)) {
46567 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Prepend" "', expected argument " "1"" of type '" "wxSizer *""'");
46568 }
46569 arg1 = reinterpret_cast< wxSizer * >(argp1);
46570 arg2 = obj1;
46571 if (obj2) {
46572 ecode3 = SWIG_AsVal_int(obj2, &val3);
46573 if (!SWIG_IsOK(ecode3)) {
46574 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Prepend" "', expected argument " "3"" of type '" "int""'");
46575 }
46576 arg3 = static_cast< int >(val3);
46577 }
46578 if (obj3) {
46579 ecode4 = SWIG_AsVal_int(obj3, &val4);
46580 if (!SWIG_IsOK(ecode4)) {
46581 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Prepend" "', expected argument " "4"" of type '" "int""'");
46582 }
46583 arg4 = static_cast< int >(val4);
46584 }
46585 if (obj4) {
46586 ecode5 = SWIG_AsVal_int(obj4, &val5);
46587 if (!SWIG_IsOK(ecode5)) {
46588 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_Prepend" "', expected argument " "5"" of type '" "int""'");
46589 }
46590 arg5 = static_cast< int >(val5);
46591 }
46592 if (obj5) {
46593 arg6 = obj5;
46594 }
46595 {
46596 PyThreadState* __tstate = wxPyBeginAllowThreads();
46597 result = (wxSizerItem *)wxSizer_Prepend(arg1,arg2,arg3,arg4,arg5,arg6);
46598 wxPyEndAllowThreads(__tstate);
46599 if (PyErr_Occurred()) SWIG_fail;
46600 }
46601 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46602 return resultobj;
46603 fail:
46604 return NULL;
46605 }
46606
46607
46608 SWIGINTERN PyObject *_wrap_Sizer_Remove(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46609 PyObject *resultobj = 0;
46610 wxSizer *arg1 = (wxSizer *) 0 ;
46611 PyObject *arg2 = (PyObject *) 0 ;
46612 bool result;
46613 void *argp1 = 0 ;
46614 int res1 = 0 ;
46615 PyObject * obj0 = 0 ;
46616 PyObject * obj1 = 0 ;
46617 char * kwnames[] = {
46618 (char *) "self",(char *) "item", NULL
46619 };
46620
46621 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Remove",kwnames,&obj0,&obj1)) SWIG_fail;
46622 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46623 if (!SWIG_IsOK(res1)) {
46624 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Remove" "', expected argument " "1"" of type '" "wxSizer *""'");
46625 }
46626 arg1 = reinterpret_cast< wxSizer * >(argp1);
46627 arg2 = obj1;
46628 {
46629 PyThreadState* __tstate = wxPyBeginAllowThreads();
46630 result = (bool)wxSizer_Remove(arg1,arg2);
46631 wxPyEndAllowThreads(__tstate);
46632 if (PyErr_Occurred()) SWIG_fail;
46633 }
46634 {
46635 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46636 }
46637 return resultobj;
46638 fail:
46639 return NULL;
46640 }
46641
46642
46643 SWIGINTERN PyObject *_wrap_Sizer_Detach(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46644 PyObject *resultobj = 0;
46645 wxSizer *arg1 = (wxSizer *) 0 ;
46646 PyObject *arg2 = (PyObject *) 0 ;
46647 bool result;
46648 void *argp1 = 0 ;
46649 int res1 = 0 ;
46650 PyObject * obj0 = 0 ;
46651 PyObject * obj1 = 0 ;
46652 char * kwnames[] = {
46653 (char *) "self",(char *) "item", NULL
46654 };
46655
46656 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Detach",kwnames,&obj0,&obj1)) SWIG_fail;
46657 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46658 if (!SWIG_IsOK(res1)) {
46659 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Detach" "', expected argument " "1"" of type '" "wxSizer *""'");
46660 }
46661 arg1 = reinterpret_cast< wxSizer * >(argp1);
46662 arg2 = obj1;
46663 {
46664 PyThreadState* __tstate = wxPyBeginAllowThreads();
46665 result = (bool)wxSizer_Detach(arg1,arg2);
46666 wxPyEndAllowThreads(__tstate);
46667 if (PyErr_Occurred()) SWIG_fail;
46668 }
46669 {
46670 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
46671 }
46672 return resultobj;
46673 fail:
46674 return NULL;
46675 }
46676
46677
46678 SWIGINTERN PyObject *_wrap_Sizer_GetItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46679 PyObject *resultobj = 0;
46680 wxSizer *arg1 = (wxSizer *) 0 ;
46681 PyObject *arg2 = (PyObject *) 0 ;
46682 wxSizerItem *result = 0 ;
46683 void *argp1 = 0 ;
46684 int res1 = 0 ;
46685 PyObject * obj0 = 0 ;
46686 PyObject * obj1 = 0 ;
46687 char * kwnames[] = {
46688 (char *) "self",(char *) "item", NULL
46689 };
46690
46691 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_GetItem",kwnames,&obj0,&obj1)) SWIG_fail;
46692 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46693 if (!SWIG_IsOK(res1)) {
46694 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46695 }
46696 arg1 = reinterpret_cast< wxSizer * >(argp1);
46697 arg2 = obj1;
46698 {
46699 PyThreadState* __tstate = wxPyBeginAllowThreads();
46700 result = (wxSizerItem *)wxSizer_GetItem(arg1,arg2);
46701 wxPyEndAllowThreads(__tstate);
46702 if (PyErr_Occurred()) SWIG_fail;
46703 }
46704 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46705 return resultobj;
46706 fail:
46707 return NULL;
46708 }
46709
46710
46711 SWIGINTERN PyObject *_wrap_Sizer__SetItemMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46712 PyObject *resultobj = 0;
46713 wxSizer *arg1 = (wxSizer *) 0 ;
46714 PyObject *arg2 = (PyObject *) 0 ;
46715 wxSize *arg3 = 0 ;
46716 void *argp1 = 0 ;
46717 int res1 = 0 ;
46718 wxSize temp3 ;
46719 PyObject * obj0 = 0 ;
46720 PyObject * obj1 = 0 ;
46721 PyObject * obj2 = 0 ;
46722 char * kwnames[] = {
46723 (char *) "self",(char *) "item",(char *) "size", NULL
46724 };
46725
46726 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer__SetItemMinSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46727 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46728 if (!SWIG_IsOK(res1)) {
46729 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer__SetItemMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46730 }
46731 arg1 = reinterpret_cast< wxSizer * >(argp1);
46732 arg2 = obj1;
46733 {
46734 arg3 = &temp3;
46735 if ( ! wxSize_helper(obj2, &arg3)) SWIG_fail;
46736 }
46737 {
46738 PyThreadState* __tstate = wxPyBeginAllowThreads();
46739 wxSizer__SetItemMinSize(arg1,arg2,(wxSize const &)*arg3);
46740 wxPyEndAllowThreads(__tstate);
46741 if (PyErr_Occurred()) SWIG_fail;
46742 }
46743 resultobj = SWIG_Py_Void();
46744 return resultobj;
46745 fail:
46746 return NULL;
46747 }
46748
46749
46750 SWIGINTERN PyObject *_wrap_Sizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46751 PyObject *resultobj = 0;
46752 wxSizer *arg1 = (wxSizer *) 0 ;
46753 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46754 wxSizerItem *result = 0 ;
46755 void *argp1 = 0 ;
46756 int res1 = 0 ;
46757 int res2 = 0 ;
46758 PyObject * obj0 = 0 ;
46759 PyObject * obj1 = 0 ;
46760 char * kwnames[] = {
46761 (char *) "self",(char *) "item", NULL
46762 };
46763
46764 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
46765 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46766 if (!SWIG_IsOK(res1)) {
46767 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_AddItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46768 }
46769 arg1 = reinterpret_cast< wxSizer * >(argp1);
46770 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46771 if (!SWIG_IsOK(res2)) {
46772 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_AddItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46773 }
46774 {
46775 PyThreadState* __tstate = wxPyBeginAllowThreads();
46776 result = (wxSizerItem *)(arg1)->Add(arg2);
46777 wxPyEndAllowThreads(__tstate);
46778 if (PyErr_Occurred()) SWIG_fail;
46779 }
46780 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46781 return resultobj;
46782 fail:
46783 return NULL;
46784 }
46785
46786
46787 SWIGINTERN PyObject *_wrap_Sizer_InsertItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46788 PyObject *resultobj = 0;
46789 wxSizer *arg1 = (wxSizer *) 0 ;
46790 size_t arg2 ;
46791 wxSizerItem *arg3 = (wxSizerItem *) 0 ;
46792 wxSizerItem *result = 0 ;
46793 void *argp1 = 0 ;
46794 int res1 = 0 ;
46795 size_t val2 ;
46796 int ecode2 = 0 ;
46797 int res3 = 0 ;
46798 PyObject * obj0 = 0 ;
46799 PyObject * obj1 = 0 ;
46800 PyObject * obj2 = 0 ;
46801 char * kwnames[] = {
46802 (char *) "self",(char *) "index",(char *) "item", NULL
46803 };
46804
46805 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:Sizer_InsertItem",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
46806 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46807 if (!SWIG_IsOK(res1)) {
46808 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_InsertItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46809 }
46810 arg1 = reinterpret_cast< wxSizer * >(argp1);
46811 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
46812 if (!SWIG_IsOK(ecode2)) {
46813 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_InsertItem" "', expected argument " "2"" of type '" "size_t""'");
46814 }
46815 arg2 = static_cast< size_t >(val2);
46816 res3 = SWIG_ConvertPtr(obj2, SWIG_as_voidptrptr(&arg3), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46817 if (!SWIG_IsOK(res3)) {
46818 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "Sizer_InsertItem" "', expected argument " "3"" of type '" "wxSizerItem *""'");
46819 }
46820 {
46821 PyThreadState* __tstate = wxPyBeginAllowThreads();
46822 result = (wxSizerItem *)(arg1)->Insert(arg2,arg3);
46823 wxPyEndAllowThreads(__tstate);
46824 if (PyErr_Occurred()) SWIG_fail;
46825 }
46826 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46827 return resultobj;
46828 fail:
46829 return NULL;
46830 }
46831
46832
46833 SWIGINTERN PyObject *_wrap_Sizer_PrependItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46834 PyObject *resultobj = 0;
46835 wxSizer *arg1 = (wxSizer *) 0 ;
46836 wxSizerItem *arg2 = (wxSizerItem *) 0 ;
46837 wxSizerItem *result = 0 ;
46838 void *argp1 = 0 ;
46839 int res1 = 0 ;
46840 int res2 = 0 ;
46841 PyObject * obj0 = 0 ;
46842 PyObject * obj1 = 0 ;
46843 char * kwnames[] = {
46844 (char *) "self",(char *) "item", NULL
46845 };
46846
46847 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_PrependItem",kwnames,&obj0,&obj1)) SWIG_fail;
46848 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46849 if (!SWIG_IsOK(res1)) {
46850 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_PrependItem" "', expected argument " "1"" of type '" "wxSizer *""'");
46851 }
46852 arg1 = reinterpret_cast< wxSizer * >(argp1);
46853 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxSizerItem, SWIG_POINTER_DISOWN | 0 );
46854 if (!SWIG_IsOK(res2)) {
46855 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_PrependItem" "', expected argument " "2"" of type '" "wxSizerItem *""'");
46856 }
46857 {
46858 PyThreadState* __tstate = wxPyBeginAllowThreads();
46859 result = (wxSizerItem *)(arg1)->Prepend(arg2);
46860 wxPyEndAllowThreads(__tstate);
46861 if (PyErr_Occurred()) SWIG_fail;
46862 }
46863 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxSizerItem, 0 | 0 );
46864 return resultobj;
46865 fail:
46866 return NULL;
46867 }
46868
46869
46870 SWIGINTERN PyObject *_wrap_Sizer_SetDimension(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46871 PyObject *resultobj = 0;
46872 wxSizer *arg1 = (wxSizer *) 0 ;
46873 int arg2 ;
46874 int arg3 ;
46875 int arg4 ;
46876 int arg5 ;
46877 void *argp1 = 0 ;
46878 int res1 = 0 ;
46879 int val2 ;
46880 int ecode2 = 0 ;
46881 int val3 ;
46882 int ecode3 = 0 ;
46883 int val4 ;
46884 int ecode4 = 0 ;
46885 int val5 ;
46886 int ecode5 = 0 ;
46887 PyObject * obj0 = 0 ;
46888 PyObject * obj1 = 0 ;
46889 PyObject * obj2 = 0 ;
46890 PyObject * obj3 = 0 ;
46891 PyObject * obj4 = 0 ;
46892 char * kwnames[] = {
46893 (char *) "self",(char *) "x",(char *) "y",(char *) "width",(char *) "height", NULL
46894 };
46895
46896 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO:Sizer_SetDimension",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4)) SWIG_fail;
46897 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46898 if (!SWIG_IsOK(res1)) {
46899 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetDimension" "', expected argument " "1"" of type '" "wxSizer *""'");
46900 }
46901 arg1 = reinterpret_cast< wxSizer * >(argp1);
46902 ecode2 = SWIG_AsVal_int(obj1, &val2);
46903 if (!SWIG_IsOK(ecode2)) {
46904 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_SetDimension" "', expected argument " "2"" of type '" "int""'");
46905 }
46906 arg2 = static_cast< int >(val2);
46907 ecode3 = SWIG_AsVal_int(obj2, &val3);
46908 if (!SWIG_IsOK(ecode3)) {
46909 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_SetDimension" "', expected argument " "3"" of type '" "int""'");
46910 }
46911 arg3 = static_cast< int >(val3);
46912 ecode4 = SWIG_AsVal_int(obj3, &val4);
46913 if (!SWIG_IsOK(ecode4)) {
46914 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_SetDimension" "', expected argument " "4"" of type '" "int""'");
46915 }
46916 arg4 = static_cast< int >(val4);
46917 ecode5 = SWIG_AsVal_int(obj4, &val5);
46918 if (!SWIG_IsOK(ecode5)) {
46919 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "Sizer_SetDimension" "', expected argument " "5"" of type '" "int""'");
46920 }
46921 arg5 = static_cast< int >(val5);
46922 {
46923 PyThreadState* __tstate = wxPyBeginAllowThreads();
46924 (arg1)->SetDimension(arg2,arg3,arg4,arg5);
46925 wxPyEndAllowThreads(__tstate);
46926 if (PyErr_Occurred()) SWIG_fail;
46927 }
46928 resultobj = SWIG_Py_Void();
46929 return resultobj;
46930 fail:
46931 return NULL;
46932 }
46933
46934
46935 SWIGINTERN PyObject *_wrap_Sizer_SetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
46936 PyObject *resultobj = 0;
46937 wxSizer *arg1 = (wxSizer *) 0 ;
46938 wxSize *arg2 = 0 ;
46939 void *argp1 = 0 ;
46940 int res1 = 0 ;
46941 wxSize temp2 ;
46942 PyObject * obj0 = 0 ;
46943 PyObject * obj1 = 0 ;
46944 char * kwnames[] = {
46945 (char *) "self",(char *) "size", NULL
46946 };
46947
46948 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetMinSize",kwnames,&obj0,&obj1)) SWIG_fail;
46949 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
46950 if (!SWIG_IsOK(res1)) {
46951 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46952 }
46953 arg1 = reinterpret_cast< wxSizer * >(argp1);
46954 {
46955 arg2 = &temp2;
46956 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
46957 }
46958 {
46959 PyThreadState* __tstate = wxPyBeginAllowThreads();
46960 (arg1)->SetMinSize((wxSize 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_Sizer_GetSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
46972 PyObject *resultobj = 0;
46973 wxSizer *arg1 = (wxSizer *) 0 ;
46974 wxSize 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_wxSizer, 0 | 0 );
46982 if (!SWIG_IsOK(res1)) {
46983 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetSize" "', expected argument " "1"" of type '" "wxSizer *""'");
46984 }
46985 arg1 = reinterpret_cast< wxSizer * >(argp1);
46986 {
46987 PyThreadState* __tstate = wxPyBeginAllowThreads();
46988 result = (arg1)->GetSize();
46989 wxPyEndAllowThreads(__tstate);
46990 if (PyErr_Occurred()) SWIG_fail;
46991 }
46992 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
46993 return resultobj;
46994 fail:
46995 return NULL;
46996 }
46997
46998
46999 SWIGINTERN PyObject *_wrap_Sizer_GetPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47000 PyObject *resultobj = 0;
47001 wxSizer *arg1 = (wxSizer *) 0 ;
47002 wxPoint result;
47003 void *argp1 = 0 ;
47004 int res1 = 0 ;
47005 PyObject *swig_obj[1] ;
47006
47007 if (!args) SWIG_fail;
47008 swig_obj[0] = args;
47009 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47010 if (!SWIG_IsOK(res1)) {
47011 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetPosition" "', expected argument " "1"" of type '" "wxSizer *""'");
47012 }
47013 arg1 = reinterpret_cast< wxSizer * >(argp1);
47014 {
47015 PyThreadState* __tstate = wxPyBeginAllowThreads();
47016 result = (arg1)->GetPosition();
47017 wxPyEndAllowThreads(__tstate);
47018 if (PyErr_Occurred()) SWIG_fail;
47019 }
47020 resultobj = SWIG_NewPointerObj((new wxPoint(static_cast< const wxPoint& >(result))), SWIGTYPE_p_wxPoint, SWIG_POINTER_OWN | 0 );
47021 return resultobj;
47022 fail:
47023 return NULL;
47024 }
47025
47026
47027 SWIGINTERN PyObject *_wrap_Sizer_GetMinSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47028 PyObject *resultobj = 0;
47029 wxSizer *arg1 = (wxSizer *) 0 ;
47030 wxSize result;
47031 void *argp1 = 0 ;
47032 int res1 = 0 ;
47033 PyObject *swig_obj[1] ;
47034
47035 if (!args) SWIG_fail;
47036 swig_obj[0] = args;
47037 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47038 if (!SWIG_IsOK(res1)) {
47039 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetMinSize" "', expected argument " "1"" of type '" "wxSizer *""'");
47040 }
47041 arg1 = reinterpret_cast< wxSizer * >(argp1);
47042 {
47043 PyThreadState* __tstate = wxPyBeginAllowThreads();
47044 result = (arg1)->GetMinSize();
47045 wxPyEndAllowThreads(__tstate);
47046 if (PyErr_Occurred()) SWIG_fail;
47047 }
47048 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47049 return resultobj;
47050 fail:
47051 return NULL;
47052 }
47053
47054
47055 SWIGINTERN PyObject *_wrap_Sizer_RecalcSizes(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47056 PyObject *resultobj = 0;
47057 wxSizer *arg1 = (wxSizer *) 0 ;
47058 void *argp1 = 0 ;
47059 int res1 = 0 ;
47060 PyObject *swig_obj[1] ;
47061
47062 if (!args) SWIG_fail;
47063 swig_obj[0] = args;
47064 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47065 if (!SWIG_IsOK(res1)) {
47066 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_RecalcSizes" "', expected argument " "1"" of type '" "wxSizer *""'");
47067 }
47068 arg1 = reinterpret_cast< wxSizer * >(argp1);
47069 {
47070 PyThreadState* __tstate = wxPyBeginAllowThreads();
47071 (arg1)->RecalcSizes();
47072 wxPyEndAllowThreads(__tstate);
47073 if (PyErr_Occurred()) SWIG_fail;
47074 }
47075 resultobj = SWIG_Py_Void();
47076 return resultobj;
47077 fail:
47078 return NULL;
47079 }
47080
47081
47082 SWIGINTERN PyObject *_wrap_Sizer_CalcMin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47083 PyObject *resultobj = 0;
47084 wxSizer *arg1 = (wxSizer *) 0 ;
47085 wxSize result;
47086 void *argp1 = 0 ;
47087 int res1 = 0 ;
47088 PyObject *swig_obj[1] ;
47089
47090 if (!args) SWIG_fail;
47091 swig_obj[0] = args;
47092 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47093 if (!SWIG_IsOK(res1)) {
47094 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_CalcMin" "', expected argument " "1"" of type '" "wxSizer *""'");
47095 }
47096 arg1 = reinterpret_cast< wxSizer * >(argp1);
47097 {
47098 PyThreadState* __tstate = wxPyBeginAllowThreads();
47099 result = (arg1)->CalcMin();
47100 wxPyEndAllowThreads(__tstate);
47101 if (PyErr_Occurred()) SWIG_fail;
47102 }
47103 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47104 return resultobj;
47105 fail:
47106 return NULL;
47107 }
47108
47109
47110 SWIGINTERN PyObject *_wrap_Sizer_Layout(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47111 PyObject *resultobj = 0;
47112 wxSizer *arg1 = (wxSizer *) 0 ;
47113 void *argp1 = 0 ;
47114 int res1 = 0 ;
47115 PyObject *swig_obj[1] ;
47116
47117 if (!args) SWIG_fail;
47118 swig_obj[0] = args;
47119 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47120 if (!SWIG_IsOK(res1)) {
47121 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Layout" "', expected argument " "1"" of type '" "wxSizer *""'");
47122 }
47123 arg1 = reinterpret_cast< wxSizer * >(argp1);
47124 {
47125 PyThreadState* __tstate = wxPyBeginAllowThreads();
47126 (arg1)->Layout();
47127 wxPyEndAllowThreads(__tstate);
47128 if (PyErr_Occurred()) SWIG_fail;
47129 }
47130 resultobj = SWIG_Py_Void();
47131 return resultobj;
47132 fail:
47133 return NULL;
47134 }
47135
47136
47137 SWIGINTERN PyObject *_wrap_Sizer_Fit(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47138 PyObject *resultobj = 0;
47139 wxSizer *arg1 = (wxSizer *) 0 ;
47140 wxWindow *arg2 = (wxWindow *) 0 ;
47141 wxSize result;
47142 void *argp1 = 0 ;
47143 int res1 = 0 ;
47144 void *argp2 = 0 ;
47145 int res2 = 0 ;
47146 PyObject * obj0 = 0 ;
47147 PyObject * obj1 = 0 ;
47148 char * kwnames[] = {
47149 (char *) "self",(char *) "window", NULL
47150 };
47151
47152 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_Fit",kwnames,&obj0,&obj1)) SWIG_fail;
47153 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47154 if (!SWIG_IsOK(res1)) {
47155 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Fit" "', expected argument " "1"" of type '" "wxSizer *""'");
47156 }
47157 arg1 = reinterpret_cast< wxSizer * >(argp1);
47158 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47159 if (!SWIG_IsOK(res2)) {
47160 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_Fit" "', expected argument " "2"" of type '" "wxWindow *""'");
47161 }
47162 arg2 = reinterpret_cast< wxWindow * >(argp2);
47163 {
47164 PyThreadState* __tstate = wxPyBeginAllowThreads();
47165 result = (arg1)->Fit(arg2);
47166 wxPyEndAllowThreads(__tstate);
47167 if (PyErr_Occurred()) SWIG_fail;
47168 }
47169 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
47170 return resultobj;
47171 fail:
47172 return NULL;
47173 }
47174
47175
47176 SWIGINTERN PyObject *_wrap_Sizer_FitInside(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47177 PyObject *resultobj = 0;
47178 wxSizer *arg1 = (wxSizer *) 0 ;
47179 wxWindow *arg2 = (wxWindow *) 0 ;
47180 void *argp1 = 0 ;
47181 int res1 = 0 ;
47182 void *argp2 = 0 ;
47183 int res2 = 0 ;
47184 PyObject * obj0 = 0 ;
47185 PyObject * obj1 = 0 ;
47186 char * kwnames[] = {
47187 (char *) "self",(char *) "window", NULL
47188 };
47189
47190 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_FitInside",kwnames,&obj0,&obj1)) SWIG_fail;
47191 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47192 if (!SWIG_IsOK(res1)) {
47193 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_FitInside" "', expected argument " "1"" of type '" "wxSizer *""'");
47194 }
47195 arg1 = reinterpret_cast< wxSizer * >(argp1);
47196 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47197 if (!SWIG_IsOK(res2)) {
47198 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_FitInside" "', expected argument " "2"" of type '" "wxWindow *""'");
47199 }
47200 arg2 = reinterpret_cast< wxWindow * >(argp2);
47201 {
47202 PyThreadState* __tstate = wxPyBeginAllowThreads();
47203 (arg1)->FitInside(arg2);
47204 wxPyEndAllowThreads(__tstate);
47205 if (PyErr_Occurred()) SWIG_fail;
47206 }
47207 resultobj = SWIG_Py_Void();
47208 return resultobj;
47209 fail:
47210 return NULL;
47211 }
47212
47213
47214 SWIGINTERN PyObject *_wrap_Sizer_SetSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47215 PyObject *resultobj = 0;
47216 wxSizer *arg1 = (wxSizer *) 0 ;
47217 wxWindow *arg2 = (wxWindow *) 0 ;
47218 void *argp1 = 0 ;
47219 int res1 = 0 ;
47220 void *argp2 = 0 ;
47221 int res2 = 0 ;
47222 PyObject * obj0 = 0 ;
47223 PyObject * obj1 = 0 ;
47224 char * kwnames[] = {
47225 (char *) "self",(char *) "window", NULL
47226 };
47227
47228 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47229 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47230 if (!SWIG_IsOK(res1)) {
47231 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47232 }
47233 arg1 = reinterpret_cast< wxSizer * >(argp1);
47234 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47235 if (!SWIG_IsOK(res2)) {
47236 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47237 }
47238 arg2 = reinterpret_cast< wxWindow * >(argp2);
47239 {
47240 PyThreadState* __tstate = wxPyBeginAllowThreads();
47241 (arg1)->SetSizeHints(arg2);
47242 wxPyEndAllowThreads(__tstate);
47243 if (PyErr_Occurred()) SWIG_fail;
47244 }
47245 resultobj = SWIG_Py_Void();
47246 return resultobj;
47247 fail:
47248 return NULL;
47249 }
47250
47251
47252 SWIGINTERN PyObject *_wrap_Sizer_SetVirtualSizeHints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47253 PyObject *resultobj = 0;
47254 wxSizer *arg1 = (wxSizer *) 0 ;
47255 wxWindow *arg2 = (wxWindow *) 0 ;
47256 void *argp1 = 0 ;
47257 int res1 = 0 ;
47258 void *argp2 = 0 ;
47259 int res2 = 0 ;
47260 PyObject * obj0 = 0 ;
47261 PyObject * obj1 = 0 ;
47262 char * kwnames[] = {
47263 (char *) "self",(char *) "window", NULL
47264 };
47265
47266 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_SetVirtualSizeHints",kwnames,&obj0,&obj1)) SWIG_fail;
47267 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47268 if (!SWIG_IsOK(res1)) {
47269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "1"" of type '" "wxSizer *""'");
47270 }
47271 arg1 = reinterpret_cast< wxSizer * >(argp1);
47272 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
47273 if (!SWIG_IsOK(res2)) {
47274 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "Sizer_SetVirtualSizeHints" "', expected argument " "2"" of type '" "wxWindow *""'");
47275 }
47276 arg2 = reinterpret_cast< wxWindow * >(argp2);
47277 {
47278 PyThreadState* __tstate = wxPyBeginAllowThreads();
47279 (arg1)->SetVirtualSizeHints(arg2);
47280 wxPyEndAllowThreads(__tstate);
47281 if (PyErr_Occurred()) SWIG_fail;
47282 }
47283 resultobj = SWIG_Py_Void();
47284 return resultobj;
47285 fail:
47286 return NULL;
47287 }
47288
47289
47290 SWIGINTERN PyObject *_wrap_Sizer_Clear(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47291 PyObject *resultobj = 0;
47292 wxSizer *arg1 = (wxSizer *) 0 ;
47293 bool arg2 = (bool) false ;
47294 void *argp1 = 0 ;
47295 int res1 = 0 ;
47296 bool val2 ;
47297 int ecode2 = 0 ;
47298 PyObject * obj0 = 0 ;
47299 PyObject * obj1 = 0 ;
47300 char * kwnames[] = {
47301 (char *) "self",(char *) "deleteWindows", NULL
47302 };
47303
47304 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:Sizer_Clear",kwnames,&obj0,&obj1)) SWIG_fail;
47305 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47306 if (!SWIG_IsOK(res1)) {
47307 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Clear" "', expected argument " "1"" of type '" "wxSizer *""'");
47308 }
47309 arg1 = reinterpret_cast< wxSizer * >(argp1);
47310 if (obj1) {
47311 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47312 if (!SWIG_IsOK(ecode2)) {
47313 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_Clear" "', expected argument " "2"" of type '" "bool""'");
47314 }
47315 arg2 = static_cast< bool >(val2);
47316 }
47317 {
47318 PyThreadState* __tstate = wxPyBeginAllowThreads();
47319 (arg1)->Clear(arg2);
47320 wxPyEndAllowThreads(__tstate);
47321 if (PyErr_Occurred()) SWIG_fail;
47322 }
47323 resultobj = SWIG_Py_Void();
47324 return resultobj;
47325 fail:
47326 return NULL;
47327 }
47328
47329
47330 SWIGINTERN PyObject *_wrap_Sizer_DeleteWindows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47331 PyObject *resultobj = 0;
47332 wxSizer *arg1 = (wxSizer *) 0 ;
47333 void *argp1 = 0 ;
47334 int res1 = 0 ;
47335 PyObject *swig_obj[1] ;
47336
47337 if (!args) SWIG_fail;
47338 swig_obj[0] = args;
47339 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47340 if (!SWIG_IsOK(res1)) {
47341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_DeleteWindows" "', expected argument " "1"" of type '" "wxSizer *""'");
47342 }
47343 arg1 = reinterpret_cast< wxSizer * >(argp1);
47344 {
47345 PyThreadState* __tstate = wxPyBeginAllowThreads();
47346 (arg1)->DeleteWindows();
47347 wxPyEndAllowThreads(__tstate);
47348 if (PyErr_Occurred()) SWIG_fail;
47349 }
47350 resultobj = SWIG_Py_Void();
47351 return resultobj;
47352 fail:
47353 return NULL;
47354 }
47355
47356
47357 SWIGINTERN PyObject *_wrap_Sizer_GetChildren(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47358 PyObject *resultobj = 0;
47359 wxSizer *arg1 = (wxSizer *) 0 ;
47360 PyObject *result = 0 ;
47361 void *argp1 = 0 ;
47362 int res1 = 0 ;
47363 PyObject *swig_obj[1] ;
47364
47365 if (!args) SWIG_fail;
47366 swig_obj[0] = args;
47367 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47368 if (!SWIG_IsOK(res1)) {
47369 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_GetChildren" "', expected argument " "1"" of type '" "wxSizer *""'");
47370 }
47371 arg1 = reinterpret_cast< wxSizer * >(argp1);
47372 {
47373 PyThreadState* __tstate = wxPyBeginAllowThreads();
47374 result = (PyObject *)wxSizer_GetChildren(arg1);
47375 wxPyEndAllowThreads(__tstate);
47376 if (PyErr_Occurred()) SWIG_fail;
47377 }
47378 resultobj = result;
47379 return resultobj;
47380 fail:
47381 return NULL;
47382 }
47383
47384
47385 SWIGINTERN PyObject *_wrap_Sizer_Show(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47386 PyObject *resultobj = 0;
47387 wxSizer *arg1 = (wxSizer *) 0 ;
47388 PyObject *arg2 = (PyObject *) 0 ;
47389 bool arg3 = (bool) true ;
47390 bool arg4 = (bool) false ;
47391 bool result;
47392 void *argp1 = 0 ;
47393 int res1 = 0 ;
47394 bool val3 ;
47395 int ecode3 = 0 ;
47396 bool val4 ;
47397 int ecode4 = 0 ;
47398 PyObject * obj0 = 0 ;
47399 PyObject * obj1 = 0 ;
47400 PyObject * obj2 = 0 ;
47401 PyObject * obj3 = 0 ;
47402 char * kwnames[] = {
47403 (char *) "self",(char *) "item",(char *) "show",(char *) "recursive", NULL
47404 };
47405
47406 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|OO:Sizer_Show",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47407 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47408 if (!SWIG_IsOK(res1)) {
47409 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_Show" "', expected argument " "1"" of type '" "wxSizer *""'");
47410 }
47411 arg1 = reinterpret_cast< wxSizer * >(argp1);
47412 arg2 = obj1;
47413 if (obj2) {
47414 ecode3 = SWIG_AsVal_bool(obj2, &val3);
47415 if (!SWIG_IsOK(ecode3)) {
47416 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "Sizer_Show" "', expected argument " "3"" of type '" "bool""'");
47417 }
47418 arg3 = static_cast< bool >(val3);
47419 }
47420 if (obj3) {
47421 ecode4 = SWIG_AsVal_bool(obj3, &val4);
47422 if (!SWIG_IsOK(ecode4)) {
47423 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "Sizer_Show" "', expected argument " "4"" of type '" "bool""'");
47424 }
47425 arg4 = static_cast< bool >(val4);
47426 }
47427 {
47428 PyThreadState* __tstate = wxPyBeginAllowThreads();
47429 result = (bool)wxSizer_Show(arg1,arg2,arg3,arg4);
47430 wxPyEndAllowThreads(__tstate);
47431 if (PyErr_Occurred()) SWIG_fail;
47432 }
47433 {
47434 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47435 }
47436 return resultobj;
47437 fail:
47438 return NULL;
47439 }
47440
47441
47442 SWIGINTERN PyObject *_wrap_Sizer_IsShown(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47443 PyObject *resultobj = 0;
47444 wxSizer *arg1 = (wxSizer *) 0 ;
47445 PyObject *arg2 = (PyObject *) 0 ;
47446 bool result;
47447 void *argp1 = 0 ;
47448 int res1 = 0 ;
47449 PyObject * obj0 = 0 ;
47450 PyObject * obj1 = 0 ;
47451 char * kwnames[] = {
47452 (char *) "self",(char *) "item", NULL
47453 };
47454
47455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_IsShown",kwnames,&obj0,&obj1)) SWIG_fail;
47456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47457 if (!SWIG_IsOK(res1)) {
47458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_IsShown" "', expected argument " "1"" of type '" "wxSizer *""'");
47459 }
47460 arg1 = reinterpret_cast< wxSizer * >(argp1);
47461 arg2 = obj1;
47462 {
47463 PyThreadState* __tstate = wxPyBeginAllowThreads();
47464 result = (bool)wxSizer_IsShown(arg1,arg2);
47465 wxPyEndAllowThreads(__tstate);
47466 if (PyErr_Occurred()) SWIG_fail;
47467 }
47468 {
47469 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
47470 }
47471 return resultobj;
47472 fail:
47473 return NULL;
47474 }
47475
47476
47477 SWIGINTERN PyObject *_wrap_Sizer_ShowItems(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47478 PyObject *resultobj = 0;
47479 wxSizer *arg1 = (wxSizer *) 0 ;
47480 bool arg2 ;
47481 void *argp1 = 0 ;
47482 int res1 = 0 ;
47483 bool val2 ;
47484 int ecode2 = 0 ;
47485 PyObject * obj0 = 0 ;
47486 PyObject * obj1 = 0 ;
47487 char * kwnames[] = {
47488 (char *) "self",(char *) "show", NULL
47489 };
47490
47491 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:Sizer_ShowItems",kwnames,&obj0,&obj1)) SWIG_fail;
47492 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxSizer, 0 | 0 );
47493 if (!SWIG_IsOK(res1)) {
47494 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "Sizer_ShowItems" "', expected argument " "1"" of type '" "wxSizer *""'");
47495 }
47496 arg1 = reinterpret_cast< wxSizer * >(argp1);
47497 ecode2 = SWIG_AsVal_bool(obj1, &val2);
47498 if (!SWIG_IsOK(ecode2)) {
47499 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "Sizer_ShowItems" "', expected argument " "2"" of type '" "bool""'");
47500 }
47501 arg2 = static_cast< bool >(val2);
47502 {
47503 PyThreadState* __tstate = wxPyBeginAllowThreads();
47504 (arg1)->ShowItems(arg2);
47505 wxPyEndAllowThreads(__tstate);
47506 if (PyErr_Occurred()) SWIG_fail;
47507 }
47508 resultobj = SWIG_Py_Void();
47509 return resultobj;
47510 fail:
47511 return NULL;
47512 }
47513
47514
47515 SWIGINTERN PyObject *Sizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47516 PyObject *obj;
47517 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47518 SWIG_TypeNewClientData(SWIGTYPE_p_wxSizer, SWIG_NewClientData(obj));
47519 return SWIG_Py_Void();
47520 }
47521
47522 SWIGINTERN PyObject *_wrap_new_PySizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47523 PyObject *resultobj = 0;
47524 wxPySizer *result = 0 ;
47525
47526 if (!SWIG_Python_UnpackTuple(args,"new_PySizer",0,0,0)) SWIG_fail;
47527 {
47528 PyThreadState* __tstate = wxPyBeginAllowThreads();
47529 result = (wxPySizer *)new wxPySizer();
47530 wxPyEndAllowThreads(__tstate);
47531 if (PyErr_Occurred()) SWIG_fail;
47532 }
47533 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxPySizer, SWIG_POINTER_NEW | 0 );
47534 return resultobj;
47535 fail:
47536 return NULL;
47537 }
47538
47539
47540 SWIGINTERN PyObject *_wrap_PySizer__setCallbackInfo(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47541 PyObject *resultobj = 0;
47542 wxPySizer *arg1 = (wxPySizer *) 0 ;
47543 PyObject *arg2 = (PyObject *) 0 ;
47544 PyObject *arg3 = (PyObject *) 0 ;
47545 void *argp1 = 0 ;
47546 int res1 = 0 ;
47547 PyObject * obj0 = 0 ;
47548 PyObject * obj1 = 0 ;
47549 PyObject * obj2 = 0 ;
47550 char * kwnames[] = {
47551 (char *) "self",(char *) "self",(char *) "_class", NULL
47552 };
47553
47554 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:PySizer__setCallbackInfo",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
47555 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxPySizer, 0 | 0 );
47556 if (!SWIG_IsOK(res1)) {
47557 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "PySizer__setCallbackInfo" "', expected argument " "1"" of type '" "wxPySizer *""'");
47558 }
47559 arg1 = reinterpret_cast< wxPySizer * >(argp1);
47560 arg2 = obj1;
47561 arg3 = obj2;
47562 {
47563 PyThreadState* __tstate = wxPyBeginAllowThreads();
47564 (arg1)->_setCallbackInfo(arg2,arg3);
47565 wxPyEndAllowThreads(__tstate);
47566 if (PyErr_Occurred()) SWIG_fail;
47567 }
47568 resultobj = SWIG_Py_Void();
47569 return resultobj;
47570 fail:
47571 return NULL;
47572 }
47573
47574
47575 SWIGINTERN PyObject *PySizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47576 PyObject *obj;
47577 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47578 SWIG_TypeNewClientData(SWIGTYPE_p_wxPySizer, SWIG_NewClientData(obj));
47579 return SWIG_Py_Void();
47580 }
47581
47582 SWIGINTERN PyObject *PySizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47583 return SWIG_Python_InitShadowInstance(args);
47584 }
47585
47586 SWIGINTERN PyObject *_wrap_new_BoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47587 PyObject *resultobj = 0;
47588 int arg1 = (int) wxHORIZONTAL ;
47589 wxBoxSizer *result = 0 ;
47590 int val1 ;
47591 int ecode1 = 0 ;
47592 PyObject * obj0 = 0 ;
47593 char * kwnames[] = {
47594 (char *) "orient", NULL
47595 };
47596
47597 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|O:new_BoxSizer",kwnames,&obj0)) SWIG_fail;
47598 if (obj0) {
47599 ecode1 = SWIG_AsVal_int(obj0, &val1);
47600 if (!SWIG_IsOK(ecode1)) {
47601 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_BoxSizer" "', expected argument " "1"" of type '" "int""'");
47602 }
47603 arg1 = static_cast< int >(val1);
47604 }
47605 {
47606 PyThreadState* __tstate = wxPyBeginAllowThreads();
47607 result = (wxBoxSizer *)new wxBoxSizer(arg1);
47608 wxPyEndAllowThreads(__tstate);
47609 if (PyErr_Occurred()) SWIG_fail;
47610 }
47611 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxBoxSizer, SWIG_POINTER_NEW | 0 );
47612 return resultobj;
47613 fail:
47614 return NULL;
47615 }
47616
47617
47618 SWIGINTERN PyObject *_wrap_BoxSizer_GetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47619 PyObject *resultobj = 0;
47620 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47621 int result;
47622 void *argp1 = 0 ;
47623 int res1 = 0 ;
47624 PyObject *swig_obj[1] ;
47625
47626 if (!args) SWIG_fail;
47627 swig_obj[0] = args;
47628 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47629 if (!SWIG_IsOK(res1)) {
47630 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_GetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47631 }
47632 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47633 {
47634 PyThreadState* __tstate = wxPyBeginAllowThreads();
47635 result = (int)(arg1)->GetOrientation();
47636 wxPyEndAllowThreads(__tstate);
47637 if (PyErr_Occurred()) SWIG_fail;
47638 }
47639 resultobj = SWIG_From_int(static_cast< int >(result));
47640 return resultobj;
47641 fail:
47642 return NULL;
47643 }
47644
47645
47646 SWIGINTERN PyObject *_wrap_BoxSizer_SetOrientation(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47647 PyObject *resultobj = 0;
47648 wxBoxSizer *arg1 = (wxBoxSizer *) 0 ;
47649 int arg2 ;
47650 void *argp1 = 0 ;
47651 int res1 = 0 ;
47652 int val2 ;
47653 int ecode2 = 0 ;
47654 PyObject * obj0 = 0 ;
47655 PyObject * obj1 = 0 ;
47656 char * kwnames[] = {
47657 (char *) "self",(char *) "orient", NULL
47658 };
47659
47660 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:BoxSizer_SetOrientation",kwnames,&obj0,&obj1)) SWIG_fail;
47661 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxBoxSizer, 0 | 0 );
47662 if (!SWIG_IsOK(res1)) {
47663 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "BoxSizer_SetOrientation" "', expected argument " "1"" of type '" "wxBoxSizer *""'");
47664 }
47665 arg1 = reinterpret_cast< wxBoxSizer * >(argp1);
47666 ecode2 = SWIG_AsVal_int(obj1, &val2);
47667 if (!SWIG_IsOK(ecode2)) {
47668 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "BoxSizer_SetOrientation" "', expected argument " "2"" of type '" "int""'");
47669 }
47670 arg2 = static_cast< int >(val2);
47671 {
47672 PyThreadState* __tstate = wxPyBeginAllowThreads();
47673 (arg1)->SetOrientation(arg2);
47674 wxPyEndAllowThreads(__tstate);
47675 if (PyErr_Occurred()) SWIG_fail;
47676 }
47677 resultobj = SWIG_Py_Void();
47678 return resultobj;
47679 fail:
47680 return NULL;
47681 }
47682
47683
47684 SWIGINTERN PyObject *BoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47685 PyObject *obj;
47686 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47687 SWIG_TypeNewClientData(SWIGTYPE_p_wxBoxSizer, SWIG_NewClientData(obj));
47688 return SWIG_Py_Void();
47689 }
47690
47691 SWIGINTERN PyObject *BoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47692 return SWIG_Python_InitShadowInstance(args);
47693 }
47694
47695 SWIGINTERN PyObject *_wrap_new_StaticBoxSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47696 PyObject *resultobj = 0;
47697 wxStaticBox *arg1 = (wxStaticBox *) 0 ;
47698 int arg2 = (int) wxHORIZONTAL ;
47699 wxStaticBoxSizer *result = 0 ;
47700 void *argp1 = 0 ;
47701 int res1 = 0 ;
47702 int val2 ;
47703 int ecode2 = 0 ;
47704 PyObject * obj0 = 0 ;
47705 PyObject * obj1 = 0 ;
47706 char * kwnames[] = {
47707 (char *) "box",(char *) "orient", NULL
47708 };
47709
47710 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|O:new_StaticBoxSizer",kwnames,&obj0,&obj1)) SWIG_fail;
47711 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStaticBox, 0 | 0 );
47712 if (!SWIG_IsOK(res1)) {
47713 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_StaticBoxSizer" "', expected argument " "1"" of type '" "wxStaticBox *""'");
47714 }
47715 arg1 = reinterpret_cast< wxStaticBox * >(argp1);
47716 if (obj1) {
47717 ecode2 = SWIG_AsVal_int(obj1, &val2);
47718 if (!SWIG_IsOK(ecode2)) {
47719 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_StaticBoxSizer" "', expected argument " "2"" of type '" "int""'");
47720 }
47721 arg2 = static_cast< int >(val2);
47722 }
47723 {
47724 PyThreadState* __tstate = wxPyBeginAllowThreads();
47725 result = (wxStaticBoxSizer *)new wxStaticBoxSizer(arg1,arg2);
47726 wxPyEndAllowThreads(__tstate);
47727 if (PyErr_Occurred()) SWIG_fail;
47728 }
47729 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStaticBoxSizer, SWIG_POINTER_NEW | 0 );
47730 return resultobj;
47731 fail:
47732 return NULL;
47733 }
47734
47735
47736 SWIGINTERN PyObject *_wrap_StaticBoxSizer_GetStaticBox(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47737 PyObject *resultobj = 0;
47738 wxStaticBoxSizer *arg1 = (wxStaticBoxSizer *) 0 ;
47739 wxStaticBox *result = 0 ;
47740 void *argp1 = 0 ;
47741 int res1 = 0 ;
47742 PyObject *swig_obj[1] ;
47743
47744 if (!args) SWIG_fail;
47745 swig_obj[0] = args;
47746 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStaticBoxSizer, 0 | 0 );
47747 if (!SWIG_IsOK(res1)) {
47748 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StaticBoxSizer_GetStaticBox" "', expected argument " "1"" of type '" "wxStaticBoxSizer *""'");
47749 }
47750 arg1 = reinterpret_cast< wxStaticBoxSizer * >(argp1);
47751 {
47752 PyThreadState* __tstate = wxPyBeginAllowThreads();
47753 result = (wxStaticBox *)(arg1)->GetStaticBox();
47754 wxPyEndAllowThreads(__tstate);
47755 if (PyErr_Occurred()) SWIG_fail;
47756 }
47757 {
47758 resultobj = wxPyMake_wxObject(result, (bool)0);
47759 }
47760 return resultobj;
47761 fail:
47762 return NULL;
47763 }
47764
47765
47766 SWIGINTERN PyObject *StaticBoxSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47767 PyObject *obj;
47768 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
47769 SWIG_TypeNewClientData(SWIGTYPE_p_wxStaticBoxSizer, SWIG_NewClientData(obj));
47770 return SWIG_Py_Void();
47771 }
47772
47773 SWIGINTERN PyObject *StaticBoxSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47774 return SWIG_Python_InitShadowInstance(args);
47775 }
47776
47777 SWIGINTERN PyObject *_wrap_new_GridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47778 PyObject *resultobj = 0;
47779 int arg1 = (int) 1 ;
47780 int arg2 = (int) 0 ;
47781 int arg3 = (int) 0 ;
47782 int arg4 = (int) 0 ;
47783 wxGridSizer *result = 0 ;
47784 int val1 ;
47785 int ecode1 = 0 ;
47786 int val2 ;
47787 int ecode2 = 0 ;
47788 int val3 ;
47789 int ecode3 = 0 ;
47790 int val4 ;
47791 int ecode4 = 0 ;
47792 PyObject * obj0 = 0 ;
47793 PyObject * obj1 = 0 ;
47794 PyObject * obj2 = 0 ;
47795 PyObject * obj3 = 0 ;
47796 char * kwnames[] = {
47797 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
47798 };
47799
47800 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_GridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
47801 if (obj0) {
47802 ecode1 = SWIG_AsVal_int(obj0, &val1);
47803 if (!SWIG_IsOK(ecode1)) {
47804 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridSizer" "', expected argument " "1"" of type '" "int""'");
47805 }
47806 arg1 = static_cast< int >(val1);
47807 }
47808 if (obj1) {
47809 ecode2 = SWIG_AsVal_int(obj1, &val2);
47810 if (!SWIG_IsOK(ecode2)) {
47811 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridSizer" "', expected argument " "2"" of type '" "int""'");
47812 }
47813 arg2 = static_cast< int >(val2);
47814 }
47815 if (obj2) {
47816 ecode3 = SWIG_AsVal_int(obj2, &val3);
47817 if (!SWIG_IsOK(ecode3)) {
47818 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_GridSizer" "', expected argument " "3"" of type '" "int""'");
47819 }
47820 arg3 = static_cast< int >(val3);
47821 }
47822 if (obj3) {
47823 ecode4 = SWIG_AsVal_int(obj3, &val4);
47824 if (!SWIG_IsOK(ecode4)) {
47825 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GridSizer" "', expected argument " "4"" of type '" "int""'");
47826 }
47827 arg4 = static_cast< int >(val4);
47828 }
47829 {
47830 PyThreadState* __tstate = wxPyBeginAllowThreads();
47831 result = (wxGridSizer *)new wxGridSizer(arg1,arg2,arg3,arg4);
47832 wxPyEndAllowThreads(__tstate);
47833 if (PyErr_Occurred()) SWIG_fail;
47834 }
47835 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridSizer, SWIG_POINTER_NEW | 0 );
47836 return resultobj;
47837 fail:
47838 return NULL;
47839 }
47840
47841
47842 SWIGINTERN PyObject *_wrap_GridSizer_SetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47843 PyObject *resultobj = 0;
47844 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47845 int arg2 ;
47846 void *argp1 = 0 ;
47847 int res1 = 0 ;
47848 int val2 ;
47849 int ecode2 = 0 ;
47850 PyObject * obj0 = 0 ;
47851 PyObject * obj1 = 0 ;
47852 char * kwnames[] = {
47853 (char *) "self",(char *) "cols", NULL
47854 };
47855
47856 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetCols",kwnames,&obj0,&obj1)) SWIG_fail;
47857 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47858 if (!SWIG_IsOK(res1)) {
47859 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47860 }
47861 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47862 ecode2 = SWIG_AsVal_int(obj1, &val2);
47863 if (!SWIG_IsOK(ecode2)) {
47864 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetCols" "', expected argument " "2"" of type '" "int""'");
47865 }
47866 arg2 = static_cast< int >(val2);
47867 {
47868 PyThreadState* __tstate = wxPyBeginAllowThreads();
47869 (arg1)->SetCols(arg2);
47870 wxPyEndAllowThreads(__tstate);
47871 if (PyErr_Occurred()) SWIG_fail;
47872 }
47873 resultobj = SWIG_Py_Void();
47874 return resultobj;
47875 fail:
47876 return NULL;
47877 }
47878
47879
47880 SWIGINTERN PyObject *_wrap_GridSizer_SetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47881 PyObject *resultobj = 0;
47882 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47883 int arg2 ;
47884 void *argp1 = 0 ;
47885 int res1 = 0 ;
47886 int val2 ;
47887 int ecode2 = 0 ;
47888 PyObject * obj0 = 0 ;
47889 PyObject * obj1 = 0 ;
47890 char * kwnames[] = {
47891 (char *) "self",(char *) "rows", NULL
47892 };
47893
47894 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetRows",kwnames,&obj0,&obj1)) SWIG_fail;
47895 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47896 if (!SWIG_IsOK(res1)) {
47897 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47898 }
47899 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47900 ecode2 = SWIG_AsVal_int(obj1, &val2);
47901 if (!SWIG_IsOK(ecode2)) {
47902 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetRows" "', expected argument " "2"" of type '" "int""'");
47903 }
47904 arg2 = static_cast< int >(val2);
47905 {
47906 PyThreadState* __tstate = wxPyBeginAllowThreads();
47907 (arg1)->SetRows(arg2);
47908 wxPyEndAllowThreads(__tstate);
47909 if (PyErr_Occurred()) SWIG_fail;
47910 }
47911 resultobj = SWIG_Py_Void();
47912 return resultobj;
47913 fail:
47914 return NULL;
47915 }
47916
47917
47918 SWIGINTERN PyObject *_wrap_GridSizer_SetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47919 PyObject *resultobj = 0;
47920 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47921 int arg2 ;
47922 void *argp1 = 0 ;
47923 int res1 = 0 ;
47924 int val2 ;
47925 int ecode2 = 0 ;
47926 PyObject * obj0 = 0 ;
47927 PyObject * obj1 = 0 ;
47928 char * kwnames[] = {
47929 (char *) "self",(char *) "gap", NULL
47930 };
47931
47932 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetVGap",kwnames,&obj0,&obj1)) SWIG_fail;
47933 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47934 if (!SWIG_IsOK(res1)) {
47935 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47936 }
47937 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47938 ecode2 = SWIG_AsVal_int(obj1, &val2);
47939 if (!SWIG_IsOK(ecode2)) {
47940 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetVGap" "', expected argument " "2"" of type '" "int""'");
47941 }
47942 arg2 = static_cast< int >(val2);
47943 {
47944 PyThreadState* __tstate = wxPyBeginAllowThreads();
47945 (arg1)->SetVGap(arg2);
47946 wxPyEndAllowThreads(__tstate);
47947 if (PyErr_Occurred()) SWIG_fail;
47948 }
47949 resultobj = SWIG_Py_Void();
47950 return resultobj;
47951 fail:
47952 return NULL;
47953 }
47954
47955
47956 SWIGINTERN PyObject *_wrap_GridSizer_SetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
47957 PyObject *resultobj = 0;
47958 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47959 int arg2 ;
47960 void *argp1 = 0 ;
47961 int res1 = 0 ;
47962 int val2 ;
47963 int ecode2 = 0 ;
47964 PyObject * obj0 = 0 ;
47965 PyObject * obj1 = 0 ;
47966 char * kwnames[] = {
47967 (char *) "self",(char *) "gap", NULL
47968 };
47969
47970 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridSizer_SetHGap",kwnames,&obj0,&obj1)) SWIG_fail;
47971 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
47972 if (!SWIG_IsOK(res1)) {
47973 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_SetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
47974 }
47975 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
47976 ecode2 = SWIG_AsVal_int(obj1, &val2);
47977 if (!SWIG_IsOK(ecode2)) {
47978 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridSizer_SetHGap" "', expected argument " "2"" of type '" "int""'");
47979 }
47980 arg2 = static_cast< int >(val2);
47981 {
47982 PyThreadState* __tstate = wxPyBeginAllowThreads();
47983 (arg1)->SetHGap(arg2);
47984 wxPyEndAllowThreads(__tstate);
47985 if (PyErr_Occurred()) SWIG_fail;
47986 }
47987 resultobj = SWIG_Py_Void();
47988 return resultobj;
47989 fail:
47990 return NULL;
47991 }
47992
47993
47994 SWIGINTERN PyObject *_wrap_GridSizer_GetCols(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
47995 PyObject *resultobj = 0;
47996 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
47997 int result;
47998 void *argp1 = 0 ;
47999 int res1 = 0 ;
48000 PyObject *swig_obj[1] ;
48001
48002 if (!args) SWIG_fail;
48003 swig_obj[0] = args;
48004 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48005 if (!SWIG_IsOK(res1)) {
48006 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetCols" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48007 }
48008 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48009 {
48010 PyThreadState* __tstate = wxPyBeginAllowThreads();
48011 result = (int)(arg1)->GetCols();
48012 wxPyEndAllowThreads(__tstate);
48013 if (PyErr_Occurred()) SWIG_fail;
48014 }
48015 resultobj = SWIG_From_int(static_cast< int >(result));
48016 return resultobj;
48017 fail:
48018 return NULL;
48019 }
48020
48021
48022 SWIGINTERN PyObject *_wrap_GridSizer_GetRows(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48023 PyObject *resultobj = 0;
48024 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48025 int result;
48026 void *argp1 = 0 ;
48027 int res1 = 0 ;
48028 PyObject *swig_obj[1] ;
48029
48030 if (!args) SWIG_fail;
48031 swig_obj[0] = args;
48032 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48033 if (!SWIG_IsOK(res1)) {
48034 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetRows" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48035 }
48036 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48037 {
48038 PyThreadState* __tstate = wxPyBeginAllowThreads();
48039 result = (int)(arg1)->GetRows();
48040 wxPyEndAllowThreads(__tstate);
48041 if (PyErr_Occurred()) SWIG_fail;
48042 }
48043 resultobj = SWIG_From_int(static_cast< int >(result));
48044 return resultobj;
48045 fail:
48046 return NULL;
48047 }
48048
48049
48050 SWIGINTERN PyObject *_wrap_GridSizer_GetVGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48051 PyObject *resultobj = 0;
48052 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48053 int result;
48054 void *argp1 = 0 ;
48055 int res1 = 0 ;
48056 PyObject *swig_obj[1] ;
48057
48058 if (!args) SWIG_fail;
48059 swig_obj[0] = args;
48060 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48061 if (!SWIG_IsOK(res1)) {
48062 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetVGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48063 }
48064 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48065 {
48066 PyThreadState* __tstate = wxPyBeginAllowThreads();
48067 result = (int)(arg1)->GetVGap();
48068 wxPyEndAllowThreads(__tstate);
48069 if (PyErr_Occurred()) SWIG_fail;
48070 }
48071 resultobj = SWIG_From_int(static_cast< int >(result));
48072 return resultobj;
48073 fail:
48074 return NULL;
48075 }
48076
48077
48078 SWIGINTERN PyObject *_wrap_GridSizer_GetHGap(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48079 PyObject *resultobj = 0;
48080 wxGridSizer *arg1 = (wxGridSizer *) 0 ;
48081 int result;
48082 void *argp1 = 0 ;
48083 int res1 = 0 ;
48084 PyObject *swig_obj[1] ;
48085
48086 if (!args) SWIG_fail;
48087 swig_obj[0] = args;
48088 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridSizer, 0 | 0 );
48089 if (!SWIG_IsOK(res1)) {
48090 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridSizer_GetHGap" "', expected argument " "1"" of type '" "wxGridSizer *""'");
48091 }
48092 arg1 = reinterpret_cast< wxGridSizer * >(argp1);
48093 {
48094 PyThreadState* __tstate = wxPyBeginAllowThreads();
48095 result = (int)(arg1)->GetHGap();
48096 wxPyEndAllowThreads(__tstate);
48097 if (PyErr_Occurred()) SWIG_fail;
48098 }
48099 resultobj = SWIG_From_int(static_cast< int >(result));
48100 return resultobj;
48101 fail:
48102 return NULL;
48103 }
48104
48105
48106 SWIGINTERN PyObject *GridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48107 PyObject *obj;
48108 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48109 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridSizer, SWIG_NewClientData(obj));
48110 return SWIG_Py_Void();
48111 }
48112
48113 SWIGINTERN PyObject *GridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48114 return SWIG_Python_InitShadowInstance(args);
48115 }
48116
48117 SWIGINTERN PyObject *_wrap_new_FlexGridSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48118 PyObject *resultobj = 0;
48119 int arg1 = (int) 1 ;
48120 int arg2 = (int) 0 ;
48121 int arg3 = (int) 0 ;
48122 int arg4 = (int) 0 ;
48123 wxFlexGridSizer *result = 0 ;
48124 int val1 ;
48125 int ecode1 = 0 ;
48126 int val2 ;
48127 int ecode2 = 0 ;
48128 int val3 ;
48129 int ecode3 = 0 ;
48130 int val4 ;
48131 int ecode4 = 0 ;
48132 PyObject * obj0 = 0 ;
48133 PyObject * obj1 = 0 ;
48134 PyObject * obj2 = 0 ;
48135 PyObject * obj3 = 0 ;
48136 char * kwnames[] = {
48137 (char *) "rows",(char *) "cols",(char *) "vgap",(char *) "hgap", NULL
48138 };
48139
48140 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OOOO:new_FlexGridSizer",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
48141 if (obj0) {
48142 ecode1 = SWIG_AsVal_int(obj0, &val1);
48143 if (!SWIG_IsOK(ecode1)) {
48144 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_FlexGridSizer" "', expected argument " "1"" of type '" "int""'");
48145 }
48146 arg1 = static_cast< int >(val1);
48147 }
48148 if (obj1) {
48149 ecode2 = SWIG_AsVal_int(obj1, &val2);
48150 if (!SWIG_IsOK(ecode2)) {
48151 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_FlexGridSizer" "', expected argument " "2"" of type '" "int""'");
48152 }
48153 arg2 = static_cast< int >(val2);
48154 }
48155 if (obj2) {
48156 ecode3 = SWIG_AsVal_int(obj2, &val3);
48157 if (!SWIG_IsOK(ecode3)) {
48158 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "new_FlexGridSizer" "', expected argument " "3"" of type '" "int""'");
48159 }
48160 arg3 = static_cast< int >(val3);
48161 }
48162 if (obj3) {
48163 ecode4 = SWIG_AsVal_int(obj3, &val4);
48164 if (!SWIG_IsOK(ecode4)) {
48165 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_FlexGridSizer" "', expected argument " "4"" of type '" "int""'");
48166 }
48167 arg4 = static_cast< int >(val4);
48168 }
48169 {
48170 PyThreadState* __tstate = wxPyBeginAllowThreads();
48171 result = (wxFlexGridSizer *)new wxFlexGridSizer(arg1,arg2,arg3,arg4);
48172 wxPyEndAllowThreads(__tstate);
48173 if (PyErr_Occurred()) SWIG_fail;
48174 }
48175 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxFlexGridSizer, SWIG_POINTER_NEW | 0 );
48176 return resultobj;
48177 fail:
48178 return NULL;
48179 }
48180
48181
48182 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48183 PyObject *resultobj = 0;
48184 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48185 size_t arg2 ;
48186 int arg3 = (int) 0 ;
48187 void *argp1 = 0 ;
48188 int res1 = 0 ;
48189 size_t val2 ;
48190 int ecode2 = 0 ;
48191 int val3 ;
48192 int ecode3 = 0 ;
48193 PyObject * obj0 = 0 ;
48194 PyObject * obj1 = 0 ;
48195 PyObject * obj2 = 0 ;
48196 char * kwnames[] = {
48197 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48198 };
48199
48200 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableRow",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48201 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48202 if (!SWIG_IsOK(res1)) {
48203 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48204 }
48205 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48206 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48207 if (!SWIG_IsOK(ecode2)) {
48208 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48209 }
48210 arg2 = static_cast< size_t >(val2);
48211 if (obj2) {
48212 ecode3 = SWIG_AsVal_int(obj2, &val3);
48213 if (!SWIG_IsOK(ecode3)) {
48214 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableRow" "', expected argument " "3"" of type '" "int""'");
48215 }
48216 arg3 = static_cast< int >(val3);
48217 }
48218 {
48219 PyThreadState* __tstate = wxPyBeginAllowThreads();
48220 (arg1)->AddGrowableRow(arg2,arg3);
48221 wxPyEndAllowThreads(__tstate);
48222 if (PyErr_Occurred()) SWIG_fail;
48223 }
48224 resultobj = SWIG_Py_Void();
48225 return resultobj;
48226 fail:
48227 return NULL;
48228 }
48229
48230
48231 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48232 PyObject *resultobj = 0;
48233 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48234 size_t arg2 ;
48235 void *argp1 = 0 ;
48236 int res1 = 0 ;
48237 size_t val2 ;
48238 int ecode2 = 0 ;
48239 PyObject * obj0 = 0 ;
48240 PyObject * obj1 = 0 ;
48241 char * kwnames[] = {
48242 (char *) "self",(char *) "idx", NULL
48243 };
48244
48245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableRow",kwnames,&obj0,&obj1)) SWIG_fail;
48246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48247 if (!SWIG_IsOK(res1)) {
48248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48249 }
48250 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48251 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48252 if (!SWIG_IsOK(ecode2)) {
48253 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableRow" "', expected argument " "2"" of type '" "size_t""'");
48254 }
48255 arg2 = static_cast< size_t >(val2);
48256 {
48257 PyThreadState* __tstate = wxPyBeginAllowThreads();
48258 (arg1)->RemoveGrowableRow(arg2);
48259 wxPyEndAllowThreads(__tstate);
48260 if (PyErr_Occurred()) SWIG_fail;
48261 }
48262 resultobj = SWIG_Py_Void();
48263 return resultobj;
48264 fail:
48265 return NULL;
48266 }
48267
48268
48269 SWIGINTERN PyObject *_wrap_FlexGridSizer_AddGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48270 PyObject *resultobj = 0;
48271 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48272 size_t arg2 ;
48273 int arg3 = (int) 0 ;
48274 void *argp1 = 0 ;
48275 int res1 = 0 ;
48276 size_t val2 ;
48277 int ecode2 = 0 ;
48278 int val3 ;
48279 int ecode3 = 0 ;
48280 PyObject * obj0 = 0 ;
48281 PyObject * obj1 = 0 ;
48282 PyObject * obj2 = 0 ;
48283 char * kwnames[] = {
48284 (char *) "self",(char *) "idx",(char *) "proportion", NULL
48285 };
48286
48287 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:FlexGridSizer_AddGrowableCol",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
48288 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48289 if (!SWIG_IsOK(res1)) {
48290 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48291 }
48292 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48293 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48294 if (!SWIG_IsOK(ecode2)) {
48295 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48296 }
48297 arg2 = static_cast< size_t >(val2);
48298 if (obj2) {
48299 ecode3 = SWIG_AsVal_int(obj2, &val3);
48300 if (!SWIG_IsOK(ecode3)) {
48301 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "FlexGridSizer_AddGrowableCol" "', expected argument " "3"" of type '" "int""'");
48302 }
48303 arg3 = static_cast< int >(val3);
48304 }
48305 {
48306 PyThreadState* __tstate = wxPyBeginAllowThreads();
48307 (arg1)->AddGrowableCol(arg2,arg3);
48308 wxPyEndAllowThreads(__tstate);
48309 if (PyErr_Occurred()) SWIG_fail;
48310 }
48311 resultobj = SWIG_Py_Void();
48312 return resultobj;
48313 fail:
48314 return NULL;
48315 }
48316
48317
48318 SWIGINTERN PyObject *_wrap_FlexGridSizer_RemoveGrowableCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48319 PyObject *resultobj = 0;
48320 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48321 size_t arg2 ;
48322 void *argp1 = 0 ;
48323 int res1 = 0 ;
48324 size_t val2 ;
48325 int ecode2 = 0 ;
48326 PyObject * obj0 = 0 ;
48327 PyObject * obj1 = 0 ;
48328 char * kwnames[] = {
48329 (char *) "self",(char *) "idx", NULL
48330 };
48331
48332 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_RemoveGrowableCol",kwnames,&obj0,&obj1)) SWIG_fail;
48333 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48334 if (!SWIG_IsOK(res1)) {
48335 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48336 }
48337 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48338 ecode2 = SWIG_AsVal_size_t(obj1, &val2);
48339 if (!SWIG_IsOK(ecode2)) {
48340 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_RemoveGrowableCol" "', expected argument " "2"" of type '" "size_t""'");
48341 }
48342 arg2 = static_cast< size_t >(val2);
48343 {
48344 PyThreadState* __tstate = wxPyBeginAllowThreads();
48345 (arg1)->RemoveGrowableCol(arg2);
48346 wxPyEndAllowThreads(__tstate);
48347 if (PyErr_Occurred()) SWIG_fail;
48348 }
48349 resultobj = SWIG_Py_Void();
48350 return resultobj;
48351 fail:
48352 return NULL;
48353 }
48354
48355
48356 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48357 PyObject *resultobj = 0;
48358 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48359 int arg2 ;
48360 void *argp1 = 0 ;
48361 int res1 = 0 ;
48362 int val2 ;
48363 int ecode2 = 0 ;
48364 PyObject * obj0 = 0 ;
48365 PyObject * obj1 = 0 ;
48366 char * kwnames[] = {
48367 (char *) "self",(char *) "direction", NULL
48368 };
48369
48370 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetFlexibleDirection",kwnames,&obj0,&obj1)) SWIG_fail;
48371 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48372 if (!SWIG_IsOK(res1)) {
48373 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48374 }
48375 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48376 ecode2 = SWIG_AsVal_int(obj1, &val2);
48377 if (!SWIG_IsOK(ecode2)) {
48378 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetFlexibleDirection" "', expected argument " "2"" of type '" "int""'");
48379 }
48380 arg2 = static_cast< int >(val2);
48381 {
48382 PyThreadState* __tstate = wxPyBeginAllowThreads();
48383 (arg1)->SetFlexibleDirection(arg2);
48384 wxPyEndAllowThreads(__tstate);
48385 if (PyErr_Occurred()) SWIG_fail;
48386 }
48387 resultobj = SWIG_Py_Void();
48388 return resultobj;
48389 fail:
48390 return NULL;
48391 }
48392
48393
48394 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetFlexibleDirection(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48395 PyObject *resultobj = 0;
48396 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48397 int result;
48398 void *argp1 = 0 ;
48399 int res1 = 0 ;
48400 PyObject *swig_obj[1] ;
48401
48402 if (!args) SWIG_fail;
48403 swig_obj[0] = args;
48404 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48405 if (!SWIG_IsOK(res1)) {
48406 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetFlexibleDirection" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48407 }
48408 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48409 {
48410 PyThreadState* __tstate = wxPyBeginAllowThreads();
48411 result = (int)(arg1)->GetFlexibleDirection();
48412 wxPyEndAllowThreads(__tstate);
48413 if (PyErr_Occurred()) SWIG_fail;
48414 }
48415 resultobj = SWIG_From_int(static_cast< int >(result));
48416 return resultobj;
48417 fail:
48418 return NULL;
48419 }
48420
48421
48422 SWIGINTERN PyObject *_wrap_FlexGridSizer_SetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48423 PyObject *resultobj = 0;
48424 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48425 wxFlexSizerGrowMode arg2 ;
48426 void *argp1 = 0 ;
48427 int res1 = 0 ;
48428 int val2 ;
48429 int ecode2 = 0 ;
48430 PyObject * obj0 = 0 ;
48431 PyObject * obj1 = 0 ;
48432 char * kwnames[] = {
48433 (char *) "self",(char *) "mode", NULL
48434 };
48435
48436 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:FlexGridSizer_SetNonFlexibleGrowMode",kwnames,&obj0,&obj1)) SWIG_fail;
48437 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48438 if (!SWIG_IsOK(res1)) {
48439 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48440 }
48441 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48442 ecode2 = SWIG_AsVal_int(obj1, &val2);
48443 if (!SWIG_IsOK(ecode2)) {
48444 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "FlexGridSizer_SetNonFlexibleGrowMode" "', expected argument " "2"" of type '" "wxFlexSizerGrowMode""'");
48445 }
48446 arg2 = static_cast< wxFlexSizerGrowMode >(val2);
48447 {
48448 PyThreadState* __tstate = wxPyBeginAllowThreads();
48449 (arg1)->SetNonFlexibleGrowMode(arg2);
48450 wxPyEndAllowThreads(__tstate);
48451 if (PyErr_Occurred()) SWIG_fail;
48452 }
48453 resultobj = SWIG_Py_Void();
48454 return resultobj;
48455 fail:
48456 return NULL;
48457 }
48458
48459
48460 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetNonFlexibleGrowMode(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48461 PyObject *resultobj = 0;
48462 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48463 wxFlexSizerGrowMode result;
48464 void *argp1 = 0 ;
48465 int res1 = 0 ;
48466 PyObject *swig_obj[1] ;
48467
48468 if (!args) SWIG_fail;
48469 swig_obj[0] = args;
48470 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48471 if (!SWIG_IsOK(res1)) {
48472 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetNonFlexibleGrowMode" "', expected argument " "1"" of type '" "wxFlexGridSizer *""'");
48473 }
48474 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48475 {
48476 PyThreadState* __tstate = wxPyBeginAllowThreads();
48477 result = (wxFlexSizerGrowMode)(arg1)->GetNonFlexibleGrowMode();
48478 wxPyEndAllowThreads(__tstate);
48479 if (PyErr_Occurred()) SWIG_fail;
48480 }
48481 resultobj = SWIG_From_int(static_cast< int >(result));
48482 return resultobj;
48483 fail:
48484 return NULL;
48485 }
48486
48487
48488 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetRowHeights(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48489 PyObject *resultobj = 0;
48490 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48491 wxArrayInt *result = 0 ;
48492 void *argp1 = 0 ;
48493 int res1 = 0 ;
48494 PyObject *swig_obj[1] ;
48495
48496 if (!args) SWIG_fail;
48497 swig_obj[0] = args;
48498 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48499 if (!SWIG_IsOK(res1)) {
48500 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetRowHeights" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48501 }
48502 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48503 {
48504 PyThreadState* __tstate = wxPyBeginAllowThreads();
48505 {
48506 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetRowHeights();
48507 result = (wxArrayInt *) &_result_ref;
48508 }
48509 wxPyEndAllowThreads(__tstate);
48510 if (PyErr_Occurred()) SWIG_fail;
48511 }
48512 {
48513 resultobj = PyList_New(0);
48514 size_t idx;
48515 for (idx = 0; idx < result->GetCount(); idx += 1) {
48516 PyObject* val = PyInt_FromLong( result->Item(idx) );
48517 PyList_Append(resultobj, val);
48518 Py_DECREF(val);
48519 }
48520 }
48521 return resultobj;
48522 fail:
48523 return NULL;
48524 }
48525
48526
48527 SWIGINTERN PyObject *_wrap_FlexGridSizer_GetColWidths(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48528 PyObject *resultobj = 0;
48529 wxFlexGridSizer *arg1 = (wxFlexGridSizer *) 0 ;
48530 wxArrayInt *result = 0 ;
48531 void *argp1 = 0 ;
48532 int res1 = 0 ;
48533 PyObject *swig_obj[1] ;
48534
48535 if (!args) SWIG_fail;
48536 swig_obj[0] = args;
48537 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxFlexGridSizer, 0 | 0 );
48538 if (!SWIG_IsOK(res1)) {
48539 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "FlexGridSizer_GetColWidths" "', expected argument " "1"" of type '" "wxFlexGridSizer const *""'");
48540 }
48541 arg1 = reinterpret_cast< wxFlexGridSizer * >(argp1);
48542 {
48543 PyThreadState* __tstate = wxPyBeginAllowThreads();
48544 {
48545 wxArrayInt const &_result_ref = ((wxFlexGridSizer const *)arg1)->GetColWidths();
48546 result = (wxArrayInt *) &_result_ref;
48547 }
48548 wxPyEndAllowThreads(__tstate);
48549 if (PyErr_Occurred()) SWIG_fail;
48550 }
48551 {
48552 resultobj = PyList_New(0);
48553 size_t idx;
48554 for (idx = 0; idx < result->GetCount(); idx += 1) {
48555 PyObject* val = PyInt_FromLong( result->Item(idx) );
48556 PyList_Append(resultobj, val);
48557 Py_DECREF(val);
48558 }
48559 }
48560 return resultobj;
48561 fail:
48562 return NULL;
48563 }
48564
48565
48566 SWIGINTERN PyObject *FlexGridSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48567 PyObject *obj;
48568 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48569 SWIG_TypeNewClientData(SWIGTYPE_p_wxFlexGridSizer, SWIG_NewClientData(obj));
48570 return SWIG_Py_Void();
48571 }
48572
48573 SWIGINTERN PyObject *FlexGridSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48574 return SWIG_Python_InitShadowInstance(args);
48575 }
48576
48577 SWIGINTERN PyObject *_wrap_new_StdDialogButtonSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48578 PyObject *resultobj = 0;
48579 wxStdDialogButtonSizer *result = 0 ;
48580
48581 if (!SWIG_Python_UnpackTuple(args,"new_StdDialogButtonSizer",0,0,0)) SWIG_fail;
48582 {
48583 PyThreadState* __tstate = wxPyBeginAllowThreads();
48584 result = (wxStdDialogButtonSizer *)new wxStdDialogButtonSizer();
48585 wxPyEndAllowThreads(__tstate);
48586 if (PyErr_Occurred()) SWIG_fail;
48587 }
48588 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_POINTER_NEW | 0 );
48589 return resultobj;
48590 fail:
48591 return NULL;
48592 }
48593
48594
48595 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_AddButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48596 PyObject *resultobj = 0;
48597 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48598 wxButton *arg2 = (wxButton *) 0 ;
48599 void *argp1 = 0 ;
48600 int res1 = 0 ;
48601 void *argp2 = 0 ;
48602 int res2 = 0 ;
48603 PyObject * obj0 = 0 ;
48604 PyObject * obj1 = 0 ;
48605 char * kwnames[] = {
48606 (char *) "self",(char *) "button", NULL
48607 };
48608
48609 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_AddButton",kwnames,&obj0,&obj1)) SWIG_fail;
48610 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48611 if (!SWIG_IsOK(res1)) {
48612 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48613 }
48614 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48615 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48616 if (!SWIG_IsOK(res2)) {
48617 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_AddButton" "', expected argument " "2"" of type '" "wxButton *""'");
48618 }
48619 arg2 = reinterpret_cast< wxButton * >(argp2);
48620 {
48621 PyThreadState* __tstate = wxPyBeginAllowThreads();
48622 (arg1)->AddButton(arg2);
48623 wxPyEndAllowThreads(__tstate);
48624 if (PyErr_Occurred()) SWIG_fail;
48625 }
48626 resultobj = SWIG_Py_Void();
48627 return resultobj;
48628 fail:
48629 return NULL;
48630 }
48631
48632
48633 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_Realize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48634 PyObject *resultobj = 0;
48635 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48636 void *argp1 = 0 ;
48637 int res1 = 0 ;
48638 PyObject *swig_obj[1] ;
48639
48640 if (!args) SWIG_fail;
48641 swig_obj[0] = args;
48642 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48643 if (!SWIG_IsOK(res1)) {
48644 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_Realize" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48645 }
48646 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48647 {
48648 PyThreadState* __tstate = wxPyBeginAllowThreads();
48649 (arg1)->Realize();
48650 wxPyEndAllowThreads(__tstate);
48651 if (PyErr_Occurred()) SWIG_fail;
48652 }
48653 resultobj = SWIG_Py_Void();
48654 return resultobj;
48655 fail:
48656 return NULL;
48657 }
48658
48659
48660 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48661 PyObject *resultobj = 0;
48662 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48663 wxButton *arg2 = (wxButton *) 0 ;
48664 void *argp1 = 0 ;
48665 int res1 = 0 ;
48666 void *argp2 = 0 ;
48667 int res2 = 0 ;
48668 PyObject * obj0 = 0 ;
48669 PyObject * obj1 = 0 ;
48670 char * kwnames[] = {
48671 (char *) "self",(char *) "button", NULL
48672 };
48673
48674 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetAffirmativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48675 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48676 if (!SWIG_IsOK(res1)) {
48677 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48678 }
48679 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48680 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48681 if (!SWIG_IsOK(res2)) {
48682 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetAffirmativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48683 }
48684 arg2 = reinterpret_cast< wxButton * >(argp2);
48685 {
48686 PyThreadState* __tstate = wxPyBeginAllowThreads();
48687 (arg1)->SetAffirmativeButton(arg2);
48688 wxPyEndAllowThreads(__tstate);
48689 if (PyErr_Occurred()) SWIG_fail;
48690 }
48691 resultobj = SWIG_Py_Void();
48692 return resultobj;
48693 fail:
48694 return NULL;
48695 }
48696
48697
48698 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48699 PyObject *resultobj = 0;
48700 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48701 wxButton *arg2 = (wxButton *) 0 ;
48702 void *argp1 = 0 ;
48703 int res1 = 0 ;
48704 void *argp2 = 0 ;
48705 int res2 = 0 ;
48706 PyObject * obj0 = 0 ;
48707 PyObject * obj1 = 0 ;
48708 char * kwnames[] = {
48709 (char *) "self",(char *) "button", NULL
48710 };
48711
48712 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetNegativeButton",kwnames,&obj0,&obj1)) SWIG_fail;
48713 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48714 if (!SWIG_IsOK(res1)) {
48715 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48716 }
48717 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48718 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48719 if (!SWIG_IsOK(res2)) {
48720 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetNegativeButton" "', expected argument " "2"" of type '" "wxButton *""'");
48721 }
48722 arg2 = reinterpret_cast< wxButton * >(argp2);
48723 {
48724 PyThreadState* __tstate = wxPyBeginAllowThreads();
48725 (arg1)->SetNegativeButton(arg2);
48726 wxPyEndAllowThreads(__tstate);
48727 if (PyErr_Occurred()) SWIG_fail;
48728 }
48729 resultobj = SWIG_Py_Void();
48730 return resultobj;
48731 fail:
48732 return NULL;
48733 }
48734
48735
48736 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_SetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48737 PyObject *resultobj = 0;
48738 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48739 wxButton *arg2 = (wxButton *) 0 ;
48740 void *argp1 = 0 ;
48741 int res1 = 0 ;
48742 void *argp2 = 0 ;
48743 int res2 = 0 ;
48744 PyObject * obj0 = 0 ;
48745 PyObject * obj1 = 0 ;
48746 char * kwnames[] = {
48747 (char *) "self",(char *) "button", NULL
48748 };
48749
48750 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:StdDialogButtonSizer_SetCancelButton",kwnames,&obj0,&obj1)) SWIG_fail;
48751 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48752 if (!SWIG_IsOK(res1)) {
48753 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer *""'");
48754 }
48755 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48756 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxButton, 0 | 0 );
48757 if (!SWIG_IsOK(res2)) {
48758 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "StdDialogButtonSizer_SetCancelButton" "', expected argument " "2"" of type '" "wxButton *""'");
48759 }
48760 arg2 = reinterpret_cast< wxButton * >(argp2);
48761 {
48762 PyThreadState* __tstate = wxPyBeginAllowThreads();
48763 (arg1)->SetCancelButton(arg2);
48764 wxPyEndAllowThreads(__tstate);
48765 if (PyErr_Occurred()) SWIG_fail;
48766 }
48767 resultobj = SWIG_Py_Void();
48768 return resultobj;
48769 fail:
48770 return NULL;
48771 }
48772
48773
48774 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetAffirmativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48775 PyObject *resultobj = 0;
48776 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48777 wxButton *result = 0 ;
48778 void *argp1 = 0 ;
48779 int res1 = 0 ;
48780 PyObject *swig_obj[1] ;
48781
48782 if (!args) SWIG_fail;
48783 swig_obj[0] = args;
48784 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48785 if (!SWIG_IsOK(res1)) {
48786 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetAffirmativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48787 }
48788 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48789 {
48790 PyThreadState* __tstate = wxPyBeginAllowThreads();
48791 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetAffirmativeButton();
48792 wxPyEndAllowThreads(__tstate);
48793 if (PyErr_Occurred()) SWIG_fail;
48794 }
48795 {
48796 resultobj = wxPyMake_wxObject(result, (bool)0);
48797 }
48798 return resultobj;
48799 fail:
48800 return NULL;
48801 }
48802
48803
48804 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetApplyButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48805 PyObject *resultobj = 0;
48806 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48807 wxButton *result = 0 ;
48808 void *argp1 = 0 ;
48809 int res1 = 0 ;
48810 PyObject *swig_obj[1] ;
48811
48812 if (!args) SWIG_fail;
48813 swig_obj[0] = args;
48814 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48815 if (!SWIG_IsOK(res1)) {
48816 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetApplyButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48817 }
48818 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48819 {
48820 PyThreadState* __tstate = wxPyBeginAllowThreads();
48821 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetApplyButton();
48822 wxPyEndAllowThreads(__tstate);
48823 if (PyErr_Occurred()) SWIG_fail;
48824 }
48825 {
48826 resultobj = wxPyMake_wxObject(result, (bool)0);
48827 }
48828 return resultobj;
48829 fail:
48830 return NULL;
48831 }
48832
48833
48834 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetNegativeButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48835 PyObject *resultobj = 0;
48836 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48837 wxButton *result = 0 ;
48838 void *argp1 = 0 ;
48839 int res1 = 0 ;
48840 PyObject *swig_obj[1] ;
48841
48842 if (!args) SWIG_fail;
48843 swig_obj[0] = args;
48844 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48845 if (!SWIG_IsOK(res1)) {
48846 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetNegativeButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48847 }
48848 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48849 {
48850 PyThreadState* __tstate = wxPyBeginAllowThreads();
48851 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetNegativeButton();
48852 wxPyEndAllowThreads(__tstate);
48853 if (PyErr_Occurred()) SWIG_fail;
48854 }
48855 {
48856 resultobj = wxPyMake_wxObject(result, (bool)0);
48857 }
48858 return resultobj;
48859 fail:
48860 return NULL;
48861 }
48862
48863
48864 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetCancelButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48865 PyObject *resultobj = 0;
48866 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48867 wxButton *result = 0 ;
48868 void *argp1 = 0 ;
48869 int res1 = 0 ;
48870 PyObject *swig_obj[1] ;
48871
48872 if (!args) SWIG_fail;
48873 swig_obj[0] = args;
48874 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48875 if (!SWIG_IsOK(res1)) {
48876 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetCancelButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48877 }
48878 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48879 {
48880 PyThreadState* __tstate = wxPyBeginAllowThreads();
48881 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetCancelButton();
48882 wxPyEndAllowThreads(__tstate);
48883 if (PyErr_Occurred()) SWIG_fail;
48884 }
48885 {
48886 resultobj = wxPyMake_wxObject(result, (bool)0);
48887 }
48888 return resultobj;
48889 fail:
48890 return NULL;
48891 }
48892
48893
48894 SWIGINTERN PyObject *_wrap_StdDialogButtonSizer_GetHelpButton(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48895 PyObject *resultobj = 0;
48896 wxStdDialogButtonSizer *arg1 = (wxStdDialogButtonSizer *) 0 ;
48897 wxButton *result = 0 ;
48898 void *argp1 = 0 ;
48899 int res1 = 0 ;
48900 PyObject *swig_obj[1] ;
48901
48902 if (!args) SWIG_fail;
48903 swig_obj[0] = args;
48904 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxStdDialogButtonSizer, 0 | 0 );
48905 if (!SWIG_IsOK(res1)) {
48906 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "StdDialogButtonSizer_GetHelpButton" "', expected argument " "1"" of type '" "wxStdDialogButtonSizer const *""'");
48907 }
48908 arg1 = reinterpret_cast< wxStdDialogButtonSizer * >(argp1);
48909 {
48910 PyThreadState* __tstate = wxPyBeginAllowThreads();
48911 result = (wxButton *)((wxStdDialogButtonSizer const *)arg1)->GetHelpButton();
48912 wxPyEndAllowThreads(__tstate);
48913 if (PyErr_Occurred()) SWIG_fail;
48914 }
48915 {
48916 resultobj = wxPyMake_wxObject(result, (bool)0);
48917 }
48918 return resultobj;
48919 fail:
48920 return NULL;
48921 }
48922
48923
48924 SWIGINTERN PyObject *StdDialogButtonSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48925 PyObject *obj;
48926 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
48927 SWIG_TypeNewClientData(SWIGTYPE_p_wxStdDialogButtonSizer, SWIG_NewClientData(obj));
48928 return SWIG_Py_Void();
48929 }
48930
48931 SWIGINTERN PyObject *StdDialogButtonSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48932 return SWIG_Python_InitShadowInstance(args);
48933 }
48934
48935 SWIGINTERN PyObject *_wrap_new_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
48936 PyObject *resultobj = 0;
48937 int arg1 = (int) 0 ;
48938 int arg2 = (int) 0 ;
48939 wxGBPosition *result = 0 ;
48940 int val1 ;
48941 int ecode1 = 0 ;
48942 int val2 ;
48943 int ecode2 = 0 ;
48944 PyObject * obj0 = 0 ;
48945 PyObject * obj1 = 0 ;
48946 char * kwnames[] = {
48947 (char *) "row",(char *) "col", NULL
48948 };
48949
48950 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBPosition",kwnames,&obj0,&obj1)) SWIG_fail;
48951 if (obj0) {
48952 ecode1 = SWIG_AsVal_int(obj0, &val1);
48953 if (!SWIG_IsOK(ecode1)) {
48954 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBPosition" "', expected argument " "1"" of type '" "int""'");
48955 }
48956 arg1 = static_cast< int >(val1);
48957 }
48958 if (obj1) {
48959 ecode2 = SWIG_AsVal_int(obj1, &val2);
48960 if (!SWIG_IsOK(ecode2)) {
48961 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBPosition" "', expected argument " "2"" of type '" "int""'");
48962 }
48963 arg2 = static_cast< int >(val2);
48964 }
48965 {
48966 PyThreadState* __tstate = wxPyBeginAllowThreads();
48967 result = (wxGBPosition *)new wxGBPosition(arg1,arg2);
48968 wxPyEndAllowThreads(__tstate);
48969 if (PyErr_Occurred()) SWIG_fail;
48970 }
48971 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_NEW | 0 );
48972 return resultobj;
48973 fail:
48974 return NULL;
48975 }
48976
48977
48978 SWIGINTERN PyObject *_wrap_delete_GBPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
48979 PyObject *resultobj = 0;
48980 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
48981 void *argp1 = 0 ;
48982 int res1 = 0 ;
48983 PyObject *swig_obj[1] ;
48984
48985 if (!args) SWIG_fail;
48986 swig_obj[0] = args;
48987 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, SWIG_POINTER_DISOWN | 0 );
48988 if (!SWIG_IsOK(res1)) {
48989 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBPosition" "', expected argument " "1"" of type '" "wxGBPosition *""'");
48990 }
48991 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
48992 {
48993 PyThreadState* __tstate = wxPyBeginAllowThreads();
48994 delete arg1;
48995
48996 wxPyEndAllowThreads(__tstate);
48997 if (PyErr_Occurred()) SWIG_fail;
48998 }
48999 resultobj = SWIG_Py_Void();
49000 return resultobj;
49001 fail:
49002 return NULL;
49003 }
49004
49005
49006 SWIGINTERN PyObject *_wrap_GBPosition_GetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49007 PyObject *resultobj = 0;
49008 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49009 int result;
49010 void *argp1 = 0 ;
49011 int res1 = 0 ;
49012 PyObject *swig_obj[1] ;
49013
49014 if (!args) SWIG_fail;
49015 swig_obj[0] = args;
49016 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49017 if (!SWIG_IsOK(res1)) {
49018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetRow" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49019 }
49020 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49021 {
49022 PyThreadState* __tstate = wxPyBeginAllowThreads();
49023 result = (int)((wxGBPosition const *)arg1)->GetRow();
49024 wxPyEndAllowThreads(__tstate);
49025 if (PyErr_Occurred()) SWIG_fail;
49026 }
49027 resultobj = SWIG_From_int(static_cast< int >(result));
49028 return resultobj;
49029 fail:
49030 return NULL;
49031 }
49032
49033
49034 SWIGINTERN PyObject *_wrap_GBPosition_GetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49035 PyObject *resultobj = 0;
49036 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49037 int result;
49038 void *argp1 = 0 ;
49039 int res1 = 0 ;
49040 PyObject *swig_obj[1] ;
49041
49042 if (!args) SWIG_fail;
49043 swig_obj[0] = args;
49044 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49045 if (!SWIG_IsOK(res1)) {
49046 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_GetCol" "', expected argument " "1"" of type '" "wxGBPosition const *""'");
49047 }
49048 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49049 {
49050 PyThreadState* __tstate = wxPyBeginAllowThreads();
49051 result = (int)((wxGBPosition const *)arg1)->GetCol();
49052 wxPyEndAllowThreads(__tstate);
49053 if (PyErr_Occurred()) SWIG_fail;
49054 }
49055 resultobj = SWIG_From_int(static_cast< int >(result));
49056 return resultobj;
49057 fail:
49058 return NULL;
49059 }
49060
49061
49062 SWIGINTERN PyObject *_wrap_GBPosition_SetRow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49063 PyObject *resultobj = 0;
49064 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49065 int arg2 ;
49066 void *argp1 = 0 ;
49067 int res1 = 0 ;
49068 int val2 ;
49069 int ecode2 = 0 ;
49070 PyObject * obj0 = 0 ;
49071 PyObject * obj1 = 0 ;
49072 char * kwnames[] = {
49073 (char *) "self",(char *) "row", NULL
49074 };
49075
49076 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetRow",kwnames,&obj0,&obj1)) SWIG_fail;
49077 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49078 if (!SWIG_IsOK(res1)) {
49079 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetRow" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49080 }
49081 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49082 ecode2 = SWIG_AsVal_int(obj1, &val2);
49083 if (!SWIG_IsOK(ecode2)) {
49084 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetRow" "', expected argument " "2"" of type '" "int""'");
49085 }
49086 arg2 = static_cast< int >(val2);
49087 {
49088 PyThreadState* __tstate = wxPyBeginAllowThreads();
49089 (arg1)->SetRow(arg2);
49090 wxPyEndAllowThreads(__tstate);
49091 if (PyErr_Occurred()) SWIG_fail;
49092 }
49093 resultobj = SWIG_Py_Void();
49094 return resultobj;
49095 fail:
49096 return NULL;
49097 }
49098
49099
49100 SWIGINTERN PyObject *_wrap_GBPosition_SetCol(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49101 PyObject *resultobj = 0;
49102 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49103 int arg2 ;
49104 void *argp1 = 0 ;
49105 int res1 = 0 ;
49106 int val2 ;
49107 int ecode2 = 0 ;
49108 PyObject * obj0 = 0 ;
49109 PyObject * obj1 = 0 ;
49110 char * kwnames[] = {
49111 (char *) "self",(char *) "col", NULL
49112 };
49113
49114 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition_SetCol",kwnames,&obj0,&obj1)) SWIG_fail;
49115 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49116 if (!SWIG_IsOK(res1)) {
49117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_SetCol" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49118 }
49119 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49120 ecode2 = SWIG_AsVal_int(obj1, &val2);
49121 if (!SWIG_IsOK(ecode2)) {
49122 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_SetCol" "', expected argument " "2"" of type '" "int""'");
49123 }
49124 arg2 = static_cast< int >(val2);
49125 {
49126 PyThreadState* __tstate = wxPyBeginAllowThreads();
49127 (arg1)->SetCol(arg2);
49128 wxPyEndAllowThreads(__tstate);
49129 if (PyErr_Occurred()) SWIG_fail;
49130 }
49131 resultobj = SWIG_Py_Void();
49132 return resultobj;
49133 fail:
49134 return NULL;
49135 }
49136
49137
49138 SWIGINTERN PyObject *_wrap_GBPosition___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49139 PyObject *resultobj = 0;
49140 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49141 PyObject *arg2 = (PyObject *) 0 ;
49142 bool result;
49143 void *argp1 = 0 ;
49144 int res1 = 0 ;
49145 PyObject * obj0 = 0 ;
49146 PyObject * obj1 = 0 ;
49147 char * kwnames[] = {
49148 (char *) "self",(char *) "other", NULL
49149 };
49150
49151 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49152 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49153 if (!SWIG_IsOK(res1)) {
49154 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___eq__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49155 }
49156 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49157 arg2 = obj1;
49158 {
49159 result = (bool)wxGBPosition___eq__(arg1,arg2);
49160 if (PyErr_Occurred()) SWIG_fail;
49161 }
49162 {
49163 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49164 }
49165 return resultobj;
49166 fail:
49167 return NULL;
49168 }
49169
49170
49171 SWIGINTERN PyObject *_wrap_GBPosition___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49172 PyObject *resultobj = 0;
49173 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49174 PyObject *arg2 = (PyObject *) 0 ;
49175 bool result;
49176 void *argp1 = 0 ;
49177 int res1 = 0 ;
49178 PyObject * obj0 = 0 ;
49179 PyObject * obj1 = 0 ;
49180 char * kwnames[] = {
49181 (char *) "self",(char *) "other", NULL
49182 };
49183
49184 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBPosition___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49185 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49186 if (!SWIG_IsOK(res1)) {
49187 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition___ne__" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49188 }
49189 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49190 arg2 = obj1;
49191 {
49192 result = (bool)wxGBPosition___ne__(arg1,arg2);
49193 if (PyErr_Occurred()) SWIG_fail;
49194 }
49195 {
49196 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49197 }
49198 return resultobj;
49199 fail:
49200 return NULL;
49201 }
49202
49203
49204 SWIGINTERN PyObject *_wrap_GBPosition_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49205 PyObject *resultobj = 0;
49206 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49207 int arg2 = (int) 0 ;
49208 int arg3 = (int) 0 ;
49209 void *argp1 = 0 ;
49210 int res1 = 0 ;
49211 int val2 ;
49212 int ecode2 = 0 ;
49213 int val3 ;
49214 int ecode3 = 0 ;
49215 PyObject * obj0 = 0 ;
49216 PyObject * obj1 = 0 ;
49217 PyObject * obj2 = 0 ;
49218 char * kwnames[] = {
49219 (char *) "self",(char *) "row",(char *) "col", NULL
49220 };
49221
49222 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBPosition_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49223 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49224 if (!SWIG_IsOK(res1)) {
49225 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Set" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49226 }
49227 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49228 if (obj1) {
49229 ecode2 = SWIG_AsVal_int(obj1, &val2);
49230 if (!SWIG_IsOK(ecode2)) {
49231 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBPosition_Set" "', expected argument " "2"" of type '" "int""'");
49232 }
49233 arg2 = static_cast< int >(val2);
49234 }
49235 if (obj2) {
49236 ecode3 = SWIG_AsVal_int(obj2, &val3);
49237 if (!SWIG_IsOK(ecode3)) {
49238 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBPosition_Set" "', expected argument " "3"" of type '" "int""'");
49239 }
49240 arg3 = static_cast< int >(val3);
49241 }
49242 {
49243 PyThreadState* __tstate = wxPyBeginAllowThreads();
49244 wxGBPosition_Set(arg1,arg2,arg3);
49245 wxPyEndAllowThreads(__tstate);
49246 if (PyErr_Occurred()) SWIG_fail;
49247 }
49248 resultobj = SWIG_Py_Void();
49249 return resultobj;
49250 fail:
49251 return NULL;
49252 }
49253
49254
49255 SWIGINTERN PyObject *_wrap_GBPosition_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49256 PyObject *resultobj = 0;
49257 wxGBPosition *arg1 = (wxGBPosition *) 0 ;
49258 PyObject *result = 0 ;
49259 void *argp1 = 0 ;
49260 int res1 = 0 ;
49261 PyObject *swig_obj[1] ;
49262
49263 if (!args) SWIG_fail;
49264 swig_obj[0] = args;
49265 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBPosition, 0 | 0 );
49266 if (!SWIG_IsOK(res1)) {
49267 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBPosition_Get" "', expected argument " "1"" of type '" "wxGBPosition *""'");
49268 }
49269 arg1 = reinterpret_cast< wxGBPosition * >(argp1);
49270 {
49271 PyThreadState* __tstate = wxPyBeginAllowThreads();
49272 result = (PyObject *)wxGBPosition_Get(arg1);
49273 wxPyEndAllowThreads(__tstate);
49274 if (PyErr_Occurred()) SWIG_fail;
49275 }
49276 resultobj = result;
49277 return resultobj;
49278 fail:
49279 return NULL;
49280 }
49281
49282
49283 SWIGINTERN PyObject *GBPosition_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49284 PyObject *obj;
49285 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49286 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBPosition, SWIG_NewClientData(obj));
49287 return SWIG_Py_Void();
49288 }
49289
49290 SWIGINTERN PyObject *GBPosition_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49291 return SWIG_Python_InitShadowInstance(args);
49292 }
49293
49294 SWIGINTERN PyObject *_wrap_new_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49295 PyObject *resultobj = 0;
49296 int arg1 = (int) 1 ;
49297 int arg2 = (int) 1 ;
49298 wxGBSpan *result = 0 ;
49299 int val1 ;
49300 int ecode1 = 0 ;
49301 int val2 ;
49302 int ecode2 = 0 ;
49303 PyObject * obj0 = 0 ;
49304 PyObject * obj1 = 0 ;
49305 char * kwnames[] = {
49306 (char *) "rowspan",(char *) "colspan", NULL
49307 };
49308
49309 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GBSpan",kwnames,&obj0,&obj1)) SWIG_fail;
49310 if (obj0) {
49311 ecode1 = SWIG_AsVal_int(obj0, &val1);
49312 if (!SWIG_IsOK(ecode1)) {
49313 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSpan" "', expected argument " "1"" of type '" "int""'");
49314 }
49315 arg1 = static_cast< int >(val1);
49316 }
49317 if (obj1) {
49318 ecode2 = SWIG_AsVal_int(obj1, &val2);
49319 if (!SWIG_IsOK(ecode2)) {
49320 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSpan" "', expected argument " "2"" of type '" "int""'");
49321 }
49322 arg2 = static_cast< int >(val2);
49323 }
49324 {
49325 PyThreadState* __tstate = wxPyBeginAllowThreads();
49326 result = (wxGBSpan *)new wxGBSpan(arg1,arg2);
49327 wxPyEndAllowThreads(__tstate);
49328 if (PyErr_Occurred()) SWIG_fail;
49329 }
49330 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_NEW | 0 );
49331 return resultobj;
49332 fail:
49333 return NULL;
49334 }
49335
49336
49337 SWIGINTERN PyObject *_wrap_delete_GBSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49338 PyObject *resultobj = 0;
49339 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49340 void *argp1 = 0 ;
49341 int res1 = 0 ;
49342 PyObject *swig_obj[1] ;
49343
49344 if (!args) SWIG_fail;
49345 swig_obj[0] = args;
49346 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, SWIG_POINTER_DISOWN | 0 );
49347 if (!SWIG_IsOK(res1)) {
49348 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSpan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49349 }
49350 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49351 {
49352 PyThreadState* __tstate = wxPyBeginAllowThreads();
49353 delete arg1;
49354
49355 wxPyEndAllowThreads(__tstate);
49356 if (PyErr_Occurred()) SWIG_fail;
49357 }
49358 resultobj = SWIG_Py_Void();
49359 return resultobj;
49360 fail:
49361 return NULL;
49362 }
49363
49364
49365 SWIGINTERN PyObject *_wrap_GBSpan_GetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49366 PyObject *resultobj = 0;
49367 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49368 int result;
49369 void *argp1 = 0 ;
49370 int res1 = 0 ;
49371 PyObject *swig_obj[1] ;
49372
49373 if (!args) SWIG_fail;
49374 swig_obj[0] = args;
49375 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49376 if (!SWIG_IsOK(res1)) {
49377 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetRowspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49378 }
49379 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49380 {
49381 PyThreadState* __tstate = wxPyBeginAllowThreads();
49382 result = (int)((wxGBSpan const *)arg1)->GetRowspan();
49383 wxPyEndAllowThreads(__tstate);
49384 if (PyErr_Occurred()) SWIG_fail;
49385 }
49386 resultobj = SWIG_From_int(static_cast< int >(result));
49387 return resultobj;
49388 fail:
49389 return NULL;
49390 }
49391
49392
49393 SWIGINTERN PyObject *_wrap_GBSpan_GetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49394 PyObject *resultobj = 0;
49395 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49396 int result;
49397 void *argp1 = 0 ;
49398 int res1 = 0 ;
49399 PyObject *swig_obj[1] ;
49400
49401 if (!args) SWIG_fail;
49402 swig_obj[0] = args;
49403 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49404 if (!SWIG_IsOK(res1)) {
49405 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_GetColspan" "', expected argument " "1"" of type '" "wxGBSpan const *""'");
49406 }
49407 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49408 {
49409 PyThreadState* __tstate = wxPyBeginAllowThreads();
49410 result = (int)((wxGBSpan const *)arg1)->GetColspan();
49411 wxPyEndAllowThreads(__tstate);
49412 if (PyErr_Occurred()) SWIG_fail;
49413 }
49414 resultobj = SWIG_From_int(static_cast< int >(result));
49415 return resultobj;
49416 fail:
49417 return NULL;
49418 }
49419
49420
49421 SWIGINTERN PyObject *_wrap_GBSpan_SetRowspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49422 PyObject *resultobj = 0;
49423 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49424 int arg2 ;
49425 void *argp1 = 0 ;
49426 int res1 = 0 ;
49427 int val2 ;
49428 int ecode2 = 0 ;
49429 PyObject * obj0 = 0 ;
49430 PyObject * obj1 = 0 ;
49431 char * kwnames[] = {
49432 (char *) "self",(char *) "rowspan", NULL
49433 };
49434
49435 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetRowspan",kwnames,&obj0,&obj1)) SWIG_fail;
49436 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49437 if (!SWIG_IsOK(res1)) {
49438 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetRowspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49439 }
49440 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49441 ecode2 = SWIG_AsVal_int(obj1, &val2);
49442 if (!SWIG_IsOK(ecode2)) {
49443 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetRowspan" "', expected argument " "2"" of type '" "int""'");
49444 }
49445 arg2 = static_cast< int >(val2);
49446 {
49447 PyThreadState* __tstate = wxPyBeginAllowThreads();
49448 (arg1)->SetRowspan(arg2);
49449 wxPyEndAllowThreads(__tstate);
49450 if (PyErr_Occurred()) SWIG_fail;
49451 }
49452 resultobj = SWIG_Py_Void();
49453 return resultobj;
49454 fail:
49455 return NULL;
49456 }
49457
49458
49459 SWIGINTERN PyObject *_wrap_GBSpan_SetColspan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49460 PyObject *resultobj = 0;
49461 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49462 int arg2 ;
49463 void *argp1 = 0 ;
49464 int res1 = 0 ;
49465 int val2 ;
49466 int ecode2 = 0 ;
49467 PyObject * obj0 = 0 ;
49468 PyObject * obj1 = 0 ;
49469 char * kwnames[] = {
49470 (char *) "self",(char *) "colspan", NULL
49471 };
49472
49473 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan_SetColspan",kwnames,&obj0,&obj1)) SWIG_fail;
49474 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49475 if (!SWIG_IsOK(res1)) {
49476 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_SetColspan" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49477 }
49478 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49479 ecode2 = SWIG_AsVal_int(obj1, &val2);
49480 if (!SWIG_IsOK(ecode2)) {
49481 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_SetColspan" "', expected argument " "2"" of type '" "int""'");
49482 }
49483 arg2 = static_cast< int >(val2);
49484 {
49485 PyThreadState* __tstate = wxPyBeginAllowThreads();
49486 (arg1)->SetColspan(arg2);
49487 wxPyEndAllowThreads(__tstate);
49488 if (PyErr_Occurred()) SWIG_fail;
49489 }
49490 resultobj = SWIG_Py_Void();
49491 return resultobj;
49492 fail:
49493 return NULL;
49494 }
49495
49496
49497 SWIGINTERN PyObject *_wrap_GBSpan___eq__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49498 PyObject *resultobj = 0;
49499 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49500 PyObject *arg2 = (PyObject *) 0 ;
49501 bool result;
49502 void *argp1 = 0 ;
49503 int res1 = 0 ;
49504 PyObject * obj0 = 0 ;
49505 PyObject * obj1 = 0 ;
49506 char * kwnames[] = {
49507 (char *) "self",(char *) "other", NULL
49508 };
49509
49510 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___eq__",kwnames,&obj0,&obj1)) SWIG_fail;
49511 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49512 if (!SWIG_IsOK(res1)) {
49513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___eq__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49514 }
49515 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49516 arg2 = obj1;
49517 {
49518 result = (bool)wxGBSpan___eq__(arg1,arg2);
49519 if (PyErr_Occurred()) SWIG_fail;
49520 }
49521 {
49522 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49523 }
49524 return resultobj;
49525 fail:
49526 return NULL;
49527 }
49528
49529
49530 SWIGINTERN PyObject *_wrap_GBSpan___ne__(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49531 PyObject *resultobj = 0;
49532 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49533 PyObject *arg2 = (PyObject *) 0 ;
49534 bool result;
49535 void *argp1 = 0 ;
49536 int res1 = 0 ;
49537 PyObject * obj0 = 0 ;
49538 PyObject * obj1 = 0 ;
49539 char * kwnames[] = {
49540 (char *) "self",(char *) "other", NULL
49541 };
49542
49543 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSpan___ne__",kwnames,&obj0,&obj1)) SWIG_fail;
49544 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49545 if (!SWIG_IsOK(res1)) {
49546 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan___ne__" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49547 }
49548 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49549 arg2 = obj1;
49550 {
49551 result = (bool)wxGBSpan___ne__(arg1,arg2);
49552 if (PyErr_Occurred()) SWIG_fail;
49553 }
49554 {
49555 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
49556 }
49557 return resultobj;
49558 fail:
49559 return NULL;
49560 }
49561
49562
49563 SWIGINTERN PyObject *_wrap_GBSpan_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49564 PyObject *resultobj = 0;
49565 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49566 int arg2 = (int) 1 ;
49567 int arg3 = (int) 1 ;
49568 void *argp1 = 0 ;
49569 int res1 = 0 ;
49570 int val2 ;
49571 int ecode2 = 0 ;
49572 int val3 ;
49573 int ecode3 = 0 ;
49574 PyObject * obj0 = 0 ;
49575 PyObject * obj1 = 0 ;
49576 PyObject * obj2 = 0 ;
49577 char * kwnames[] = {
49578 (char *) "self",(char *) "rowspan",(char *) "colspan", NULL
49579 };
49580
49581 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"O|OO:GBSpan_Set",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
49582 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49583 if (!SWIG_IsOK(res1)) {
49584 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Set" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49585 }
49586 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49587 if (obj1) {
49588 ecode2 = SWIG_AsVal_int(obj1, &val2);
49589 if (!SWIG_IsOK(ecode2)) {
49590 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GBSpan_Set" "', expected argument " "2"" of type '" "int""'");
49591 }
49592 arg2 = static_cast< int >(val2);
49593 }
49594 if (obj2) {
49595 ecode3 = SWIG_AsVal_int(obj2, &val3);
49596 if (!SWIG_IsOK(ecode3)) {
49597 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GBSpan_Set" "', expected argument " "3"" of type '" "int""'");
49598 }
49599 arg3 = static_cast< int >(val3);
49600 }
49601 {
49602 PyThreadState* __tstate = wxPyBeginAllowThreads();
49603 wxGBSpan_Set(arg1,arg2,arg3);
49604 wxPyEndAllowThreads(__tstate);
49605 if (PyErr_Occurred()) SWIG_fail;
49606 }
49607 resultobj = SWIG_Py_Void();
49608 return resultobj;
49609 fail:
49610 return NULL;
49611 }
49612
49613
49614 SWIGINTERN PyObject *_wrap_GBSpan_Get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49615 PyObject *resultobj = 0;
49616 wxGBSpan *arg1 = (wxGBSpan *) 0 ;
49617 PyObject *result = 0 ;
49618 void *argp1 = 0 ;
49619 int res1 = 0 ;
49620 PyObject *swig_obj[1] ;
49621
49622 if (!args) SWIG_fail;
49623 swig_obj[0] = args;
49624 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSpan, 0 | 0 );
49625 if (!SWIG_IsOK(res1)) {
49626 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSpan_Get" "', expected argument " "1"" of type '" "wxGBSpan *""'");
49627 }
49628 arg1 = reinterpret_cast< wxGBSpan * >(argp1);
49629 {
49630 PyThreadState* __tstate = wxPyBeginAllowThreads();
49631 result = (PyObject *)wxGBSpan_Get(arg1);
49632 wxPyEndAllowThreads(__tstate);
49633 if (PyErr_Occurred()) SWIG_fail;
49634 }
49635 resultobj = result;
49636 return resultobj;
49637 fail:
49638 return NULL;
49639 }
49640
49641
49642 SWIGINTERN PyObject *GBSpan_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49643 PyObject *obj;
49644 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
49645 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSpan, SWIG_NewClientData(obj));
49646 return SWIG_Py_Void();
49647 }
49648
49649 SWIGINTERN PyObject *GBSpan_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49650 return SWIG_Python_InitShadowInstance(args);
49651 }
49652
49653 SWIGINTERN int DefaultSpan_set(PyObject *) {
49654 SWIG_Error(SWIG_AttributeError,"Variable DefaultSpan is read-only.");
49655 return 1;
49656 }
49657
49658
49659 SWIGINTERN PyObject *DefaultSpan_get(void) {
49660 PyObject *pyobj = 0;
49661
49662 pyobj = SWIG_NewPointerObj(SWIG_as_voidptr(&wxDefaultSpan), SWIGTYPE_p_wxGBSpan, 0 );
49663 return pyobj;
49664 }
49665
49666
49667 SWIGINTERN PyObject *_wrap_new_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49668 PyObject *resultobj = 0;
49669 wxGBSizerItem *result = 0 ;
49670
49671 if (!SWIG_Python_UnpackTuple(args,"new_GBSizerItem",0,0,0)) SWIG_fail;
49672 {
49673 PyThreadState* __tstate = wxPyBeginAllowThreads();
49674 result = (wxGBSizerItem *)new wxGBSizerItem();
49675 wxPyEndAllowThreads(__tstate);
49676 if (PyErr_Occurred()) SWIG_fail;
49677 }
49678 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_NEW | 0 );
49679 return resultobj;
49680 fail:
49681 return NULL;
49682 }
49683
49684
49685 SWIGINTERN PyObject *_wrap_delete_GBSizerItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49686 PyObject *resultobj = 0;
49687 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49688 void *argp1 = 0 ;
49689 int res1 = 0 ;
49690 PyObject *swig_obj[1] ;
49691
49692 if (!args) SWIG_fail;
49693 swig_obj[0] = args;
49694 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
49695 if (!SWIG_IsOK(res1)) {
49696 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_GBSizerItem" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49697 }
49698 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49699 {
49700 PyThreadState* __tstate = wxPyBeginAllowThreads();
49701 delete arg1;
49702
49703 wxPyEndAllowThreads(__tstate);
49704 if (PyErr_Occurred()) SWIG_fail;
49705 }
49706 resultobj = SWIG_Py_Void();
49707 return resultobj;
49708 fail:
49709 return NULL;
49710 }
49711
49712
49713 SWIGINTERN PyObject *_wrap_new_GBSizerItemWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49714 PyObject *resultobj = 0;
49715 wxWindow *arg1 = (wxWindow *) 0 ;
49716 wxGBPosition *arg2 = 0 ;
49717 wxGBSpan *arg3 = 0 ;
49718 int arg4 ;
49719 int arg5 ;
49720 PyObject *arg6 = (PyObject *) NULL ;
49721 wxGBSizerItem *result = 0 ;
49722 void *argp1 = 0 ;
49723 int res1 = 0 ;
49724 wxGBPosition temp2 ;
49725 wxGBSpan temp3 ;
49726 int val4 ;
49727 int ecode4 = 0 ;
49728 int val5 ;
49729 int ecode5 = 0 ;
49730 PyObject * obj0 = 0 ;
49731 PyObject * obj1 = 0 ;
49732 PyObject * obj2 = 0 ;
49733 PyObject * obj3 = 0 ;
49734 PyObject * obj4 = 0 ;
49735 PyObject * obj5 = 0 ;
49736 char * kwnames[] = {
49737 (char *) "window",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49738 };
49739
49740 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemWindow",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49741 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxWindow, 0 | 0 );
49742 if (!SWIG_IsOK(res1)) {
49743 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemWindow" "', expected argument " "1"" of type '" "wxWindow *""'");
49744 }
49745 arg1 = reinterpret_cast< wxWindow * >(argp1);
49746 {
49747 arg2 = &temp2;
49748 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49749 }
49750 {
49751 arg3 = &temp3;
49752 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49753 }
49754 ecode4 = SWIG_AsVal_int(obj3, &val4);
49755 if (!SWIG_IsOK(ecode4)) {
49756 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemWindow" "', expected argument " "4"" of type '" "int""'");
49757 }
49758 arg4 = static_cast< int >(val4);
49759 ecode5 = SWIG_AsVal_int(obj4, &val5);
49760 if (!SWIG_IsOK(ecode5)) {
49761 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemWindow" "', expected argument " "5"" of type '" "int""'");
49762 }
49763 arg5 = static_cast< int >(val5);
49764 if (obj5) {
49765 arg6 = obj5;
49766 }
49767 {
49768 PyThreadState* __tstate = wxPyBeginAllowThreads();
49769 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49770 wxPyEndAllowThreads(__tstate);
49771 if (PyErr_Occurred()) SWIG_fail;
49772 }
49773 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49774 return resultobj;
49775 fail:
49776 return NULL;
49777 }
49778
49779
49780 SWIGINTERN PyObject *_wrap_new_GBSizerItemSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49781 PyObject *resultobj = 0;
49782 wxSizer *arg1 = (wxSizer *) 0 ;
49783 wxGBPosition *arg2 = 0 ;
49784 wxGBSpan *arg3 = 0 ;
49785 int arg4 ;
49786 int arg5 ;
49787 PyObject *arg6 = (PyObject *) NULL ;
49788 wxGBSizerItem *result = 0 ;
49789 int res1 = 0 ;
49790 wxGBPosition temp2 ;
49791 wxGBSpan temp3 ;
49792 int val4 ;
49793 int ecode4 = 0 ;
49794 int val5 ;
49795 int ecode5 = 0 ;
49796 PyObject * obj0 = 0 ;
49797 PyObject * obj1 = 0 ;
49798 PyObject * obj2 = 0 ;
49799 PyObject * obj3 = 0 ;
49800 PyObject * obj4 = 0 ;
49801 PyObject * obj5 = 0 ;
49802 char * kwnames[] = {
49803 (char *) "sizer",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49804 };
49805
49806 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOO|O:new_GBSizerItemSizer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
49807 res1 = SWIG_ConvertPtr(obj0, SWIG_as_voidptrptr(&arg1), SWIGTYPE_p_wxSizer, SWIG_POINTER_DISOWN | 0 );
49808 if (!SWIG_IsOK(res1)) {
49809 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "new_GBSizerItemSizer" "', expected argument " "1"" of type '" "wxSizer *""'");
49810 }
49811 {
49812 arg2 = &temp2;
49813 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
49814 }
49815 {
49816 arg3 = &temp3;
49817 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
49818 }
49819 ecode4 = SWIG_AsVal_int(obj3, &val4);
49820 if (!SWIG_IsOK(ecode4)) {
49821 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "new_GBSizerItemSizer" "', expected argument " "4"" of type '" "int""'");
49822 }
49823 arg4 = static_cast< int >(val4);
49824 ecode5 = SWIG_AsVal_int(obj4, &val5);
49825 if (!SWIG_IsOK(ecode5)) {
49826 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSizer" "', expected argument " "5"" of type '" "int""'");
49827 }
49828 arg5 = static_cast< int >(val5);
49829 if (obj5) {
49830 arg6 = obj5;
49831 }
49832 {
49833 PyThreadState* __tstate = wxPyBeginAllowThreads();
49834 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,(wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4,arg5,arg6);
49835 wxPyEndAllowThreads(__tstate);
49836 if (PyErr_Occurred()) SWIG_fail;
49837 }
49838 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49839 return resultobj;
49840 fail:
49841 return NULL;
49842 }
49843
49844
49845 SWIGINTERN PyObject *_wrap_new_GBSizerItemSpacer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49846 PyObject *resultobj = 0;
49847 int arg1 ;
49848 int arg2 ;
49849 wxGBPosition *arg3 = 0 ;
49850 wxGBSpan *arg4 = 0 ;
49851 int arg5 ;
49852 int arg6 ;
49853 PyObject *arg7 = (PyObject *) NULL ;
49854 wxGBSizerItem *result = 0 ;
49855 int val1 ;
49856 int ecode1 = 0 ;
49857 int val2 ;
49858 int ecode2 = 0 ;
49859 wxGBPosition temp3 ;
49860 wxGBSpan temp4 ;
49861 int val5 ;
49862 int ecode5 = 0 ;
49863 int val6 ;
49864 int ecode6 = 0 ;
49865 PyObject * obj0 = 0 ;
49866 PyObject * obj1 = 0 ;
49867 PyObject * obj2 = 0 ;
49868 PyObject * obj3 = 0 ;
49869 PyObject * obj4 = 0 ;
49870 PyObject * obj5 = 0 ;
49871 PyObject * obj6 = 0 ;
49872 char * kwnames[] = {
49873 (char *) "width",(char *) "height",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
49874 };
49875
49876 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOOOO|O:new_GBSizerItemSpacer",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
49877 ecode1 = SWIG_AsVal_int(obj0, &val1);
49878 if (!SWIG_IsOK(ecode1)) {
49879 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GBSizerItemSpacer" "', expected argument " "1"" of type '" "int""'");
49880 }
49881 arg1 = static_cast< int >(val1);
49882 ecode2 = SWIG_AsVal_int(obj1, &val2);
49883 if (!SWIG_IsOK(ecode2)) {
49884 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GBSizerItemSpacer" "', expected argument " "2"" of type '" "int""'");
49885 }
49886 arg2 = static_cast< int >(val2);
49887 {
49888 arg3 = &temp3;
49889 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
49890 }
49891 {
49892 arg4 = &temp4;
49893 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
49894 }
49895 ecode5 = SWIG_AsVal_int(obj4, &val5);
49896 if (!SWIG_IsOK(ecode5)) {
49897 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "new_GBSizerItemSpacer" "', expected argument " "5"" of type '" "int""'");
49898 }
49899 arg5 = static_cast< int >(val5);
49900 ecode6 = SWIG_AsVal_int(obj5, &val6);
49901 if (!SWIG_IsOK(ecode6)) {
49902 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "new_GBSizerItemSpacer" "', expected argument " "6"" of type '" "int""'");
49903 }
49904 arg6 = static_cast< int >(val6);
49905 if (obj6) {
49906 arg7 = obj6;
49907 }
49908 {
49909 PyThreadState* __tstate = wxPyBeginAllowThreads();
49910 result = (wxGBSizerItem *)new_wxGBSizerItem(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
49911 wxPyEndAllowThreads(__tstate);
49912 if (PyErr_Occurred()) SWIG_fail;
49913 }
49914 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_OWN | 0 );
49915 return resultobj;
49916 fail:
49917 return NULL;
49918 }
49919
49920
49921 SWIGINTERN PyObject *_wrap_GBSizerItem_GetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49922 PyObject *resultobj = 0;
49923 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49924 wxGBPosition result;
49925 void *argp1 = 0 ;
49926 int res1 = 0 ;
49927 PyObject *swig_obj[1] ;
49928
49929 if (!args) SWIG_fail;
49930 swig_obj[0] = args;
49931 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49932 if (!SWIG_IsOK(res1)) {
49933 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetPos" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49934 }
49935 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49936 {
49937 PyThreadState* __tstate = wxPyBeginAllowThreads();
49938 result = ((wxGBSizerItem const *)arg1)->GetPos();
49939 wxPyEndAllowThreads(__tstate);
49940 if (PyErr_Occurred()) SWIG_fail;
49941 }
49942 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
49943 return resultobj;
49944 fail:
49945 return NULL;
49946 }
49947
49948
49949 SWIGINTERN PyObject *_wrap_GBSizerItem_GetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
49950 PyObject *resultobj = 0;
49951 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49952 wxGBSpan result;
49953 void *argp1 = 0 ;
49954 int res1 = 0 ;
49955 PyObject *swig_obj[1] ;
49956
49957 if (!args) SWIG_fail;
49958 swig_obj[0] = args;
49959 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49960 if (!SWIG_IsOK(res1)) {
49961 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
49962 }
49963 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49964 {
49965 PyThreadState* __tstate = wxPyBeginAllowThreads();
49966 result = ((wxGBSizerItem const *)arg1)->GetSpan();
49967 wxPyEndAllowThreads(__tstate);
49968 if (PyErr_Occurred()) SWIG_fail;
49969 }
49970 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
49971 return resultobj;
49972 fail:
49973 return NULL;
49974 }
49975
49976
49977 SWIGINTERN PyObject *_wrap_GBSizerItem_SetPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
49978 PyObject *resultobj = 0;
49979 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
49980 wxGBPosition *arg2 = 0 ;
49981 bool result;
49982 void *argp1 = 0 ;
49983 int res1 = 0 ;
49984 wxGBPosition temp2 ;
49985 PyObject * obj0 = 0 ;
49986 PyObject * obj1 = 0 ;
49987 char * kwnames[] = {
49988 (char *) "self",(char *) "pos", NULL
49989 };
49990
49991 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetPos",kwnames,&obj0,&obj1)) SWIG_fail;
49992 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
49993 if (!SWIG_IsOK(res1)) {
49994 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
49995 }
49996 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
49997 {
49998 arg2 = &temp2;
49999 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50000 }
50001 {
50002 PyThreadState* __tstate = wxPyBeginAllowThreads();
50003 result = (bool)(arg1)->SetPos((wxGBPosition const &)*arg2);
50004 wxPyEndAllowThreads(__tstate);
50005 if (PyErr_Occurred()) SWIG_fail;
50006 }
50007 {
50008 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50009 }
50010 return resultobj;
50011 fail:
50012 return NULL;
50013 }
50014
50015
50016 SWIGINTERN PyObject *_wrap_GBSizerItem_SetSpan(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50017 PyObject *resultobj = 0;
50018 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50019 wxGBSpan *arg2 = 0 ;
50020 bool result;
50021 void *argp1 = 0 ;
50022 int res1 = 0 ;
50023 wxGBSpan temp2 ;
50024 PyObject * obj0 = 0 ;
50025 PyObject * obj1 = 0 ;
50026 char * kwnames[] = {
50027 (char *) "self",(char *) "span", NULL
50028 };
50029
50030 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetSpan",kwnames,&obj0,&obj1)) SWIG_fail;
50031 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50032 if (!SWIG_IsOK(res1)) {
50033 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetSpan" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50034 }
50035 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50036 {
50037 arg2 = &temp2;
50038 if ( ! wxGBSpan_helper(obj1, &arg2)) SWIG_fail;
50039 }
50040 {
50041 PyThreadState* __tstate = wxPyBeginAllowThreads();
50042 result = (bool)(arg1)->SetSpan((wxGBSpan const &)*arg2);
50043 wxPyEndAllowThreads(__tstate);
50044 if (PyErr_Occurred()) SWIG_fail;
50045 }
50046 {
50047 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50048 }
50049 return resultobj;
50050 fail:
50051 return NULL;
50052 }
50053
50054
50055 SWIGINTERN PyObject *_wrap_GBSizerItem_Intersects(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50056 PyObject *resultobj = 0;
50057 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50058 wxGBSizerItem *arg2 = 0 ;
50059 bool result;
50060 void *argp1 = 0 ;
50061 int res1 = 0 ;
50062 void *argp2 = 0 ;
50063 int res2 = 0 ;
50064 PyObject * obj0 = 0 ;
50065 PyObject * obj1 = 0 ;
50066 char * kwnames[] = {
50067 (char *) "self",(char *) "other", NULL
50068 };
50069
50070 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_Intersects",kwnames,&obj0,&obj1)) SWIG_fail;
50071 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50072 if (!SWIG_IsOK(res1)) {
50073 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_Intersects" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50074 }
50075 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50076 res2 = SWIG_ConvertPtr(obj1, &argp2, SWIGTYPE_p_wxGBSizerItem, 0 | 0);
50077 if (!SWIG_IsOK(res2)) {
50078 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50079 }
50080 if (!argp2) {
50081 SWIG_exception_fail(SWIG_ValueError, "invalid null reference " "in method '" "GBSizerItem_Intersects" "', expected argument " "2"" of type '" "wxGBSizerItem const &""'");
50082 }
50083 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
50084 {
50085 PyThreadState* __tstate = wxPyBeginAllowThreads();
50086 result = (bool)(arg1)->Intersects((wxGBSizerItem const &)*arg2);
50087 wxPyEndAllowThreads(__tstate);
50088 if (PyErr_Occurred()) SWIG_fail;
50089 }
50090 {
50091 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50092 }
50093 return resultobj;
50094 fail:
50095 return NULL;
50096 }
50097
50098
50099 SWIGINTERN PyObject *_wrap_GBSizerItem_IntersectsPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50100 PyObject *resultobj = 0;
50101 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50102 wxGBPosition *arg2 = 0 ;
50103 wxGBSpan *arg3 = 0 ;
50104 bool result;
50105 void *argp1 = 0 ;
50106 int res1 = 0 ;
50107 wxGBPosition temp2 ;
50108 wxGBSpan temp3 ;
50109 PyObject * obj0 = 0 ;
50110 PyObject * obj1 = 0 ;
50111 PyObject * obj2 = 0 ;
50112 char * kwnames[] = {
50113 (char *) "self",(char *) "pos",(char *) "span", NULL
50114 };
50115
50116 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GBSizerItem_IntersectsPos",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50117 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50118 if (!SWIG_IsOK(res1)) {
50119 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_IntersectsPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50120 }
50121 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50122 {
50123 arg2 = &temp2;
50124 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
50125 }
50126 {
50127 arg3 = &temp3;
50128 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
50129 }
50130 {
50131 PyThreadState* __tstate = wxPyBeginAllowThreads();
50132 result = (bool)(arg1)->Intersects((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3);
50133 wxPyEndAllowThreads(__tstate);
50134 if (PyErr_Occurred()) SWIG_fail;
50135 }
50136 {
50137 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50138 }
50139 return resultobj;
50140 fail:
50141 return NULL;
50142 }
50143
50144
50145 SWIGINTERN PyObject *_wrap_GBSizerItem_GetEndPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50146 PyObject *resultobj = 0;
50147 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50148 wxGBPosition result;
50149 void *argp1 = 0 ;
50150 int res1 = 0 ;
50151 PyObject *swig_obj[1] ;
50152
50153 if (!args) SWIG_fail;
50154 swig_obj[0] = args;
50155 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50156 if (!SWIG_IsOK(res1)) {
50157 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetEndPos" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50158 }
50159 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50160 {
50161 PyThreadState* __tstate = wxPyBeginAllowThreads();
50162 result = wxGBSizerItem_GetEndPos(arg1);
50163 wxPyEndAllowThreads(__tstate);
50164 if (PyErr_Occurred()) SWIG_fail;
50165 }
50166 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50167 return resultobj;
50168 fail:
50169 return NULL;
50170 }
50171
50172
50173 SWIGINTERN PyObject *_wrap_GBSizerItem_GetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50174 PyObject *resultobj = 0;
50175 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50176 wxGridBagSizer *result = 0 ;
50177 void *argp1 = 0 ;
50178 int res1 = 0 ;
50179 PyObject *swig_obj[1] ;
50180
50181 if (!args) SWIG_fail;
50182 swig_obj[0] = args;
50183 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50184 if (!SWIG_IsOK(res1)) {
50185 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_GetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem const *""'");
50186 }
50187 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50188 {
50189 PyThreadState* __tstate = wxPyBeginAllowThreads();
50190 result = (wxGridBagSizer *)((wxGBSizerItem const *)arg1)->GetGBSizer();
50191 wxPyEndAllowThreads(__tstate);
50192 if (PyErr_Occurred()) SWIG_fail;
50193 }
50194 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50195 return resultobj;
50196 fail:
50197 return NULL;
50198 }
50199
50200
50201 SWIGINTERN PyObject *_wrap_GBSizerItem_SetGBSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50202 PyObject *resultobj = 0;
50203 wxGBSizerItem *arg1 = (wxGBSizerItem *) 0 ;
50204 wxGridBagSizer *arg2 = (wxGridBagSizer *) 0 ;
50205 void *argp1 = 0 ;
50206 int res1 = 0 ;
50207 void *argp2 = 0 ;
50208 int res2 = 0 ;
50209 PyObject * obj0 = 0 ;
50210 PyObject * obj1 = 0 ;
50211 char * kwnames[] = {
50212 (char *) "self",(char *) "sizer", NULL
50213 };
50214
50215 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GBSizerItem_SetGBSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50216 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50217 if (!SWIG_IsOK(res1)) {
50218 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "1"" of type '" "wxGBSizerItem *""'");
50219 }
50220 arg1 = reinterpret_cast< wxGBSizerItem * >(argp1);
50221 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50222 if (!SWIG_IsOK(res2)) {
50223 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GBSizerItem_SetGBSizer" "', expected argument " "2"" of type '" "wxGridBagSizer *""'");
50224 }
50225 arg2 = reinterpret_cast< wxGridBagSizer * >(argp2);
50226 {
50227 PyThreadState* __tstate = wxPyBeginAllowThreads();
50228 (arg1)->SetGBSizer(arg2);
50229 wxPyEndAllowThreads(__tstate);
50230 if (PyErr_Occurred()) SWIG_fail;
50231 }
50232 resultobj = SWIG_Py_Void();
50233 return resultobj;
50234 fail:
50235 return NULL;
50236 }
50237
50238
50239 SWIGINTERN PyObject *GBSizerItem_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50240 PyObject *obj;
50241 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
50242 SWIG_TypeNewClientData(SWIGTYPE_p_wxGBSizerItem, SWIG_NewClientData(obj));
50243 return SWIG_Py_Void();
50244 }
50245
50246 SWIGINTERN PyObject *GBSizerItem_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50247 return SWIG_Python_InitShadowInstance(args);
50248 }
50249
50250 SWIGINTERN PyObject *_wrap_new_GridBagSizer(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50251 PyObject *resultobj = 0;
50252 int arg1 = (int) 0 ;
50253 int arg2 = (int) 0 ;
50254 wxGridBagSizer *result = 0 ;
50255 int val1 ;
50256 int ecode1 = 0 ;
50257 int val2 ;
50258 int ecode2 = 0 ;
50259 PyObject * obj0 = 0 ;
50260 PyObject * obj1 = 0 ;
50261 char * kwnames[] = {
50262 (char *) "vgap",(char *) "hgap", NULL
50263 };
50264
50265 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"|OO:new_GridBagSizer",kwnames,&obj0,&obj1)) SWIG_fail;
50266 if (obj0) {
50267 ecode1 = SWIG_AsVal_int(obj0, &val1);
50268 if (!SWIG_IsOK(ecode1)) {
50269 SWIG_exception_fail(SWIG_ArgError(ecode1), "in method '" "new_GridBagSizer" "', expected argument " "1"" of type '" "int""'");
50270 }
50271 arg1 = static_cast< int >(val1);
50272 }
50273 if (obj1) {
50274 ecode2 = SWIG_AsVal_int(obj1, &val2);
50275 if (!SWIG_IsOK(ecode2)) {
50276 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "new_GridBagSizer" "', expected argument " "2"" of type '" "int""'");
50277 }
50278 arg2 = static_cast< int >(val2);
50279 }
50280 {
50281 PyThreadState* __tstate = wxPyBeginAllowThreads();
50282 result = (wxGridBagSizer *)new wxGridBagSizer(arg1,arg2);
50283 wxPyEndAllowThreads(__tstate);
50284 if (PyErr_Occurred()) SWIG_fail;
50285 }
50286 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGridBagSizer, SWIG_POINTER_NEW | 0 );
50287 return resultobj;
50288 fail:
50289 return NULL;
50290 }
50291
50292
50293 SWIGINTERN PyObject *_wrap_GridBagSizer_Add(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50294 PyObject *resultobj = 0;
50295 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50296 PyObject *arg2 = (PyObject *) 0 ;
50297 wxGBPosition *arg3 = 0 ;
50298 wxGBSpan const &arg4_defvalue = wxDefaultSpan ;
50299 wxGBSpan *arg4 = (wxGBSpan *) &arg4_defvalue ;
50300 int arg5 = (int) 0 ;
50301 int arg6 = (int) 0 ;
50302 PyObject *arg7 = (PyObject *) NULL ;
50303 wxGBSizerItem *result = 0 ;
50304 void *argp1 = 0 ;
50305 int res1 = 0 ;
50306 wxGBPosition temp3 ;
50307 wxGBSpan temp4 ;
50308 int val5 ;
50309 int ecode5 = 0 ;
50310 int val6 ;
50311 int ecode6 = 0 ;
50312 PyObject * obj0 = 0 ;
50313 PyObject * obj1 = 0 ;
50314 PyObject * obj2 = 0 ;
50315 PyObject * obj3 = 0 ;
50316 PyObject * obj4 = 0 ;
50317 PyObject * obj5 = 0 ;
50318 PyObject * obj6 = 0 ;
50319 char * kwnames[] = {
50320 (char *) "self",(char *) "item",(char *) "pos",(char *) "span",(char *) "flag",(char *) "border",(char *) "userData", NULL
50321 };
50322
50323 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|OOOO:GridBagSizer_Add",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5,&obj6)) SWIG_fail;
50324 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50325 if (!SWIG_IsOK(res1)) {
50326 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_Add" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50327 }
50328 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50329 arg2 = obj1;
50330 {
50331 arg3 = &temp3;
50332 if ( ! wxGBPosition_helper(obj2, &arg3)) SWIG_fail;
50333 }
50334 if (obj3) {
50335 {
50336 arg4 = &temp4;
50337 if ( ! wxGBSpan_helper(obj3, &arg4)) SWIG_fail;
50338 }
50339 }
50340 if (obj4) {
50341 ecode5 = SWIG_AsVal_int(obj4, &val5);
50342 if (!SWIG_IsOK(ecode5)) {
50343 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "GridBagSizer_Add" "', expected argument " "5"" of type '" "int""'");
50344 }
50345 arg5 = static_cast< int >(val5);
50346 }
50347 if (obj5) {
50348 ecode6 = SWIG_AsVal_int(obj5, &val6);
50349 if (!SWIG_IsOK(ecode6)) {
50350 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "GridBagSizer_Add" "', expected argument " "6"" of type '" "int""'");
50351 }
50352 arg6 = static_cast< int >(val6);
50353 }
50354 if (obj6) {
50355 arg7 = obj6;
50356 }
50357 {
50358 PyThreadState* __tstate = wxPyBeginAllowThreads();
50359 result = (wxGBSizerItem *)wxGridBagSizer_Add(arg1,arg2,(wxGBPosition const &)*arg3,(wxGBSpan const &)*arg4,arg5,arg6,arg7);
50360 wxPyEndAllowThreads(__tstate);
50361 if (PyErr_Occurred()) SWIG_fail;
50362 }
50363 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50364 return resultobj;
50365 fail:
50366 return NULL;
50367 }
50368
50369
50370 SWIGINTERN PyObject *_wrap_GridBagSizer_AddItem(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50371 PyObject *resultobj = 0;
50372 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50373 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
50374 wxGBSizerItem *result = 0 ;
50375 void *argp1 = 0 ;
50376 int res1 = 0 ;
50377 int res2 = 0 ;
50378 PyObject * obj0 = 0 ;
50379 PyObject * obj1 = 0 ;
50380 char * kwnames[] = {
50381 (char *) "self",(char *) "item", NULL
50382 };
50383
50384 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_AddItem",kwnames,&obj0,&obj1)) SWIG_fail;
50385 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50386 if (!SWIG_IsOK(res1)) {
50387 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_AddItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50388 }
50389 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50390 res2 = SWIG_ConvertPtr(obj1, SWIG_as_voidptrptr(&arg2), SWIGTYPE_p_wxGBSizerItem, SWIG_POINTER_DISOWN | 0 );
50391 if (!SWIG_IsOK(res2)) {
50392 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_AddItem" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
50393 }
50394 {
50395 PyThreadState* __tstate = wxPyBeginAllowThreads();
50396 result = (wxGBSizerItem *)(arg1)->Add(arg2);
50397 wxPyEndAllowThreads(__tstate);
50398 if (PyErr_Occurred()) SWIG_fail;
50399 }
50400 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
50401 return resultobj;
50402 fail:
50403 return NULL;
50404 }
50405
50406
50407 SWIGINTERN PyObject *_wrap_GridBagSizer_GetCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50408 PyObject *resultobj = 0;
50409 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50410 int arg2 ;
50411 int arg3 ;
50412 wxSize result;
50413 void *argp1 = 0 ;
50414 int res1 = 0 ;
50415 int val2 ;
50416 int ecode2 = 0 ;
50417 int val3 ;
50418 int ecode3 = 0 ;
50419 PyObject * obj0 = 0 ;
50420 PyObject * obj1 = 0 ;
50421 PyObject * obj2 = 0 ;
50422 char * kwnames[] = {
50423 (char *) "self",(char *) "row",(char *) "col", NULL
50424 };
50425
50426 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:GridBagSizer_GetCellSize",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
50427 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50428 if (!SWIG_IsOK(res1)) {
50429 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50430 }
50431 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50432 ecode2 = SWIG_AsVal_int(obj1, &val2);
50433 if (!SWIG_IsOK(ecode2)) {
50434 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "2"" of type '" "int""'");
50435 }
50436 arg2 = static_cast< int >(val2);
50437 ecode3 = SWIG_AsVal_int(obj2, &val3);
50438 if (!SWIG_IsOK(ecode3)) {
50439 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "GridBagSizer_GetCellSize" "', expected argument " "3"" of type '" "int""'");
50440 }
50441 arg3 = static_cast< int >(val3);
50442 {
50443 PyThreadState* __tstate = wxPyBeginAllowThreads();
50444 result = ((wxGridBagSizer const *)arg1)->GetCellSize(arg2,arg3);
50445 wxPyEndAllowThreads(__tstate);
50446 if (PyErr_Occurred()) SWIG_fail;
50447 }
50448 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50449 return resultobj;
50450 fail:
50451 return NULL;
50452 }
50453
50454
50455 SWIGINTERN PyObject *_wrap_GridBagSizer_GetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
50456 PyObject *resultobj = 0;
50457 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50458 wxSize result;
50459 void *argp1 = 0 ;
50460 int res1 = 0 ;
50461 PyObject *swig_obj[1] ;
50462
50463 if (!args) SWIG_fail;
50464 swig_obj[0] = args;
50465 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50466 if (!SWIG_IsOK(res1)) {
50467 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer const *""'");
50468 }
50469 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50470 {
50471 PyThreadState* __tstate = wxPyBeginAllowThreads();
50472 result = ((wxGridBagSizer const *)arg1)->GetEmptyCellSize();
50473 wxPyEndAllowThreads(__tstate);
50474 if (PyErr_Occurred()) SWIG_fail;
50475 }
50476 resultobj = SWIG_NewPointerObj((new wxSize(static_cast< const wxSize& >(result))), SWIGTYPE_p_wxSize, SWIG_POINTER_OWN | 0 );
50477 return resultobj;
50478 fail:
50479 return NULL;
50480 }
50481
50482
50483 SWIGINTERN PyObject *_wrap_GridBagSizer_SetEmptyCellSize(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
50484 PyObject *resultobj = 0;
50485 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50486 wxSize *arg2 = 0 ;
50487 void *argp1 = 0 ;
50488 int res1 = 0 ;
50489 wxSize temp2 ;
50490 PyObject * obj0 = 0 ;
50491 PyObject * obj1 = 0 ;
50492 char * kwnames[] = {
50493 (char *) "self",(char *) "sz", NULL
50494 };
50495
50496 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_SetEmptyCellSize",kwnames,&obj0,&obj1)) SWIG_fail;
50497 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50498 if (!SWIG_IsOK(res1)) {
50499 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetEmptyCellSize" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50500 }
50501 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50502 {
50503 arg2 = &temp2;
50504 if ( ! wxSize_helper(obj1, &arg2)) SWIG_fail;
50505 }
50506 {
50507 PyThreadState* __tstate = wxPyBeginAllowThreads();
50508 (arg1)->SetEmptyCellSize((wxSize const &)*arg2);
50509 wxPyEndAllowThreads(__tstate);
50510 if (PyErr_Occurred()) SWIG_fail;
50511 }
50512 resultobj = SWIG_Py_Void();
50513 return resultobj;
50514 fail:
50515 return NULL;
50516 }
50517
50518
50519 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50520 PyObject *resultobj = 0;
50521 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50522 wxWindow *arg2 = (wxWindow *) 0 ;
50523 wxGBPosition result;
50524 void *argp1 = 0 ;
50525 int res1 = 0 ;
50526 void *argp2 = 0 ;
50527 int res2 = 0 ;
50528
50529 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50530 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50531 if (!SWIG_IsOK(res1)) {
50532 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50533 }
50534 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50535 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50536 if (!SWIG_IsOK(res2)) {
50537 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50538 }
50539 arg2 = reinterpret_cast< wxWindow * >(argp2);
50540 {
50541 PyThreadState* __tstate = wxPyBeginAllowThreads();
50542 result = (arg1)->GetItemPosition(arg2);
50543 wxPyEndAllowThreads(__tstate);
50544 if (PyErr_Occurred()) SWIG_fail;
50545 }
50546 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50547 return resultobj;
50548 fail:
50549 return NULL;
50550 }
50551
50552
50553 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50554 PyObject *resultobj = 0;
50555 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50556 wxSizer *arg2 = (wxSizer *) 0 ;
50557 wxGBPosition result;
50558 void *argp1 = 0 ;
50559 int res1 = 0 ;
50560 void *argp2 = 0 ;
50561 int res2 = 0 ;
50562
50563 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50564 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50565 if (!SWIG_IsOK(res1)) {
50566 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50567 }
50568 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50569 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50570 if (!SWIG_IsOK(res2)) {
50571 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50572 }
50573 arg2 = reinterpret_cast< wxSizer * >(argp2);
50574 {
50575 PyThreadState* __tstate = wxPyBeginAllowThreads();
50576 result = (arg1)->GetItemPosition(arg2);
50577 wxPyEndAllowThreads(__tstate);
50578 if (PyErr_Occurred()) SWIG_fail;
50579 }
50580 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50581 return resultobj;
50582 fail:
50583 return NULL;
50584 }
50585
50586
50587 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50588 PyObject *resultobj = 0;
50589 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50590 size_t arg2 ;
50591 wxGBPosition result;
50592 void *argp1 = 0 ;
50593 int res1 = 0 ;
50594 size_t val2 ;
50595 int ecode2 = 0 ;
50596
50597 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50598 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50599 if (!SWIG_IsOK(res1)) {
50600 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50601 }
50602 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50603 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50604 if (!SWIG_IsOK(ecode2)) {
50605 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50606 }
50607 arg2 = static_cast< size_t >(val2);
50608 {
50609 PyThreadState* __tstate = wxPyBeginAllowThreads();
50610 result = (arg1)->GetItemPosition(arg2);
50611 wxPyEndAllowThreads(__tstate);
50612 if (PyErr_Occurred()) SWIG_fail;
50613 }
50614 resultobj = SWIG_NewPointerObj((new wxGBPosition(static_cast< const wxGBPosition& >(result))), SWIGTYPE_p_wxGBPosition, SWIG_POINTER_OWN | 0 );
50615 return resultobj;
50616 fail:
50617 return NULL;
50618 }
50619
50620
50621 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemPosition(PyObject *self, PyObject *args) {
50622 int argc;
50623 PyObject *argv[3];
50624
50625 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemPosition",0,2,argv))) SWIG_fail;
50626 --argc;
50627 if (argc == 2) {
50628 int _v = 0;
50629 {
50630 void *vptr = 0;
50631 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50632 _v = SWIG_CheckState(res);
50633 }
50634 if (!_v) goto check_1;
50635 return _wrap_GridBagSizer_GetItemPosition__SWIG_0(self, argc, argv);
50636 }
50637 check_1:
50638
50639 if (argc == 2) {
50640 int _v = 0;
50641 {
50642 void *vptr = 0;
50643 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50644 _v = SWIG_CheckState(res);
50645 }
50646 if (!_v) goto check_2;
50647 return _wrap_GridBagSizer_GetItemPosition__SWIG_1(self, argc, argv);
50648 }
50649 check_2:
50650
50651 if (argc == 2) {
50652 return _wrap_GridBagSizer_GetItemPosition__SWIG_2(self, argc, argv);
50653 }
50654
50655 fail:
50656 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemPosition'");
50657 return NULL;
50658 }
50659
50660
50661 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50662 PyObject *resultobj = 0;
50663 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50664 wxWindow *arg2 = (wxWindow *) 0 ;
50665 wxGBPosition *arg3 = 0 ;
50666 bool result;
50667 void *argp1 = 0 ;
50668 int res1 = 0 ;
50669 void *argp2 = 0 ;
50670 int res2 = 0 ;
50671 wxGBPosition temp3 ;
50672
50673 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50674 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50675 if (!SWIG_IsOK(res1)) {
50676 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50677 }
50678 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50679 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50680 if (!SWIG_IsOK(res2)) {
50681 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxWindow *""'");
50682 }
50683 arg2 = reinterpret_cast< wxWindow * >(argp2);
50684 {
50685 arg3 = &temp3;
50686 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50687 }
50688 {
50689 PyThreadState* __tstate = wxPyBeginAllowThreads();
50690 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50691 wxPyEndAllowThreads(__tstate);
50692 if (PyErr_Occurred()) SWIG_fail;
50693 }
50694 {
50695 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50696 }
50697 return resultobj;
50698 fail:
50699 return NULL;
50700 }
50701
50702
50703 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50704 PyObject *resultobj = 0;
50705 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50706 wxSizer *arg2 = (wxSizer *) 0 ;
50707 wxGBPosition *arg3 = 0 ;
50708 bool result;
50709 void *argp1 = 0 ;
50710 int res1 = 0 ;
50711 void *argp2 = 0 ;
50712 int res2 = 0 ;
50713 wxGBPosition temp3 ;
50714
50715 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50716 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50717 if (!SWIG_IsOK(res1)) {
50718 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50719 }
50720 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50721 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50722 if (!SWIG_IsOK(res2)) {
50723 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "wxSizer *""'");
50724 }
50725 arg2 = reinterpret_cast< wxSizer * >(argp2);
50726 {
50727 arg3 = &temp3;
50728 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50729 }
50730 {
50731 PyThreadState* __tstate = wxPyBeginAllowThreads();
50732 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50733 wxPyEndAllowThreads(__tstate);
50734 if (PyErr_Occurred()) SWIG_fail;
50735 }
50736 {
50737 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50738 }
50739 return resultobj;
50740 fail:
50741 return NULL;
50742 }
50743
50744
50745 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50746 PyObject *resultobj = 0;
50747 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50748 size_t arg2 ;
50749 wxGBPosition *arg3 = 0 ;
50750 bool result;
50751 void *argp1 = 0 ;
50752 int res1 = 0 ;
50753 size_t val2 ;
50754 int ecode2 = 0 ;
50755 wxGBPosition temp3 ;
50756
50757 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50758 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50759 if (!SWIG_IsOK(res1)) {
50760 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50761 }
50762 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50763 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50764 if (!SWIG_IsOK(ecode2)) {
50765 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemPosition" "', expected argument " "2"" of type '" "size_t""'");
50766 }
50767 arg2 = static_cast< size_t >(val2);
50768 {
50769 arg3 = &temp3;
50770 if ( ! wxGBPosition_helper(swig_obj[2], &arg3)) SWIG_fail;
50771 }
50772 {
50773 PyThreadState* __tstate = wxPyBeginAllowThreads();
50774 result = (bool)(arg1)->SetItemPosition(arg2,(wxGBPosition const &)*arg3);
50775 wxPyEndAllowThreads(__tstate);
50776 if (PyErr_Occurred()) SWIG_fail;
50777 }
50778 {
50779 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
50780 }
50781 return resultobj;
50782 fail:
50783 return NULL;
50784 }
50785
50786
50787 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemPosition(PyObject *self, PyObject *args) {
50788 int argc;
50789 PyObject *argv[4];
50790
50791 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemPosition",0,3,argv))) SWIG_fail;
50792 --argc;
50793 if (argc == 3) {
50794 int _v = 0;
50795 {
50796 void *vptr = 0;
50797 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50798 _v = SWIG_CheckState(res);
50799 }
50800 if (!_v) goto check_1;
50801 return _wrap_GridBagSizer_SetItemPosition__SWIG_0(self, argc, argv);
50802 }
50803 check_1:
50804
50805 if (argc == 3) {
50806 int _v = 0;
50807 {
50808 void *vptr = 0;
50809 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50810 _v = SWIG_CheckState(res);
50811 }
50812 if (!_v) goto check_2;
50813 return _wrap_GridBagSizer_SetItemPosition__SWIG_1(self, argc, argv);
50814 }
50815 check_2:
50816
50817 if (argc == 3) {
50818 return _wrap_GridBagSizer_SetItemPosition__SWIG_2(self, argc, argv);
50819 }
50820
50821 fail:
50822 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemPosition'");
50823 return NULL;
50824 }
50825
50826
50827 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50828 PyObject *resultobj = 0;
50829 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50830 wxWindow *arg2 = (wxWindow *) 0 ;
50831 wxGBSpan result;
50832 void *argp1 = 0 ;
50833 int res1 = 0 ;
50834 void *argp2 = 0 ;
50835 int res2 = 0 ;
50836
50837 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50838 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50839 if (!SWIG_IsOK(res1)) {
50840 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50841 }
50842 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50843 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50844 if (!SWIG_IsOK(res2)) {
50845 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50846 }
50847 arg2 = reinterpret_cast< wxWindow * >(argp2);
50848 {
50849 PyThreadState* __tstate = wxPyBeginAllowThreads();
50850 result = (arg1)->GetItemSpan(arg2);
50851 wxPyEndAllowThreads(__tstate);
50852 if (PyErr_Occurred()) SWIG_fail;
50853 }
50854 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50855 return resultobj;
50856 fail:
50857 return NULL;
50858 }
50859
50860
50861 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50862 PyObject *resultobj = 0;
50863 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50864 wxSizer *arg2 = (wxSizer *) 0 ;
50865 wxGBSpan result;
50866 void *argp1 = 0 ;
50867 int res1 = 0 ;
50868 void *argp2 = 0 ;
50869 int res2 = 0 ;
50870
50871 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50872 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50873 if (!SWIG_IsOK(res1)) {
50874 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50875 }
50876 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50877 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
50878 if (!SWIG_IsOK(res2)) {
50879 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
50880 }
50881 arg2 = reinterpret_cast< wxSizer * >(argp2);
50882 {
50883 PyThreadState* __tstate = wxPyBeginAllowThreads();
50884 result = (arg1)->GetItemSpan(arg2);
50885 wxPyEndAllowThreads(__tstate);
50886 if (PyErr_Occurred()) SWIG_fail;
50887 }
50888 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50889 return resultobj;
50890 fail:
50891 return NULL;
50892 }
50893
50894
50895 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50896 PyObject *resultobj = 0;
50897 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50898 size_t arg2 ;
50899 wxGBSpan result;
50900 void *argp1 = 0 ;
50901 int res1 = 0 ;
50902 size_t val2 ;
50903 int ecode2 = 0 ;
50904
50905 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
50906 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50907 if (!SWIG_IsOK(res1)) {
50908 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50909 }
50910 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50911 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
50912 if (!SWIG_IsOK(ecode2)) {
50913 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_GetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
50914 }
50915 arg2 = static_cast< size_t >(val2);
50916 {
50917 PyThreadState* __tstate = wxPyBeginAllowThreads();
50918 result = (arg1)->GetItemSpan(arg2);
50919 wxPyEndAllowThreads(__tstate);
50920 if (PyErr_Occurred()) SWIG_fail;
50921 }
50922 resultobj = SWIG_NewPointerObj((new wxGBSpan(static_cast< const wxGBSpan& >(result))), SWIGTYPE_p_wxGBSpan, SWIG_POINTER_OWN | 0 );
50923 return resultobj;
50924 fail:
50925 return NULL;
50926 }
50927
50928
50929 SWIGINTERN PyObject *_wrap_GridBagSizer_GetItemSpan(PyObject *self, PyObject *args) {
50930 int argc;
50931 PyObject *argv[3];
50932
50933 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_GetItemSpan",0,2,argv))) SWIG_fail;
50934 --argc;
50935 if (argc == 2) {
50936 int _v = 0;
50937 {
50938 void *vptr = 0;
50939 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
50940 _v = SWIG_CheckState(res);
50941 }
50942 if (!_v) goto check_1;
50943 return _wrap_GridBagSizer_GetItemSpan__SWIG_0(self, argc, argv);
50944 }
50945 check_1:
50946
50947 if (argc == 2) {
50948 int _v = 0;
50949 {
50950 void *vptr = 0;
50951 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
50952 _v = SWIG_CheckState(res);
50953 }
50954 if (!_v) goto check_2;
50955 return _wrap_GridBagSizer_GetItemSpan__SWIG_1(self, argc, argv);
50956 }
50957 check_2:
50958
50959 if (argc == 2) {
50960 return _wrap_GridBagSizer_GetItemSpan__SWIG_2(self, argc, argv);
50961 }
50962
50963 fail:
50964 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_GetItemSpan'");
50965 return NULL;
50966 }
50967
50968
50969 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
50970 PyObject *resultobj = 0;
50971 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
50972 wxWindow *arg2 = (wxWindow *) 0 ;
50973 wxGBSpan *arg3 = 0 ;
50974 bool result;
50975 void *argp1 = 0 ;
50976 int res1 = 0 ;
50977 void *argp2 = 0 ;
50978 int res2 = 0 ;
50979 wxGBSpan temp3 ;
50980
50981 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
50982 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
50983 if (!SWIG_IsOK(res1)) {
50984 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
50985 }
50986 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
50987 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
50988 if (!SWIG_IsOK(res2)) {
50989 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxWindow *""'");
50990 }
50991 arg2 = reinterpret_cast< wxWindow * >(argp2);
50992 {
50993 arg3 = &temp3;
50994 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
50995 }
50996 {
50997 PyThreadState* __tstate = wxPyBeginAllowThreads();
50998 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
50999 wxPyEndAllowThreads(__tstate);
51000 if (PyErr_Occurred()) SWIG_fail;
51001 }
51002 {
51003 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51004 }
51005 return resultobj;
51006 fail:
51007 return NULL;
51008 }
51009
51010
51011 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51012 PyObject *resultobj = 0;
51013 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51014 wxSizer *arg2 = (wxSizer *) 0 ;
51015 wxGBSpan *arg3 = 0 ;
51016 bool result;
51017 void *argp1 = 0 ;
51018 int res1 = 0 ;
51019 void *argp2 = 0 ;
51020 int res2 = 0 ;
51021 wxGBSpan temp3 ;
51022
51023 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51024 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51025 if (!SWIG_IsOK(res1)) {
51026 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51027 }
51028 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51029 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51030 if (!SWIG_IsOK(res2)) {
51031 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "wxSizer *""'");
51032 }
51033 arg2 = reinterpret_cast< wxSizer * >(argp2);
51034 {
51035 arg3 = &temp3;
51036 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51037 }
51038 {
51039 PyThreadState* __tstate = wxPyBeginAllowThreads();
51040 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51041 wxPyEndAllowThreads(__tstate);
51042 if (PyErr_Occurred()) SWIG_fail;
51043 }
51044 {
51045 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51046 }
51047 return resultobj;
51048 fail:
51049 return NULL;
51050 }
51051
51052
51053 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan__SWIG_2(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51054 PyObject *resultobj = 0;
51055 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51056 size_t arg2 ;
51057 wxGBSpan *arg3 = 0 ;
51058 bool result;
51059 void *argp1 = 0 ;
51060 int res1 = 0 ;
51061 size_t val2 ;
51062 int ecode2 = 0 ;
51063 wxGBSpan temp3 ;
51064
51065 if ((nobjs < 3) || (nobjs > 3)) SWIG_fail;
51066 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51067 if (!SWIG_IsOK(res1)) {
51068 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51069 }
51070 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51071 ecode2 = SWIG_AsVal_size_t(swig_obj[1], &val2);
51072 if (!SWIG_IsOK(ecode2)) {
51073 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "GridBagSizer_SetItemSpan" "', expected argument " "2"" of type '" "size_t""'");
51074 }
51075 arg2 = static_cast< size_t >(val2);
51076 {
51077 arg3 = &temp3;
51078 if ( ! wxGBSpan_helper(swig_obj[2], &arg3)) SWIG_fail;
51079 }
51080 {
51081 PyThreadState* __tstate = wxPyBeginAllowThreads();
51082 result = (bool)(arg1)->SetItemSpan(arg2,(wxGBSpan const &)*arg3);
51083 wxPyEndAllowThreads(__tstate);
51084 if (PyErr_Occurred()) SWIG_fail;
51085 }
51086 {
51087 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51088 }
51089 return resultobj;
51090 fail:
51091 return NULL;
51092 }
51093
51094
51095 SWIGINTERN PyObject *_wrap_GridBagSizer_SetItemSpan(PyObject *self, PyObject *args) {
51096 int argc;
51097 PyObject *argv[4];
51098
51099 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_SetItemSpan",0,3,argv))) SWIG_fail;
51100 --argc;
51101 if (argc == 3) {
51102 int _v = 0;
51103 {
51104 void *vptr = 0;
51105 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51106 _v = SWIG_CheckState(res);
51107 }
51108 if (!_v) goto check_1;
51109 return _wrap_GridBagSizer_SetItemSpan__SWIG_0(self, argc, argv);
51110 }
51111 check_1:
51112
51113 if (argc == 3) {
51114 int _v = 0;
51115 {
51116 void *vptr = 0;
51117 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxSizer, 0);
51118 _v = SWIG_CheckState(res);
51119 }
51120 if (!_v) goto check_2;
51121 return _wrap_GridBagSizer_SetItemSpan__SWIG_1(self, argc, argv);
51122 }
51123 check_2:
51124
51125 if (argc == 3) {
51126 return _wrap_GridBagSizer_SetItemSpan__SWIG_2(self, argc, argv);
51127 }
51128
51129 fail:
51130 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_SetItemSpan'");
51131 return NULL;
51132 }
51133
51134
51135 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_0(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51136 PyObject *resultobj = 0;
51137 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51138 wxWindow *arg2 = (wxWindow *) 0 ;
51139 wxGBSizerItem *result = 0 ;
51140 void *argp1 = 0 ;
51141 int res1 = 0 ;
51142 void *argp2 = 0 ;
51143 int res2 = 0 ;
51144
51145 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51146 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51147 if (!SWIG_IsOK(res1)) {
51148 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51149 }
51150 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51151 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51152 if (!SWIG_IsOK(res2)) {
51153 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxWindow *""'");
51154 }
51155 arg2 = reinterpret_cast< wxWindow * >(argp2);
51156 {
51157 PyThreadState* __tstate = wxPyBeginAllowThreads();
51158 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51159 wxPyEndAllowThreads(__tstate);
51160 if (PyErr_Occurred()) SWIG_fail;
51161 }
51162 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51163 return resultobj;
51164 fail:
51165 return NULL;
51166 }
51167
51168
51169 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem__SWIG_1(PyObject *SWIGUNUSEDPARM(self), int nobjs, PyObject **swig_obj) {
51170 PyObject *resultobj = 0;
51171 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51172 wxSizer *arg2 = (wxSizer *) 0 ;
51173 wxGBSizerItem *result = 0 ;
51174 void *argp1 = 0 ;
51175 int res1 = 0 ;
51176 void *argp2 = 0 ;
51177 int res2 = 0 ;
51178
51179 if ((nobjs < 2) || (nobjs > 2)) SWIG_fail;
51180 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51181 if (!SWIG_IsOK(res1)) {
51182 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItem" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51183 }
51184 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51185 res2 = SWIG_ConvertPtr(swig_obj[1], &argp2,SWIGTYPE_p_wxSizer, 0 | 0 );
51186 if (!SWIG_IsOK(res2)) {
51187 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_FindItem" "', expected argument " "2"" of type '" "wxSizer *""'");
51188 }
51189 arg2 = reinterpret_cast< wxSizer * >(argp2);
51190 {
51191 PyThreadState* __tstate = wxPyBeginAllowThreads();
51192 result = (wxGBSizerItem *)(arg1)->FindItem(arg2);
51193 wxPyEndAllowThreads(__tstate);
51194 if (PyErr_Occurred()) SWIG_fail;
51195 }
51196 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51197 return resultobj;
51198 fail:
51199 return NULL;
51200 }
51201
51202
51203 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItem(PyObject *self, PyObject *args) {
51204 int argc;
51205 PyObject *argv[3];
51206
51207 if (!(argc = SWIG_Python_UnpackTuple(args,"GridBagSizer_FindItem",0,2,argv))) SWIG_fail;
51208 --argc;
51209 if (argc == 2) {
51210 int _v = 0;
51211 {
51212 void *vptr = 0;
51213 int res = SWIG_ConvertPtr(argv[1], &vptr, SWIGTYPE_p_wxWindow, 0);
51214 _v = SWIG_CheckState(res);
51215 }
51216 if (!_v) goto check_1;
51217 return _wrap_GridBagSizer_FindItem__SWIG_0(self, argc, argv);
51218 }
51219 check_1:
51220
51221 if (argc == 2) {
51222 return _wrap_GridBagSizer_FindItem__SWIG_1(self, argc, argv);
51223 }
51224
51225 fail:
51226 SWIG_SetErrorMsg(PyExc_NotImplementedError,"No matching function for overloaded 'GridBagSizer_FindItem'");
51227 return NULL;
51228 }
51229
51230
51231 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPosition(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51232 PyObject *resultobj = 0;
51233 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51234 wxGBPosition *arg2 = 0 ;
51235 wxGBSizerItem *result = 0 ;
51236 void *argp1 = 0 ;
51237 int res1 = 0 ;
51238 wxGBPosition temp2 ;
51239 PyObject * obj0 = 0 ;
51240 PyObject * obj1 = 0 ;
51241 char * kwnames[] = {
51242 (char *) "self",(char *) "pos", NULL
51243 };
51244
51245 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPosition",kwnames,&obj0,&obj1)) SWIG_fail;
51246 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51247 if (!SWIG_IsOK(res1)) {
51248 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPosition" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51249 }
51250 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51251 {
51252 arg2 = &temp2;
51253 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51254 }
51255 {
51256 PyThreadState* __tstate = wxPyBeginAllowThreads();
51257 result = (wxGBSizerItem *)(arg1)->FindItemAtPosition((wxGBPosition const &)*arg2);
51258 wxPyEndAllowThreads(__tstate);
51259 if (PyErr_Occurred()) SWIG_fail;
51260 }
51261 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51262 return resultobj;
51263 fail:
51264 return NULL;
51265 }
51266
51267
51268 SWIGINTERN PyObject *_wrap_GridBagSizer_FindItemAtPoint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51269 PyObject *resultobj = 0;
51270 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51271 wxPoint *arg2 = 0 ;
51272 wxGBSizerItem *result = 0 ;
51273 void *argp1 = 0 ;
51274 int res1 = 0 ;
51275 wxPoint temp2 ;
51276 PyObject * obj0 = 0 ;
51277 PyObject * obj1 = 0 ;
51278 char * kwnames[] = {
51279 (char *) "self",(char *) "pt", NULL
51280 };
51281
51282 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:GridBagSizer_FindItemAtPoint",kwnames,&obj0,&obj1)) SWIG_fail;
51283 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51284 if (!SWIG_IsOK(res1)) {
51285 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_FindItemAtPoint" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51286 }
51287 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51288 {
51289 arg2 = &temp2;
51290 if ( ! wxPoint_helper(obj1, &arg2)) SWIG_fail;
51291 }
51292 {
51293 PyThreadState* __tstate = wxPyBeginAllowThreads();
51294 result = (wxGBSizerItem *)(arg1)->FindItemAtPoint((wxPoint const &)*arg2);
51295 wxPyEndAllowThreads(__tstate);
51296 if (PyErr_Occurred()) SWIG_fail;
51297 }
51298 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51299 return resultobj;
51300 fail:
51301 return NULL;
51302 }
51303
51304
51305 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersection(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51306 PyObject *resultobj = 0;
51307 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51308 wxGBSizerItem *arg2 = (wxGBSizerItem *) 0 ;
51309 wxGBSizerItem *arg3 = (wxGBSizerItem *) NULL ;
51310 bool result;
51311 void *argp1 = 0 ;
51312 int res1 = 0 ;
51313 void *argp2 = 0 ;
51314 int res2 = 0 ;
51315 void *argp3 = 0 ;
51316 int res3 = 0 ;
51317 PyObject * obj0 = 0 ;
51318 PyObject * obj1 = 0 ;
51319 PyObject * obj2 = 0 ;
51320 char * kwnames[] = {
51321 (char *) "self",(char *) "item",(char *) "excludeItem", NULL
51322 };
51323
51324 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:GridBagSizer_CheckForIntersection",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51325 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51326 if (!SWIG_IsOK(res1)) {
51327 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51328 }
51329 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51330 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51331 if (!SWIG_IsOK(res2)) {
51332 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "2"" of type '" "wxGBSizerItem *""'");
51333 }
51334 arg2 = reinterpret_cast< wxGBSizerItem * >(argp2);
51335 if (obj2) {
51336 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51337 if (!SWIG_IsOK(res3)) {
51338 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "GridBagSizer_CheckForIntersection" "', expected argument " "3"" of type '" "wxGBSizerItem *""'");
51339 }
51340 arg3 = reinterpret_cast< wxGBSizerItem * >(argp3);
51341 }
51342 {
51343 PyThreadState* __tstate = wxPyBeginAllowThreads();
51344 result = (bool)(arg1)->CheckForIntersection(arg2,arg3);
51345 wxPyEndAllowThreads(__tstate);
51346 if (PyErr_Occurred()) SWIG_fail;
51347 }
51348 {
51349 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51350 }
51351 return resultobj;
51352 fail:
51353 return NULL;
51354 }
51355
51356
51357 SWIGINTERN PyObject *_wrap_GridBagSizer_CheckForIntersectionPos(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51358 PyObject *resultobj = 0;
51359 wxGridBagSizer *arg1 = (wxGridBagSizer *) 0 ;
51360 wxGBPosition *arg2 = 0 ;
51361 wxGBSpan *arg3 = 0 ;
51362 wxGBSizerItem *arg4 = (wxGBSizerItem *) NULL ;
51363 bool result;
51364 void *argp1 = 0 ;
51365 int res1 = 0 ;
51366 wxGBPosition temp2 ;
51367 wxGBSpan temp3 ;
51368 void *argp4 = 0 ;
51369 int res4 = 0 ;
51370 PyObject * obj0 = 0 ;
51371 PyObject * obj1 = 0 ;
51372 PyObject * obj2 = 0 ;
51373 PyObject * obj3 = 0 ;
51374 char * kwnames[] = {
51375 (char *) "self",(char *) "pos",(char *) "span",(char *) "excludeItem", NULL
51376 };
51377
51378 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:GridBagSizer_CheckForIntersectionPos",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51379 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxGridBagSizer, 0 | 0 );
51380 if (!SWIG_IsOK(res1)) {
51381 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "1"" of type '" "wxGridBagSizer *""'");
51382 }
51383 arg1 = reinterpret_cast< wxGridBagSizer * >(argp1);
51384 {
51385 arg2 = &temp2;
51386 if ( ! wxGBPosition_helper(obj1, &arg2)) SWIG_fail;
51387 }
51388 {
51389 arg3 = &temp3;
51390 if ( ! wxGBSpan_helper(obj2, &arg3)) SWIG_fail;
51391 }
51392 if (obj3) {
51393 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxGBSizerItem, 0 | 0 );
51394 if (!SWIG_IsOK(res4)) {
51395 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "GridBagSizer_CheckForIntersectionPos" "', expected argument " "4"" of type '" "wxGBSizerItem *""'");
51396 }
51397 arg4 = reinterpret_cast< wxGBSizerItem * >(argp4);
51398 }
51399 {
51400 PyThreadState* __tstate = wxPyBeginAllowThreads();
51401 result = (bool)(arg1)->CheckForIntersection((wxGBPosition const &)*arg2,(wxGBSpan const &)*arg3,arg4);
51402 wxPyEndAllowThreads(__tstate);
51403 if (PyErr_Occurred()) SWIG_fail;
51404 }
51405 {
51406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
51407 }
51408 return resultobj;
51409 fail:
51410 return NULL;
51411 }
51412
51413
51414 SWIGINTERN PyObject *GridBagSizer_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51415 PyObject *obj;
51416 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
51417 SWIG_TypeNewClientData(SWIGTYPE_p_wxGridBagSizer, SWIG_NewClientData(obj));
51418 return SWIG_Py_Void();
51419 }
51420
51421 SWIGINTERN PyObject *GridBagSizer_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51422 return SWIG_Python_InitShadowInstance(args);
51423 }
51424
51425 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Set(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51426 PyObject *resultobj = 0;
51427 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51428 wxRelationship arg2 ;
51429 wxWindow *arg3 = (wxWindow *) 0 ;
51430 wxEdge arg4 ;
51431 int arg5 = (int) 0 ;
51432 int arg6 = (int) wxLAYOUT_DEFAULT_MARGIN ;
51433 void *argp1 = 0 ;
51434 int res1 = 0 ;
51435 int val2 ;
51436 int ecode2 = 0 ;
51437 void *argp3 = 0 ;
51438 int res3 = 0 ;
51439 int val4 ;
51440 int ecode4 = 0 ;
51441 int val5 ;
51442 int ecode5 = 0 ;
51443 int val6 ;
51444 int ecode6 = 0 ;
51445 PyObject * obj0 = 0 ;
51446 PyObject * obj1 = 0 ;
51447 PyObject * obj2 = 0 ;
51448 PyObject * obj3 = 0 ;
51449 PyObject * obj4 = 0 ;
51450 PyObject * obj5 = 0 ;
51451 char * kwnames[] = {
51452 (char *) "self",(char *) "rel",(char *) "otherW",(char *) "otherE",(char *) "val",(char *) "marg", NULL
51453 };
51454
51455 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO|OO:IndividualLayoutConstraint_Set",kwnames,&obj0,&obj1,&obj2,&obj3,&obj4,&obj5)) SWIG_fail;
51456 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51457 if (!SWIG_IsOK(res1)) {
51458 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51459 }
51460 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51461 ecode2 = SWIG_AsVal_int(obj1, &val2);
51462 if (!SWIG_IsOK(ecode2)) {
51463 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "2"" of type '" "wxRelationship""'");
51464 }
51465 arg2 = static_cast< wxRelationship >(val2);
51466 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
51467 if (!SWIG_IsOK(res3)) {
51468 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "3"" of type '" "wxWindow *""'");
51469 }
51470 arg3 = reinterpret_cast< wxWindow * >(argp3);
51471 ecode4 = SWIG_AsVal_int(obj3, &val4);
51472 if (!SWIG_IsOK(ecode4)) {
51473 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "4"" of type '" "wxEdge""'");
51474 }
51475 arg4 = static_cast< wxEdge >(val4);
51476 if (obj4) {
51477 ecode5 = SWIG_AsVal_int(obj4, &val5);
51478 if (!SWIG_IsOK(ecode5)) {
51479 SWIG_exception_fail(SWIG_ArgError(ecode5), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "5"" of type '" "int""'");
51480 }
51481 arg5 = static_cast< int >(val5);
51482 }
51483 if (obj5) {
51484 ecode6 = SWIG_AsVal_int(obj5, &val6);
51485 if (!SWIG_IsOK(ecode6)) {
51486 SWIG_exception_fail(SWIG_ArgError(ecode6), "in method '" "IndividualLayoutConstraint_Set" "', expected argument " "6"" of type '" "int""'");
51487 }
51488 arg6 = static_cast< int >(val6);
51489 }
51490 {
51491 PyThreadState* __tstate = wxPyBeginAllowThreads();
51492 (arg1)->Set(arg2,arg3,arg4,arg5,arg6);
51493 wxPyEndAllowThreads(__tstate);
51494 if (PyErr_Occurred()) SWIG_fail;
51495 }
51496 resultobj = SWIG_Py_Void();
51497 return resultobj;
51498 fail:
51499 return NULL;
51500 }
51501
51502
51503 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_LeftOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51504 PyObject *resultobj = 0;
51505 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51506 wxWindow *arg2 = (wxWindow *) 0 ;
51507 int arg3 = (int) 0 ;
51508 void *argp1 = 0 ;
51509 int res1 = 0 ;
51510 void *argp2 = 0 ;
51511 int res2 = 0 ;
51512 int val3 ;
51513 int ecode3 = 0 ;
51514 PyObject * obj0 = 0 ;
51515 PyObject * obj1 = 0 ;
51516 PyObject * obj2 = 0 ;
51517 char * kwnames[] = {
51518 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51519 };
51520
51521 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_LeftOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51522 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51523 if (!SWIG_IsOK(res1)) {
51524 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51525 }
51526 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51527 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51528 if (!SWIG_IsOK(res2)) {
51529 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51530 }
51531 arg2 = reinterpret_cast< wxWindow * >(argp2);
51532 if (obj2) {
51533 ecode3 = SWIG_AsVal_int(obj2, &val3);
51534 if (!SWIG_IsOK(ecode3)) {
51535 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_LeftOf" "', expected argument " "3"" of type '" "int""'");
51536 }
51537 arg3 = static_cast< int >(val3);
51538 }
51539 {
51540 PyThreadState* __tstate = wxPyBeginAllowThreads();
51541 (arg1)->LeftOf(arg2,arg3);
51542 wxPyEndAllowThreads(__tstate);
51543 if (PyErr_Occurred()) SWIG_fail;
51544 }
51545 resultobj = SWIG_Py_Void();
51546 return resultobj;
51547 fail:
51548 return NULL;
51549 }
51550
51551
51552 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_RightOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51553 PyObject *resultobj = 0;
51554 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51555 wxWindow *arg2 = (wxWindow *) 0 ;
51556 int arg3 = (int) 0 ;
51557 void *argp1 = 0 ;
51558 int res1 = 0 ;
51559 void *argp2 = 0 ;
51560 int res2 = 0 ;
51561 int val3 ;
51562 int ecode3 = 0 ;
51563 PyObject * obj0 = 0 ;
51564 PyObject * obj1 = 0 ;
51565 PyObject * obj2 = 0 ;
51566 char * kwnames[] = {
51567 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51568 };
51569
51570 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_RightOf",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51571 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51572 if (!SWIG_IsOK(res1)) {
51573 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51574 }
51575 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51576 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51577 if (!SWIG_IsOK(res2)) {
51578 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51579 }
51580 arg2 = reinterpret_cast< wxWindow * >(argp2);
51581 if (obj2) {
51582 ecode3 = SWIG_AsVal_int(obj2, &val3);
51583 if (!SWIG_IsOK(ecode3)) {
51584 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_RightOf" "', expected argument " "3"" of type '" "int""'");
51585 }
51586 arg3 = static_cast< int >(val3);
51587 }
51588 {
51589 PyThreadState* __tstate = wxPyBeginAllowThreads();
51590 (arg1)->RightOf(arg2,arg3);
51591 wxPyEndAllowThreads(__tstate);
51592 if (PyErr_Occurred()) SWIG_fail;
51593 }
51594 resultobj = SWIG_Py_Void();
51595 return resultobj;
51596 fail:
51597 return NULL;
51598 }
51599
51600
51601 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Above(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51602 PyObject *resultobj = 0;
51603 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51604 wxWindow *arg2 = (wxWindow *) 0 ;
51605 int arg3 = (int) 0 ;
51606 void *argp1 = 0 ;
51607 int res1 = 0 ;
51608 void *argp2 = 0 ;
51609 int res2 = 0 ;
51610 int val3 ;
51611 int ecode3 = 0 ;
51612 PyObject * obj0 = 0 ;
51613 PyObject * obj1 = 0 ;
51614 PyObject * obj2 = 0 ;
51615 char * kwnames[] = {
51616 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51617 };
51618
51619 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Above",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51620 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51621 if (!SWIG_IsOK(res1)) {
51622 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51623 }
51624 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51625 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51626 if (!SWIG_IsOK(res2)) {
51627 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "2"" of type '" "wxWindow *""'");
51628 }
51629 arg2 = reinterpret_cast< wxWindow * >(argp2);
51630 if (obj2) {
51631 ecode3 = SWIG_AsVal_int(obj2, &val3);
51632 if (!SWIG_IsOK(ecode3)) {
51633 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Above" "', expected argument " "3"" of type '" "int""'");
51634 }
51635 arg3 = static_cast< int >(val3);
51636 }
51637 {
51638 PyThreadState* __tstate = wxPyBeginAllowThreads();
51639 (arg1)->Above(arg2,arg3);
51640 wxPyEndAllowThreads(__tstate);
51641 if (PyErr_Occurred()) SWIG_fail;
51642 }
51643 resultobj = SWIG_Py_Void();
51644 return resultobj;
51645 fail:
51646 return NULL;
51647 }
51648
51649
51650 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Below(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51651 PyObject *resultobj = 0;
51652 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51653 wxWindow *arg2 = (wxWindow *) 0 ;
51654 int arg3 = (int) 0 ;
51655 void *argp1 = 0 ;
51656 int res1 = 0 ;
51657 void *argp2 = 0 ;
51658 int res2 = 0 ;
51659 int val3 ;
51660 int ecode3 = 0 ;
51661 PyObject * obj0 = 0 ;
51662 PyObject * obj1 = 0 ;
51663 PyObject * obj2 = 0 ;
51664 char * kwnames[] = {
51665 (char *) "self",(char *) "sibling",(char *) "marg", NULL
51666 };
51667
51668 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO|O:IndividualLayoutConstraint_Below",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
51669 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51670 if (!SWIG_IsOK(res1)) {
51671 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51672 }
51673 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51674 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51675 if (!SWIG_IsOK(res2)) {
51676 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "2"" of type '" "wxWindow *""'");
51677 }
51678 arg2 = reinterpret_cast< wxWindow * >(argp2);
51679 if (obj2) {
51680 ecode3 = SWIG_AsVal_int(obj2, &val3);
51681 if (!SWIG_IsOK(ecode3)) {
51682 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_Below" "', expected argument " "3"" of type '" "int""'");
51683 }
51684 arg3 = static_cast< int >(val3);
51685 }
51686 {
51687 PyThreadState* __tstate = wxPyBeginAllowThreads();
51688 (arg1)->Below(arg2,arg3);
51689 wxPyEndAllowThreads(__tstate);
51690 if (PyErr_Occurred()) SWIG_fail;
51691 }
51692 resultobj = SWIG_Py_Void();
51693 return resultobj;
51694 fail:
51695 return NULL;
51696 }
51697
51698
51699 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SameAs(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51700 PyObject *resultobj = 0;
51701 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51702 wxWindow *arg2 = (wxWindow *) 0 ;
51703 wxEdge arg3 ;
51704 int arg4 = (int) 0 ;
51705 void *argp1 = 0 ;
51706 int res1 = 0 ;
51707 void *argp2 = 0 ;
51708 int res2 = 0 ;
51709 int val3 ;
51710 int ecode3 = 0 ;
51711 int val4 ;
51712 int ecode4 = 0 ;
51713 PyObject * obj0 = 0 ;
51714 PyObject * obj1 = 0 ;
51715 PyObject * obj2 = 0 ;
51716 PyObject * obj3 = 0 ;
51717 char * kwnames[] = {
51718 (char *) "self",(char *) "otherW",(char *) "edge",(char *) "marg", NULL
51719 };
51720
51721 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO|O:IndividualLayoutConstraint_SameAs",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51722 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51723 if (!SWIG_IsOK(res1)) {
51724 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51725 }
51726 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51727 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51728 if (!SWIG_IsOK(res2)) {
51729 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "2"" of type '" "wxWindow *""'");
51730 }
51731 arg2 = reinterpret_cast< wxWindow * >(argp2);
51732 ecode3 = SWIG_AsVal_int(obj2, &val3);
51733 if (!SWIG_IsOK(ecode3)) {
51734 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "3"" of type '" "wxEdge""'");
51735 }
51736 arg3 = static_cast< wxEdge >(val3);
51737 if (obj3) {
51738 ecode4 = SWIG_AsVal_int(obj3, &val4);
51739 if (!SWIG_IsOK(ecode4)) {
51740 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_SameAs" "', expected argument " "4"" of type '" "int""'");
51741 }
51742 arg4 = static_cast< int >(val4);
51743 }
51744 {
51745 PyThreadState* __tstate = wxPyBeginAllowThreads();
51746 (arg1)->SameAs(arg2,arg3,arg4);
51747 wxPyEndAllowThreads(__tstate);
51748 if (PyErr_Occurred()) SWIG_fail;
51749 }
51750 resultobj = SWIG_Py_Void();
51751 return resultobj;
51752 fail:
51753 return NULL;
51754 }
51755
51756
51757 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_PercentOf(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51758 PyObject *resultobj = 0;
51759 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51760 wxWindow *arg2 = (wxWindow *) 0 ;
51761 wxEdge arg3 ;
51762 int arg4 ;
51763 void *argp1 = 0 ;
51764 int res1 = 0 ;
51765 void *argp2 = 0 ;
51766 int res2 = 0 ;
51767 int val3 ;
51768 int ecode3 = 0 ;
51769 int val4 ;
51770 int ecode4 = 0 ;
51771 PyObject * obj0 = 0 ;
51772 PyObject * obj1 = 0 ;
51773 PyObject * obj2 = 0 ;
51774 PyObject * obj3 = 0 ;
51775 char * kwnames[] = {
51776 (char *) "self",(char *) "otherW",(char *) "wh",(char *) "per", NULL
51777 };
51778
51779 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_PercentOf",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
51780 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51781 if (!SWIG_IsOK(res1)) {
51782 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51783 }
51784 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51785 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
51786 if (!SWIG_IsOK(res2)) {
51787 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "2"" of type '" "wxWindow *""'");
51788 }
51789 arg2 = reinterpret_cast< wxWindow * >(argp2);
51790 ecode3 = SWIG_AsVal_int(obj2, &val3);
51791 if (!SWIG_IsOK(ecode3)) {
51792 SWIG_exception_fail(SWIG_ArgError(ecode3), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "3"" of type '" "wxEdge""'");
51793 }
51794 arg3 = static_cast< wxEdge >(val3);
51795 ecode4 = SWIG_AsVal_int(obj3, &val4);
51796 if (!SWIG_IsOK(ecode4)) {
51797 SWIG_exception_fail(SWIG_ArgError(ecode4), "in method '" "IndividualLayoutConstraint_PercentOf" "', expected argument " "4"" of type '" "int""'");
51798 }
51799 arg4 = static_cast< int >(val4);
51800 {
51801 PyThreadState* __tstate = wxPyBeginAllowThreads();
51802 (arg1)->PercentOf(arg2,arg3,arg4);
51803 wxPyEndAllowThreads(__tstate);
51804 if (PyErr_Occurred()) SWIG_fail;
51805 }
51806 resultobj = SWIG_Py_Void();
51807 return resultobj;
51808 fail:
51809 return NULL;
51810 }
51811
51812
51813 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Absolute(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51814 PyObject *resultobj = 0;
51815 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51816 int arg2 ;
51817 void *argp1 = 0 ;
51818 int res1 = 0 ;
51819 int val2 ;
51820 int ecode2 = 0 ;
51821 PyObject * obj0 = 0 ;
51822 PyObject * obj1 = 0 ;
51823 char * kwnames[] = {
51824 (char *) "self",(char *) "val", NULL
51825 };
51826
51827 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_Absolute",kwnames,&obj0,&obj1)) SWIG_fail;
51828 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51829 if (!SWIG_IsOK(res1)) {
51830 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51831 }
51832 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51833 ecode2 = SWIG_AsVal_int(obj1, &val2);
51834 if (!SWIG_IsOK(ecode2)) {
51835 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_Absolute" "', expected argument " "2"" of type '" "int""'");
51836 }
51837 arg2 = static_cast< int >(val2);
51838 {
51839 PyThreadState* __tstate = wxPyBeginAllowThreads();
51840 (arg1)->Absolute(arg2);
51841 wxPyEndAllowThreads(__tstate);
51842 if (PyErr_Occurred()) SWIG_fail;
51843 }
51844 resultobj = SWIG_Py_Void();
51845 return resultobj;
51846 fail:
51847 return NULL;
51848 }
51849
51850
51851 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_Unconstrained(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51852 PyObject *resultobj = 0;
51853 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51854 void *argp1 = 0 ;
51855 int res1 = 0 ;
51856 PyObject *swig_obj[1] ;
51857
51858 if (!args) SWIG_fail;
51859 swig_obj[0] = args;
51860 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51861 if (!SWIG_IsOK(res1)) {
51862 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_Unconstrained" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51863 }
51864 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51865 {
51866 PyThreadState* __tstate = wxPyBeginAllowThreads();
51867 (arg1)->Unconstrained();
51868 wxPyEndAllowThreads(__tstate);
51869 if (PyErr_Occurred()) SWIG_fail;
51870 }
51871 resultobj = SWIG_Py_Void();
51872 return resultobj;
51873 fail:
51874 return NULL;
51875 }
51876
51877
51878 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_AsIs(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51879 PyObject *resultobj = 0;
51880 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51881 void *argp1 = 0 ;
51882 int res1 = 0 ;
51883 PyObject *swig_obj[1] ;
51884
51885 if (!args) SWIG_fail;
51886 swig_obj[0] = args;
51887 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51888 if (!SWIG_IsOK(res1)) {
51889 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_AsIs" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51890 }
51891 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51892 {
51893 PyThreadState* __tstate = wxPyBeginAllowThreads();
51894 (arg1)->AsIs();
51895 wxPyEndAllowThreads(__tstate);
51896 if (PyErr_Occurred()) SWIG_fail;
51897 }
51898 resultobj = SWIG_Py_Void();
51899 return resultobj;
51900 fail:
51901 return NULL;
51902 }
51903
51904
51905 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherWindow(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51906 PyObject *resultobj = 0;
51907 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51908 wxWindow *result = 0 ;
51909 void *argp1 = 0 ;
51910 int res1 = 0 ;
51911 PyObject *swig_obj[1] ;
51912
51913 if (!args) SWIG_fail;
51914 swig_obj[0] = args;
51915 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51916 if (!SWIG_IsOK(res1)) {
51917 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherWindow" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51918 }
51919 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51920 {
51921 PyThreadState* __tstate = wxPyBeginAllowThreads();
51922 result = (wxWindow *)(arg1)->GetOtherWindow();
51923 wxPyEndAllowThreads(__tstate);
51924 if (PyErr_Occurred()) SWIG_fail;
51925 }
51926 {
51927 resultobj = wxPyMake_wxObject(result, 0);
51928 }
51929 return resultobj;
51930 fail:
51931 return NULL;
51932 }
51933
51934
51935 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMyEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
51936 PyObject *resultobj = 0;
51937 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51938 wxEdge result;
51939 void *argp1 = 0 ;
51940 int res1 = 0 ;
51941 PyObject *swig_obj[1] ;
51942
51943 if (!args) SWIG_fail;
51944 swig_obj[0] = args;
51945 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51946 if (!SWIG_IsOK(res1)) {
51947 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMyEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
51948 }
51949 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51950 {
51951 PyThreadState* __tstate = wxPyBeginAllowThreads();
51952 result = (wxEdge)((wxIndividualLayoutConstraint const *)arg1)->GetMyEdge();
51953 wxPyEndAllowThreads(__tstate);
51954 if (PyErr_Occurred()) SWIG_fail;
51955 }
51956 resultobj = SWIG_From_int(static_cast< int >(result));
51957 return resultobj;
51958 fail:
51959 return NULL;
51960 }
51961
51962
51963 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
51964 PyObject *resultobj = 0;
51965 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
51966 wxEdge arg2 ;
51967 void *argp1 = 0 ;
51968 int res1 = 0 ;
51969 int val2 ;
51970 int ecode2 = 0 ;
51971 PyObject * obj0 = 0 ;
51972 PyObject * obj1 = 0 ;
51973 char * kwnames[] = {
51974 (char *) "self",(char *) "which", NULL
51975 };
51976
51977 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetEdge",kwnames,&obj0,&obj1)) SWIG_fail;
51978 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
51979 if (!SWIG_IsOK(res1)) {
51980 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
51981 }
51982 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
51983 ecode2 = SWIG_AsVal_int(obj1, &val2);
51984 if (!SWIG_IsOK(ecode2)) {
51985 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
51986 }
51987 arg2 = static_cast< wxEdge >(val2);
51988 {
51989 PyThreadState* __tstate = wxPyBeginAllowThreads();
51990 (arg1)->SetEdge(arg2);
51991 wxPyEndAllowThreads(__tstate);
51992 if (PyErr_Occurred()) SWIG_fail;
51993 }
51994 resultobj = SWIG_Py_Void();
51995 return resultobj;
51996 fail:
51997 return NULL;
51998 }
51999
52000
52001 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52002 PyObject *resultobj = 0;
52003 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52004 int arg2 ;
52005 void *argp1 = 0 ;
52006 int res1 = 0 ;
52007 int val2 ;
52008 int ecode2 = 0 ;
52009 PyObject * obj0 = 0 ;
52010 PyObject * obj1 = 0 ;
52011 char * kwnames[] = {
52012 (char *) "self",(char *) "v", NULL
52013 };
52014
52015 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetValue",kwnames,&obj0,&obj1)) SWIG_fail;
52016 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52017 if (!SWIG_IsOK(res1)) {
52018 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52019 }
52020 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52021 ecode2 = SWIG_AsVal_int(obj1, &val2);
52022 if (!SWIG_IsOK(ecode2)) {
52023 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetValue" "', expected argument " "2"" of type '" "int""'");
52024 }
52025 arg2 = static_cast< int >(val2);
52026 {
52027 PyThreadState* __tstate = wxPyBeginAllowThreads();
52028 (arg1)->SetValue(arg2);
52029 wxPyEndAllowThreads(__tstate);
52030 if (PyErr_Occurred()) SWIG_fail;
52031 }
52032 resultobj = SWIG_Py_Void();
52033 return resultobj;
52034 fail:
52035 return NULL;
52036 }
52037
52038
52039 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52040 PyObject *resultobj = 0;
52041 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52042 int result;
52043 void *argp1 = 0 ;
52044 int res1 = 0 ;
52045 PyObject *swig_obj[1] ;
52046
52047 if (!args) SWIG_fail;
52048 swig_obj[0] = args;
52049 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52050 if (!SWIG_IsOK(res1)) {
52051 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52052 }
52053 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52054 {
52055 PyThreadState* __tstate = wxPyBeginAllowThreads();
52056 result = (int)(arg1)->GetMargin();
52057 wxPyEndAllowThreads(__tstate);
52058 if (PyErr_Occurred()) SWIG_fail;
52059 }
52060 resultobj = SWIG_From_int(static_cast< int >(result));
52061 return resultobj;
52062 fail:
52063 return NULL;
52064 }
52065
52066
52067 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetMargin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52068 PyObject *resultobj = 0;
52069 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52070 int arg2 ;
52071 void *argp1 = 0 ;
52072 int res1 = 0 ;
52073 int val2 ;
52074 int ecode2 = 0 ;
52075 PyObject * obj0 = 0 ;
52076 PyObject * obj1 = 0 ;
52077 char * kwnames[] = {
52078 (char *) "self",(char *) "m", NULL
52079 };
52080
52081 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetMargin",kwnames,&obj0,&obj1)) SWIG_fail;
52082 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52083 if (!SWIG_IsOK(res1)) {
52084 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52085 }
52086 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52087 ecode2 = SWIG_AsVal_int(obj1, &val2);
52088 if (!SWIG_IsOK(ecode2)) {
52089 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetMargin" "', expected argument " "2"" of type '" "int""'");
52090 }
52091 arg2 = static_cast< int >(val2);
52092 {
52093 PyThreadState* __tstate = wxPyBeginAllowThreads();
52094 (arg1)->SetMargin(arg2);
52095 wxPyEndAllowThreads(__tstate);
52096 if (PyErr_Occurred()) SWIG_fail;
52097 }
52098 resultobj = SWIG_Py_Void();
52099 return resultobj;
52100 fail:
52101 return NULL;
52102 }
52103
52104
52105 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetValue(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52106 PyObject *resultobj = 0;
52107 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52108 int result;
52109 void *argp1 = 0 ;
52110 int res1 = 0 ;
52111 PyObject *swig_obj[1] ;
52112
52113 if (!args) SWIG_fail;
52114 swig_obj[0] = args;
52115 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52116 if (!SWIG_IsOK(res1)) {
52117 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetValue" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52118 }
52119 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52120 {
52121 PyThreadState* __tstate = wxPyBeginAllowThreads();
52122 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetValue();
52123 wxPyEndAllowThreads(__tstate);
52124 if (PyErr_Occurred()) SWIG_fail;
52125 }
52126 resultobj = SWIG_From_int(static_cast< int >(result));
52127 return resultobj;
52128 fail:
52129 return NULL;
52130 }
52131
52132
52133 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetPercent(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52134 PyObject *resultobj = 0;
52135 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52136 int result;
52137 void *argp1 = 0 ;
52138 int res1 = 0 ;
52139 PyObject *swig_obj[1] ;
52140
52141 if (!args) SWIG_fail;
52142 swig_obj[0] = args;
52143 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52144 if (!SWIG_IsOK(res1)) {
52145 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetPercent" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52146 }
52147 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52148 {
52149 PyThreadState* __tstate = wxPyBeginAllowThreads();
52150 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetPercent();
52151 wxPyEndAllowThreads(__tstate);
52152 if (PyErr_Occurred()) SWIG_fail;
52153 }
52154 resultobj = SWIG_From_int(static_cast< int >(result));
52155 return resultobj;
52156 fail:
52157 return NULL;
52158 }
52159
52160
52161 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetOtherEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52162 PyObject *resultobj = 0;
52163 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52164 int result;
52165 void *argp1 = 0 ;
52166 int res1 = 0 ;
52167 PyObject *swig_obj[1] ;
52168
52169 if (!args) SWIG_fail;
52170 swig_obj[0] = args;
52171 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52172 if (!SWIG_IsOK(res1)) {
52173 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetOtherEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52174 }
52175 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52176 {
52177 PyThreadState* __tstate = wxPyBeginAllowThreads();
52178 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetOtherEdge();
52179 wxPyEndAllowThreads(__tstate);
52180 if (PyErr_Occurred()) SWIG_fail;
52181 }
52182 resultobj = SWIG_From_int(static_cast< int >(result));
52183 return resultobj;
52184 fail:
52185 return NULL;
52186 }
52187
52188
52189 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52190 PyObject *resultobj = 0;
52191 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52192 bool result;
52193 void *argp1 = 0 ;
52194 int res1 = 0 ;
52195 PyObject *swig_obj[1] ;
52196
52197 if (!args) SWIG_fail;
52198 swig_obj[0] = args;
52199 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52200 if (!SWIG_IsOK(res1)) {
52201 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52202 }
52203 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52204 {
52205 PyThreadState* __tstate = wxPyBeginAllowThreads();
52206 result = (bool)((wxIndividualLayoutConstraint const *)arg1)->GetDone();
52207 wxPyEndAllowThreads(__tstate);
52208 if (PyErr_Occurred()) SWIG_fail;
52209 }
52210 {
52211 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52212 }
52213 return resultobj;
52214 fail:
52215 return NULL;
52216 }
52217
52218
52219 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetDone(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52220 PyObject *resultobj = 0;
52221 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52222 bool arg2 ;
52223 void *argp1 = 0 ;
52224 int res1 = 0 ;
52225 bool val2 ;
52226 int ecode2 = 0 ;
52227 PyObject * obj0 = 0 ;
52228 PyObject * obj1 = 0 ;
52229 char * kwnames[] = {
52230 (char *) "self",(char *) "d", NULL
52231 };
52232
52233 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetDone",kwnames,&obj0,&obj1)) SWIG_fail;
52234 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52235 if (!SWIG_IsOK(res1)) {
52236 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52237 }
52238 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52239 ecode2 = SWIG_AsVal_bool(obj1, &val2);
52240 if (!SWIG_IsOK(ecode2)) {
52241 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetDone" "', expected argument " "2"" of type '" "bool""'");
52242 }
52243 arg2 = static_cast< bool >(val2);
52244 {
52245 PyThreadState* __tstate = wxPyBeginAllowThreads();
52246 (arg1)->SetDone(arg2);
52247 wxPyEndAllowThreads(__tstate);
52248 if (PyErr_Occurred()) SWIG_fail;
52249 }
52250 resultobj = SWIG_Py_Void();
52251 return resultobj;
52252 fail:
52253 return NULL;
52254 }
52255
52256
52257 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52258 PyObject *resultobj = 0;
52259 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52260 wxRelationship result;
52261 void *argp1 = 0 ;
52262 int res1 = 0 ;
52263 PyObject *swig_obj[1] ;
52264
52265 if (!args) SWIG_fail;
52266 swig_obj[0] = args;
52267 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52268 if (!SWIG_IsOK(res1)) {
52269 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52270 }
52271 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52272 {
52273 PyThreadState* __tstate = wxPyBeginAllowThreads();
52274 result = (wxRelationship)(arg1)->GetRelationship();
52275 wxPyEndAllowThreads(__tstate);
52276 if (PyErr_Occurred()) SWIG_fail;
52277 }
52278 resultobj = SWIG_From_int(static_cast< int >(result));
52279 return resultobj;
52280 fail:
52281 return NULL;
52282 }
52283
52284
52285 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SetRelationship(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52286 PyObject *resultobj = 0;
52287 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52288 wxRelationship arg2 ;
52289 void *argp1 = 0 ;
52290 int res1 = 0 ;
52291 int val2 ;
52292 int ecode2 = 0 ;
52293 PyObject * obj0 = 0 ;
52294 PyObject * obj1 = 0 ;
52295 char * kwnames[] = {
52296 (char *) "self",(char *) "r", NULL
52297 };
52298
52299 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_SetRelationship",kwnames,&obj0,&obj1)) SWIG_fail;
52300 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52301 if (!SWIG_IsOK(res1)) {
52302 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52303 }
52304 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52305 ecode2 = SWIG_AsVal_int(obj1, &val2);
52306 if (!SWIG_IsOK(ecode2)) {
52307 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_SetRelationship" "', expected argument " "2"" of type '" "wxRelationship""'");
52308 }
52309 arg2 = static_cast< wxRelationship >(val2);
52310 {
52311 PyThreadState* __tstate = wxPyBeginAllowThreads();
52312 (arg1)->SetRelationship(arg2);
52313 wxPyEndAllowThreads(__tstate);
52314 if (PyErr_Occurred()) SWIG_fail;
52315 }
52316 resultobj = SWIG_Py_Void();
52317 return resultobj;
52318 fail:
52319 return NULL;
52320 }
52321
52322
52323 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_ResetIfWin(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52324 PyObject *resultobj = 0;
52325 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52326 wxWindow *arg2 = (wxWindow *) 0 ;
52327 bool result;
52328 void *argp1 = 0 ;
52329 int res1 = 0 ;
52330 void *argp2 = 0 ;
52331 int res2 = 0 ;
52332 PyObject * obj0 = 0 ;
52333 PyObject * obj1 = 0 ;
52334 char * kwnames[] = {
52335 (char *) "self",(char *) "otherW", NULL
52336 };
52337
52338 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:IndividualLayoutConstraint_ResetIfWin",kwnames,&obj0,&obj1)) SWIG_fail;
52339 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52340 if (!SWIG_IsOK(res1)) {
52341 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52342 }
52343 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52344 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52345 if (!SWIG_IsOK(res2)) {
52346 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_ResetIfWin" "', expected argument " "2"" of type '" "wxWindow *""'");
52347 }
52348 arg2 = reinterpret_cast< wxWindow * >(argp2);
52349 {
52350 PyThreadState* __tstate = wxPyBeginAllowThreads();
52351 result = (bool)(arg1)->ResetIfWin(arg2);
52352 wxPyEndAllowThreads(__tstate);
52353 if (PyErr_Occurred()) SWIG_fail;
52354 }
52355 {
52356 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52357 }
52358 return resultobj;
52359 fail:
52360 return NULL;
52361 }
52362
52363
52364 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_SatisfyConstraint(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52365 PyObject *resultobj = 0;
52366 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52367 wxLayoutConstraints *arg2 = (wxLayoutConstraints *) 0 ;
52368 wxWindow *arg3 = (wxWindow *) 0 ;
52369 bool result;
52370 void *argp1 = 0 ;
52371 int res1 = 0 ;
52372 void *argp2 = 0 ;
52373 int res2 = 0 ;
52374 void *argp3 = 0 ;
52375 int res3 = 0 ;
52376 PyObject * obj0 = 0 ;
52377 PyObject * obj1 = 0 ;
52378 PyObject * obj2 = 0 ;
52379 char * kwnames[] = {
52380 (char *) "self",(char *) "constraints",(char *) "win", NULL
52381 };
52382
52383 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOO:IndividualLayoutConstraint_SatisfyConstraint",kwnames,&obj0,&obj1,&obj2)) SWIG_fail;
52384 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52385 if (!SWIG_IsOK(res1)) {
52386 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint *""'");
52387 }
52388 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52389 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52390 if (!SWIG_IsOK(res2)) {
52391 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "2"" of type '" "wxLayoutConstraints *""'");
52392 }
52393 arg2 = reinterpret_cast< wxLayoutConstraints * >(argp2);
52394 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52395 if (!SWIG_IsOK(res3)) {
52396 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_SatisfyConstraint" "', expected argument " "3"" of type '" "wxWindow *""'");
52397 }
52398 arg3 = reinterpret_cast< wxWindow * >(argp3);
52399 {
52400 PyThreadState* __tstate = wxPyBeginAllowThreads();
52401 result = (bool)(arg1)->SatisfyConstraint(arg2,arg3);
52402 wxPyEndAllowThreads(__tstate);
52403 if (PyErr_Occurred()) SWIG_fail;
52404 }
52405 {
52406 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52407 }
52408 return resultobj;
52409 fail:
52410 return NULL;
52411 }
52412
52413
52414 SWIGINTERN PyObject *_wrap_IndividualLayoutConstraint_GetEdge(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52415 PyObject *resultobj = 0;
52416 wxIndividualLayoutConstraint *arg1 = (wxIndividualLayoutConstraint *) 0 ;
52417 wxEdge arg2 ;
52418 wxWindow *arg3 = (wxWindow *) 0 ;
52419 wxWindow *arg4 = (wxWindow *) 0 ;
52420 int result;
52421 void *argp1 = 0 ;
52422 int res1 = 0 ;
52423 int val2 ;
52424 int ecode2 = 0 ;
52425 void *argp3 = 0 ;
52426 int res3 = 0 ;
52427 void *argp4 = 0 ;
52428 int res4 = 0 ;
52429 PyObject * obj0 = 0 ;
52430 PyObject * obj1 = 0 ;
52431 PyObject * obj2 = 0 ;
52432 PyObject * obj3 = 0 ;
52433 char * kwnames[] = {
52434 (char *) "self",(char *) "which",(char *) "thisWin",(char *) "other", NULL
52435 };
52436
52437 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OOOO:IndividualLayoutConstraint_GetEdge",kwnames,&obj0,&obj1,&obj2,&obj3)) SWIG_fail;
52438 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52439 if (!SWIG_IsOK(res1)) {
52440 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "1"" of type '" "wxIndividualLayoutConstraint const *""'");
52441 }
52442 arg1 = reinterpret_cast< wxIndividualLayoutConstraint * >(argp1);
52443 ecode2 = SWIG_AsVal_int(obj1, &val2);
52444 if (!SWIG_IsOK(ecode2)) {
52445 SWIG_exception_fail(SWIG_ArgError(ecode2), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "2"" of type '" "wxEdge""'");
52446 }
52447 arg2 = static_cast< wxEdge >(val2);
52448 res3 = SWIG_ConvertPtr(obj2, &argp3,SWIGTYPE_p_wxWindow, 0 | 0 );
52449 if (!SWIG_IsOK(res3)) {
52450 SWIG_exception_fail(SWIG_ArgError(res3), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "3"" of type '" "wxWindow *""'");
52451 }
52452 arg3 = reinterpret_cast< wxWindow * >(argp3);
52453 res4 = SWIG_ConvertPtr(obj3, &argp4,SWIGTYPE_p_wxWindow, 0 | 0 );
52454 if (!SWIG_IsOK(res4)) {
52455 SWIG_exception_fail(SWIG_ArgError(res4), "in method '" "IndividualLayoutConstraint_GetEdge" "', expected argument " "4"" of type '" "wxWindow *""'");
52456 }
52457 arg4 = reinterpret_cast< wxWindow * >(argp4);
52458 {
52459 PyThreadState* __tstate = wxPyBeginAllowThreads();
52460 result = (int)((wxIndividualLayoutConstraint const *)arg1)->GetEdge(arg2,arg3,arg4);
52461 wxPyEndAllowThreads(__tstate);
52462 if (PyErr_Occurred()) SWIG_fail;
52463 }
52464 resultobj = SWIG_From_int(static_cast< int >(result));
52465 return resultobj;
52466 fail:
52467 return NULL;
52468 }
52469
52470
52471 SWIGINTERN PyObject *IndividualLayoutConstraint_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52472 PyObject *obj;
52473 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52474 SWIG_TypeNewClientData(SWIGTYPE_p_wxIndividualLayoutConstraint, SWIG_NewClientData(obj));
52475 return SWIG_Py_Void();
52476 }
52477
52478 SWIGINTERN PyObject *_wrap_LayoutConstraints_left_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52479 PyObject *resultobj = 0;
52480 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52481 wxIndividualLayoutConstraint *result = 0 ;
52482 void *argp1 = 0 ;
52483 int res1 = 0 ;
52484 PyObject *swig_obj[1] ;
52485
52486 if (!args) SWIG_fail;
52487 swig_obj[0] = args;
52488 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52489 if (!SWIG_IsOK(res1)) {
52490 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_left_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52491 }
52492 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52493 result = (wxIndividualLayoutConstraint *)& ((arg1)->left);
52494 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52495 return resultobj;
52496 fail:
52497 return NULL;
52498 }
52499
52500
52501 SWIGINTERN PyObject *_wrap_LayoutConstraints_top_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52502 PyObject *resultobj = 0;
52503 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52504 wxIndividualLayoutConstraint *result = 0 ;
52505 void *argp1 = 0 ;
52506 int res1 = 0 ;
52507 PyObject *swig_obj[1] ;
52508
52509 if (!args) SWIG_fail;
52510 swig_obj[0] = args;
52511 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52512 if (!SWIG_IsOK(res1)) {
52513 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_top_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52514 }
52515 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52516 result = (wxIndividualLayoutConstraint *)& ((arg1)->top);
52517 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52518 return resultobj;
52519 fail:
52520 return NULL;
52521 }
52522
52523
52524 SWIGINTERN PyObject *_wrap_LayoutConstraints_right_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52525 PyObject *resultobj = 0;
52526 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52527 wxIndividualLayoutConstraint *result = 0 ;
52528 void *argp1 = 0 ;
52529 int res1 = 0 ;
52530 PyObject *swig_obj[1] ;
52531
52532 if (!args) SWIG_fail;
52533 swig_obj[0] = args;
52534 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52535 if (!SWIG_IsOK(res1)) {
52536 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_right_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52537 }
52538 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52539 result = (wxIndividualLayoutConstraint *)& ((arg1)->right);
52540 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52541 return resultobj;
52542 fail:
52543 return NULL;
52544 }
52545
52546
52547 SWIGINTERN PyObject *_wrap_LayoutConstraints_bottom_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52548 PyObject *resultobj = 0;
52549 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52550 wxIndividualLayoutConstraint *result = 0 ;
52551 void *argp1 = 0 ;
52552 int res1 = 0 ;
52553 PyObject *swig_obj[1] ;
52554
52555 if (!args) SWIG_fail;
52556 swig_obj[0] = args;
52557 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52558 if (!SWIG_IsOK(res1)) {
52559 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_bottom_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52560 }
52561 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52562 result = (wxIndividualLayoutConstraint *)& ((arg1)->bottom);
52563 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52564 return resultobj;
52565 fail:
52566 return NULL;
52567 }
52568
52569
52570 SWIGINTERN PyObject *_wrap_LayoutConstraints_width_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52571 PyObject *resultobj = 0;
52572 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52573 wxIndividualLayoutConstraint *result = 0 ;
52574 void *argp1 = 0 ;
52575 int res1 = 0 ;
52576 PyObject *swig_obj[1] ;
52577
52578 if (!args) SWIG_fail;
52579 swig_obj[0] = args;
52580 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52581 if (!SWIG_IsOK(res1)) {
52582 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_width_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52583 }
52584 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52585 result = (wxIndividualLayoutConstraint *)& ((arg1)->width);
52586 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52587 return resultobj;
52588 fail:
52589 return NULL;
52590 }
52591
52592
52593 SWIGINTERN PyObject *_wrap_LayoutConstraints_height_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52594 PyObject *resultobj = 0;
52595 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52596 wxIndividualLayoutConstraint *result = 0 ;
52597 void *argp1 = 0 ;
52598 int res1 = 0 ;
52599 PyObject *swig_obj[1] ;
52600
52601 if (!args) SWIG_fail;
52602 swig_obj[0] = args;
52603 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52604 if (!SWIG_IsOK(res1)) {
52605 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_height_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52606 }
52607 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52608 result = (wxIndividualLayoutConstraint *)& ((arg1)->height);
52609 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52610 return resultobj;
52611 fail:
52612 return NULL;
52613 }
52614
52615
52616 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreX_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52617 PyObject *resultobj = 0;
52618 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52619 wxIndividualLayoutConstraint *result = 0 ;
52620 void *argp1 = 0 ;
52621 int res1 = 0 ;
52622 PyObject *swig_obj[1] ;
52623
52624 if (!args) SWIG_fail;
52625 swig_obj[0] = args;
52626 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52627 if (!SWIG_IsOK(res1)) {
52628 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreX_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52629 }
52630 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52631 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreX);
52632 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52633 return resultobj;
52634 fail:
52635 return NULL;
52636 }
52637
52638
52639 SWIGINTERN PyObject *_wrap_LayoutConstraints_centreY_get(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52640 PyObject *resultobj = 0;
52641 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52642 wxIndividualLayoutConstraint *result = 0 ;
52643 void *argp1 = 0 ;
52644 int res1 = 0 ;
52645 PyObject *swig_obj[1] ;
52646
52647 if (!args) SWIG_fail;
52648 swig_obj[0] = args;
52649 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52650 if (!SWIG_IsOK(res1)) {
52651 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_centreY_get" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52652 }
52653 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52654 result = (wxIndividualLayoutConstraint *)& ((arg1)->centreY);
52655 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxIndividualLayoutConstraint, 0 | 0 );
52656 return resultobj;
52657 fail:
52658 return NULL;
52659 }
52660
52661
52662 SWIGINTERN PyObject *_wrap_new_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52663 PyObject *resultobj = 0;
52664 wxLayoutConstraints *result = 0 ;
52665
52666 if (!SWIG_Python_UnpackTuple(args,"new_LayoutConstraints",0,0,0)) SWIG_fail;
52667 {
52668 PyThreadState* __tstate = wxPyBeginAllowThreads();
52669 result = (wxLayoutConstraints *)new wxLayoutConstraints();
52670 wxPyEndAllowThreads(__tstate);
52671 if (PyErr_Occurred()) SWIG_fail;
52672 }
52673 resultobj = SWIG_NewPointerObj(SWIG_as_voidptr(result), SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_NEW | 0 );
52674 return resultobj;
52675 fail:
52676 return NULL;
52677 }
52678
52679
52680 SWIGINTERN PyObject *_wrap_delete_LayoutConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52681 PyObject *resultobj = 0;
52682 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52683 void *argp1 = 0 ;
52684 int res1 = 0 ;
52685 PyObject *swig_obj[1] ;
52686
52687 if (!args) SWIG_fail;
52688 swig_obj[0] = args;
52689 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, SWIG_POINTER_DISOWN | 0 );
52690 if (!SWIG_IsOK(res1)) {
52691 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "delete_LayoutConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52692 }
52693 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52694 {
52695 PyThreadState* __tstate = wxPyBeginAllowThreads();
52696 delete arg1;
52697
52698 wxPyEndAllowThreads(__tstate);
52699 if (PyErr_Occurred()) SWIG_fail;
52700 }
52701 resultobj = SWIG_Py_Void();
52702 return resultobj;
52703 fail:
52704 return NULL;
52705 }
52706
52707
52708 SWIGINTERN PyObject *_wrap_LayoutConstraints_SatisfyConstraints(PyObject *SWIGUNUSEDPARM(self), PyObject *args, PyObject *kwargs) {
52709 PyObject *resultobj = 0;
52710 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52711 wxWindow *arg2 = (wxWindow *) 0 ;
52712 int *arg3 = (int *) 0 ;
52713 bool result;
52714 void *argp1 = 0 ;
52715 int res1 = 0 ;
52716 void *argp2 = 0 ;
52717 int res2 = 0 ;
52718 int temp3 ;
52719 int res3 = SWIG_TMPOBJ ;
52720 PyObject * obj0 = 0 ;
52721 PyObject * obj1 = 0 ;
52722 char * kwnames[] = {
52723 (char *) "self",(char *) "win", NULL
52724 };
52725
52726 arg3 = &temp3;
52727 if (!PyArg_ParseTupleAndKeywords(args,kwargs,(char *)"OO:LayoutConstraints_SatisfyConstraints",kwnames,&obj0,&obj1)) SWIG_fail;
52728 res1 = SWIG_ConvertPtr(obj0, &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52729 if (!SWIG_IsOK(res1)) {
52730 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "1"" of type '" "wxLayoutConstraints *""'");
52731 }
52732 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52733 res2 = SWIG_ConvertPtr(obj1, &argp2,SWIGTYPE_p_wxWindow, 0 | 0 );
52734 if (!SWIG_IsOK(res2)) {
52735 SWIG_exception_fail(SWIG_ArgError(res2), "in method '" "LayoutConstraints_SatisfyConstraints" "', expected argument " "2"" of type '" "wxWindow *""'");
52736 }
52737 arg2 = reinterpret_cast< wxWindow * >(argp2);
52738 {
52739 PyThreadState* __tstate = wxPyBeginAllowThreads();
52740 result = (bool)(arg1)->SatisfyConstraints(arg2,arg3);
52741 wxPyEndAllowThreads(__tstate);
52742 if (PyErr_Occurred()) SWIG_fail;
52743 }
52744 {
52745 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52746 }
52747 if (SWIG_IsTmpObj(res3)) {
52748 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_From_int((*arg3)));
52749 } else {
52750 int new_flags = SWIG_IsNewObj(res3) ? (SWIG_POINTER_OWN | 0 ) : 0 ;
52751 resultobj = SWIG_Python_AppendOutput(resultobj, SWIG_NewPointerObj((void*)(arg3), SWIGTYPE_p_int, new_flags));
52752 }
52753 return resultobj;
52754 fail:
52755 return NULL;
52756 }
52757
52758
52759 SWIGINTERN PyObject *_wrap_LayoutConstraints_AreSatisfied(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52760 PyObject *resultobj = 0;
52761 wxLayoutConstraints *arg1 = (wxLayoutConstraints *) 0 ;
52762 bool result;
52763 void *argp1 = 0 ;
52764 int res1 = 0 ;
52765 PyObject *swig_obj[1] ;
52766
52767 if (!args) SWIG_fail;
52768 swig_obj[0] = args;
52769 res1 = SWIG_ConvertPtr(swig_obj[0], &argp1,SWIGTYPE_p_wxLayoutConstraints, 0 | 0 );
52770 if (!SWIG_IsOK(res1)) {
52771 SWIG_exception_fail(SWIG_ArgError(res1), "in method '" "LayoutConstraints_AreSatisfied" "', expected argument " "1"" of type '" "wxLayoutConstraints const *""'");
52772 }
52773 arg1 = reinterpret_cast< wxLayoutConstraints * >(argp1);
52774 {
52775 PyThreadState* __tstate = wxPyBeginAllowThreads();
52776 result = (bool)((wxLayoutConstraints const *)arg1)->AreSatisfied();
52777 wxPyEndAllowThreads(__tstate);
52778 if (PyErr_Occurred()) SWIG_fail;
52779 }
52780 {
52781 resultobj = result ? Py_True : Py_False; Py_INCREF(resultobj);
52782 }
52783 return resultobj;
52784 fail:
52785 return NULL;
52786 }
52787
52788
52789 SWIGINTERN PyObject *LayoutConstraints_swigregister(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52790 PyObject *obj;
52791 if (!SWIG_Python_UnpackTuple(args,(char*)"swigregister", 1, 1,&obj)) return NULL;
52792 SWIG_TypeNewClientData(SWIGTYPE_p_wxLayoutConstraints, SWIG_NewClientData(obj));
52793 return SWIG_Py_Void();
52794 }
52795
52796 SWIGINTERN PyObject *LayoutConstraints_swiginit(PyObject *SWIGUNUSEDPARM(self), PyObject *args) {
52797 return SWIG_Python_InitShadowInstance(args);
52798 }
52799
52800 static PyMethodDef SwigMethods[] = {
52801 { (char *)"_wxPySetDictionary", __wxPySetDictionary, METH_VARARGS, NULL},
52802 { (char *)"Object_GetClassName", (PyCFunction)_wrap_Object_GetClassName, METH_O, NULL},
52803 { (char *)"Object_Destroy", (PyCFunction)_wrap_Object_Destroy, METH_O, NULL},
52804 { (char *)"Object_swigregister", Object_swigregister, METH_VARARGS, NULL},
52805 { (char *)"Size_width_set", _wrap_Size_width_set, METH_VARARGS, NULL},
52806 { (char *)"Size_width_get", (PyCFunction)_wrap_Size_width_get, METH_O, NULL},
52807 { (char *)"Size_height_set", _wrap_Size_height_set, METH_VARARGS, NULL},
52808 { (char *)"Size_height_get", (PyCFunction)_wrap_Size_height_get, METH_O, NULL},
52809 { (char *)"new_Size", (PyCFunction) _wrap_new_Size, METH_VARARGS | METH_KEYWORDS, NULL},
52810 { (char *)"delete_Size", (PyCFunction)_wrap_delete_Size, METH_O, NULL},
52811 { (char *)"Size___eq__", (PyCFunction) _wrap_Size___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52812 { (char *)"Size___ne__", (PyCFunction) _wrap_Size___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52813 { (char *)"Size___add__", (PyCFunction) _wrap_Size___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52814 { (char *)"Size___sub__", (PyCFunction) _wrap_Size___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52815 { (char *)"Size_IncTo", (PyCFunction) _wrap_Size_IncTo, METH_VARARGS | METH_KEYWORDS, NULL},
52816 { (char *)"Size_DecTo", (PyCFunction) _wrap_Size_DecTo, METH_VARARGS | METH_KEYWORDS, NULL},
52817 { (char *)"Size_Scale", (PyCFunction) _wrap_Size_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
52818 { (char *)"Size_Set", (PyCFunction) _wrap_Size_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52819 { (char *)"Size_SetWidth", (PyCFunction) _wrap_Size_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52820 { (char *)"Size_SetHeight", (PyCFunction) _wrap_Size_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52821 { (char *)"Size_GetWidth", (PyCFunction)_wrap_Size_GetWidth, METH_O, NULL},
52822 { (char *)"Size_GetHeight", (PyCFunction)_wrap_Size_GetHeight, METH_O, NULL},
52823 { (char *)"Size_IsFullySpecified", (PyCFunction)_wrap_Size_IsFullySpecified, METH_O, NULL},
52824 { (char *)"Size_SetDefaults", (PyCFunction) _wrap_Size_SetDefaults, METH_VARARGS | METH_KEYWORDS, NULL},
52825 { (char *)"Size_Get", (PyCFunction)_wrap_Size_Get, METH_O, NULL},
52826 { (char *)"Size_swigregister", Size_swigregister, METH_VARARGS, NULL},
52827 { (char *)"Size_swiginit", Size_swiginit, METH_VARARGS, NULL},
52828 { (char *)"RealPoint_x_set", _wrap_RealPoint_x_set, METH_VARARGS, NULL},
52829 { (char *)"RealPoint_x_get", (PyCFunction)_wrap_RealPoint_x_get, METH_O, NULL},
52830 { (char *)"RealPoint_y_set", _wrap_RealPoint_y_set, METH_VARARGS, NULL},
52831 { (char *)"RealPoint_y_get", (PyCFunction)_wrap_RealPoint_y_get, METH_O, NULL},
52832 { (char *)"new_RealPoint", (PyCFunction) _wrap_new_RealPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52833 { (char *)"delete_RealPoint", (PyCFunction)_wrap_delete_RealPoint, METH_O, NULL},
52834 { (char *)"RealPoint___eq__", (PyCFunction) _wrap_RealPoint___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52835 { (char *)"RealPoint___ne__", (PyCFunction) _wrap_RealPoint___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52836 { (char *)"RealPoint___add__", (PyCFunction) _wrap_RealPoint___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52837 { (char *)"RealPoint___sub__", (PyCFunction) _wrap_RealPoint___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52838 { (char *)"RealPoint_Set", (PyCFunction) _wrap_RealPoint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52839 { (char *)"RealPoint_Get", (PyCFunction)_wrap_RealPoint_Get, METH_O, NULL},
52840 { (char *)"RealPoint_swigregister", RealPoint_swigregister, METH_VARARGS, NULL},
52841 { (char *)"RealPoint_swiginit", RealPoint_swiginit, METH_VARARGS, NULL},
52842 { (char *)"Point_x_set", _wrap_Point_x_set, METH_VARARGS, NULL},
52843 { (char *)"Point_x_get", (PyCFunction)_wrap_Point_x_get, METH_O, NULL},
52844 { (char *)"Point_y_set", _wrap_Point_y_set, METH_VARARGS, NULL},
52845 { (char *)"Point_y_get", (PyCFunction)_wrap_Point_y_get, METH_O, NULL},
52846 { (char *)"new_Point", (PyCFunction) _wrap_new_Point, METH_VARARGS | METH_KEYWORDS, NULL},
52847 { (char *)"delete_Point", (PyCFunction)_wrap_delete_Point, METH_O, NULL},
52848 { (char *)"Point___eq__", (PyCFunction) _wrap_Point___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52849 { (char *)"Point___ne__", (PyCFunction) _wrap_Point___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52850 { (char *)"Point___add__", (PyCFunction) _wrap_Point___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52851 { (char *)"Point___sub__", (PyCFunction) _wrap_Point___sub__, METH_VARARGS | METH_KEYWORDS, NULL},
52852 { (char *)"Point___iadd__", (PyCFunction) _wrap_Point___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52853 { (char *)"Point___isub__", (PyCFunction) _wrap_Point___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52854 { (char *)"Point_Set", (PyCFunction) _wrap_Point_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52855 { (char *)"Point_Get", (PyCFunction)_wrap_Point_Get, METH_O, NULL},
52856 { (char *)"Point_swigregister", Point_swigregister, METH_VARARGS, NULL},
52857 { (char *)"Point_swiginit", Point_swiginit, METH_VARARGS, NULL},
52858 { (char *)"new_Rect", (PyCFunction) _wrap_new_Rect, METH_VARARGS | METH_KEYWORDS, NULL},
52859 { (char *)"new_RectPP", (PyCFunction) _wrap_new_RectPP, METH_VARARGS | METH_KEYWORDS, NULL},
52860 { (char *)"new_RectPS", (PyCFunction) _wrap_new_RectPS, METH_VARARGS | METH_KEYWORDS, NULL},
52861 { (char *)"new_RectS", (PyCFunction) _wrap_new_RectS, METH_VARARGS | METH_KEYWORDS, NULL},
52862 { (char *)"delete_Rect", (PyCFunction)_wrap_delete_Rect, METH_O, NULL},
52863 { (char *)"Rect_GetX", (PyCFunction)_wrap_Rect_GetX, METH_O, NULL},
52864 { (char *)"Rect_SetX", (PyCFunction) _wrap_Rect_SetX, METH_VARARGS | METH_KEYWORDS, NULL},
52865 { (char *)"Rect_GetY", (PyCFunction)_wrap_Rect_GetY, METH_O, NULL},
52866 { (char *)"Rect_SetY", (PyCFunction) _wrap_Rect_SetY, METH_VARARGS | METH_KEYWORDS, NULL},
52867 { (char *)"Rect_GetWidth", (PyCFunction)_wrap_Rect_GetWidth, METH_O, NULL},
52868 { (char *)"Rect_SetWidth", (PyCFunction) _wrap_Rect_SetWidth, METH_VARARGS | METH_KEYWORDS, NULL},
52869 { (char *)"Rect_GetHeight", (PyCFunction)_wrap_Rect_GetHeight, METH_O, NULL},
52870 { (char *)"Rect_SetHeight", (PyCFunction) _wrap_Rect_SetHeight, METH_VARARGS | METH_KEYWORDS, NULL},
52871 { (char *)"Rect_GetPosition", (PyCFunction)_wrap_Rect_GetPosition, METH_O, NULL},
52872 { (char *)"Rect_SetPosition", (PyCFunction) _wrap_Rect_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
52873 { (char *)"Rect_GetSize", (PyCFunction)_wrap_Rect_GetSize, METH_O, NULL},
52874 { (char *)"Rect_SetSize", (PyCFunction) _wrap_Rect_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
52875 { (char *)"Rect_IsEmpty", (PyCFunction)_wrap_Rect_IsEmpty, METH_O, NULL},
52876 { (char *)"Rect_GetTopLeft", (PyCFunction)_wrap_Rect_GetTopLeft, METH_O, NULL},
52877 { (char *)"Rect_SetTopLeft", (PyCFunction) _wrap_Rect_SetTopLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52878 { (char *)"Rect_GetBottomRight", (PyCFunction)_wrap_Rect_GetBottomRight, METH_O, NULL},
52879 { (char *)"Rect_SetBottomRight", (PyCFunction) _wrap_Rect_SetBottomRight, METH_VARARGS | METH_KEYWORDS, NULL},
52880 { (char *)"Rect_GetLeft", (PyCFunction)_wrap_Rect_GetLeft, METH_O, NULL},
52881 { (char *)"Rect_GetTop", (PyCFunction)_wrap_Rect_GetTop, METH_O, NULL},
52882 { (char *)"Rect_GetBottom", (PyCFunction)_wrap_Rect_GetBottom, METH_O, NULL},
52883 { (char *)"Rect_GetRight", (PyCFunction)_wrap_Rect_GetRight, METH_O, NULL},
52884 { (char *)"Rect_SetLeft", (PyCFunction) _wrap_Rect_SetLeft, METH_VARARGS | METH_KEYWORDS, NULL},
52885 { (char *)"Rect_SetRight", (PyCFunction) _wrap_Rect_SetRight, METH_VARARGS | METH_KEYWORDS, NULL},
52886 { (char *)"Rect_SetTop", (PyCFunction) _wrap_Rect_SetTop, METH_VARARGS | METH_KEYWORDS, NULL},
52887 { (char *)"Rect_SetBottom", (PyCFunction) _wrap_Rect_SetBottom, METH_VARARGS | METH_KEYWORDS, NULL},
52888 { (char *)"Rect_Inflate", (PyCFunction) _wrap_Rect_Inflate, METH_VARARGS | METH_KEYWORDS, NULL},
52889 { (char *)"Rect_Deflate", (PyCFunction) _wrap_Rect_Deflate, METH_VARARGS | METH_KEYWORDS, NULL},
52890 { (char *)"Rect_OffsetXY", (PyCFunction) _wrap_Rect_OffsetXY, METH_VARARGS | METH_KEYWORDS, NULL},
52891 { (char *)"Rect_Offset", (PyCFunction) _wrap_Rect_Offset, METH_VARARGS | METH_KEYWORDS, NULL},
52892 { (char *)"Rect_Intersect", (PyCFunction) _wrap_Rect_Intersect, METH_VARARGS | METH_KEYWORDS, NULL},
52893 { (char *)"Rect_Union", (PyCFunction) _wrap_Rect_Union, METH_VARARGS | METH_KEYWORDS, NULL},
52894 { (char *)"Rect___add__", (PyCFunction) _wrap_Rect___add__, METH_VARARGS | METH_KEYWORDS, NULL},
52895 { (char *)"Rect___iadd__", (PyCFunction) _wrap_Rect___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52896 { (char *)"Rect___eq__", (PyCFunction) _wrap_Rect___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52897 { (char *)"Rect___ne__", (PyCFunction) _wrap_Rect___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52898 { (char *)"Rect_InsideXY", (PyCFunction) _wrap_Rect_InsideXY, METH_VARARGS | METH_KEYWORDS, NULL},
52899 { (char *)"Rect_Inside", (PyCFunction) _wrap_Rect_Inside, METH_VARARGS | METH_KEYWORDS, NULL},
52900 { (char *)"Rect_Intersects", (PyCFunction) _wrap_Rect_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
52901 { (char *)"Rect_CenterIn", (PyCFunction) _wrap_Rect_CenterIn, METH_VARARGS | METH_KEYWORDS, NULL},
52902 { (char *)"Rect_x_set", _wrap_Rect_x_set, METH_VARARGS, NULL},
52903 { (char *)"Rect_x_get", (PyCFunction)_wrap_Rect_x_get, METH_O, NULL},
52904 { (char *)"Rect_y_set", _wrap_Rect_y_set, METH_VARARGS, NULL},
52905 { (char *)"Rect_y_get", (PyCFunction)_wrap_Rect_y_get, METH_O, NULL},
52906 { (char *)"Rect_width_set", _wrap_Rect_width_set, METH_VARARGS, NULL},
52907 { (char *)"Rect_width_get", (PyCFunction)_wrap_Rect_width_get, METH_O, NULL},
52908 { (char *)"Rect_height_set", _wrap_Rect_height_set, METH_VARARGS, NULL},
52909 { (char *)"Rect_height_get", (PyCFunction)_wrap_Rect_height_get, METH_O, NULL},
52910 { (char *)"Rect_Set", (PyCFunction) _wrap_Rect_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52911 { (char *)"Rect_Get", (PyCFunction)_wrap_Rect_Get, METH_O, NULL},
52912 { (char *)"Rect_swigregister", Rect_swigregister, METH_VARARGS, NULL},
52913 { (char *)"Rect_swiginit", Rect_swiginit, METH_VARARGS, NULL},
52914 { (char *)"IntersectRect", (PyCFunction) _wrap_IntersectRect, METH_VARARGS | METH_KEYWORDS, NULL},
52915 { (char *)"new_Point2D", (PyCFunction) _wrap_new_Point2D, METH_VARARGS | METH_KEYWORDS, NULL},
52916 { (char *)"new_Point2DCopy", (PyCFunction) _wrap_new_Point2DCopy, METH_VARARGS | METH_KEYWORDS, NULL},
52917 { (char *)"new_Point2DFromPoint", (PyCFunction) _wrap_new_Point2DFromPoint, METH_VARARGS | METH_KEYWORDS, NULL},
52918 { (char *)"Point2D_GetFloor", (PyCFunction)_wrap_Point2D_GetFloor, METH_O, NULL},
52919 { (char *)"Point2D_GetRounded", (PyCFunction)_wrap_Point2D_GetRounded, METH_O, NULL},
52920 { (char *)"Point2D_GetVectorLength", (PyCFunction)_wrap_Point2D_GetVectorLength, METH_O, NULL},
52921 { (char *)"Point2D_GetVectorAngle", (PyCFunction)_wrap_Point2D_GetVectorAngle, METH_O, NULL},
52922 { (char *)"Point2D_SetVectorLength", (PyCFunction) _wrap_Point2D_SetVectorLength, METH_VARARGS | METH_KEYWORDS, NULL},
52923 { (char *)"Point2D_SetVectorAngle", (PyCFunction) _wrap_Point2D_SetVectorAngle, METH_VARARGS | METH_KEYWORDS, NULL},
52924 { (char *)"Point2D_GetDistance", (PyCFunction) _wrap_Point2D_GetDistance, METH_VARARGS | METH_KEYWORDS, NULL},
52925 { (char *)"Point2D_GetDistanceSquare", (PyCFunction) _wrap_Point2D_GetDistanceSquare, METH_VARARGS | METH_KEYWORDS, NULL},
52926 { (char *)"Point2D_GetDotProduct", (PyCFunction) _wrap_Point2D_GetDotProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52927 { (char *)"Point2D_GetCrossProduct", (PyCFunction) _wrap_Point2D_GetCrossProduct, METH_VARARGS | METH_KEYWORDS, NULL},
52928 { (char *)"Point2D___neg__", (PyCFunction)_wrap_Point2D___neg__, METH_O, NULL},
52929 { (char *)"Point2D___iadd__", (PyCFunction) _wrap_Point2D___iadd__, METH_VARARGS | METH_KEYWORDS, NULL},
52930 { (char *)"Point2D___isub__", (PyCFunction) _wrap_Point2D___isub__, METH_VARARGS | METH_KEYWORDS, NULL},
52931 { (char *)"Point2D___imul__", (PyCFunction) _wrap_Point2D___imul__, METH_VARARGS | METH_KEYWORDS, NULL},
52932 { (char *)"Point2D___idiv__", (PyCFunction) _wrap_Point2D___idiv__, METH_VARARGS | METH_KEYWORDS, NULL},
52933 { (char *)"Point2D___eq__", (PyCFunction) _wrap_Point2D___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
52934 { (char *)"Point2D___ne__", (PyCFunction) _wrap_Point2D___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
52935 { (char *)"Point2D_x_set", _wrap_Point2D_x_set, METH_VARARGS, NULL},
52936 { (char *)"Point2D_x_get", (PyCFunction)_wrap_Point2D_x_get, METH_O, NULL},
52937 { (char *)"Point2D_y_set", _wrap_Point2D_y_set, METH_VARARGS, NULL},
52938 { (char *)"Point2D_y_get", (PyCFunction)_wrap_Point2D_y_get, METH_O, NULL},
52939 { (char *)"Point2D_Set", (PyCFunction) _wrap_Point2D_Set, METH_VARARGS | METH_KEYWORDS, NULL},
52940 { (char *)"Point2D_Get", (PyCFunction)_wrap_Point2D_Get, METH_O, NULL},
52941 { (char *)"Point2D_swigregister", Point2D_swigregister, METH_VARARGS, NULL},
52942 { (char *)"Point2D_swiginit", Point2D_swiginit, METH_VARARGS, NULL},
52943 { (char *)"new_InputStream", (PyCFunction) _wrap_new_InputStream, METH_VARARGS | METH_KEYWORDS, NULL},
52944 { (char *)"delete_InputStream", (PyCFunction)_wrap_delete_InputStream, METH_O, NULL},
52945 { (char *)"InputStream_close", (PyCFunction)_wrap_InputStream_close, METH_O, NULL},
52946 { (char *)"InputStream_flush", (PyCFunction)_wrap_InputStream_flush, METH_O, NULL},
52947 { (char *)"InputStream_eof", (PyCFunction)_wrap_InputStream_eof, METH_O, NULL},
52948 { (char *)"InputStream_read", (PyCFunction) _wrap_InputStream_read, METH_VARARGS | METH_KEYWORDS, NULL},
52949 { (char *)"InputStream_readline", (PyCFunction) _wrap_InputStream_readline, METH_VARARGS | METH_KEYWORDS, NULL},
52950 { (char *)"InputStream_readlines", (PyCFunction) _wrap_InputStream_readlines, METH_VARARGS | METH_KEYWORDS, NULL},
52951 { (char *)"InputStream_seek", (PyCFunction) _wrap_InputStream_seek, METH_VARARGS | METH_KEYWORDS, NULL},
52952 { (char *)"InputStream_tell", (PyCFunction)_wrap_InputStream_tell, METH_O, NULL},
52953 { (char *)"InputStream_Peek", (PyCFunction)_wrap_InputStream_Peek, METH_O, NULL},
52954 { (char *)"InputStream_GetC", (PyCFunction)_wrap_InputStream_GetC, METH_O, NULL},
52955 { (char *)"InputStream_LastRead", (PyCFunction)_wrap_InputStream_LastRead, METH_O, NULL},
52956 { (char *)"InputStream_CanRead", (PyCFunction)_wrap_InputStream_CanRead, METH_O, NULL},
52957 { (char *)"InputStream_Eof", (PyCFunction)_wrap_InputStream_Eof, METH_O, NULL},
52958 { (char *)"InputStream_Ungetch", (PyCFunction) _wrap_InputStream_Ungetch, METH_VARARGS | METH_KEYWORDS, NULL},
52959 { (char *)"InputStream_SeekI", (PyCFunction) _wrap_InputStream_SeekI, METH_VARARGS | METH_KEYWORDS, NULL},
52960 { (char *)"InputStream_TellI", (PyCFunction)_wrap_InputStream_TellI, METH_O, NULL},
52961 { (char *)"InputStream_swigregister", InputStream_swigregister, METH_VARARGS, NULL},
52962 { (char *)"InputStream_swiginit", InputStream_swiginit, METH_VARARGS, NULL},
52963 { (char *)"OutputStream_write", (PyCFunction) _wrap_OutputStream_write, METH_VARARGS | METH_KEYWORDS, NULL},
52964 { (char *)"OutputStream_LastWrite", (PyCFunction)_wrap_OutputStream_LastWrite, METH_O, NULL},
52965 { (char *)"OutputStream_swigregister", OutputStream_swigregister, METH_VARARGS, NULL},
52966 { (char *)"new_FSFile", (PyCFunction) _wrap_new_FSFile, METH_VARARGS | METH_KEYWORDS, NULL},
52967 { (char *)"delete_FSFile", (PyCFunction)_wrap_delete_FSFile, METH_O, NULL},
52968 { (char *)"FSFile_GetStream", (PyCFunction)_wrap_FSFile_GetStream, METH_O, NULL},
52969 { (char *)"FSFile_GetMimeType", (PyCFunction)_wrap_FSFile_GetMimeType, METH_O, NULL},
52970 { (char *)"FSFile_GetLocation", (PyCFunction)_wrap_FSFile_GetLocation, METH_O, NULL},
52971 { (char *)"FSFile_GetAnchor", (PyCFunction)_wrap_FSFile_GetAnchor, METH_O, NULL},
52972 { (char *)"FSFile_GetModificationTime", (PyCFunction)_wrap_FSFile_GetModificationTime, METH_O, NULL},
52973 { (char *)"FSFile_swigregister", FSFile_swigregister, METH_VARARGS, NULL},
52974 { (char *)"FSFile_swiginit", FSFile_swiginit, METH_VARARGS, NULL},
52975 { (char *)"delete_CPPFileSystemHandler", (PyCFunction)_wrap_delete_CPPFileSystemHandler, METH_O, NULL},
52976 { (char *)"CPPFileSystemHandler_swigregister", CPPFileSystemHandler_swigregister, METH_VARARGS, NULL},
52977 { (char *)"new_FileSystemHandler", (PyCFunction)_wrap_new_FileSystemHandler, METH_NOARGS, NULL},
52978 { (char *)"FileSystemHandler__setCallbackInfo", (PyCFunction) _wrap_FileSystemHandler__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
52979 { (char *)"FileSystemHandler_CanOpen", (PyCFunction) _wrap_FileSystemHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
52980 { (char *)"FileSystemHandler_OpenFile", (PyCFunction) _wrap_FileSystemHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52981 { (char *)"FileSystemHandler_FindFirst", (PyCFunction) _wrap_FileSystemHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52982 { (char *)"FileSystemHandler_FindNext", (PyCFunction)_wrap_FileSystemHandler_FindNext, METH_O, NULL},
52983 { (char *)"FileSystemHandler_GetProtocol", (PyCFunction) _wrap_FileSystemHandler_GetProtocol, METH_VARARGS | METH_KEYWORDS, NULL},
52984 { (char *)"FileSystemHandler_GetLeftLocation", (PyCFunction) _wrap_FileSystemHandler_GetLeftLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52985 { (char *)"FileSystemHandler_GetAnchor", (PyCFunction) _wrap_FileSystemHandler_GetAnchor, METH_VARARGS | METH_KEYWORDS, NULL},
52986 { (char *)"FileSystemHandler_GetRightLocation", (PyCFunction) _wrap_FileSystemHandler_GetRightLocation, METH_VARARGS | METH_KEYWORDS, NULL},
52987 { (char *)"FileSystemHandler_GetMimeTypeFromExt", (PyCFunction) _wrap_FileSystemHandler_GetMimeTypeFromExt, METH_VARARGS | METH_KEYWORDS, NULL},
52988 { (char *)"FileSystemHandler_swigregister", FileSystemHandler_swigregister, METH_VARARGS, NULL},
52989 { (char *)"FileSystemHandler_swiginit", FileSystemHandler_swiginit, METH_VARARGS, NULL},
52990 { (char *)"new_FileSystem", (PyCFunction)_wrap_new_FileSystem, METH_NOARGS, NULL},
52991 { (char *)"delete_FileSystem", (PyCFunction)_wrap_delete_FileSystem, METH_O, NULL},
52992 { (char *)"FileSystem_ChangePathTo", (PyCFunction) _wrap_FileSystem_ChangePathTo, METH_VARARGS | METH_KEYWORDS, NULL},
52993 { (char *)"FileSystem_GetPath", (PyCFunction)_wrap_FileSystem_GetPath, METH_O, NULL},
52994 { (char *)"FileSystem_OpenFile", (PyCFunction) _wrap_FileSystem_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
52995 { (char *)"FileSystem_FindFirst", (PyCFunction) _wrap_FileSystem_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
52996 { (char *)"FileSystem_FindNext", (PyCFunction)_wrap_FileSystem_FindNext, METH_O, NULL},
52997 { (char *)"FileSystem_AddHandler", (PyCFunction) _wrap_FileSystem_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
52998 { (char *)"FileSystem_CleanUpHandlers", (PyCFunction)_wrap_FileSystem_CleanUpHandlers, METH_NOARGS, NULL},
52999 { (char *)"FileSystem_FileNameToURL", (PyCFunction) _wrap_FileSystem_FileNameToURL, METH_VARARGS | METH_KEYWORDS, NULL},
53000 { (char *)"FileSystem_URLToFileName", (PyCFunction) _wrap_FileSystem_URLToFileName, METH_VARARGS | METH_KEYWORDS, NULL},
53001 { (char *)"FileSystem_swigregister", FileSystem_swigregister, METH_VARARGS, NULL},
53002 { (char *)"FileSystem_swiginit", FileSystem_swiginit, METH_VARARGS, NULL},
53003 { (char *)"new_InternetFSHandler", (PyCFunction)_wrap_new_InternetFSHandler, METH_NOARGS, NULL},
53004 { (char *)"InternetFSHandler_CanOpen", (PyCFunction) _wrap_InternetFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53005 { (char *)"InternetFSHandler_OpenFile", (PyCFunction) _wrap_InternetFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53006 { (char *)"InternetFSHandler_swigregister", InternetFSHandler_swigregister, METH_VARARGS, NULL},
53007 { (char *)"InternetFSHandler_swiginit", InternetFSHandler_swiginit, METH_VARARGS, NULL},
53008 { (char *)"new_ZipFSHandler", (PyCFunction)_wrap_new_ZipFSHandler, METH_NOARGS, NULL},
53009 { (char *)"ZipFSHandler_CanOpen", (PyCFunction) _wrap_ZipFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53010 { (char *)"ZipFSHandler_OpenFile", (PyCFunction) _wrap_ZipFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53011 { (char *)"ZipFSHandler_FindFirst", (PyCFunction) _wrap_ZipFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53012 { (char *)"ZipFSHandler_FindNext", (PyCFunction)_wrap_ZipFSHandler_FindNext, METH_O, NULL},
53013 { (char *)"ZipFSHandler_swigregister", ZipFSHandler_swigregister, METH_VARARGS, NULL},
53014 { (char *)"ZipFSHandler_swiginit", ZipFSHandler_swiginit, METH_VARARGS, NULL},
53015 { (char *)"__wxMemoryFSHandler_AddFile_wxImage", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxImage, METH_VARARGS | METH_KEYWORDS, NULL},
53016 { (char *)"__wxMemoryFSHandler_AddFile_wxBitmap", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_wxBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53017 { (char *)"__wxMemoryFSHandler_AddFile_Data", (PyCFunction) _wrap___wxMemoryFSHandler_AddFile_Data, METH_VARARGS | METH_KEYWORDS, NULL},
53018 { (char *)"new_MemoryFSHandler", (PyCFunction)_wrap_new_MemoryFSHandler, METH_NOARGS, NULL},
53019 { (char *)"MemoryFSHandler_RemoveFile", (PyCFunction) _wrap_MemoryFSHandler_RemoveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53020 { (char *)"MemoryFSHandler_CanOpen", (PyCFunction) _wrap_MemoryFSHandler_CanOpen, METH_VARARGS | METH_KEYWORDS, NULL},
53021 { (char *)"MemoryFSHandler_OpenFile", (PyCFunction) _wrap_MemoryFSHandler_OpenFile, METH_VARARGS | METH_KEYWORDS, NULL},
53022 { (char *)"MemoryFSHandler_FindFirst", (PyCFunction) _wrap_MemoryFSHandler_FindFirst, METH_VARARGS | METH_KEYWORDS, NULL},
53023 { (char *)"MemoryFSHandler_FindNext", (PyCFunction)_wrap_MemoryFSHandler_FindNext, METH_O, NULL},
53024 { (char *)"MemoryFSHandler_swigregister", MemoryFSHandler_swigregister, METH_VARARGS, NULL},
53025 { (char *)"MemoryFSHandler_swiginit", MemoryFSHandler_swiginit, METH_VARARGS, NULL},
53026 { (char *)"ImageHandler_GetName", (PyCFunction)_wrap_ImageHandler_GetName, METH_O, NULL},
53027 { (char *)"ImageHandler_GetExtension", (PyCFunction)_wrap_ImageHandler_GetExtension, METH_O, NULL},
53028 { (char *)"ImageHandler_GetType", (PyCFunction)_wrap_ImageHandler_GetType, METH_O, NULL},
53029 { (char *)"ImageHandler_GetMimeType", (PyCFunction)_wrap_ImageHandler_GetMimeType, METH_O, NULL},
53030 { (char *)"ImageHandler_CanRead", (PyCFunction) _wrap_ImageHandler_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53031 { (char *)"ImageHandler_CanReadStream", (PyCFunction) _wrap_ImageHandler_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53032 { (char *)"ImageHandler_SetName", (PyCFunction) _wrap_ImageHandler_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53033 { (char *)"ImageHandler_SetExtension", (PyCFunction) _wrap_ImageHandler_SetExtension, METH_VARARGS | METH_KEYWORDS, NULL},
53034 { (char *)"ImageHandler_SetType", (PyCFunction) _wrap_ImageHandler_SetType, METH_VARARGS | METH_KEYWORDS, NULL},
53035 { (char *)"ImageHandler_SetMimeType", (PyCFunction) _wrap_ImageHandler_SetMimeType, METH_VARARGS | METH_KEYWORDS, NULL},
53036 { (char *)"ImageHandler_swigregister", ImageHandler_swigregister, METH_VARARGS, NULL},
53037 { (char *)"new_PyImageHandler", (PyCFunction)_wrap_new_PyImageHandler, METH_NOARGS, NULL},
53038 { (char *)"PyImageHandler__SetSelf", (PyCFunction) _wrap_PyImageHandler__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53039 { (char *)"PyImageHandler_swigregister", PyImageHandler_swigregister, METH_VARARGS, NULL},
53040 { (char *)"PyImageHandler_swiginit", PyImageHandler_swiginit, METH_VARARGS, NULL},
53041 { (char *)"new_ImageHistogram", (PyCFunction)_wrap_new_ImageHistogram, METH_NOARGS, NULL},
53042 { (char *)"ImageHistogram_MakeKey", (PyCFunction) _wrap_ImageHistogram_MakeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53043 { (char *)"ImageHistogram_FindFirstUnusedColour", (PyCFunction) _wrap_ImageHistogram_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53044 { (char *)"ImageHistogram_GetCount", (PyCFunction) _wrap_ImageHistogram_GetCount, METH_VARARGS | METH_KEYWORDS, NULL},
53045 { (char *)"ImageHistogram_GetCountRGB", (PyCFunction) _wrap_ImageHistogram_GetCountRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53046 { (char *)"ImageHistogram_GetCountColour", (PyCFunction) _wrap_ImageHistogram_GetCountColour, METH_VARARGS | METH_KEYWORDS, NULL},
53047 { (char *)"ImageHistogram_swigregister", ImageHistogram_swigregister, METH_VARARGS, NULL},
53048 { (char *)"ImageHistogram_swiginit", ImageHistogram_swiginit, METH_VARARGS, NULL},
53049 { (char *)"new_Image_RGBValue", (PyCFunction) _wrap_new_Image_RGBValue, METH_VARARGS | METH_KEYWORDS, NULL},
53050 { (char *)"Image_RGBValue_red_set", _wrap_Image_RGBValue_red_set, METH_VARARGS, NULL},
53051 { (char *)"Image_RGBValue_red_get", (PyCFunction)_wrap_Image_RGBValue_red_get, METH_O, NULL},
53052 { (char *)"Image_RGBValue_green_set", _wrap_Image_RGBValue_green_set, METH_VARARGS, NULL},
53053 { (char *)"Image_RGBValue_green_get", (PyCFunction)_wrap_Image_RGBValue_green_get, METH_O, NULL},
53054 { (char *)"Image_RGBValue_blue_set", _wrap_Image_RGBValue_blue_set, METH_VARARGS, NULL},
53055 { (char *)"Image_RGBValue_blue_get", (PyCFunction)_wrap_Image_RGBValue_blue_get, METH_O, NULL},
53056 { (char *)"Image_RGBValue_swigregister", Image_RGBValue_swigregister, METH_VARARGS, NULL},
53057 { (char *)"Image_RGBValue_swiginit", Image_RGBValue_swiginit, METH_VARARGS, NULL},
53058 { (char *)"new_Image_HSVValue", (PyCFunction) _wrap_new_Image_HSVValue, METH_VARARGS | METH_KEYWORDS, NULL},
53059 { (char *)"Image_HSVValue_hue_set", _wrap_Image_HSVValue_hue_set, METH_VARARGS, NULL},
53060 { (char *)"Image_HSVValue_hue_get", (PyCFunction)_wrap_Image_HSVValue_hue_get, METH_O, NULL},
53061 { (char *)"Image_HSVValue_saturation_set", _wrap_Image_HSVValue_saturation_set, METH_VARARGS, NULL},
53062 { (char *)"Image_HSVValue_saturation_get", (PyCFunction)_wrap_Image_HSVValue_saturation_get, METH_O, NULL},
53063 { (char *)"Image_HSVValue_value_set", _wrap_Image_HSVValue_value_set, METH_VARARGS, NULL},
53064 { (char *)"Image_HSVValue_value_get", (PyCFunction)_wrap_Image_HSVValue_value_get, METH_O, NULL},
53065 { (char *)"Image_HSVValue_swigregister", Image_HSVValue_swigregister, METH_VARARGS, NULL},
53066 { (char *)"Image_HSVValue_swiginit", Image_HSVValue_swiginit, METH_VARARGS, NULL},
53067 { (char *)"new_Image", (PyCFunction) _wrap_new_Image, METH_VARARGS | METH_KEYWORDS, NULL},
53068 { (char *)"delete_Image", (PyCFunction)_wrap_delete_Image, METH_O, NULL},
53069 { (char *)"new_ImageFromMime", (PyCFunction) _wrap_new_ImageFromMime, METH_VARARGS | METH_KEYWORDS, NULL},
53070 { (char *)"new_ImageFromStream", (PyCFunction) _wrap_new_ImageFromStream, METH_VARARGS | METH_KEYWORDS, NULL},
53071 { (char *)"new_ImageFromStreamMime", (PyCFunction) _wrap_new_ImageFromStreamMime, METH_VARARGS | METH_KEYWORDS, NULL},
53072 { (char *)"new_EmptyImage", (PyCFunction) _wrap_new_EmptyImage, METH_VARARGS | METH_KEYWORDS, NULL},
53073 { (char *)"new_ImageFromBitmap", (PyCFunction) _wrap_new_ImageFromBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53074 { (char *)"new_ImageFromData", (PyCFunction) _wrap_new_ImageFromData, METH_VARARGS | METH_KEYWORDS, NULL},
53075 { (char *)"new_ImageFromDataWithAlpha", (PyCFunction) _wrap_new_ImageFromDataWithAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53076 { (char *)"Image_Create", (PyCFunction) _wrap_Image_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53077 { (char *)"Image_Destroy", (PyCFunction)_wrap_Image_Destroy, METH_O, NULL},
53078 { (char *)"Image_Scale", (PyCFunction) _wrap_Image_Scale, METH_VARARGS | METH_KEYWORDS, NULL},
53079 { (char *)"Image_ShrinkBy", (PyCFunction) _wrap_Image_ShrinkBy, METH_VARARGS | METH_KEYWORDS, NULL},
53080 { (char *)"Image_Rescale", (PyCFunction) _wrap_Image_Rescale, METH_VARARGS | METH_KEYWORDS, NULL},
53081 { (char *)"Image_Resize", (PyCFunction) _wrap_Image_Resize, METH_VARARGS | METH_KEYWORDS, NULL},
53082 { (char *)"Image_SetRGB", (PyCFunction) _wrap_Image_SetRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53083 { (char *)"Image_SetRGBRect", (PyCFunction) _wrap_Image_SetRGBRect, METH_VARARGS | METH_KEYWORDS, NULL},
53084 { (char *)"Image_GetRed", (PyCFunction) _wrap_Image_GetRed, METH_VARARGS | METH_KEYWORDS, NULL},
53085 { (char *)"Image_GetGreen", (PyCFunction) _wrap_Image_GetGreen, METH_VARARGS | METH_KEYWORDS, NULL},
53086 { (char *)"Image_GetBlue", (PyCFunction) _wrap_Image_GetBlue, METH_VARARGS | METH_KEYWORDS, NULL},
53087 { (char *)"Image_SetAlpha", (PyCFunction) _wrap_Image_SetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53088 { (char *)"Image_GetAlpha", (PyCFunction) _wrap_Image_GetAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53089 { (char *)"Image_HasAlpha", (PyCFunction)_wrap_Image_HasAlpha, METH_O, NULL},
53090 { (char *)"Image_InitAlpha", (PyCFunction)_wrap_Image_InitAlpha, METH_O, NULL},
53091 { (char *)"Image_IsTransparent", (PyCFunction) _wrap_Image_IsTransparent, METH_VARARGS | METH_KEYWORDS, NULL},
53092 { (char *)"Image_FindFirstUnusedColour", (PyCFunction) _wrap_Image_FindFirstUnusedColour, METH_VARARGS | METH_KEYWORDS, NULL},
53093 { (char *)"Image_ConvertAlphaToMask", (PyCFunction) _wrap_Image_ConvertAlphaToMask, METH_VARARGS | METH_KEYWORDS, NULL},
53094 { (char *)"Image_ConvertColourToAlpha", (PyCFunction) _wrap_Image_ConvertColourToAlpha, METH_VARARGS | METH_KEYWORDS, NULL},
53095 { (char *)"Image_SetMaskFromImage", (PyCFunction) _wrap_Image_SetMaskFromImage, METH_VARARGS | METH_KEYWORDS, NULL},
53096 { (char *)"Image_CanRead", (PyCFunction) _wrap_Image_CanRead, METH_VARARGS | METH_KEYWORDS, NULL},
53097 { (char *)"Image_GetImageCount", (PyCFunction) _wrap_Image_GetImageCount, METH_VARARGS | METH_KEYWORDS, NULL},
53098 { (char *)"Image_LoadFile", (PyCFunction) _wrap_Image_LoadFile, METH_VARARGS | METH_KEYWORDS, NULL},
53099 { (char *)"Image_LoadMimeFile", (PyCFunction) _wrap_Image_LoadMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53100 { (char *)"Image_SaveFile", (PyCFunction) _wrap_Image_SaveFile, METH_VARARGS | METH_KEYWORDS, NULL},
53101 { (char *)"Image_SaveMimeFile", (PyCFunction) _wrap_Image_SaveMimeFile, METH_VARARGS | METH_KEYWORDS, NULL},
53102 { (char *)"Image_CanReadStream", (PyCFunction) _wrap_Image_CanReadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53103 { (char *)"Image_LoadStream", (PyCFunction) _wrap_Image_LoadStream, METH_VARARGS | METH_KEYWORDS, NULL},
53104 { (char *)"Image_LoadMimeStream", (PyCFunction) _wrap_Image_LoadMimeStream, METH_VARARGS | METH_KEYWORDS, NULL},
53105 { (char *)"Image_Ok", (PyCFunction)_wrap_Image_Ok, METH_O, NULL},
53106 { (char *)"Image_GetWidth", (PyCFunction)_wrap_Image_GetWidth, METH_O, NULL},
53107 { (char *)"Image_GetHeight", (PyCFunction)_wrap_Image_GetHeight, METH_O, NULL},
53108 { (char *)"Image_GetSize", (PyCFunction)_wrap_Image_GetSize, METH_O, NULL},
53109 { (char *)"Image_GetSubImage", (PyCFunction) _wrap_Image_GetSubImage, METH_VARARGS | METH_KEYWORDS, NULL},
53110 { (char *)"Image_Size", (PyCFunction) _wrap_Image_Size, METH_VARARGS | METH_KEYWORDS, NULL},
53111 { (char *)"Image_Copy", (PyCFunction)_wrap_Image_Copy, METH_O, NULL},
53112 { (char *)"Image_Paste", (PyCFunction) _wrap_Image_Paste, METH_VARARGS | METH_KEYWORDS, NULL},
53113 { (char *)"Image_GetData", (PyCFunction)_wrap_Image_GetData, METH_O, NULL},
53114 { (char *)"Image_SetData", (PyCFunction) _wrap_Image_SetData, METH_VARARGS | METH_KEYWORDS, NULL},
53115 { (char *)"Image_GetDataBuffer", (PyCFunction)_wrap_Image_GetDataBuffer, METH_O, NULL},
53116 { (char *)"Image_SetDataBuffer", (PyCFunction) _wrap_Image_SetDataBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53117 { (char *)"Image_GetAlphaData", (PyCFunction)_wrap_Image_GetAlphaData, METH_O, NULL},
53118 { (char *)"Image_SetAlphaData", (PyCFunction) _wrap_Image_SetAlphaData, METH_VARARGS | METH_KEYWORDS, NULL},
53119 { (char *)"Image_GetAlphaBuffer", (PyCFunction)_wrap_Image_GetAlphaBuffer, METH_O, NULL},
53120 { (char *)"Image_SetAlphaBuffer", (PyCFunction) _wrap_Image_SetAlphaBuffer, METH_VARARGS | METH_KEYWORDS, NULL},
53121 { (char *)"Image_SetMaskColour", (PyCFunction) _wrap_Image_SetMaskColour, METH_VARARGS | METH_KEYWORDS, NULL},
53122 { (char *)"Image_GetOrFindMaskColour", (PyCFunction)_wrap_Image_GetOrFindMaskColour, METH_O, NULL},
53123 { (char *)"Image_GetMaskRed", (PyCFunction)_wrap_Image_GetMaskRed, METH_O, NULL},
53124 { (char *)"Image_GetMaskGreen", (PyCFunction)_wrap_Image_GetMaskGreen, METH_O, NULL},
53125 { (char *)"Image_GetMaskBlue", (PyCFunction)_wrap_Image_GetMaskBlue, METH_O, NULL},
53126 { (char *)"Image_SetMask", (PyCFunction) _wrap_Image_SetMask, METH_VARARGS | METH_KEYWORDS, NULL},
53127 { (char *)"Image_HasMask", (PyCFunction)_wrap_Image_HasMask, METH_O, NULL},
53128 { (char *)"Image_Rotate", (PyCFunction) _wrap_Image_Rotate, METH_VARARGS | METH_KEYWORDS, NULL},
53129 { (char *)"Image_Rotate90", (PyCFunction) _wrap_Image_Rotate90, METH_VARARGS | METH_KEYWORDS, NULL},
53130 { (char *)"Image_Mirror", (PyCFunction) _wrap_Image_Mirror, METH_VARARGS | METH_KEYWORDS, NULL},
53131 { (char *)"Image_Replace", (PyCFunction) _wrap_Image_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53132 { (char *)"Image_ConvertToGreyscale", (PyCFunction) _wrap_Image_ConvertToGreyscale, METH_VARARGS | METH_KEYWORDS, NULL},
53133 { (char *)"Image_ConvertToMono", (PyCFunction) _wrap_Image_ConvertToMono, METH_VARARGS | METH_KEYWORDS, NULL},
53134 { (char *)"Image_SetOption", (PyCFunction) _wrap_Image_SetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53135 { (char *)"Image_SetOptionInt", (PyCFunction) _wrap_Image_SetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53136 { (char *)"Image_GetOption", (PyCFunction) _wrap_Image_GetOption, METH_VARARGS | METH_KEYWORDS, NULL},
53137 { (char *)"Image_GetOptionInt", (PyCFunction) _wrap_Image_GetOptionInt, METH_VARARGS | METH_KEYWORDS, NULL},
53138 { (char *)"Image_HasOption", (PyCFunction) _wrap_Image_HasOption, METH_VARARGS | METH_KEYWORDS, NULL},
53139 { (char *)"Image_CountColours", (PyCFunction) _wrap_Image_CountColours, METH_VARARGS | METH_KEYWORDS, NULL},
53140 { (char *)"Image_ComputeHistogram", (PyCFunction) _wrap_Image_ComputeHistogram, METH_VARARGS | METH_KEYWORDS, NULL},
53141 { (char *)"Image_AddHandler", (PyCFunction) _wrap_Image_AddHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53142 { (char *)"Image_InsertHandler", (PyCFunction) _wrap_Image_InsertHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53143 { (char *)"Image_RemoveHandler", (PyCFunction) _wrap_Image_RemoveHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53144 { (char *)"Image_GetHandlers", (PyCFunction)_wrap_Image_GetHandlers, METH_NOARGS, NULL},
53145 { (char *)"Image_GetImageExtWildcard", (PyCFunction)_wrap_Image_GetImageExtWildcard, METH_NOARGS, NULL},
53146 { (char *)"Image_ConvertToBitmap", (PyCFunction) _wrap_Image_ConvertToBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53147 { (char *)"Image_ConvertToMonoBitmap", (PyCFunction) _wrap_Image_ConvertToMonoBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53148 { (char *)"Image_RotateHue", (PyCFunction) _wrap_Image_RotateHue, METH_VARARGS | METH_KEYWORDS, NULL},
53149 { (char *)"Image_RGBtoHSV", (PyCFunction) _wrap_Image_RGBtoHSV, METH_VARARGS | METH_KEYWORDS, NULL},
53150 { (char *)"Image_HSVtoRGB", (PyCFunction) _wrap_Image_HSVtoRGB, METH_VARARGS | METH_KEYWORDS, NULL},
53151 { (char *)"Image_swigregister", Image_swigregister, METH_VARARGS, NULL},
53152 { (char *)"Image_swiginit", Image_swiginit, METH_VARARGS, NULL},
53153 { (char *)"new_BMPHandler", (PyCFunction)_wrap_new_BMPHandler, METH_NOARGS, NULL},
53154 { (char *)"BMPHandler_swigregister", BMPHandler_swigregister, METH_VARARGS, NULL},
53155 { (char *)"BMPHandler_swiginit", BMPHandler_swiginit, METH_VARARGS, NULL},
53156 { (char *)"new_ICOHandler", (PyCFunction)_wrap_new_ICOHandler, METH_NOARGS, NULL},
53157 { (char *)"ICOHandler_swigregister", ICOHandler_swigregister, METH_VARARGS, NULL},
53158 { (char *)"ICOHandler_swiginit", ICOHandler_swiginit, METH_VARARGS, NULL},
53159 { (char *)"new_CURHandler", (PyCFunction)_wrap_new_CURHandler, METH_NOARGS, NULL},
53160 { (char *)"CURHandler_swigregister", CURHandler_swigregister, METH_VARARGS, NULL},
53161 { (char *)"CURHandler_swiginit", CURHandler_swiginit, METH_VARARGS, NULL},
53162 { (char *)"new_ANIHandler", (PyCFunction)_wrap_new_ANIHandler, METH_NOARGS, NULL},
53163 { (char *)"ANIHandler_swigregister", ANIHandler_swigregister, METH_VARARGS, NULL},
53164 { (char *)"ANIHandler_swiginit", ANIHandler_swiginit, METH_VARARGS, NULL},
53165 { (char *)"new_PNGHandler", (PyCFunction)_wrap_new_PNGHandler, METH_NOARGS, NULL},
53166 { (char *)"PNGHandler_swigregister", PNGHandler_swigregister, METH_VARARGS, NULL},
53167 { (char *)"PNGHandler_swiginit", PNGHandler_swiginit, METH_VARARGS, NULL},
53168 { (char *)"new_GIFHandler", (PyCFunction)_wrap_new_GIFHandler, METH_NOARGS, NULL},
53169 { (char *)"GIFHandler_swigregister", GIFHandler_swigregister, METH_VARARGS, NULL},
53170 { (char *)"GIFHandler_swiginit", GIFHandler_swiginit, METH_VARARGS, NULL},
53171 { (char *)"new_PCXHandler", (PyCFunction)_wrap_new_PCXHandler, METH_NOARGS, NULL},
53172 { (char *)"PCXHandler_swigregister", PCXHandler_swigregister, METH_VARARGS, NULL},
53173 { (char *)"PCXHandler_swiginit", PCXHandler_swiginit, METH_VARARGS, NULL},
53174 { (char *)"new_JPEGHandler", (PyCFunction)_wrap_new_JPEGHandler, METH_NOARGS, NULL},
53175 { (char *)"JPEGHandler_swigregister", JPEGHandler_swigregister, METH_VARARGS, NULL},
53176 { (char *)"JPEGHandler_swiginit", JPEGHandler_swiginit, METH_VARARGS, NULL},
53177 { (char *)"new_PNMHandler", (PyCFunction)_wrap_new_PNMHandler, METH_NOARGS, NULL},
53178 { (char *)"PNMHandler_swigregister", PNMHandler_swigregister, METH_VARARGS, NULL},
53179 { (char *)"PNMHandler_swiginit", PNMHandler_swiginit, METH_VARARGS, NULL},
53180 { (char *)"new_XPMHandler", (PyCFunction)_wrap_new_XPMHandler, METH_NOARGS, NULL},
53181 { (char *)"XPMHandler_swigregister", XPMHandler_swigregister, METH_VARARGS, NULL},
53182 { (char *)"XPMHandler_swiginit", XPMHandler_swiginit, METH_VARARGS, NULL},
53183 { (char *)"new_TIFFHandler", (PyCFunction)_wrap_new_TIFFHandler, METH_NOARGS, NULL},
53184 { (char *)"TIFFHandler_swigregister", TIFFHandler_swigregister, METH_VARARGS, NULL},
53185 { (char *)"TIFFHandler_swiginit", TIFFHandler_swiginit, METH_VARARGS, NULL},
53186 { (char *)"Quantize_Quantize", (PyCFunction) _wrap_Quantize_Quantize, METH_VARARGS | METH_KEYWORDS, NULL},
53187 { (char *)"Quantize_swigregister", Quantize_swigregister, METH_VARARGS, NULL},
53188 { (char *)"new_EvtHandler", (PyCFunction)_wrap_new_EvtHandler, METH_NOARGS, NULL},
53189 { (char *)"EvtHandler_GetNextHandler", (PyCFunction)_wrap_EvtHandler_GetNextHandler, METH_O, NULL},
53190 { (char *)"EvtHandler_GetPreviousHandler", (PyCFunction)_wrap_EvtHandler_GetPreviousHandler, METH_O, NULL},
53191 { (char *)"EvtHandler_SetNextHandler", (PyCFunction) _wrap_EvtHandler_SetNextHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53192 { (char *)"EvtHandler_SetPreviousHandler", (PyCFunction) _wrap_EvtHandler_SetPreviousHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53193 { (char *)"EvtHandler_GetEvtHandlerEnabled", (PyCFunction)_wrap_EvtHandler_GetEvtHandlerEnabled, METH_O, NULL},
53194 { (char *)"EvtHandler_SetEvtHandlerEnabled", (PyCFunction) _wrap_EvtHandler_SetEvtHandlerEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53195 { (char *)"EvtHandler_ProcessEvent", (PyCFunction) _wrap_EvtHandler_ProcessEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53196 { (char *)"EvtHandler_AddPendingEvent", (PyCFunction) _wrap_EvtHandler_AddPendingEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53197 { (char *)"EvtHandler_ProcessPendingEvents", (PyCFunction)_wrap_EvtHandler_ProcessPendingEvents, METH_O, NULL},
53198 { (char *)"EvtHandler_Connect", (PyCFunction) _wrap_EvtHandler_Connect, METH_VARARGS | METH_KEYWORDS, NULL},
53199 { (char *)"EvtHandler_Disconnect", (PyCFunction) _wrap_EvtHandler_Disconnect, METH_VARARGS | METH_KEYWORDS, NULL},
53200 { (char *)"EvtHandler__setOORInfo", (PyCFunction) _wrap_EvtHandler__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53201 { (char *)"EvtHandler_swigregister", EvtHandler_swigregister, METH_VARARGS, NULL},
53202 { (char *)"EvtHandler_swiginit", EvtHandler_swiginit, METH_VARARGS, NULL},
53203 { (char *)"NewEventType", (PyCFunction)_wrap_NewEventType, METH_NOARGS, NULL},
53204 { (char *)"delete_Event", (PyCFunction)_wrap_delete_Event, METH_O, NULL},
53205 { (char *)"Event_SetEventType", (PyCFunction) _wrap_Event_SetEventType, METH_VARARGS | METH_KEYWORDS, NULL},
53206 { (char *)"Event_GetEventType", (PyCFunction)_wrap_Event_GetEventType, METH_O, NULL},
53207 { (char *)"Event_GetEventObject", (PyCFunction)_wrap_Event_GetEventObject, METH_O, NULL},
53208 { (char *)"Event_SetEventObject", (PyCFunction) _wrap_Event_SetEventObject, METH_VARARGS | METH_KEYWORDS, NULL},
53209 { (char *)"Event_GetTimestamp", (PyCFunction)_wrap_Event_GetTimestamp, METH_O, NULL},
53210 { (char *)"Event_SetTimestamp", (PyCFunction) _wrap_Event_SetTimestamp, METH_VARARGS | METH_KEYWORDS, NULL},
53211 { (char *)"Event_GetId", (PyCFunction)_wrap_Event_GetId, METH_O, NULL},
53212 { (char *)"Event_SetId", (PyCFunction) _wrap_Event_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53213 { (char *)"Event_IsCommandEvent", (PyCFunction)_wrap_Event_IsCommandEvent, METH_O, NULL},
53214 { (char *)"Event_Skip", (PyCFunction) _wrap_Event_Skip, METH_VARARGS | METH_KEYWORDS, NULL},
53215 { (char *)"Event_GetSkipped", (PyCFunction)_wrap_Event_GetSkipped, METH_O, NULL},
53216 { (char *)"Event_ShouldPropagate", (PyCFunction)_wrap_Event_ShouldPropagate, METH_O, NULL},
53217 { (char *)"Event_StopPropagation", (PyCFunction)_wrap_Event_StopPropagation, METH_O, NULL},
53218 { (char *)"Event_ResumePropagation", (PyCFunction) _wrap_Event_ResumePropagation, METH_VARARGS | METH_KEYWORDS, NULL},
53219 { (char *)"Event_Clone", (PyCFunction)_wrap_Event_Clone, METH_O, NULL},
53220 { (char *)"Event_swigregister", Event_swigregister, METH_VARARGS, NULL},
53221 { (char *)"new_PropagationDisabler", (PyCFunction) _wrap_new_PropagationDisabler, METH_VARARGS | METH_KEYWORDS, NULL},
53222 { (char *)"delete_PropagationDisabler", (PyCFunction)_wrap_delete_PropagationDisabler, METH_O, NULL},
53223 { (char *)"PropagationDisabler_swigregister", PropagationDisabler_swigregister, METH_VARARGS, NULL},
53224 { (char *)"PropagationDisabler_swiginit", PropagationDisabler_swiginit, METH_VARARGS, NULL},
53225 { (char *)"new_PropagateOnce", (PyCFunction) _wrap_new_PropagateOnce, METH_VARARGS | METH_KEYWORDS, NULL},
53226 { (char *)"delete_PropagateOnce", (PyCFunction)_wrap_delete_PropagateOnce, METH_O, NULL},
53227 { (char *)"PropagateOnce_swigregister", PropagateOnce_swigregister, METH_VARARGS, NULL},
53228 { (char *)"PropagateOnce_swiginit", PropagateOnce_swiginit, METH_VARARGS, NULL},
53229 { (char *)"new_CommandEvent", (PyCFunction) _wrap_new_CommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53230 { (char *)"CommandEvent_GetSelection", (PyCFunction)_wrap_CommandEvent_GetSelection, METH_O, NULL},
53231 { (char *)"CommandEvent_SetString", (PyCFunction) _wrap_CommandEvent_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
53232 { (char *)"CommandEvent_GetString", (PyCFunction)_wrap_CommandEvent_GetString, METH_O, NULL},
53233 { (char *)"CommandEvent_IsChecked", (PyCFunction)_wrap_CommandEvent_IsChecked, METH_O, NULL},
53234 { (char *)"CommandEvent_IsSelection", (PyCFunction)_wrap_CommandEvent_IsSelection, METH_O, NULL},
53235 { (char *)"CommandEvent_SetExtraLong", (PyCFunction) _wrap_CommandEvent_SetExtraLong, METH_VARARGS | METH_KEYWORDS, NULL},
53236 { (char *)"CommandEvent_GetExtraLong", (PyCFunction)_wrap_CommandEvent_GetExtraLong, METH_O, NULL},
53237 { (char *)"CommandEvent_SetInt", (PyCFunction) _wrap_CommandEvent_SetInt, METH_VARARGS | METH_KEYWORDS, NULL},
53238 { (char *)"CommandEvent_GetInt", (PyCFunction)_wrap_CommandEvent_GetInt, METH_O, NULL},
53239 { (char *)"CommandEvent_GetClientData", (PyCFunction)_wrap_CommandEvent_GetClientData, METH_O, NULL},
53240 { (char *)"CommandEvent_SetClientData", (PyCFunction) _wrap_CommandEvent_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
53241 { (char *)"CommandEvent_Clone", (PyCFunction)_wrap_CommandEvent_Clone, METH_O, NULL},
53242 { (char *)"CommandEvent_swigregister", CommandEvent_swigregister, METH_VARARGS, NULL},
53243 { (char *)"CommandEvent_swiginit", CommandEvent_swiginit, METH_VARARGS, NULL},
53244 { (char *)"new_NotifyEvent", (PyCFunction) _wrap_new_NotifyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53245 { (char *)"NotifyEvent_Veto", (PyCFunction)_wrap_NotifyEvent_Veto, METH_O, NULL},
53246 { (char *)"NotifyEvent_Allow", (PyCFunction)_wrap_NotifyEvent_Allow, METH_O, NULL},
53247 { (char *)"NotifyEvent_IsAllowed", (PyCFunction)_wrap_NotifyEvent_IsAllowed, METH_O, NULL},
53248 { (char *)"NotifyEvent_swigregister", NotifyEvent_swigregister, METH_VARARGS, NULL},
53249 { (char *)"NotifyEvent_swiginit", NotifyEvent_swiginit, METH_VARARGS, NULL},
53250 { (char *)"new_ScrollEvent", (PyCFunction) _wrap_new_ScrollEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53251 { (char *)"ScrollEvent_GetOrientation", (PyCFunction)_wrap_ScrollEvent_GetOrientation, METH_O, NULL},
53252 { (char *)"ScrollEvent_GetPosition", (PyCFunction)_wrap_ScrollEvent_GetPosition, METH_O, NULL},
53253 { (char *)"ScrollEvent_SetOrientation", (PyCFunction) _wrap_ScrollEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53254 { (char *)"ScrollEvent_SetPosition", (PyCFunction) _wrap_ScrollEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53255 { (char *)"ScrollEvent_swigregister", ScrollEvent_swigregister, METH_VARARGS, NULL},
53256 { (char *)"ScrollEvent_swiginit", ScrollEvent_swiginit, METH_VARARGS, NULL},
53257 { (char *)"new_ScrollWinEvent", (PyCFunction) _wrap_new_ScrollWinEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53258 { (char *)"ScrollWinEvent_GetOrientation", (PyCFunction)_wrap_ScrollWinEvent_GetOrientation, METH_O, NULL},
53259 { (char *)"ScrollWinEvent_GetPosition", (PyCFunction)_wrap_ScrollWinEvent_GetPosition, METH_O, NULL},
53260 { (char *)"ScrollWinEvent_SetOrientation", (PyCFunction) _wrap_ScrollWinEvent_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
53261 { (char *)"ScrollWinEvent_SetPosition", (PyCFunction) _wrap_ScrollWinEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53262 { (char *)"ScrollWinEvent_swigregister", ScrollWinEvent_swigregister, METH_VARARGS, NULL},
53263 { (char *)"ScrollWinEvent_swiginit", ScrollWinEvent_swiginit, METH_VARARGS, NULL},
53264 { (char *)"new_MouseEvent", (PyCFunction) _wrap_new_MouseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53265 { (char *)"MouseEvent_IsButton", (PyCFunction)_wrap_MouseEvent_IsButton, METH_O, NULL},
53266 { (char *)"MouseEvent_ButtonDown", (PyCFunction) _wrap_MouseEvent_ButtonDown, METH_VARARGS | METH_KEYWORDS, NULL},
53267 { (char *)"MouseEvent_ButtonDClick", (PyCFunction) _wrap_MouseEvent_ButtonDClick, METH_VARARGS | METH_KEYWORDS, NULL},
53268 { (char *)"MouseEvent_ButtonUp", (PyCFunction) _wrap_MouseEvent_ButtonUp, METH_VARARGS | METH_KEYWORDS, NULL},
53269 { (char *)"MouseEvent_Button", (PyCFunction) _wrap_MouseEvent_Button, METH_VARARGS | METH_KEYWORDS, NULL},
53270 { (char *)"MouseEvent_ButtonIsDown", (PyCFunction) _wrap_MouseEvent_ButtonIsDown, METH_VARARGS | METH_KEYWORDS, NULL},
53271 { (char *)"MouseEvent_GetButton", (PyCFunction)_wrap_MouseEvent_GetButton, METH_O, NULL},
53272 { (char *)"MouseEvent_ControlDown", (PyCFunction)_wrap_MouseEvent_ControlDown, METH_O, NULL},
53273 { (char *)"MouseEvent_MetaDown", (PyCFunction)_wrap_MouseEvent_MetaDown, METH_O, NULL},
53274 { (char *)"MouseEvent_AltDown", (PyCFunction)_wrap_MouseEvent_AltDown, METH_O, NULL},
53275 { (char *)"MouseEvent_ShiftDown", (PyCFunction)_wrap_MouseEvent_ShiftDown, METH_O, NULL},
53276 { (char *)"MouseEvent_CmdDown", (PyCFunction)_wrap_MouseEvent_CmdDown, METH_O, NULL},
53277 { (char *)"MouseEvent_LeftDown", (PyCFunction)_wrap_MouseEvent_LeftDown, METH_O, NULL},
53278 { (char *)"MouseEvent_MiddleDown", (PyCFunction)_wrap_MouseEvent_MiddleDown, METH_O, NULL},
53279 { (char *)"MouseEvent_RightDown", (PyCFunction)_wrap_MouseEvent_RightDown, METH_O, NULL},
53280 { (char *)"MouseEvent_LeftUp", (PyCFunction)_wrap_MouseEvent_LeftUp, METH_O, NULL},
53281 { (char *)"MouseEvent_MiddleUp", (PyCFunction)_wrap_MouseEvent_MiddleUp, METH_O, NULL},
53282 { (char *)"MouseEvent_RightUp", (PyCFunction)_wrap_MouseEvent_RightUp, METH_O, NULL},
53283 { (char *)"MouseEvent_LeftDClick", (PyCFunction)_wrap_MouseEvent_LeftDClick, METH_O, NULL},
53284 { (char *)"MouseEvent_MiddleDClick", (PyCFunction)_wrap_MouseEvent_MiddleDClick, METH_O, NULL},
53285 { (char *)"MouseEvent_RightDClick", (PyCFunction)_wrap_MouseEvent_RightDClick, METH_O, NULL},
53286 { (char *)"MouseEvent_LeftIsDown", (PyCFunction)_wrap_MouseEvent_LeftIsDown, METH_O, NULL},
53287 { (char *)"MouseEvent_MiddleIsDown", (PyCFunction)_wrap_MouseEvent_MiddleIsDown, METH_O, NULL},
53288 { (char *)"MouseEvent_RightIsDown", (PyCFunction)_wrap_MouseEvent_RightIsDown, METH_O, NULL},
53289 { (char *)"MouseEvent_Dragging", (PyCFunction)_wrap_MouseEvent_Dragging, METH_O, NULL},
53290 { (char *)"MouseEvent_Moving", (PyCFunction)_wrap_MouseEvent_Moving, METH_O, NULL},
53291 { (char *)"MouseEvent_Entering", (PyCFunction)_wrap_MouseEvent_Entering, METH_O, NULL},
53292 { (char *)"MouseEvent_Leaving", (PyCFunction)_wrap_MouseEvent_Leaving, METH_O, NULL},
53293 { (char *)"MouseEvent_GetPosition", (PyCFunction)_wrap_MouseEvent_GetPosition, METH_O, NULL},
53294 { (char *)"MouseEvent_GetPositionTuple", (PyCFunction)_wrap_MouseEvent_GetPositionTuple, METH_O, NULL},
53295 { (char *)"MouseEvent_GetLogicalPosition", (PyCFunction) _wrap_MouseEvent_GetLogicalPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53296 { (char *)"MouseEvent_GetX", (PyCFunction)_wrap_MouseEvent_GetX, METH_O, NULL},
53297 { (char *)"MouseEvent_GetY", (PyCFunction)_wrap_MouseEvent_GetY, METH_O, NULL},
53298 { (char *)"MouseEvent_GetWheelRotation", (PyCFunction)_wrap_MouseEvent_GetWheelRotation, METH_O, NULL},
53299 { (char *)"MouseEvent_GetWheelDelta", (PyCFunction)_wrap_MouseEvent_GetWheelDelta, METH_O, NULL},
53300 { (char *)"MouseEvent_GetLinesPerAction", (PyCFunction)_wrap_MouseEvent_GetLinesPerAction, METH_O, NULL},
53301 { (char *)"MouseEvent_IsPageScroll", (PyCFunction)_wrap_MouseEvent_IsPageScroll, METH_O, NULL},
53302 { (char *)"MouseEvent_m_x_set", _wrap_MouseEvent_m_x_set, METH_VARARGS, NULL},
53303 { (char *)"MouseEvent_m_x_get", (PyCFunction)_wrap_MouseEvent_m_x_get, METH_O, NULL},
53304 { (char *)"MouseEvent_m_y_set", _wrap_MouseEvent_m_y_set, METH_VARARGS, NULL},
53305 { (char *)"MouseEvent_m_y_get", (PyCFunction)_wrap_MouseEvent_m_y_get, METH_O, NULL},
53306 { (char *)"MouseEvent_m_leftDown_set", _wrap_MouseEvent_m_leftDown_set, METH_VARARGS, NULL},
53307 { (char *)"MouseEvent_m_leftDown_get", (PyCFunction)_wrap_MouseEvent_m_leftDown_get, METH_O, NULL},
53308 { (char *)"MouseEvent_m_middleDown_set", _wrap_MouseEvent_m_middleDown_set, METH_VARARGS, NULL},
53309 { (char *)"MouseEvent_m_middleDown_get", (PyCFunction)_wrap_MouseEvent_m_middleDown_get, METH_O, NULL},
53310 { (char *)"MouseEvent_m_rightDown_set", _wrap_MouseEvent_m_rightDown_set, METH_VARARGS, NULL},
53311 { (char *)"MouseEvent_m_rightDown_get", (PyCFunction)_wrap_MouseEvent_m_rightDown_get, METH_O, NULL},
53312 { (char *)"MouseEvent_m_controlDown_set", _wrap_MouseEvent_m_controlDown_set, METH_VARARGS, NULL},
53313 { (char *)"MouseEvent_m_controlDown_get", (PyCFunction)_wrap_MouseEvent_m_controlDown_get, METH_O, NULL},
53314 { (char *)"MouseEvent_m_shiftDown_set", _wrap_MouseEvent_m_shiftDown_set, METH_VARARGS, NULL},
53315 { (char *)"MouseEvent_m_shiftDown_get", (PyCFunction)_wrap_MouseEvent_m_shiftDown_get, METH_O, NULL},
53316 { (char *)"MouseEvent_m_altDown_set", _wrap_MouseEvent_m_altDown_set, METH_VARARGS, NULL},
53317 { (char *)"MouseEvent_m_altDown_get", (PyCFunction)_wrap_MouseEvent_m_altDown_get, METH_O, NULL},
53318 { (char *)"MouseEvent_m_metaDown_set", _wrap_MouseEvent_m_metaDown_set, METH_VARARGS, NULL},
53319 { (char *)"MouseEvent_m_metaDown_get", (PyCFunction)_wrap_MouseEvent_m_metaDown_get, METH_O, NULL},
53320 { (char *)"MouseEvent_m_wheelRotation_set", _wrap_MouseEvent_m_wheelRotation_set, METH_VARARGS, NULL},
53321 { (char *)"MouseEvent_m_wheelRotation_get", (PyCFunction)_wrap_MouseEvent_m_wheelRotation_get, METH_O, NULL},
53322 { (char *)"MouseEvent_m_wheelDelta_set", _wrap_MouseEvent_m_wheelDelta_set, METH_VARARGS, NULL},
53323 { (char *)"MouseEvent_m_wheelDelta_get", (PyCFunction)_wrap_MouseEvent_m_wheelDelta_get, METH_O, NULL},
53324 { (char *)"MouseEvent_m_linesPerAction_set", _wrap_MouseEvent_m_linesPerAction_set, METH_VARARGS, NULL},
53325 { (char *)"MouseEvent_m_linesPerAction_get", (PyCFunction)_wrap_MouseEvent_m_linesPerAction_get, METH_O, NULL},
53326 { (char *)"MouseEvent_swigregister", MouseEvent_swigregister, METH_VARARGS, NULL},
53327 { (char *)"MouseEvent_swiginit", MouseEvent_swiginit, METH_VARARGS, NULL},
53328 { (char *)"new_SetCursorEvent", (PyCFunction) _wrap_new_SetCursorEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53329 { (char *)"SetCursorEvent_GetX", (PyCFunction)_wrap_SetCursorEvent_GetX, METH_O, NULL},
53330 { (char *)"SetCursorEvent_GetY", (PyCFunction)_wrap_SetCursorEvent_GetY, METH_O, NULL},
53331 { (char *)"SetCursorEvent_SetCursor", (PyCFunction) _wrap_SetCursorEvent_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53332 { (char *)"SetCursorEvent_GetCursor", (PyCFunction)_wrap_SetCursorEvent_GetCursor, METH_O, NULL},
53333 { (char *)"SetCursorEvent_HasCursor", (PyCFunction)_wrap_SetCursorEvent_HasCursor, METH_O, NULL},
53334 { (char *)"SetCursorEvent_swigregister", SetCursorEvent_swigregister, METH_VARARGS, NULL},
53335 { (char *)"SetCursorEvent_swiginit", SetCursorEvent_swiginit, METH_VARARGS, NULL},
53336 { (char *)"new_KeyEvent", (PyCFunction) _wrap_new_KeyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53337 { (char *)"KeyEvent_GetModifiers", (PyCFunction)_wrap_KeyEvent_GetModifiers, METH_O, NULL},
53338 { (char *)"KeyEvent_ControlDown", (PyCFunction)_wrap_KeyEvent_ControlDown, METH_O, NULL},
53339 { (char *)"KeyEvent_MetaDown", (PyCFunction)_wrap_KeyEvent_MetaDown, METH_O, NULL},
53340 { (char *)"KeyEvent_AltDown", (PyCFunction)_wrap_KeyEvent_AltDown, METH_O, NULL},
53341 { (char *)"KeyEvent_ShiftDown", (PyCFunction)_wrap_KeyEvent_ShiftDown, METH_O, NULL},
53342 { (char *)"KeyEvent_CmdDown", (PyCFunction)_wrap_KeyEvent_CmdDown, METH_O, NULL},
53343 { (char *)"KeyEvent_HasModifiers", (PyCFunction)_wrap_KeyEvent_HasModifiers, METH_O, NULL},
53344 { (char *)"KeyEvent_GetKeyCode", (PyCFunction)_wrap_KeyEvent_GetKeyCode, METH_O, NULL},
53345 { (char *)"KeyEvent_GetUnicodeKey", (PyCFunction)_wrap_KeyEvent_GetUnicodeKey, METH_O, NULL},
53346 { (char *)"KeyEvent_SetUnicodeKey", (PyCFunction) _wrap_KeyEvent_SetUnicodeKey, METH_VARARGS | METH_KEYWORDS, NULL},
53347 { (char *)"KeyEvent_GetRawKeyCode", (PyCFunction)_wrap_KeyEvent_GetRawKeyCode, METH_O, NULL},
53348 { (char *)"KeyEvent_GetRawKeyFlags", (PyCFunction)_wrap_KeyEvent_GetRawKeyFlags, METH_O, NULL},
53349 { (char *)"KeyEvent_GetPosition", (PyCFunction)_wrap_KeyEvent_GetPosition, METH_O, NULL},
53350 { (char *)"KeyEvent_GetPositionTuple", (PyCFunction)_wrap_KeyEvent_GetPositionTuple, METH_O, NULL},
53351 { (char *)"KeyEvent_GetX", (PyCFunction)_wrap_KeyEvent_GetX, METH_O, NULL},
53352 { (char *)"KeyEvent_GetY", (PyCFunction)_wrap_KeyEvent_GetY, METH_O, NULL},
53353 { (char *)"KeyEvent_m_x_set", _wrap_KeyEvent_m_x_set, METH_VARARGS, NULL},
53354 { (char *)"KeyEvent_m_x_get", (PyCFunction)_wrap_KeyEvent_m_x_get, METH_O, NULL},
53355 { (char *)"KeyEvent_m_y_set", _wrap_KeyEvent_m_y_set, METH_VARARGS, NULL},
53356 { (char *)"KeyEvent_m_y_get", (PyCFunction)_wrap_KeyEvent_m_y_get, METH_O, NULL},
53357 { (char *)"KeyEvent_m_keyCode_set", _wrap_KeyEvent_m_keyCode_set, METH_VARARGS, NULL},
53358 { (char *)"KeyEvent_m_keyCode_get", (PyCFunction)_wrap_KeyEvent_m_keyCode_get, METH_O, NULL},
53359 { (char *)"KeyEvent_m_controlDown_set", _wrap_KeyEvent_m_controlDown_set, METH_VARARGS, NULL},
53360 { (char *)"KeyEvent_m_controlDown_get", (PyCFunction)_wrap_KeyEvent_m_controlDown_get, METH_O, NULL},
53361 { (char *)"KeyEvent_m_shiftDown_set", _wrap_KeyEvent_m_shiftDown_set, METH_VARARGS, NULL},
53362 { (char *)"KeyEvent_m_shiftDown_get", (PyCFunction)_wrap_KeyEvent_m_shiftDown_get, METH_O, NULL},
53363 { (char *)"KeyEvent_m_altDown_set", _wrap_KeyEvent_m_altDown_set, METH_VARARGS, NULL},
53364 { (char *)"KeyEvent_m_altDown_get", (PyCFunction)_wrap_KeyEvent_m_altDown_get, METH_O, NULL},
53365 { (char *)"KeyEvent_m_metaDown_set", _wrap_KeyEvent_m_metaDown_set, METH_VARARGS, NULL},
53366 { (char *)"KeyEvent_m_metaDown_get", (PyCFunction)_wrap_KeyEvent_m_metaDown_get, METH_O, NULL},
53367 { (char *)"KeyEvent_m_scanCode_set", _wrap_KeyEvent_m_scanCode_set, METH_VARARGS, NULL},
53368 { (char *)"KeyEvent_m_scanCode_get", (PyCFunction)_wrap_KeyEvent_m_scanCode_get, METH_O, NULL},
53369 { (char *)"KeyEvent_m_rawCode_set", _wrap_KeyEvent_m_rawCode_set, METH_VARARGS, NULL},
53370 { (char *)"KeyEvent_m_rawCode_get", (PyCFunction)_wrap_KeyEvent_m_rawCode_get, METH_O, NULL},
53371 { (char *)"KeyEvent_m_rawFlags_set", _wrap_KeyEvent_m_rawFlags_set, METH_VARARGS, NULL},
53372 { (char *)"KeyEvent_m_rawFlags_get", (PyCFunction)_wrap_KeyEvent_m_rawFlags_get, METH_O, NULL},
53373 { (char *)"KeyEvent_swigregister", KeyEvent_swigregister, METH_VARARGS, NULL},
53374 { (char *)"KeyEvent_swiginit", KeyEvent_swiginit, METH_VARARGS, NULL},
53375 { (char *)"new_SizeEvent", (PyCFunction) _wrap_new_SizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53376 { (char *)"SizeEvent_GetSize", (PyCFunction)_wrap_SizeEvent_GetSize, METH_O, NULL},
53377 { (char *)"SizeEvent_GetRect", (PyCFunction)_wrap_SizeEvent_GetRect, METH_O, NULL},
53378 { (char *)"SizeEvent_SetRect", (PyCFunction) _wrap_SizeEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53379 { (char *)"SizeEvent_SetSize", (PyCFunction) _wrap_SizeEvent_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53380 { (char *)"SizeEvent_m_size_set", _wrap_SizeEvent_m_size_set, METH_VARARGS, NULL},
53381 { (char *)"SizeEvent_m_size_get", (PyCFunction)_wrap_SizeEvent_m_size_get, METH_O, NULL},
53382 { (char *)"SizeEvent_m_rect_set", _wrap_SizeEvent_m_rect_set, METH_VARARGS, NULL},
53383 { (char *)"SizeEvent_m_rect_get", (PyCFunction)_wrap_SizeEvent_m_rect_get, METH_O, NULL},
53384 { (char *)"SizeEvent_swigregister", SizeEvent_swigregister, METH_VARARGS, NULL},
53385 { (char *)"SizeEvent_swiginit", SizeEvent_swiginit, METH_VARARGS, NULL},
53386 { (char *)"new_MoveEvent", (PyCFunction) _wrap_new_MoveEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53387 { (char *)"MoveEvent_GetPosition", (PyCFunction)_wrap_MoveEvent_GetPosition, METH_O, NULL},
53388 { (char *)"MoveEvent_GetRect", (PyCFunction)_wrap_MoveEvent_GetRect, METH_O, NULL},
53389 { (char *)"MoveEvent_SetRect", (PyCFunction) _wrap_MoveEvent_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53390 { (char *)"MoveEvent_SetPosition", (PyCFunction) _wrap_MoveEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53391 { (char *)"MoveEvent_swigregister", MoveEvent_swigregister, METH_VARARGS, NULL},
53392 { (char *)"MoveEvent_swiginit", MoveEvent_swiginit, METH_VARARGS, NULL},
53393 { (char *)"new_PaintEvent", (PyCFunction) _wrap_new_PaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53394 { (char *)"PaintEvent_swigregister", PaintEvent_swigregister, METH_VARARGS, NULL},
53395 { (char *)"PaintEvent_swiginit", PaintEvent_swiginit, METH_VARARGS, NULL},
53396 { (char *)"new_NcPaintEvent", (PyCFunction) _wrap_new_NcPaintEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53397 { (char *)"NcPaintEvent_swigregister", NcPaintEvent_swigregister, METH_VARARGS, NULL},
53398 { (char *)"NcPaintEvent_swiginit", NcPaintEvent_swiginit, METH_VARARGS, NULL},
53399 { (char *)"new_EraseEvent", (PyCFunction) _wrap_new_EraseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53400 { (char *)"EraseEvent_GetDC", (PyCFunction)_wrap_EraseEvent_GetDC, METH_O, NULL},
53401 { (char *)"EraseEvent_swigregister", EraseEvent_swigregister, METH_VARARGS, NULL},
53402 { (char *)"EraseEvent_swiginit", EraseEvent_swiginit, METH_VARARGS, NULL},
53403 { (char *)"new_FocusEvent", (PyCFunction) _wrap_new_FocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53404 { (char *)"FocusEvent_GetWindow", (PyCFunction)_wrap_FocusEvent_GetWindow, METH_O, NULL},
53405 { (char *)"FocusEvent_SetWindow", (PyCFunction) _wrap_FocusEvent_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53406 { (char *)"FocusEvent_swigregister", FocusEvent_swigregister, METH_VARARGS, NULL},
53407 { (char *)"FocusEvent_swiginit", FocusEvent_swiginit, METH_VARARGS, NULL},
53408 { (char *)"new_ChildFocusEvent", (PyCFunction) _wrap_new_ChildFocusEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53409 { (char *)"ChildFocusEvent_GetWindow", (PyCFunction)_wrap_ChildFocusEvent_GetWindow, METH_O, NULL},
53410 { (char *)"ChildFocusEvent_swigregister", ChildFocusEvent_swigregister, METH_VARARGS, NULL},
53411 { (char *)"ChildFocusEvent_swiginit", ChildFocusEvent_swiginit, METH_VARARGS, NULL},
53412 { (char *)"new_ActivateEvent", (PyCFunction) _wrap_new_ActivateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53413 { (char *)"ActivateEvent_GetActive", (PyCFunction)_wrap_ActivateEvent_GetActive, METH_O, NULL},
53414 { (char *)"ActivateEvent_swigregister", ActivateEvent_swigregister, METH_VARARGS, NULL},
53415 { (char *)"ActivateEvent_swiginit", ActivateEvent_swiginit, METH_VARARGS, NULL},
53416 { (char *)"new_InitDialogEvent", (PyCFunction) _wrap_new_InitDialogEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53417 { (char *)"InitDialogEvent_swigregister", InitDialogEvent_swigregister, METH_VARARGS, NULL},
53418 { (char *)"InitDialogEvent_swiginit", InitDialogEvent_swiginit, METH_VARARGS, NULL},
53419 { (char *)"new_MenuEvent", (PyCFunction) _wrap_new_MenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53420 { (char *)"MenuEvent_GetMenuId", (PyCFunction)_wrap_MenuEvent_GetMenuId, METH_O, NULL},
53421 { (char *)"MenuEvent_IsPopup", (PyCFunction)_wrap_MenuEvent_IsPopup, METH_O, NULL},
53422 { (char *)"MenuEvent_GetMenu", (PyCFunction)_wrap_MenuEvent_GetMenu, METH_O, NULL},
53423 { (char *)"MenuEvent_swigregister", MenuEvent_swigregister, METH_VARARGS, NULL},
53424 { (char *)"MenuEvent_swiginit", MenuEvent_swiginit, METH_VARARGS, NULL},
53425 { (char *)"new_CloseEvent", (PyCFunction) _wrap_new_CloseEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53426 { (char *)"CloseEvent_SetLoggingOff", (PyCFunction) _wrap_CloseEvent_SetLoggingOff, METH_VARARGS | METH_KEYWORDS, NULL},
53427 { (char *)"CloseEvent_GetLoggingOff", (PyCFunction)_wrap_CloseEvent_GetLoggingOff, METH_O, NULL},
53428 { (char *)"CloseEvent_Veto", (PyCFunction) _wrap_CloseEvent_Veto, METH_VARARGS | METH_KEYWORDS, NULL},
53429 { (char *)"CloseEvent_GetVeto", (PyCFunction)_wrap_CloseEvent_GetVeto, METH_O, NULL},
53430 { (char *)"CloseEvent_SetCanVeto", (PyCFunction) _wrap_CloseEvent_SetCanVeto, METH_VARARGS | METH_KEYWORDS, NULL},
53431 { (char *)"CloseEvent_CanVeto", (PyCFunction)_wrap_CloseEvent_CanVeto, METH_O, NULL},
53432 { (char *)"CloseEvent_swigregister", CloseEvent_swigregister, METH_VARARGS, NULL},
53433 { (char *)"CloseEvent_swiginit", CloseEvent_swiginit, METH_VARARGS, NULL},
53434 { (char *)"new_ShowEvent", (PyCFunction) _wrap_new_ShowEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53435 { (char *)"ShowEvent_SetShow", (PyCFunction) _wrap_ShowEvent_SetShow, METH_VARARGS | METH_KEYWORDS, NULL},
53436 { (char *)"ShowEvent_GetShow", (PyCFunction)_wrap_ShowEvent_GetShow, METH_O, NULL},
53437 { (char *)"ShowEvent_swigregister", ShowEvent_swigregister, METH_VARARGS, NULL},
53438 { (char *)"ShowEvent_swiginit", ShowEvent_swiginit, METH_VARARGS, NULL},
53439 { (char *)"new_IconizeEvent", (PyCFunction) _wrap_new_IconizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53440 { (char *)"IconizeEvent_Iconized", (PyCFunction)_wrap_IconizeEvent_Iconized, METH_O, NULL},
53441 { (char *)"IconizeEvent_swigregister", IconizeEvent_swigregister, METH_VARARGS, NULL},
53442 { (char *)"IconizeEvent_swiginit", IconizeEvent_swiginit, METH_VARARGS, NULL},
53443 { (char *)"new_MaximizeEvent", (PyCFunction) _wrap_new_MaximizeEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53444 { (char *)"MaximizeEvent_swigregister", MaximizeEvent_swigregister, METH_VARARGS, NULL},
53445 { (char *)"MaximizeEvent_swiginit", MaximizeEvent_swiginit, METH_VARARGS, NULL},
53446 { (char *)"DropFilesEvent_GetPosition", (PyCFunction)_wrap_DropFilesEvent_GetPosition, METH_O, NULL},
53447 { (char *)"DropFilesEvent_GetNumberOfFiles", (PyCFunction)_wrap_DropFilesEvent_GetNumberOfFiles, METH_O, NULL},
53448 { (char *)"DropFilesEvent_GetFiles", (PyCFunction)_wrap_DropFilesEvent_GetFiles, METH_O, NULL},
53449 { (char *)"DropFilesEvent_swigregister", DropFilesEvent_swigregister, METH_VARARGS, NULL},
53450 { (char *)"new_UpdateUIEvent", (PyCFunction) _wrap_new_UpdateUIEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53451 { (char *)"UpdateUIEvent_GetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetChecked, METH_O, NULL},
53452 { (char *)"UpdateUIEvent_GetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetEnabled, METH_O, NULL},
53453 { (char *)"UpdateUIEvent_GetShown", (PyCFunction)_wrap_UpdateUIEvent_GetShown, METH_O, NULL},
53454 { (char *)"UpdateUIEvent_GetText", (PyCFunction)_wrap_UpdateUIEvent_GetText, METH_O, NULL},
53455 { (char *)"UpdateUIEvent_GetSetText", (PyCFunction)_wrap_UpdateUIEvent_GetSetText, METH_O, NULL},
53456 { (char *)"UpdateUIEvent_GetSetChecked", (PyCFunction)_wrap_UpdateUIEvent_GetSetChecked, METH_O, NULL},
53457 { (char *)"UpdateUIEvent_GetSetEnabled", (PyCFunction)_wrap_UpdateUIEvent_GetSetEnabled, METH_O, NULL},
53458 { (char *)"UpdateUIEvent_GetSetShown", (PyCFunction)_wrap_UpdateUIEvent_GetSetShown, METH_O, NULL},
53459 { (char *)"UpdateUIEvent_Check", (PyCFunction) _wrap_UpdateUIEvent_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53460 { (char *)"UpdateUIEvent_Enable", (PyCFunction) _wrap_UpdateUIEvent_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53461 { (char *)"UpdateUIEvent_Show", (PyCFunction) _wrap_UpdateUIEvent_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53462 { (char *)"UpdateUIEvent_SetText", (PyCFunction) _wrap_UpdateUIEvent_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53463 { (char *)"UpdateUIEvent_SetUpdateInterval", (PyCFunction) _wrap_UpdateUIEvent_SetUpdateInterval, METH_VARARGS | METH_KEYWORDS, NULL},
53464 { (char *)"UpdateUIEvent_GetUpdateInterval", (PyCFunction)_wrap_UpdateUIEvent_GetUpdateInterval, METH_NOARGS, NULL},
53465 { (char *)"UpdateUIEvent_CanUpdate", (PyCFunction) _wrap_UpdateUIEvent_CanUpdate, METH_VARARGS | METH_KEYWORDS, NULL},
53466 { (char *)"UpdateUIEvent_ResetUpdateTime", (PyCFunction)_wrap_UpdateUIEvent_ResetUpdateTime, METH_NOARGS, NULL},
53467 { (char *)"UpdateUIEvent_SetMode", (PyCFunction) _wrap_UpdateUIEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53468 { (char *)"UpdateUIEvent_GetMode", (PyCFunction)_wrap_UpdateUIEvent_GetMode, METH_NOARGS, NULL},
53469 { (char *)"UpdateUIEvent_swigregister", UpdateUIEvent_swigregister, METH_VARARGS, NULL},
53470 { (char *)"UpdateUIEvent_swiginit", UpdateUIEvent_swiginit, METH_VARARGS, NULL},
53471 { (char *)"new_SysColourChangedEvent", (PyCFunction)_wrap_new_SysColourChangedEvent, METH_NOARGS, NULL},
53472 { (char *)"SysColourChangedEvent_swigregister", SysColourChangedEvent_swigregister, METH_VARARGS, NULL},
53473 { (char *)"SysColourChangedEvent_swiginit", SysColourChangedEvent_swiginit, METH_VARARGS, NULL},
53474 { (char *)"new_MouseCaptureChangedEvent", (PyCFunction) _wrap_new_MouseCaptureChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53475 { (char *)"MouseCaptureChangedEvent_GetCapturedWindow", (PyCFunction)_wrap_MouseCaptureChangedEvent_GetCapturedWindow, METH_O, NULL},
53476 { (char *)"MouseCaptureChangedEvent_swigregister", MouseCaptureChangedEvent_swigregister, METH_VARARGS, NULL},
53477 { (char *)"MouseCaptureChangedEvent_swiginit", MouseCaptureChangedEvent_swiginit, METH_VARARGS, NULL},
53478 { (char *)"new_MouseCaptureLostEvent", (PyCFunction) _wrap_new_MouseCaptureLostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53479 { (char *)"MouseCaptureLostEvent_swigregister", MouseCaptureLostEvent_swigregister, METH_VARARGS, NULL},
53480 { (char *)"MouseCaptureLostEvent_swiginit", MouseCaptureLostEvent_swiginit, METH_VARARGS, NULL},
53481 { (char *)"new_DisplayChangedEvent", (PyCFunction)_wrap_new_DisplayChangedEvent, METH_NOARGS, NULL},
53482 { (char *)"DisplayChangedEvent_swigregister", DisplayChangedEvent_swigregister, METH_VARARGS, NULL},
53483 { (char *)"DisplayChangedEvent_swiginit", DisplayChangedEvent_swiginit, METH_VARARGS, NULL},
53484 { (char *)"new_PaletteChangedEvent", (PyCFunction) _wrap_new_PaletteChangedEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53485 { (char *)"PaletteChangedEvent_SetChangedWindow", (PyCFunction) _wrap_PaletteChangedEvent_SetChangedWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53486 { (char *)"PaletteChangedEvent_GetChangedWindow", (PyCFunction)_wrap_PaletteChangedEvent_GetChangedWindow, METH_O, NULL},
53487 { (char *)"PaletteChangedEvent_swigregister", PaletteChangedEvent_swigregister, METH_VARARGS, NULL},
53488 { (char *)"PaletteChangedEvent_swiginit", PaletteChangedEvent_swiginit, METH_VARARGS, NULL},
53489 { (char *)"new_QueryNewPaletteEvent", (PyCFunction) _wrap_new_QueryNewPaletteEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53490 { (char *)"QueryNewPaletteEvent_SetPaletteRealized", (PyCFunction) _wrap_QueryNewPaletteEvent_SetPaletteRealized, METH_VARARGS | METH_KEYWORDS, NULL},
53491 { (char *)"QueryNewPaletteEvent_GetPaletteRealized", (PyCFunction)_wrap_QueryNewPaletteEvent_GetPaletteRealized, METH_O, NULL},
53492 { (char *)"QueryNewPaletteEvent_swigregister", QueryNewPaletteEvent_swigregister, METH_VARARGS, NULL},
53493 { (char *)"QueryNewPaletteEvent_swiginit", QueryNewPaletteEvent_swiginit, METH_VARARGS, NULL},
53494 { (char *)"new_NavigationKeyEvent", (PyCFunction)_wrap_new_NavigationKeyEvent, METH_NOARGS, NULL},
53495 { (char *)"NavigationKeyEvent_GetDirection", (PyCFunction)_wrap_NavigationKeyEvent_GetDirection, METH_O, NULL},
53496 { (char *)"NavigationKeyEvent_SetDirection", (PyCFunction) _wrap_NavigationKeyEvent_SetDirection, METH_VARARGS | METH_KEYWORDS, NULL},
53497 { (char *)"NavigationKeyEvent_IsWindowChange", (PyCFunction)_wrap_NavigationKeyEvent_IsWindowChange, METH_O, NULL},
53498 { (char *)"NavigationKeyEvent_SetWindowChange", (PyCFunction) _wrap_NavigationKeyEvent_SetWindowChange, METH_VARARGS | METH_KEYWORDS, NULL},
53499 { (char *)"NavigationKeyEvent_IsFromTab", (PyCFunction)_wrap_NavigationKeyEvent_IsFromTab, METH_O, NULL},
53500 { (char *)"NavigationKeyEvent_SetFromTab", (PyCFunction) _wrap_NavigationKeyEvent_SetFromTab, METH_VARARGS | METH_KEYWORDS, NULL},
53501 { (char *)"NavigationKeyEvent_SetFlags", (PyCFunction) _wrap_NavigationKeyEvent_SetFlags, METH_VARARGS | METH_KEYWORDS, NULL},
53502 { (char *)"NavigationKeyEvent_GetCurrentFocus", (PyCFunction)_wrap_NavigationKeyEvent_GetCurrentFocus, METH_O, NULL},
53503 { (char *)"NavigationKeyEvent_SetCurrentFocus", (PyCFunction) _wrap_NavigationKeyEvent_SetCurrentFocus, METH_VARARGS | METH_KEYWORDS, NULL},
53504 { (char *)"NavigationKeyEvent_swigregister", NavigationKeyEvent_swigregister, METH_VARARGS, NULL},
53505 { (char *)"NavigationKeyEvent_swiginit", NavigationKeyEvent_swiginit, METH_VARARGS, NULL},
53506 { (char *)"new_WindowCreateEvent", (PyCFunction) _wrap_new_WindowCreateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53507 { (char *)"WindowCreateEvent_GetWindow", (PyCFunction)_wrap_WindowCreateEvent_GetWindow, METH_O, NULL},
53508 { (char *)"WindowCreateEvent_swigregister", WindowCreateEvent_swigregister, METH_VARARGS, NULL},
53509 { (char *)"WindowCreateEvent_swiginit", WindowCreateEvent_swiginit, METH_VARARGS, NULL},
53510 { (char *)"new_WindowDestroyEvent", (PyCFunction) _wrap_new_WindowDestroyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53511 { (char *)"WindowDestroyEvent_GetWindow", (PyCFunction)_wrap_WindowDestroyEvent_GetWindow, METH_O, NULL},
53512 { (char *)"WindowDestroyEvent_swigregister", WindowDestroyEvent_swigregister, METH_VARARGS, NULL},
53513 { (char *)"WindowDestroyEvent_swiginit", WindowDestroyEvent_swiginit, METH_VARARGS, NULL},
53514 { (char *)"new_ContextMenuEvent", (PyCFunction) _wrap_new_ContextMenuEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53515 { (char *)"ContextMenuEvent_GetPosition", (PyCFunction)_wrap_ContextMenuEvent_GetPosition, METH_O, NULL},
53516 { (char *)"ContextMenuEvent_SetPosition", (PyCFunction) _wrap_ContextMenuEvent_SetPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53517 { (char *)"ContextMenuEvent_swigregister", ContextMenuEvent_swigregister, METH_VARARGS, NULL},
53518 { (char *)"ContextMenuEvent_swiginit", ContextMenuEvent_swiginit, METH_VARARGS, NULL},
53519 { (char *)"new_IdleEvent", (PyCFunction)_wrap_new_IdleEvent, METH_NOARGS, NULL},
53520 { (char *)"IdleEvent_RequestMore", (PyCFunction) _wrap_IdleEvent_RequestMore, METH_VARARGS | METH_KEYWORDS, NULL},
53521 { (char *)"IdleEvent_MoreRequested", (PyCFunction)_wrap_IdleEvent_MoreRequested, METH_O, NULL},
53522 { (char *)"IdleEvent_SetMode", (PyCFunction) _wrap_IdleEvent_SetMode, METH_VARARGS | METH_KEYWORDS, NULL},
53523 { (char *)"IdleEvent_GetMode", (PyCFunction)_wrap_IdleEvent_GetMode, METH_NOARGS, NULL},
53524 { (char *)"IdleEvent_CanSend", (PyCFunction) _wrap_IdleEvent_CanSend, METH_VARARGS | METH_KEYWORDS, NULL},
53525 { (char *)"IdleEvent_swigregister", IdleEvent_swigregister, METH_VARARGS, NULL},
53526 { (char *)"IdleEvent_swiginit", IdleEvent_swiginit, METH_VARARGS, NULL},
53527 { (char *)"new_ClipboardTextEvent", (PyCFunction) _wrap_new_ClipboardTextEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53528 { (char *)"ClipboardTextEvent_swigregister", ClipboardTextEvent_swigregister, METH_VARARGS, NULL},
53529 { (char *)"ClipboardTextEvent_swiginit", ClipboardTextEvent_swiginit, METH_VARARGS, NULL},
53530 { (char *)"new_PyEvent", (PyCFunction) _wrap_new_PyEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53531 { (char *)"delete_PyEvent", (PyCFunction)_wrap_delete_PyEvent, METH_O, NULL},
53532 { (char *)"PyEvent__SetSelf", (PyCFunction) _wrap_PyEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53533 { (char *)"PyEvent__GetSelf", (PyCFunction)_wrap_PyEvent__GetSelf, METH_O, NULL},
53534 { (char *)"PyEvent_swigregister", PyEvent_swigregister, METH_VARARGS, NULL},
53535 { (char *)"PyEvent_swiginit", PyEvent_swiginit, METH_VARARGS, NULL},
53536 { (char *)"new_PyCommandEvent", (PyCFunction) _wrap_new_PyCommandEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53537 { (char *)"delete_PyCommandEvent", (PyCFunction)_wrap_delete_PyCommandEvent, METH_O, NULL},
53538 { (char *)"PyCommandEvent__SetSelf", (PyCFunction) _wrap_PyCommandEvent__SetSelf, METH_VARARGS | METH_KEYWORDS, NULL},
53539 { (char *)"PyCommandEvent__GetSelf", (PyCFunction)_wrap_PyCommandEvent__GetSelf, METH_O, NULL},
53540 { (char *)"PyCommandEvent_swigregister", PyCommandEvent_swigregister, METH_VARARGS, NULL},
53541 { (char *)"PyCommandEvent_swiginit", PyCommandEvent_swiginit, METH_VARARGS, NULL},
53542 { (char *)"new_DateEvent", (PyCFunction) _wrap_new_DateEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53543 { (char *)"DateEvent_GetDate", (PyCFunction)_wrap_DateEvent_GetDate, METH_O, NULL},
53544 { (char *)"DateEvent_SetDate", (PyCFunction) _wrap_DateEvent_SetDate, METH_VARARGS | METH_KEYWORDS, NULL},
53545 { (char *)"DateEvent_swigregister", DateEvent_swigregister, METH_VARARGS, NULL},
53546 { (char *)"DateEvent_swiginit", DateEvent_swiginit, METH_VARARGS, NULL},
53547 { (char *)"new_PyApp", (PyCFunction)_wrap_new_PyApp, METH_NOARGS, NULL},
53548 { (char *)"delete_PyApp", (PyCFunction)_wrap_delete_PyApp, METH_O, NULL},
53549 { (char *)"PyApp__setCallbackInfo", (PyCFunction) _wrap_PyApp__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53550 { (char *)"PyApp_GetAppName", (PyCFunction)_wrap_PyApp_GetAppName, METH_O, NULL},
53551 { (char *)"PyApp_SetAppName", (PyCFunction) _wrap_PyApp_SetAppName, METH_VARARGS | METH_KEYWORDS, NULL},
53552 { (char *)"PyApp_GetClassName", (PyCFunction)_wrap_PyApp_GetClassName, METH_O, NULL},
53553 { (char *)"PyApp_SetClassName", (PyCFunction) _wrap_PyApp_SetClassName, METH_VARARGS | METH_KEYWORDS, NULL},
53554 { (char *)"PyApp_GetVendorName", (PyCFunction)_wrap_PyApp_GetVendorName, METH_O, NULL},
53555 { (char *)"PyApp_SetVendorName", (PyCFunction) _wrap_PyApp_SetVendorName, METH_VARARGS | METH_KEYWORDS, NULL},
53556 { (char *)"PyApp_GetTraits", (PyCFunction)_wrap_PyApp_GetTraits, METH_O, NULL},
53557 { (char *)"PyApp_ProcessPendingEvents", (PyCFunction)_wrap_PyApp_ProcessPendingEvents, METH_O, NULL},
53558 { (char *)"PyApp_Yield", (PyCFunction) _wrap_PyApp_Yield, METH_VARARGS | METH_KEYWORDS, NULL},
53559 { (char *)"PyApp_WakeUpIdle", (PyCFunction)_wrap_PyApp_WakeUpIdle, METH_O, NULL},
53560 { (char *)"PyApp_IsMainLoopRunning", (PyCFunction)_wrap_PyApp_IsMainLoopRunning, METH_NOARGS, NULL},
53561 { (char *)"PyApp_MainLoop", (PyCFunction)_wrap_PyApp_MainLoop, METH_O, NULL},
53562 { (char *)"PyApp_Exit", (PyCFunction)_wrap_PyApp_Exit, METH_O, NULL},
53563 { (char *)"PyApp_ExitMainLoop", (PyCFunction)_wrap_PyApp_ExitMainLoop, METH_O, NULL},
53564 { (char *)"PyApp_Pending", (PyCFunction)_wrap_PyApp_Pending, METH_O, NULL},
53565 { (char *)"PyApp_Dispatch", (PyCFunction)_wrap_PyApp_Dispatch, METH_O, NULL},
53566 { (char *)"PyApp_ProcessIdle", (PyCFunction)_wrap_PyApp_ProcessIdle, METH_O, NULL},
53567 { (char *)"PyApp_SendIdleEvents", (PyCFunction) _wrap_PyApp_SendIdleEvents, METH_VARARGS | METH_KEYWORDS, NULL},
53568 { (char *)"PyApp_IsActive", (PyCFunction)_wrap_PyApp_IsActive, METH_O, NULL},
53569 { (char *)"PyApp_SetTopWindow", (PyCFunction) _wrap_PyApp_SetTopWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53570 { (char *)"PyApp_GetTopWindow", (PyCFunction)_wrap_PyApp_GetTopWindow, METH_O, NULL},
53571 { (char *)"PyApp_SetExitOnFrameDelete", (PyCFunction) _wrap_PyApp_SetExitOnFrameDelete, METH_VARARGS | METH_KEYWORDS, NULL},
53572 { (char *)"PyApp_GetExitOnFrameDelete", (PyCFunction)_wrap_PyApp_GetExitOnFrameDelete, METH_O, NULL},
53573 { (char *)"PyApp_SetUseBestVisual", (PyCFunction) _wrap_PyApp_SetUseBestVisual, METH_VARARGS | METH_KEYWORDS, NULL},
53574 { (char *)"PyApp_GetUseBestVisual", (PyCFunction)_wrap_PyApp_GetUseBestVisual, METH_O, NULL},
53575 { (char *)"PyApp_SetPrintMode", (PyCFunction) _wrap_PyApp_SetPrintMode, METH_VARARGS | METH_KEYWORDS, NULL},
53576 { (char *)"PyApp_GetPrintMode", (PyCFunction)_wrap_PyApp_GetPrintMode, METH_O, NULL},
53577 { (char *)"PyApp_SetAssertMode", (PyCFunction) _wrap_PyApp_SetAssertMode, METH_VARARGS | METH_KEYWORDS, NULL},
53578 { (char *)"PyApp_GetAssertMode", (PyCFunction)_wrap_PyApp_GetAssertMode, METH_O, NULL},
53579 { (char *)"PyApp_GetMacSupportPCMenuShortcuts", (PyCFunction)_wrap_PyApp_GetMacSupportPCMenuShortcuts, METH_NOARGS, NULL},
53580 { (char *)"PyApp_GetMacAboutMenuItemId", (PyCFunction)_wrap_PyApp_GetMacAboutMenuItemId, METH_NOARGS, NULL},
53581 { (char *)"PyApp_GetMacPreferencesMenuItemId", (PyCFunction)_wrap_PyApp_GetMacPreferencesMenuItemId, METH_NOARGS, NULL},
53582 { (char *)"PyApp_GetMacExitMenuItemId", (PyCFunction)_wrap_PyApp_GetMacExitMenuItemId, METH_NOARGS, NULL},
53583 { (char *)"PyApp_GetMacHelpMenuTitleName", (PyCFunction)_wrap_PyApp_GetMacHelpMenuTitleName, METH_NOARGS, NULL},
53584 { (char *)"PyApp_SetMacSupportPCMenuShortcuts", (PyCFunction) _wrap_PyApp_SetMacSupportPCMenuShortcuts, METH_VARARGS | METH_KEYWORDS, NULL},
53585 { (char *)"PyApp_SetMacAboutMenuItemId", (PyCFunction) _wrap_PyApp_SetMacAboutMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53586 { (char *)"PyApp_SetMacPreferencesMenuItemId", (PyCFunction) _wrap_PyApp_SetMacPreferencesMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53587 { (char *)"PyApp_SetMacExitMenuItemId", (PyCFunction) _wrap_PyApp_SetMacExitMenuItemId, METH_VARARGS | METH_KEYWORDS, NULL},
53588 { (char *)"PyApp_SetMacHelpMenuTitleName", (PyCFunction) _wrap_PyApp_SetMacHelpMenuTitleName, METH_VARARGS | METH_KEYWORDS, NULL},
53589 { (char *)"PyApp__BootstrapApp", (PyCFunction)_wrap_PyApp__BootstrapApp, METH_O, NULL},
53590 { (char *)"PyApp_GetComCtl32Version", (PyCFunction)_wrap_PyApp_GetComCtl32Version, METH_NOARGS, NULL},
53591 { (char *)"PyApp_swigregister", PyApp_swigregister, METH_VARARGS, NULL},
53592 { (char *)"PyApp_swiginit", PyApp_swiginit, METH_VARARGS, NULL},
53593 { (char *)"Exit", (PyCFunction)_wrap_Exit, METH_NOARGS, NULL},
53594 { (char *)"Yield", (PyCFunction)_wrap_Yield, METH_NOARGS, NULL},
53595 { (char *)"YieldIfNeeded", (PyCFunction)_wrap_YieldIfNeeded, METH_NOARGS, NULL},
53596 { (char *)"SafeYield", (PyCFunction) _wrap_SafeYield, METH_VARARGS | METH_KEYWORDS, NULL},
53597 { (char *)"WakeUpIdle", (PyCFunction)_wrap_WakeUpIdle, METH_NOARGS, NULL},
53598 { (char *)"PostEvent", (PyCFunction) _wrap_PostEvent, METH_VARARGS | METH_KEYWORDS, NULL},
53599 { (char *)"App_CleanUp", (PyCFunction)_wrap_App_CleanUp, METH_NOARGS, NULL},
53600 { (char *)"GetApp", (PyCFunction)_wrap_GetApp, METH_NOARGS, NULL},
53601 { (char *)"SetDefaultPyEncoding", (PyCFunction) _wrap_SetDefaultPyEncoding, METH_VARARGS | METH_KEYWORDS, NULL},
53602 { (char *)"GetDefaultPyEncoding", (PyCFunction)_wrap_GetDefaultPyEncoding, METH_NOARGS, NULL},
53603 { (char *)"new_EventLoop", (PyCFunction)_wrap_new_EventLoop, METH_NOARGS, NULL},
53604 { (char *)"delete_EventLoop", (PyCFunction)_wrap_delete_EventLoop, METH_O, NULL},
53605 { (char *)"EventLoop_Run", (PyCFunction)_wrap_EventLoop_Run, METH_O, NULL},
53606 { (char *)"EventLoop_Exit", (PyCFunction) _wrap_EventLoop_Exit, METH_VARARGS | METH_KEYWORDS, NULL},
53607 { (char *)"EventLoop_Pending", (PyCFunction)_wrap_EventLoop_Pending, METH_O, NULL},
53608 { (char *)"EventLoop_Dispatch", (PyCFunction)_wrap_EventLoop_Dispatch, METH_O, NULL},
53609 { (char *)"EventLoop_IsRunning", (PyCFunction)_wrap_EventLoop_IsRunning, METH_O, NULL},
53610 { (char *)"EventLoop_GetActive", (PyCFunction)_wrap_EventLoop_GetActive, METH_NOARGS, NULL},
53611 { (char *)"EventLoop_SetActive", (PyCFunction) _wrap_EventLoop_SetActive, METH_VARARGS | METH_KEYWORDS, NULL},
53612 { (char *)"EventLoop_swigregister", EventLoop_swigregister, METH_VARARGS, NULL},
53613 { (char *)"EventLoop_swiginit", EventLoop_swiginit, METH_VARARGS, NULL},
53614 { (char *)"new_EventLoopActivator", (PyCFunction) _wrap_new_EventLoopActivator, METH_VARARGS | METH_KEYWORDS, NULL},
53615 { (char *)"delete_EventLoopActivator", (PyCFunction)_wrap_delete_EventLoopActivator, METH_O, NULL},
53616 { (char *)"EventLoopActivator_swigregister", EventLoopActivator_swigregister, METH_VARARGS, NULL},
53617 { (char *)"EventLoopActivator_swiginit", EventLoopActivator_swiginit, METH_VARARGS, NULL},
53618 { (char *)"new_AcceleratorEntry", (PyCFunction) _wrap_new_AcceleratorEntry, METH_VARARGS | METH_KEYWORDS, NULL},
53619 { (char *)"delete_AcceleratorEntry", (PyCFunction)_wrap_delete_AcceleratorEntry, METH_O, NULL},
53620 { (char *)"AcceleratorEntry_Set", (PyCFunction) _wrap_AcceleratorEntry_Set, METH_VARARGS | METH_KEYWORDS, NULL},
53621 { (char *)"AcceleratorEntry_GetFlags", (PyCFunction)_wrap_AcceleratorEntry_GetFlags, METH_O, NULL},
53622 { (char *)"AcceleratorEntry_GetKeyCode", (PyCFunction)_wrap_AcceleratorEntry_GetKeyCode, METH_O, NULL},
53623 { (char *)"AcceleratorEntry_GetCommand", (PyCFunction)_wrap_AcceleratorEntry_GetCommand, METH_O, NULL},
53624 { (char *)"AcceleratorEntry_swigregister", AcceleratorEntry_swigregister, METH_VARARGS, NULL},
53625 { (char *)"AcceleratorEntry_swiginit", AcceleratorEntry_swiginit, METH_VARARGS, NULL},
53626 { (char *)"new_AcceleratorTable", (PyCFunction) _wrap_new_AcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53627 { (char *)"delete_AcceleratorTable", (PyCFunction)_wrap_delete_AcceleratorTable, METH_O, NULL},
53628 { (char *)"AcceleratorTable_Ok", (PyCFunction)_wrap_AcceleratorTable_Ok, METH_O, NULL},
53629 { (char *)"AcceleratorTable_swigregister", AcceleratorTable_swigregister, METH_VARARGS, NULL},
53630 { (char *)"AcceleratorTable_swiginit", AcceleratorTable_swiginit, METH_VARARGS, NULL},
53631 { (char *)"GetAccelFromString", (PyCFunction) _wrap_GetAccelFromString, METH_VARARGS | METH_KEYWORDS, NULL},
53632 { (char *)"new_VisualAttributes", (PyCFunction)_wrap_new_VisualAttributes, METH_NOARGS, NULL},
53633 { (char *)"delete_VisualAttributes", (PyCFunction)_wrap_delete_VisualAttributes, METH_O, NULL},
53634 { (char *)"VisualAttributes_font_set", _wrap_VisualAttributes_font_set, METH_VARARGS, NULL},
53635 { (char *)"VisualAttributes_font_get", (PyCFunction)_wrap_VisualAttributes_font_get, METH_O, NULL},
53636 { (char *)"VisualAttributes_colFg_set", _wrap_VisualAttributes_colFg_set, METH_VARARGS, NULL},
53637 { (char *)"VisualAttributes_colFg_get", (PyCFunction)_wrap_VisualAttributes_colFg_get, METH_O, NULL},
53638 { (char *)"VisualAttributes_colBg_set", _wrap_VisualAttributes_colBg_set, METH_VARARGS, NULL},
53639 { (char *)"VisualAttributes_colBg_get", (PyCFunction)_wrap_VisualAttributes_colBg_get, METH_O, NULL},
53640 { (char *)"VisualAttributes_swigregister", VisualAttributes_swigregister, METH_VARARGS, NULL},
53641 { (char *)"VisualAttributes_swiginit", VisualAttributes_swiginit, METH_VARARGS, NULL},
53642 { (char *)"new_Window", (PyCFunction) _wrap_new_Window, METH_VARARGS | METH_KEYWORDS, NULL},
53643 { (char *)"new_PreWindow", (PyCFunction)_wrap_new_PreWindow, METH_NOARGS, NULL},
53644 { (char *)"Window_Create", (PyCFunction) _wrap_Window_Create, METH_VARARGS | METH_KEYWORDS, NULL},
53645 { (char *)"Window_Close", (PyCFunction) _wrap_Window_Close, METH_VARARGS | METH_KEYWORDS, NULL},
53646 { (char *)"Window_Destroy", (PyCFunction)_wrap_Window_Destroy, METH_O, NULL},
53647 { (char *)"Window_DestroyChildren", (PyCFunction)_wrap_Window_DestroyChildren, METH_O, NULL},
53648 { (char *)"Window_IsBeingDeleted", (PyCFunction)_wrap_Window_IsBeingDeleted, METH_O, NULL},
53649 { (char *)"Window_SetLabel", (PyCFunction) _wrap_Window_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53650 { (char *)"Window_GetLabel", (PyCFunction)_wrap_Window_GetLabel, METH_O, NULL},
53651 { (char *)"Window_SetName", (PyCFunction) _wrap_Window_SetName, METH_VARARGS | METH_KEYWORDS, NULL},
53652 { (char *)"Window_GetName", (PyCFunction)_wrap_Window_GetName, METH_O, NULL},
53653 { (char *)"Window_SetWindowVariant", (PyCFunction) _wrap_Window_SetWindowVariant, METH_VARARGS | METH_KEYWORDS, NULL},
53654 { (char *)"Window_GetWindowVariant", (PyCFunction)_wrap_Window_GetWindowVariant, METH_O, NULL},
53655 { (char *)"Window_SetId", (PyCFunction) _wrap_Window_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53656 { (char *)"Window_GetId", (PyCFunction)_wrap_Window_GetId, METH_O, NULL},
53657 { (char *)"Window_NewControlId", (PyCFunction)_wrap_Window_NewControlId, METH_NOARGS, NULL},
53658 { (char *)"Window_NextControlId", (PyCFunction) _wrap_Window_NextControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53659 { (char *)"Window_PrevControlId", (PyCFunction) _wrap_Window_PrevControlId, METH_VARARGS | METH_KEYWORDS, NULL},
53660 { (char *)"Window_SetSize", (PyCFunction) _wrap_Window_SetSize, METH_VARARGS | METH_KEYWORDS, NULL},
53661 { (char *)"Window_SetDimensions", (PyCFunction) _wrap_Window_SetDimensions, METH_VARARGS | METH_KEYWORDS, NULL},
53662 { (char *)"Window_SetRect", (PyCFunction) _wrap_Window_SetRect, METH_VARARGS | METH_KEYWORDS, NULL},
53663 { (char *)"Window_SetSizeWH", (PyCFunction) _wrap_Window_SetSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53664 { (char *)"Window_Move", (PyCFunction) _wrap_Window_Move, METH_VARARGS | METH_KEYWORDS, NULL},
53665 { (char *)"Window_MoveXY", (PyCFunction) _wrap_Window_MoveXY, METH_VARARGS | METH_KEYWORDS, NULL},
53666 { (char *)"Window_SetBestFittingSize", (PyCFunction) _wrap_Window_SetBestFittingSize, METH_VARARGS | METH_KEYWORDS, NULL},
53667 { (char *)"Window_Raise", (PyCFunction)_wrap_Window_Raise, METH_O, NULL},
53668 { (char *)"Window_Lower", (PyCFunction)_wrap_Window_Lower, METH_O, NULL},
53669 { (char *)"Window_SetClientSize", (PyCFunction) _wrap_Window_SetClientSize, METH_VARARGS | METH_KEYWORDS, NULL},
53670 { (char *)"Window_SetClientSizeWH", (PyCFunction) _wrap_Window_SetClientSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53671 { (char *)"Window_SetClientRect", (PyCFunction) _wrap_Window_SetClientRect, METH_VARARGS | METH_KEYWORDS, NULL},
53672 { (char *)"Window_GetPosition", (PyCFunction)_wrap_Window_GetPosition, METH_O, NULL},
53673 { (char *)"Window_GetPositionTuple", (PyCFunction)_wrap_Window_GetPositionTuple, METH_O, NULL},
53674 { (char *)"Window_GetScreenPosition", (PyCFunction)_wrap_Window_GetScreenPosition, METH_O, NULL},
53675 { (char *)"Window_GetScreenPositionTuple", (PyCFunction)_wrap_Window_GetScreenPositionTuple, METH_O, NULL},
53676 { (char *)"Window_GetScreenRect", (PyCFunction)_wrap_Window_GetScreenRect, METH_O, NULL},
53677 { (char *)"Window_GetSize", (PyCFunction)_wrap_Window_GetSize, METH_O, NULL},
53678 { (char *)"Window_GetSizeTuple", (PyCFunction)_wrap_Window_GetSizeTuple, METH_O, NULL},
53679 { (char *)"Window_GetRect", (PyCFunction)_wrap_Window_GetRect, METH_O, NULL},
53680 { (char *)"Window_GetClientSize", (PyCFunction)_wrap_Window_GetClientSize, METH_O, NULL},
53681 { (char *)"Window_GetClientSizeTuple", (PyCFunction)_wrap_Window_GetClientSizeTuple, METH_O, NULL},
53682 { (char *)"Window_GetClientAreaOrigin", (PyCFunction)_wrap_Window_GetClientAreaOrigin, METH_O, NULL},
53683 { (char *)"Window_GetClientRect", (PyCFunction)_wrap_Window_GetClientRect, METH_O, NULL},
53684 { (char *)"Window_GetBestSize", (PyCFunction)_wrap_Window_GetBestSize, METH_O, NULL},
53685 { (char *)"Window_GetBestSizeTuple", (PyCFunction)_wrap_Window_GetBestSizeTuple, METH_O, NULL},
53686 { (char *)"Window_InvalidateBestSize", (PyCFunction)_wrap_Window_InvalidateBestSize, METH_O, NULL},
53687 { (char *)"Window_CacheBestSize", (PyCFunction) _wrap_Window_CacheBestSize, METH_VARARGS | METH_KEYWORDS, NULL},
53688 { (char *)"Window_GetBestFittingSize", (PyCFunction)_wrap_Window_GetBestFittingSize, METH_O, NULL},
53689 { (char *)"Window_GetAdjustedBestSize", (PyCFunction)_wrap_Window_GetAdjustedBestSize, METH_O, NULL},
53690 { (char *)"Window_Center", (PyCFunction) _wrap_Window_Center, METH_VARARGS | METH_KEYWORDS, NULL},
53691 { (char *)"Window_CenterOnParent", (PyCFunction) _wrap_Window_CenterOnParent, METH_VARARGS | METH_KEYWORDS, NULL},
53692 { (char *)"Window_Fit", (PyCFunction)_wrap_Window_Fit, METH_O, NULL},
53693 { (char *)"Window_FitInside", (PyCFunction)_wrap_Window_FitInside, METH_O, NULL},
53694 { (char *)"Window_SetSizeHints", (PyCFunction) _wrap_Window_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53695 { (char *)"Window_SetSizeHintsSz", (PyCFunction) _wrap_Window_SetSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53696 { (char *)"Window_SetVirtualSizeHints", (PyCFunction) _wrap_Window_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
53697 { (char *)"Window_SetVirtualSizeHintsSz", (PyCFunction) _wrap_Window_SetVirtualSizeHintsSz, METH_VARARGS | METH_KEYWORDS, NULL},
53698 { (char *)"Window_GetMaxSize", (PyCFunction)_wrap_Window_GetMaxSize, METH_O, NULL},
53699 { (char *)"Window_GetMinSize", (PyCFunction)_wrap_Window_GetMinSize, METH_O, NULL},
53700 { (char *)"Window_SetMinSize", (PyCFunction) _wrap_Window_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
53701 { (char *)"Window_SetMaxSize", (PyCFunction) _wrap_Window_SetMaxSize, METH_VARARGS | METH_KEYWORDS, NULL},
53702 { (char *)"Window_GetMinWidth", (PyCFunction)_wrap_Window_GetMinWidth, METH_O, NULL},
53703 { (char *)"Window_GetMinHeight", (PyCFunction)_wrap_Window_GetMinHeight, METH_O, NULL},
53704 { (char *)"Window_GetMaxWidth", (PyCFunction)_wrap_Window_GetMaxWidth, METH_O, NULL},
53705 { (char *)"Window_GetMaxHeight", (PyCFunction)_wrap_Window_GetMaxHeight, METH_O, NULL},
53706 { (char *)"Window_SetVirtualSize", (PyCFunction) _wrap_Window_SetVirtualSize, METH_VARARGS | METH_KEYWORDS, NULL},
53707 { (char *)"Window_SetVirtualSizeWH", (PyCFunction) _wrap_Window_SetVirtualSizeWH, METH_VARARGS | METH_KEYWORDS, NULL},
53708 { (char *)"Window_GetVirtualSize", (PyCFunction)_wrap_Window_GetVirtualSize, METH_O, NULL},
53709 { (char *)"Window_GetVirtualSizeTuple", (PyCFunction)_wrap_Window_GetVirtualSizeTuple, METH_O, NULL},
53710 { (char *)"Window_GetBestVirtualSize", (PyCFunction)_wrap_Window_GetBestVirtualSize, METH_O, NULL},
53711 { (char *)"Window_Show", (PyCFunction) _wrap_Window_Show, METH_VARARGS | METH_KEYWORDS, NULL},
53712 { (char *)"Window_Hide", (PyCFunction)_wrap_Window_Hide, METH_O, NULL},
53713 { (char *)"Window_Enable", (PyCFunction) _wrap_Window_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53714 { (char *)"Window_Disable", (PyCFunction)_wrap_Window_Disable, METH_O, NULL},
53715 { (char *)"Window_IsShown", (PyCFunction)_wrap_Window_IsShown, METH_O, NULL},
53716 { (char *)"Window_IsEnabled", (PyCFunction)_wrap_Window_IsEnabled, METH_O, NULL},
53717 { (char *)"Window_SetWindowStyleFlag", (PyCFunction) _wrap_Window_SetWindowStyleFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53718 { (char *)"Window_GetWindowStyleFlag", (PyCFunction)_wrap_Window_GetWindowStyleFlag, METH_O, NULL},
53719 { (char *)"Window_HasFlag", (PyCFunction) _wrap_Window_HasFlag, METH_VARARGS | METH_KEYWORDS, NULL},
53720 { (char *)"Window_IsRetained", (PyCFunction)_wrap_Window_IsRetained, METH_O, NULL},
53721 { (char *)"Window_SetExtraStyle", (PyCFunction) _wrap_Window_SetExtraStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53722 { (char *)"Window_GetExtraStyle", (PyCFunction)_wrap_Window_GetExtraStyle, METH_O, NULL},
53723 { (char *)"Window_MakeModal", (PyCFunction) _wrap_Window_MakeModal, METH_VARARGS | METH_KEYWORDS, NULL},
53724 { (char *)"Window_SetThemeEnabled", (PyCFunction) _wrap_Window_SetThemeEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53725 { (char *)"Window_GetThemeEnabled", (PyCFunction)_wrap_Window_GetThemeEnabled, METH_O, NULL},
53726 { (char *)"Window_SetFocus", (PyCFunction)_wrap_Window_SetFocus, METH_O, NULL},
53727 { (char *)"Window_SetFocusFromKbd", (PyCFunction)_wrap_Window_SetFocusFromKbd, METH_O, NULL},
53728 { (char *)"Window_FindFocus", (PyCFunction)_wrap_Window_FindFocus, METH_NOARGS, NULL},
53729 { (char *)"Window_AcceptsFocus", (PyCFunction)_wrap_Window_AcceptsFocus, METH_O, NULL},
53730 { (char *)"Window_AcceptsFocusFromKeyboard", (PyCFunction)_wrap_Window_AcceptsFocusFromKeyboard, METH_O, NULL},
53731 { (char *)"Window_Navigate", (PyCFunction) _wrap_Window_Navigate, METH_VARARGS | METH_KEYWORDS, NULL},
53732 { (char *)"Window_MoveAfterInTabOrder", (PyCFunction) _wrap_Window_MoveAfterInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53733 { (char *)"Window_MoveBeforeInTabOrder", (PyCFunction) _wrap_Window_MoveBeforeInTabOrder, METH_VARARGS | METH_KEYWORDS, NULL},
53734 { (char *)"Window_GetChildren", (PyCFunction)_wrap_Window_GetChildren, METH_O, NULL},
53735 { (char *)"Window_GetParent", (PyCFunction)_wrap_Window_GetParent, METH_O, NULL},
53736 { (char *)"Window_GetGrandParent", (PyCFunction)_wrap_Window_GetGrandParent, METH_O, NULL},
53737 { (char *)"Window_IsTopLevel", (PyCFunction)_wrap_Window_IsTopLevel, METH_O, NULL},
53738 { (char *)"Window_Reparent", (PyCFunction) _wrap_Window_Reparent, METH_VARARGS | METH_KEYWORDS, NULL},
53739 { (char *)"Window_AddChild", (PyCFunction) _wrap_Window_AddChild, METH_VARARGS | METH_KEYWORDS, NULL},
53740 { (char *)"Window_RemoveChild", (PyCFunction) _wrap_Window_RemoveChild, METH_VARARGS | METH_KEYWORDS, NULL},
53741 { (char *)"Window_SetDoubleBuffered", (PyCFunction) _wrap_Window_SetDoubleBuffered, METH_VARARGS | METH_KEYWORDS, NULL},
53742 { (char *)"Window_FindWindowById", (PyCFunction) _wrap_Window_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53743 { (char *)"Window_FindWindowByName", (PyCFunction) _wrap_Window_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53744 { (char *)"Window_GetEventHandler", (PyCFunction)_wrap_Window_GetEventHandler, METH_O, NULL},
53745 { (char *)"Window_SetEventHandler", (PyCFunction) _wrap_Window_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53746 { (char *)"Window_PushEventHandler", (PyCFunction) _wrap_Window_PushEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53747 { (char *)"Window_PopEventHandler", (PyCFunction) _wrap_Window_PopEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53748 { (char *)"Window_RemoveEventHandler", (PyCFunction) _wrap_Window_RemoveEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53749 { (char *)"Window_SetValidator", (PyCFunction) _wrap_Window_SetValidator, METH_VARARGS | METH_KEYWORDS, NULL},
53750 { (char *)"Window_GetValidator", (PyCFunction)_wrap_Window_GetValidator, METH_O, NULL},
53751 { (char *)"Window_Validate", (PyCFunction)_wrap_Window_Validate, METH_O, NULL},
53752 { (char *)"Window_TransferDataToWindow", (PyCFunction)_wrap_Window_TransferDataToWindow, METH_O, NULL},
53753 { (char *)"Window_TransferDataFromWindow", (PyCFunction)_wrap_Window_TransferDataFromWindow, METH_O, NULL},
53754 { (char *)"Window_InitDialog", (PyCFunction)_wrap_Window_InitDialog, METH_O, NULL},
53755 { (char *)"Window_SetAcceleratorTable", (PyCFunction) _wrap_Window_SetAcceleratorTable, METH_VARARGS | METH_KEYWORDS, NULL},
53756 { (char *)"Window_GetAcceleratorTable", (PyCFunction)_wrap_Window_GetAcceleratorTable, METH_O, NULL},
53757 { (char *)"Window_RegisterHotKey", (PyCFunction) _wrap_Window_RegisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53758 { (char *)"Window_UnregisterHotKey", (PyCFunction) _wrap_Window_UnregisterHotKey, METH_VARARGS | METH_KEYWORDS, NULL},
53759 { (char *)"Window_ConvertDialogPointToPixels", (PyCFunction) _wrap_Window_ConvertDialogPointToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53760 { (char *)"Window_ConvertDialogSizeToPixels", (PyCFunction) _wrap_Window_ConvertDialogSizeToPixels, METH_VARARGS | METH_KEYWORDS, NULL},
53761 { (char *)"Window_DLG_PNT", (PyCFunction) _wrap_Window_DLG_PNT, METH_VARARGS | METH_KEYWORDS, NULL},
53762 { (char *)"Window_DLG_SZE", (PyCFunction) _wrap_Window_DLG_SZE, METH_VARARGS | METH_KEYWORDS, NULL},
53763 { (char *)"Window_ConvertPixelPointToDialog", (PyCFunction) _wrap_Window_ConvertPixelPointToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53764 { (char *)"Window_ConvertPixelSizeToDialog", (PyCFunction) _wrap_Window_ConvertPixelSizeToDialog, METH_VARARGS | METH_KEYWORDS, NULL},
53765 { (char *)"Window_WarpPointer", (PyCFunction) _wrap_Window_WarpPointer, METH_VARARGS | METH_KEYWORDS, NULL},
53766 { (char *)"Window_CaptureMouse", (PyCFunction)_wrap_Window_CaptureMouse, METH_O, NULL},
53767 { (char *)"Window_ReleaseMouse", (PyCFunction)_wrap_Window_ReleaseMouse, METH_O, NULL},
53768 { (char *)"Window_GetCapture", (PyCFunction)_wrap_Window_GetCapture, METH_NOARGS, NULL},
53769 { (char *)"Window_HasCapture", (PyCFunction)_wrap_Window_HasCapture, METH_O, NULL},
53770 { (char *)"Window_Refresh", (PyCFunction) _wrap_Window_Refresh, METH_VARARGS | METH_KEYWORDS, NULL},
53771 { (char *)"Window_RefreshRect", (PyCFunction) _wrap_Window_RefreshRect, METH_VARARGS | METH_KEYWORDS, NULL},
53772 { (char *)"Window_Update", (PyCFunction)_wrap_Window_Update, METH_O, NULL},
53773 { (char *)"Window_ClearBackground", (PyCFunction)_wrap_Window_ClearBackground, METH_O, NULL},
53774 { (char *)"Window_Freeze", (PyCFunction)_wrap_Window_Freeze, METH_O, NULL},
53775 { (char *)"Window_Thaw", (PyCFunction)_wrap_Window_Thaw, METH_O, NULL},
53776 { (char *)"Window_PrepareDC", (PyCFunction) _wrap_Window_PrepareDC, METH_VARARGS | METH_KEYWORDS, NULL},
53777 { (char *)"Window_GetUpdateRegion", (PyCFunction)_wrap_Window_GetUpdateRegion, METH_O, NULL},
53778 { (char *)"Window_GetUpdateClientRect", (PyCFunction)_wrap_Window_GetUpdateClientRect, METH_O, NULL},
53779 { (char *)"Window_IsExposed", (PyCFunction) _wrap_Window_IsExposed, METH_VARARGS | METH_KEYWORDS, NULL},
53780 { (char *)"Window_IsExposedPoint", (PyCFunction) _wrap_Window_IsExposedPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53781 { (char *)"Window_IsExposedRect", (PyCFunction) _wrap_Window_IsExposedRect, METH_VARARGS | METH_KEYWORDS, NULL},
53782 { (char *)"Window_GetDefaultAttributes", (PyCFunction)_wrap_Window_GetDefaultAttributes, METH_O, NULL},
53783 { (char *)"Window_GetClassDefaultAttributes", (PyCFunction) _wrap_Window_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
53784 { (char *)"Window_SetBackgroundColour", (PyCFunction) _wrap_Window_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53785 { (char *)"Window_SetOwnBackgroundColour", (PyCFunction) _wrap_Window_SetOwnBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53786 { (char *)"Window_SetForegroundColour", (PyCFunction) _wrap_Window_SetForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53787 { (char *)"Window_SetOwnForegroundColour", (PyCFunction) _wrap_Window_SetOwnForegroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53788 { (char *)"Window_GetBackgroundColour", (PyCFunction)_wrap_Window_GetBackgroundColour, METH_O, NULL},
53789 { (char *)"Window_GetForegroundColour", (PyCFunction)_wrap_Window_GetForegroundColour, METH_O, NULL},
53790 { (char *)"Window_InheritsBackgroundColour", (PyCFunction)_wrap_Window_InheritsBackgroundColour, METH_O, NULL},
53791 { (char *)"Window_UseBgCol", (PyCFunction)_wrap_Window_UseBgCol, METH_O, NULL},
53792 { (char *)"Window_SetBackgroundStyle", (PyCFunction) _wrap_Window_SetBackgroundStyle, METH_VARARGS | METH_KEYWORDS, NULL},
53793 { (char *)"Window_GetBackgroundStyle", (PyCFunction)_wrap_Window_GetBackgroundStyle, METH_O, NULL},
53794 { (char *)"Window_HasTransparentBackground", (PyCFunction)_wrap_Window_HasTransparentBackground, METH_O, NULL},
53795 { (char *)"Window_SetCursor", (PyCFunction) _wrap_Window_SetCursor, METH_VARARGS | METH_KEYWORDS, NULL},
53796 { (char *)"Window_GetCursor", (PyCFunction)_wrap_Window_GetCursor, METH_O, NULL},
53797 { (char *)"Window_SetFont", (PyCFunction) _wrap_Window_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53798 { (char *)"Window_SetOwnFont", (PyCFunction) _wrap_Window_SetOwnFont, METH_VARARGS | METH_KEYWORDS, NULL},
53799 { (char *)"Window_GetFont", (PyCFunction)_wrap_Window_GetFont, METH_O, NULL},
53800 { (char *)"Window_SetCaret", (PyCFunction) _wrap_Window_SetCaret, METH_VARARGS | METH_KEYWORDS, NULL},
53801 { (char *)"Window_GetCaret", (PyCFunction)_wrap_Window_GetCaret, METH_O, NULL},
53802 { (char *)"Window_GetCharHeight", (PyCFunction)_wrap_Window_GetCharHeight, METH_O, NULL},
53803 { (char *)"Window_GetCharWidth", (PyCFunction)_wrap_Window_GetCharWidth, METH_O, NULL},
53804 { (char *)"Window_GetTextExtent", (PyCFunction) _wrap_Window_GetTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53805 { (char *)"Window_GetFullTextExtent", (PyCFunction) _wrap_Window_GetFullTextExtent, METH_VARARGS | METH_KEYWORDS, NULL},
53806 { (char *)"Window_ClientToScreenXY", (PyCFunction) _wrap_Window_ClientToScreenXY, METH_VARARGS | METH_KEYWORDS, NULL},
53807 { (char *)"Window_ScreenToClientXY", (PyCFunction) _wrap_Window_ScreenToClientXY, METH_VARARGS | METH_KEYWORDS, NULL},
53808 { (char *)"Window_ClientToScreen", (PyCFunction) _wrap_Window_ClientToScreen, METH_VARARGS | METH_KEYWORDS, NULL},
53809 { (char *)"Window_ScreenToClient", (PyCFunction) _wrap_Window_ScreenToClient, METH_VARARGS | METH_KEYWORDS, NULL},
53810 { (char *)"Window_HitTestXY", (PyCFunction) _wrap_Window_HitTestXY, METH_VARARGS | METH_KEYWORDS, NULL},
53811 { (char *)"Window_HitTest", (PyCFunction) _wrap_Window_HitTest, METH_VARARGS | METH_KEYWORDS, NULL},
53812 { (char *)"Window_GetBorder", _wrap_Window_GetBorder, METH_VARARGS, NULL},
53813 { (char *)"Window_UpdateWindowUI", (PyCFunction) _wrap_Window_UpdateWindowUI, METH_VARARGS | METH_KEYWORDS, NULL},
53814 { (char *)"Window_PopupMenuXY", (PyCFunction) _wrap_Window_PopupMenuXY, METH_VARARGS | METH_KEYWORDS, NULL},
53815 { (char *)"Window_PopupMenu", (PyCFunction) _wrap_Window_PopupMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53816 { (char *)"Window_HasMultiplePages", (PyCFunction)_wrap_Window_HasMultiplePages, METH_O, NULL},
53817 { (char *)"Window_GetHandle", (PyCFunction)_wrap_Window_GetHandle, METH_O, NULL},
53818 { (char *)"Window_AssociateHandle", (PyCFunction) _wrap_Window_AssociateHandle, METH_VARARGS | METH_KEYWORDS, NULL},
53819 { (char *)"Window_DissociateHandle", (PyCFunction)_wrap_Window_DissociateHandle, METH_O, NULL},
53820 { (char *)"Window_HasScrollbar", (PyCFunction) _wrap_Window_HasScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53821 { (char *)"Window_SetScrollbar", (PyCFunction) _wrap_Window_SetScrollbar, METH_VARARGS | METH_KEYWORDS, NULL},
53822 { (char *)"Window_SetScrollPos", (PyCFunction) _wrap_Window_SetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53823 { (char *)"Window_GetScrollPos", (PyCFunction) _wrap_Window_GetScrollPos, METH_VARARGS | METH_KEYWORDS, NULL},
53824 { (char *)"Window_GetScrollThumb", (PyCFunction) _wrap_Window_GetScrollThumb, METH_VARARGS | METH_KEYWORDS, NULL},
53825 { (char *)"Window_GetScrollRange", (PyCFunction) _wrap_Window_GetScrollRange, METH_VARARGS | METH_KEYWORDS, NULL},
53826 { (char *)"Window_ScrollWindow", (PyCFunction) _wrap_Window_ScrollWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53827 { (char *)"Window_ScrollLines", (PyCFunction) _wrap_Window_ScrollLines, METH_VARARGS | METH_KEYWORDS, NULL},
53828 { (char *)"Window_ScrollPages", (PyCFunction) _wrap_Window_ScrollPages, METH_VARARGS | METH_KEYWORDS, NULL},
53829 { (char *)"Window_LineUp", (PyCFunction)_wrap_Window_LineUp, METH_O, NULL},
53830 { (char *)"Window_LineDown", (PyCFunction)_wrap_Window_LineDown, METH_O, NULL},
53831 { (char *)"Window_PageUp", (PyCFunction)_wrap_Window_PageUp, METH_O, NULL},
53832 { (char *)"Window_PageDown", (PyCFunction)_wrap_Window_PageDown, METH_O, NULL},
53833 { (char *)"Window_SetHelpText", (PyCFunction) _wrap_Window_SetHelpText, METH_VARARGS | METH_KEYWORDS, NULL},
53834 { (char *)"Window_SetHelpTextForId", (PyCFunction) _wrap_Window_SetHelpTextForId, METH_VARARGS | METH_KEYWORDS, NULL},
53835 { (char *)"Window_GetHelpTextAtPoint", (PyCFunction) _wrap_Window_GetHelpTextAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
53836 { (char *)"Window_GetHelpText", (PyCFunction)_wrap_Window_GetHelpText, METH_O, NULL},
53837 { (char *)"Window_SetToolTipString", (PyCFunction) _wrap_Window_SetToolTipString, METH_VARARGS | METH_KEYWORDS, NULL},
53838 { (char *)"Window_SetToolTip", (PyCFunction) _wrap_Window_SetToolTip, METH_VARARGS | METH_KEYWORDS, NULL},
53839 { (char *)"Window_GetToolTip", (PyCFunction)_wrap_Window_GetToolTip, METH_O, NULL},
53840 { (char *)"Window_SetDropTarget", (PyCFunction) _wrap_Window_SetDropTarget, METH_VARARGS | METH_KEYWORDS, NULL},
53841 { (char *)"Window_GetDropTarget", (PyCFunction)_wrap_Window_GetDropTarget, METH_O, NULL},
53842 { (char *)"Window_DragAcceptFiles", (PyCFunction) _wrap_Window_DragAcceptFiles, METH_VARARGS | METH_KEYWORDS, NULL},
53843 { (char *)"Window_SetConstraints", (PyCFunction) _wrap_Window_SetConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
53844 { (char *)"Window_GetConstraints", (PyCFunction)_wrap_Window_GetConstraints, METH_O, NULL},
53845 { (char *)"Window_SetAutoLayout", (PyCFunction) _wrap_Window_SetAutoLayout, METH_VARARGS | METH_KEYWORDS, NULL},
53846 { (char *)"Window_GetAutoLayout", (PyCFunction)_wrap_Window_GetAutoLayout, METH_O, NULL},
53847 { (char *)"Window_Layout", (PyCFunction)_wrap_Window_Layout, METH_O, NULL},
53848 { (char *)"Window_SetSizer", (PyCFunction) _wrap_Window_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53849 { (char *)"Window_SetSizerAndFit", (PyCFunction) _wrap_Window_SetSizerAndFit, METH_VARARGS | METH_KEYWORDS, NULL},
53850 { (char *)"Window_GetSizer", (PyCFunction)_wrap_Window_GetSizer, METH_O, NULL},
53851 { (char *)"Window_SetContainingSizer", (PyCFunction) _wrap_Window_SetContainingSizer, METH_VARARGS | METH_KEYWORDS, NULL},
53852 { (char *)"Window_GetContainingSizer", (PyCFunction)_wrap_Window_GetContainingSizer, METH_O, NULL},
53853 { (char *)"Window_InheritAttributes", (PyCFunction)_wrap_Window_InheritAttributes, METH_O, NULL},
53854 { (char *)"Window_ShouldInheritColours", (PyCFunction)_wrap_Window_ShouldInheritColours, METH_O, NULL},
53855 { (char *)"Window_swigregister", Window_swigregister, METH_VARARGS, NULL},
53856 { (char *)"Window_swiginit", Window_swiginit, METH_VARARGS, NULL},
53857 { (char *)"FindWindowById", (PyCFunction) _wrap_FindWindowById, METH_VARARGS | METH_KEYWORDS, NULL},
53858 { (char *)"FindWindowByName", (PyCFunction) _wrap_FindWindowByName, METH_VARARGS | METH_KEYWORDS, NULL},
53859 { (char *)"FindWindowByLabel", (PyCFunction) _wrap_FindWindowByLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53860 { (char *)"Window_FromHWND", (PyCFunction) _wrap_Window_FromHWND, METH_VARARGS | METH_KEYWORDS, NULL},
53861 { (char *)"GetTopLevelWindows", (PyCFunction)_wrap_GetTopLevelWindows, METH_NOARGS, NULL},
53862 { (char *)"new_Validator", (PyCFunction)_wrap_new_Validator, METH_NOARGS, NULL},
53863 { (char *)"Validator_Clone", (PyCFunction)_wrap_Validator_Clone, METH_O, NULL},
53864 { (char *)"Validator_Validate", (PyCFunction) _wrap_Validator_Validate, METH_VARARGS | METH_KEYWORDS, NULL},
53865 { (char *)"Validator_TransferToWindow", (PyCFunction)_wrap_Validator_TransferToWindow, METH_O, NULL},
53866 { (char *)"Validator_TransferFromWindow", (PyCFunction)_wrap_Validator_TransferFromWindow, METH_O, NULL},
53867 { (char *)"Validator_GetWindow", (PyCFunction)_wrap_Validator_GetWindow, METH_O, NULL},
53868 { (char *)"Validator_SetWindow", (PyCFunction) _wrap_Validator_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53869 { (char *)"Validator_IsSilent", (PyCFunction)_wrap_Validator_IsSilent, METH_NOARGS, NULL},
53870 { (char *)"Validator_SetBellOnError", (PyCFunction) _wrap_Validator_SetBellOnError, METH_VARARGS | METH_KEYWORDS, NULL},
53871 { (char *)"Validator_swigregister", Validator_swigregister, METH_VARARGS, NULL},
53872 { (char *)"Validator_swiginit", Validator_swiginit, METH_VARARGS, NULL},
53873 { (char *)"new_PyValidator", (PyCFunction)_wrap_new_PyValidator, METH_NOARGS, NULL},
53874 { (char *)"PyValidator__setCallbackInfo", (PyCFunction) _wrap_PyValidator__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
53875 { (char *)"PyValidator_swigregister", PyValidator_swigregister, METH_VARARGS, NULL},
53876 { (char *)"PyValidator_swiginit", PyValidator_swiginit, METH_VARARGS, NULL},
53877 { (char *)"new_Menu", (PyCFunction) _wrap_new_Menu, METH_VARARGS | METH_KEYWORDS, NULL},
53878 { (char *)"Menu_Append", (PyCFunction) _wrap_Menu_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53879 { (char *)"Menu_AppendSeparator", (PyCFunction)_wrap_Menu_AppendSeparator, METH_O, NULL},
53880 { (char *)"Menu_AppendCheckItem", (PyCFunction) _wrap_Menu_AppendCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53881 { (char *)"Menu_AppendRadioItem", (PyCFunction) _wrap_Menu_AppendRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53882 { (char *)"Menu_AppendMenu", (PyCFunction) _wrap_Menu_AppendMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53883 { (char *)"Menu_AppendSubMenu", (PyCFunction) _wrap_Menu_AppendSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53884 { (char *)"Menu_AppendItem", (PyCFunction) _wrap_Menu_AppendItem, METH_VARARGS | METH_KEYWORDS, NULL},
53885 { (char *)"Menu_InsertItem", (PyCFunction) _wrap_Menu_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
53886 { (char *)"Menu_PrependItem", (PyCFunction) _wrap_Menu_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
53887 { (char *)"Menu_Break", (PyCFunction)_wrap_Menu_Break, METH_O, NULL},
53888 { (char *)"Menu_Insert", (PyCFunction) _wrap_Menu_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53889 { (char *)"Menu_InsertSeparator", (PyCFunction) _wrap_Menu_InsertSeparator, METH_VARARGS | METH_KEYWORDS, NULL},
53890 { (char *)"Menu_InsertCheckItem", (PyCFunction) _wrap_Menu_InsertCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53891 { (char *)"Menu_InsertRadioItem", (PyCFunction) _wrap_Menu_InsertRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53892 { (char *)"Menu_InsertMenu", (PyCFunction) _wrap_Menu_InsertMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53893 { (char *)"Menu_Prepend", (PyCFunction) _wrap_Menu_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
53894 { (char *)"Menu_PrependSeparator", (PyCFunction)_wrap_Menu_PrependSeparator, METH_O, NULL},
53895 { (char *)"Menu_PrependCheckItem", (PyCFunction) _wrap_Menu_PrependCheckItem, METH_VARARGS | METH_KEYWORDS, NULL},
53896 { (char *)"Menu_PrependRadioItem", (PyCFunction) _wrap_Menu_PrependRadioItem, METH_VARARGS | METH_KEYWORDS, NULL},
53897 { (char *)"Menu_PrependMenu", (PyCFunction) _wrap_Menu_PrependMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53898 { (char *)"Menu_Remove", (PyCFunction) _wrap_Menu_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53899 { (char *)"Menu_RemoveItem", (PyCFunction) _wrap_Menu_RemoveItem, METH_VARARGS | METH_KEYWORDS, NULL},
53900 { (char *)"Menu_Delete", (PyCFunction) _wrap_Menu_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
53901 { (char *)"Menu_DeleteItem", (PyCFunction) _wrap_Menu_DeleteItem, METH_VARARGS | METH_KEYWORDS, NULL},
53902 { (char *)"Menu_Destroy", (PyCFunction)_wrap_Menu_Destroy, METH_O, NULL},
53903 { (char *)"Menu_DestroyId", (PyCFunction) _wrap_Menu_DestroyId, METH_VARARGS | METH_KEYWORDS, NULL},
53904 { (char *)"Menu_DestroyItem", (PyCFunction) _wrap_Menu_DestroyItem, METH_VARARGS | METH_KEYWORDS, NULL},
53905 { (char *)"Menu_GetMenuItemCount", (PyCFunction)_wrap_Menu_GetMenuItemCount, METH_O, NULL},
53906 { (char *)"Menu_GetMenuItems", (PyCFunction)_wrap_Menu_GetMenuItems, METH_O, NULL},
53907 { (char *)"Menu_FindItem", (PyCFunction) _wrap_Menu_FindItem, METH_VARARGS | METH_KEYWORDS, NULL},
53908 { (char *)"Menu_FindItemById", (PyCFunction) _wrap_Menu_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53909 { (char *)"Menu_FindItemByPosition", (PyCFunction) _wrap_Menu_FindItemByPosition, METH_VARARGS | METH_KEYWORDS, NULL},
53910 { (char *)"Menu_Enable", (PyCFunction) _wrap_Menu_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53911 { (char *)"Menu_IsEnabled", (PyCFunction) _wrap_Menu_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53912 { (char *)"Menu_Check", (PyCFunction) _wrap_Menu_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53913 { (char *)"Menu_IsChecked", (PyCFunction) _wrap_Menu_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53914 { (char *)"Menu_SetLabel", (PyCFunction) _wrap_Menu_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53915 { (char *)"Menu_GetLabel", (PyCFunction) _wrap_Menu_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53916 { (char *)"Menu_SetHelpString", (PyCFunction) _wrap_Menu_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53917 { (char *)"Menu_GetHelpString", (PyCFunction) _wrap_Menu_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53918 { (char *)"Menu_SetTitle", (PyCFunction) _wrap_Menu_SetTitle, METH_VARARGS | METH_KEYWORDS, NULL},
53919 { (char *)"Menu_GetTitle", (PyCFunction)_wrap_Menu_GetTitle, METH_O, NULL},
53920 { (char *)"Menu_SetEventHandler", (PyCFunction) _wrap_Menu_SetEventHandler, METH_VARARGS | METH_KEYWORDS, NULL},
53921 { (char *)"Menu_GetEventHandler", (PyCFunction)_wrap_Menu_GetEventHandler, METH_O, NULL},
53922 { (char *)"Menu_SetInvokingWindow", (PyCFunction) _wrap_Menu_SetInvokingWindow, METH_VARARGS | METH_KEYWORDS, NULL},
53923 { (char *)"Menu_GetInvokingWindow", (PyCFunction)_wrap_Menu_GetInvokingWindow, METH_O, NULL},
53924 { (char *)"Menu_GetStyle", (PyCFunction)_wrap_Menu_GetStyle, METH_O, NULL},
53925 { (char *)"Menu_UpdateUI", (PyCFunction) _wrap_Menu_UpdateUI, METH_VARARGS | METH_KEYWORDS, NULL},
53926 { (char *)"Menu_GetMenuBar", (PyCFunction)_wrap_Menu_GetMenuBar, METH_O, NULL},
53927 { (char *)"Menu_Attach", (PyCFunction) _wrap_Menu_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53928 { (char *)"Menu_Detach", (PyCFunction)_wrap_Menu_Detach, METH_O, NULL},
53929 { (char *)"Menu_IsAttached", (PyCFunction)_wrap_Menu_IsAttached, METH_O, NULL},
53930 { (char *)"Menu_SetParent", (PyCFunction) _wrap_Menu_SetParent, METH_VARARGS | METH_KEYWORDS, NULL},
53931 { (char *)"Menu_GetParent", (PyCFunction)_wrap_Menu_GetParent, METH_O, NULL},
53932 { (char *)"Menu_swigregister", Menu_swigregister, METH_VARARGS, NULL},
53933 { (char *)"Menu_swiginit", Menu_swiginit, METH_VARARGS, NULL},
53934 { (char *)"new_MenuBar", (PyCFunction) _wrap_new_MenuBar, METH_VARARGS | METH_KEYWORDS, NULL},
53935 { (char *)"MenuBar_Append", (PyCFunction) _wrap_MenuBar_Append, METH_VARARGS | METH_KEYWORDS, NULL},
53936 { (char *)"MenuBar_Insert", (PyCFunction) _wrap_MenuBar_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
53937 { (char *)"MenuBar_GetMenuCount", (PyCFunction)_wrap_MenuBar_GetMenuCount, METH_O, NULL},
53938 { (char *)"MenuBar_GetMenu", (PyCFunction) _wrap_MenuBar_GetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53939 { (char *)"MenuBar_Replace", (PyCFunction) _wrap_MenuBar_Replace, METH_VARARGS | METH_KEYWORDS, NULL},
53940 { (char *)"MenuBar_Remove", (PyCFunction) _wrap_MenuBar_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
53941 { (char *)"MenuBar_EnableTop", (PyCFunction) _wrap_MenuBar_EnableTop, METH_VARARGS | METH_KEYWORDS, NULL},
53942 { (char *)"MenuBar_IsEnabledTop", (PyCFunction) _wrap_MenuBar_IsEnabledTop, METH_VARARGS | METH_KEYWORDS, NULL},
53943 { (char *)"MenuBar_SetLabelTop", (PyCFunction) _wrap_MenuBar_SetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53944 { (char *)"MenuBar_GetLabelTop", (PyCFunction) _wrap_MenuBar_GetLabelTop, METH_VARARGS | METH_KEYWORDS, NULL},
53945 { (char *)"MenuBar_FindMenuItem", (PyCFunction) _wrap_MenuBar_FindMenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53946 { (char *)"MenuBar_FindItemById", (PyCFunction) _wrap_MenuBar_FindItemById, METH_VARARGS | METH_KEYWORDS, NULL},
53947 { (char *)"MenuBar_FindMenu", (PyCFunction) _wrap_MenuBar_FindMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53948 { (char *)"MenuBar_Enable", (PyCFunction) _wrap_MenuBar_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53949 { (char *)"MenuBar_Check", (PyCFunction) _wrap_MenuBar_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53950 { (char *)"MenuBar_IsChecked", (PyCFunction) _wrap_MenuBar_IsChecked, METH_VARARGS | METH_KEYWORDS, NULL},
53951 { (char *)"MenuBar_IsEnabled", (PyCFunction) _wrap_MenuBar_IsEnabled, METH_VARARGS | METH_KEYWORDS, NULL},
53952 { (char *)"MenuBar_SetLabel", (PyCFunction) _wrap_MenuBar_SetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53953 { (char *)"MenuBar_GetLabel", (PyCFunction) _wrap_MenuBar_GetLabel, METH_VARARGS | METH_KEYWORDS, NULL},
53954 { (char *)"MenuBar_SetHelpString", (PyCFunction) _wrap_MenuBar_SetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53955 { (char *)"MenuBar_GetHelpString", (PyCFunction) _wrap_MenuBar_GetHelpString, METH_VARARGS | METH_KEYWORDS, NULL},
53956 { (char *)"MenuBar_GetFrame", (PyCFunction)_wrap_MenuBar_GetFrame, METH_O, NULL},
53957 { (char *)"MenuBar_IsAttached", (PyCFunction)_wrap_MenuBar_IsAttached, METH_O, NULL},
53958 { (char *)"MenuBar_Attach", (PyCFunction) _wrap_MenuBar_Attach, METH_VARARGS | METH_KEYWORDS, NULL},
53959 { (char *)"MenuBar_Detach", (PyCFunction)_wrap_MenuBar_Detach, METH_O, NULL},
53960 { (char *)"MenuBar_SetAutoWindowMenu", (PyCFunction) _wrap_MenuBar_SetAutoWindowMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53961 { (char *)"MenuBar_GetAutoWindowMenu", (PyCFunction)_wrap_MenuBar_GetAutoWindowMenu, METH_NOARGS, NULL},
53962 { (char *)"MenuBar_swigregister", MenuBar_swigregister, METH_VARARGS, NULL},
53963 { (char *)"MenuBar_swiginit", MenuBar_swiginit, METH_VARARGS, NULL},
53964 { (char *)"new_MenuItem", (PyCFunction) _wrap_new_MenuItem, METH_VARARGS | METH_KEYWORDS, NULL},
53965 { (char *)"delete_MenuItem", (PyCFunction)_wrap_delete_MenuItem, METH_O, NULL},
53966 { (char *)"MenuItem_GetMenu", (PyCFunction)_wrap_MenuItem_GetMenu, METH_O, NULL},
53967 { (char *)"MenuItem_SetMenu", (PyCFunction) _wrap_MenuItem_SetMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53968 { (char *)"MenuItem_SetId", (PyCFunction) _wrap_MenuItem_SetId, METH_VARARGS | METH_KEYWORDS, NULL},
53969 { (char *)"MenuItem_GetId", (PyCFunction)_wrap_MenuItem_GetId, METH_O, NULL},
53970 { (char *)"MenuItem_IsSeparator", (PyCFunction)_wrap_MenuItem_IsSeparator, METH_O, NULL},
53971 { (char *)"MenuItem_SetText", (PyCFunction) _wrap_MenuItem_SetText, METH_VARARGS | METH_KEYWORDS, NULL},
53972 { (char *)"MenuItem_GetLabel", (PyCFunction)_wrap_MenuItem_GetLabel, METH_O, NULL},
53973 { (char *)"MenuItem_GetText", (PyCFunction)_wrap_MenuItem_GetText, METH_O, NULL},
53974 { (char *)"MenuItem_GetLabelFromText", (PyCFunction) _wrap_MenuItem_GetLabelFromText, METH_VARARGS | METH_KEYWORDS, NULL},
53975 { (char *)"MenuItem_GetKind", (PyCFunction)_wrap_MenuItem_GetKind, METH_O, NULL},
53976 { (char *)"MenuItem_SetKind", (PyCFunction) _wrap_MenuItem_SetKind, METH_VARARGS | METH_KEYWORDS, NULL},
53977 { (char *)"MenuItem_SetCheckable", (PyCFunction) _wrap_MenuItem_SetCheckable, METH_VARARGS | METH_KEYWORDS, NULL},
53978 { (char *)"MenuItem_IsCheckable", (PyCFunction)_wrap_MenuItem_IsCheckable, METH_O, NULL},
53979 { (char *)"MenuItem_IsSubMenu", (PyCFunction)_wrap_MenuItem_IsSubMenu, METH_O, NULL},
53980 { (char *)"MenuItem_SetSubMenu", (PyCFunction) _wrap_MenuItem_SetSubMenu, METH_VARARGS | METH_KEYWORDS, NULL},
53981 { (char *)"MenuItem_GetSubMenu", (PyCFunction)_wrap_MenuItem_GetSubMenu, METH_O, NULL},
53982 { (char *)"MenuItem_Enable", (PyCFunction) _wrap_MenuItem_Enable, METH_VARARGS | METH_KEYWORDS, NULL},
53983 { (char *)"MenuItem_IsEnabled", (PyCFunction)_wrap_MenuItem_IsEnabled, METH_O, NULL},
53984 { (char *)"MenuItem_Check", (PyCFunction) _wrap_MenuItem_Check, METH_VARARGS | METH_KEYWORDS, NULL},
53985 { (char *)"MenuItem_IsChecked", (PyCFunction)_wrap_MenuItem_IsChecked, METH_O, NULL},
53986 { (char *)"MenuItem_Toggle", (PyCFunction)_wrap_MenuItem_Toggle, METH_O, NULL},
53987 { (char *)"MenuItem_SetHelp", (PyCFunction) _wrap_MenuItem_SetHelp, METH_VARARGS | METH_KEYWORDS, NULL},
53988 { (char *)"MenuItem_GetHelp", (PyCFunction)_wrap_MenuItem_GetHelp, METH_O, NULL},
53989 { (char *)"MenuItem_GetAccel", (PyCFunction)_wrap_MenuItem_GetAccel, METH_O, NULL},
53990 { (char *)"MenuItem_SetAccel", (PyCFunction) _wrap_MenuItem_SetAccel, METH_VARARGS | METH_KEYWORDS, NULL},
53991 { (char *)"MenuItem_SetBitmap", (PyCFunction) _wrap_MenuItem_SetBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
53992 { (char *)"MenuItem_GetBitmap", (PyCFunction)_wrap_MenuItem_GetBitmap, METH_O, NULL},
53993 { (char *)"MenuItem_SetFont", (PyCFunction) _wrap_MenuItem_SetFont, METH_VARARGS | METH_KEYWORDS, NULL},
53994 { (char *)"MenuItem_GetFont", (PyCFunction)_wrap_MenuItem_GetFont, METH_O, NULL},
53995 { (char *)"MenuItem_SetTextColour", (PyCFunction) _wrap_MenuItem_SetTextColour, METH_VARARGS | METH_KEYWORDS, NULL},
53996 { (char *)"MenuItem_GetTextColour", (PyCFunction)_wrap_MenuItem_GetTextColour, METH_O, NULL},
53997 { (char *)"MenuItem_SetBackgroundColour", (PyCFunction) _wrap_MenuItem_SetBackgroundColour, METH_VARARGS | METH_KEYWORDS, NULL},
53998 { (char *)"MenuItem_GetBackgroundColour", (PyCFunction)_wrap_MenuItem_GetBackgroundColour, METH_O, NULL},
53999 { (char *)"MenuItem_SetBitmaps", (PyCFunction) _wrap_MenuItem_SetBitmaps, METH_VARARGS | METH_KEYWORDS, NULL},
54000 { (char *)"MenuItem_SetDisabledBitmap", (PyCFunction) _wrap_MenuItem_SetDisabledBitmap, METH_VARARGS | METH_KEYWORDS, NULL},
54001 { (char *)"MenuItem_GetDisabledBitmap", (PyCFunction)_wrap_MenuItem_GetDisabledBitmap, METH_O, NULL},
54002 { (char *)"MenuItem_SetMarginWidth", (PyCFunction) _wrap_MenuItem_SetMarginWidth, METH_VARARGS | METH_KEYWORDS, NULL},
54003 { (char *)"MenuItem_GetMarginWidth", (PyCFunction)_wrap_MenuItem_GetMarginWidth, METH_O, NULL},
54004 { (char *)"MenuItem_GetDefaultMarginWidth", (PyCFunction)_wrap_MenuItem_GetDefaultMarginWidth, METH_NOARGS, NULL},
54005 { (char *)"MenuItem_IsOwnerDrawn", (PyCFunction)_wrap_MenuItem_IsOwnerDrawn, METH_O, NULL},
54006 { (char *)"MenuItem_SetOwnerDrawn", (PyCFunction) _wrap_MenuItem_SetOwnerDrawn, METH_VARARGS | METH_KEYWORDS, NULL},
54007 { (char *)"MenuItem_ResetOwnerDrawn", (PyCFunction)_wrap_MenuItem_ResetOwnerDrawn, METH_O, NULL},
54008 { (char *)"MenuItem_swigregister", MenuItem_swigregister, METH_VARARGS, NULL},
54009 { (char *)"MenuItem_swiginit", MenuItem_swiginit, METH_VARARGS, NULL},
54010 { (char *)"new_Control", (PyCFunction) _wrap_new_Control, METH_VARARGS | METH_KEYWORDS, NULL},
54011 { (char *)"new_PreControl", (PyCFunction)_wrap_new_PreControl, METH_NOARGS, NULL},
54012 { (char *)"Control_Create", (PyCFunction) _wrap_Control_Create, METH_VARARGS | METH_KEYWORDS, NULL},
54013 { (char *)"Control_GetAlignment", (PyCFunction)_wrap_Control_GetAlignment, METH_O, NULL},
54014 { (char *)"Control_GetLabelText", (PyCFunction)_wrap_Control_GetLabelText, METH_O, NULL},
54015 { (char *)"Control_Command", (PyCFunction) _wrap_Control_Command, METH_VARARGS | METH_KEYWORDS, NULL},
54016 { (char *)"Control_GetLabel", (PyCFunction)_wrap_Control_GetLabel, METH_O, NULL},
54017 { (char *)"Control_GetClassDefaultAttributes", (PyCFunction) _wrap_Control_GetClassDefaultAttributes, METH_VARARGS | METH_KEYWORDS, NULL},
54018 { (char *)"Control_swigregister", Control_swigregister, METH_VARARGS, NULL},
54019 { (char *)"Control_swiginit", Control_swiginit, METH_VARARGS, NULL},
54020 { (char *)"ItemContainer_Append", (PyCFunction) _wrap_ItemContainer_Append, METH_VARARGS | METH_KEYWORDS, NULL},
54021 { (char *)"ItemContainer_AppendItems", (PyCFunction) _wrap_ItemContainer_AppendItems, METH_VARARGS | METH_KEYWORDS, NULL},
54022 { (char *)"ItemContainer_Insert", (PyCFunction) _wrap_ItemContainer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54023 { (char *)"ItemContainer_Clear", (PyCFunction)_wrap_ItemContainer_Clear, METH_O, NULL},
54024 { (char *)"ItemContainer_Delete", (PyCFunction) _wrap_ItemContainer_Delete, METH_VARARGS | METH_KEYWORDS, NULL},
54025 { (char *)"ItemContainer_GetClientData", (PyCFunction) _wrap_ItemContainer_GetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54026 { (char *)"ItemContainer_SetClientData", (PyCFunction) _wrap_ItemContainer_SetClientData, METH_VARARGS | METH_KEYWORDS, NULL},
54027 { (char *)"ItemContainer_GetCount", (PyCFunction)_wrap_ItemContainer_GetCount, METH_O, NULL},
54028 { (char *)"ItemContainer_IsEmpty", (PyCFunction)_wrap_ItemContainer_IsEmpty, METH_O, NULL},
54029 { (char *)"ItemContainer_GetString", (PyCFunction) _wrap_ItemContainer_GetString, METH_VARARGS | METH_KEYWORDS, NULL},
54030 { (char *)"ItemContainer_GetStrings", (PyCFunction)_wrap_ItemContainer_GetStrings, METH_O, NULL},
54031 { (char *)"ItemContainer_SetString", (PyCFunction) _wrap_ItemContainer_SetString, METH_VARARGS | METH_KEYWORDS, NULL},
54032 { (char *)"ItemContainer_FindString", (PyCFunction) _wrap_ItemContainer_FindString, METH_VARARGS | METH_KEYWORDS, NULL},
54033 { (char *)"ItemContainer_SetSelection", (PyCFunction) _wrap_ItemContainer_SetSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54034 { (char *)"ItemContainer_GetSelection", (PyCFunction)_wrap_ItemContainer_GetSelection, METH_O, NULL},
54035 { (char *)"ItemContainer_SetStringSelection", (PyCFunction) _wrap_ItemContainer_SetStringSelection, METH_VARARGS | METH_KEYWORDS, NULL},
54036 { (char *)"ItemContainer_GetStringSelection", (PyCFunction)_wrap_ItemContainer_GetStringSelection, METH_O, NULL},
54037 { (char *)"ItemContainer_Select", (PyCFunction) _wrap_ItemContainer_Select, METH_VARARGS | METH_KEYWORDS, NULL},
54038 { (char *)"ItemContainer_swigregister", ItemContainer_swigregister, METH_VARARGS, NULL},
54039 { (char *)"ControlWithItems_swigregister", ControlWithItems_swigregister, METH_VARARGS, NULL},
54040 { (char *)"new_SizerItem", (PyCFunction)_wrap_new_SizerItem, METH_NOARGS, NULL},
54041 { (char *)"delete_SizerItem", (PyCFunction)_wrap_delete_SizerItem, METH_O, NULL},
54042 { (char *)"new_SizerItemWindow", (PyCFunction) _wrap_new_SizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54043 { (char *)"new_SizerItemSpacer", (PyCFunction) _wrap_new_SizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54044 { (char *)"new_SizerItemSizer", (PyCFunction) _wrap_new_SizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54045 { (char *)"SizerItem_DeleteWindows", (PyCFunction)_wrap_SizerItem_DeleteWindows, METH_O, NULL},
54046 { (char *)"SizerItem_DetachSizer", (PyCFunction)_wrap_SizerItem_DetachSizer, METH_O, NULL},
54047 { (char *)"SizerItem_GetSize", (PyCFunction)_wrap_SizerItem_GetSize, METH_O, NULL},
54048 { (char *)"SizerItem_CalcMin", (PyCFunction)_wrap_SizerItem_CalcMin, METH_O, NULL},
54049 { (char *)"SizerItem_SetDimension", (PyCFunction) _wrap_SizerItem_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54050 { (char *)"SizerItem_GetMinSize", (PyCFunction)_wrap_SizerItem_GetMinSize, METH_O, NULL},
54051 { (char *)"SizerItem_GetMinSizeWithBorder", (PyCFunction)_wrap_SizerItem_GetMinSizeWithBorder, METH_O, NULL},
54052 { (char *)"SizerItem_SetInitSize", (PyCFunction) _wrap_SizerItem_SetInitSize, METH_VARARGS | METH_KEYWORDS, NULL},
54053 { (char *)"SizerItem_SetRatioWH", (PyCFunction) _wrap_SizerItem_SetRatioWH, METH_VARARGS | METH_KEYWORDS, NULL},
54054 { (char *)"SizerItem_SetRatioSize", (PyCFunction) _wrap_SizerItem_SetRatioSize, METH_VARARGS | METH_KEYWORDS, NULL},
54055 { (char *)"SizerItem_SetRatio", (PyCFunction) _wrap_SizerItem_SetRatio, METH_VARARGS | METH_KEYWORDS, NULL},
54056 { (char *)"SizerItem_GetRatio", (PyCFunction)_wrap_SizerItem_GetRatio, METH_O, NULL},
54057 { (char *)"SizerItem_GetRect", (PyCFunction)_wrap_SizerItem_GetRect, METH_O, NULL},
54058 { (char *)"SizerItem_IsWindow", (PyCFunction)_wrap_SizerItem_IsWindow, METH_O, NULL},
54059 { (char *)"SizerItem_IsSizer", (PyCFunction)_wrap_SizerItem_IsSizer, METH_O, NULL},
54060 { (char *)"SizerItem_IsSpacer", (PyCFunction)_wrap_SizerItem_IsSpacer, METH_O, NULL},
54061 { (char *)"SizerItem_SetProportion", (PyCFunction) _wrap_SizerItem_SetProportion, METH_VARARGS | METH_KEYWORDS, NULL},
54062 { (char *)"SizerItem_GetProportion", (PyCFunction)_wrap_SizerItem_GetProportion, METH_O, NULL},
54063 { (char *)"SizerItem_SetFlag", (PyCFunction) _wrap_SizerItem_SetFlag, METH_VARARGS | METH_KEYWORDS, NULL},
54064 { (char *)"SizerItem_GetFlag", (PyCFunction)_wrap_SizerItem_GetFlag, METH_O, NULL},
54065 { (char *)"SizerItem_SetBorder", (PyCFunction) _wrap_SizerItem_SetBorder, METH_VARARGS | METH_KEYWORDS, NULL},
54066 { (char *)"SizerItem_GetBorder", (PyCFunction)_wrap_SizerItem_GetBorder, METH_O, NULL},
54067 { (char *)"SizerItem_GetWindow", (PyCFunction)_wrap_SizerItem_GetWindow, METH_O, NULL},
54068 { (char *)"SizerItem_SetWindow", (PyCFunction) _wrap_SizerItem_SetWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54069 { (char *)"SizerItem_GetSizer", (PyCFunction)_wrap_SizerItem_GetSizer, METH_O, NULL},
54070 { (char *)"SizerItem_SetSizer", (PyCFunction) _wrap_SizerItem_SetSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54071 { (char *)"SizerItem_GetSpacer", (PyCFunction)_wrap_SizerItem_GetSpacer, METH_O, NULL},
54072 { (char *)"SizerItem_SetSpacer", (PyCFunction) _wrap_SizerItem_SetSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54073 { (char *)"SizerItem_Show", (PyCFunction) _wrap_SizerItem_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54074 { (char *)"SizerItem_IsShown", (PyCFunction)_wrap_SizerItem_IsShown, METH_O, NULL},
54075 { (char *)"SizerItem_GetPosition", (PyCFunction)_wrap_SizerItem_GetPosition, METH_O, NULL},
54076 { (char *)"SizerItem_GetUserData", (PyCFunction)_wrap_SizerItem_GetUserData, METH_O, NULL},
54077 { (char *)"SizerItem_SetUserData", (PyCFunction) _wrap_SizerItem_SetUserData, METH_VARARGS | METH_KEYWORDS, NULL},
54078 { (char *)"SizerItem_swigregister", SizerItem_swigregister, METH_VARARGS, NULL},
54079 { (char *)"SizerItem_swiginit", SizerItem_swiginit, METH_VARARGS, NULL},
54080 { (char *)"delete_Sizer", (PyCFunction)_wrap_delete_Sizer, METH_O, NULL},
54081 { (char *)"Sizer__setOORInfo", (PyCFunction) _wrap_Sizer__setOORInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54082 { (char *)"Sizer_Add", (PyCFunction) _wrap_Sizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54083 { (char *)"Sizer_Insert", (PyCFunction) _wrap_Sizer_Insert, METH_VARARGS | METH_KEYWORDS, NULL},
54084 { (char *)"Sizer_Prepend", (PyCFunction) _wrap_Sizer_Prepend, METH_VARARGS | METH_KEYWORDS, NULL},
54085 { (char *)"Sizer_Remove", (PyCFunction) _wrap_Sizer_Remove, METH_VARARGS | METH_KEYWORDS, NULL},
54086 { (char *)"Sizer_Detach", (PyCFunction) _wrap_Sizer_Detach, METH_VARARGS | METH_KEYWORDS, NULL},
54087 { (char *)"Sizer_GetItem", (PyCFunction) _wrap_Sizer_GetItem, METH_VARARGS | METH_KEYWORDS, NULL},
54088 { (char *)"Sizer__SetItemMinSize", (PyCFunction) _wrap_Sizer__SetItemMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54089 { (char *)"Sizer_AddItem", (PyCFunction) _wrap_Sizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54090 { (char *)"Sizer_InsertItem", (PyCFunction) _wrap_Sizer_InsertItem, METH_VARARGS | METH_KEYWORDS, NULL},
54091 { (char *)"Sizer_PrependItem", (PyCFunction) _wrap_Sizer_PrependItem, METH_VARARGS | METH_KEYWORDS, NULL},
54092 { (char *)"Sizer_SetDimension", (PyCFunction) _wrap_Sizer_SetDimension, METH_VARARGS | METH_KEYWORDS, NULL},
54093 { (char *)"Sizer_SetMinSize", (PyCFunction) _wrap_Sizer_SetMinSize, METH_VARARGS | METH_KEYWORDS, NULL},
54094 { (char *)"Sizer_GetSize", (PyCFunction)_wrap_Sizer_GetSize, METH_O, NULL},
54095 { (char *)"Sizer_GetPosition", (PyCFunction)_wrap_Sizer_GetPosition, METH_O, NULL},
54096 { (char *)"Sizer_GetMinSize", (PyCFunction)_wrap_Sizer_GetMinSize, METH_O, NULL},
54097 { (char *)"Sizer_RecalcSizes", (PyCFunction)_wrap_Sizer_RecalcSizes, METH_O, NULL},
54098 { (char *)"Sizer_CalcMin", (PyCFunction)_wrap_Sizer_CalcMin, METH_O, NULL},
54099 { (char *)"Sizer_Layout", (PyCFunction)_wrap_Sizer_Layout, METH_O, NULL},
54100 { (char *)"Sizer_Fit", (PyCFunction) _wrap_Sizer_Fit, METH_VARARGS | METH_KEYWORDS, NULL},
54101 { (char *)"Sizer_FitInside", (PyCFunction) _wrap_Sizer_FitInside, METH_VARARGS | METH_KEYWORDS, NULL},
54102 { (char *)"Sizer_SetSizeHints", (PyCFunction) _wrap_Sizer_SetSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54103 { (char *)"Sizer_SetVirtualSizeHints", (PyCFunction) _wrap_Sizer_SetVirtualSizeHints, METH_VARARGS | METH_KEYWORDS, NULL},
54104 { (char *)"Sizer_Clear", (PyCFunction) _wrap_Sizer_Clear, METH_VARARGS | METH_KEYWORDS, NULL},
54105 { (char *)"Sizer_DeleteWindows", (PyCFunction)_wrap_Sizer_DeleteWindows, METH_O, NULL},
54106 { (char *)"Sizer_GetChildren", (PyCFunction)_wrap_Sizer_GetChildren, METH_O, NULL},
54107 { (char *)"Sizer_Show", (PyCFunction) _wrap_Sizer_Show, METH_VARARGS | METH_KEYWORDS, NULL},
54108 { (char *)"Sizer_IsShown", (PyCFunction) _wrap_Sizer_IsShown, METH_VARARGS | METH_KEYWORDS, NULL},
54109 { (char *)"Sizer_ShowItems", (PyCFunction) _wrap_Sizer_ShowItems, METH_VARARGS | METH_KEYWORDS, NULL},
54110 { (char *)"Sizer_swigregister", Sizer_swigregister, METH_VARARGS, NULL},
54111 { (char *)"new_PySizer", (PyCFunction)_wrap_new_PySizer, METH_NOARGS, NULL},
54112 { (char *)"PySizer__setCallbackInfo", (PyCFunction) _wrap_PySizer__setCallbackInfo, METH_VARARGS | METH_KEYWORDS, NULL},
54113 { (char *)"PySizer_swigregister", PySizer_swigregister, METH_VARARGS, NULL},
54114 { (char *)"PySizer_swiginit", PySizer_swiginit, METH_VARARGS, NULL},
54115 { (char *)"new_BoxSizer", (PyCFunction) _wrap_new_BoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54116 { (char *)"BoxSizer_GetOrientation", (PyCFunction)_wrap_BoxSizer_GetOrientation, METH_O, NULL},
54117 { (char *)"BoxSizer_SetOrientation", (PyCFunction) _wrap_BoxSizer_SetOrientation, METH_VARARGS | METH_KEYWORDS, NULL},
54118 { (char *)"BoxSizer_swigregister", BoxSizer_swigregister, METH_VARARGS, NULL},
54119 { (char *)"BoxSizer_swiginit", BoxSizer_swiginit, METH_VARARGS, NULL},
54120 { (char *)"new_StaticBoxSizer", (PyCFunction) _wrap_new_StaticBoxSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54121 { (char *)"StaticBoxSizer_GetStaticBox", (PyCFunction)_wrap_StaticBoxSizer_GetStaticBox, METH_O, NULL},
54122 { (char *)"StaticBoxSizer_swigregister", StaticBoxSizer_swigregister, METH_VARARGS, NULL},
54123 { (char *)"StaticBoxSizer_swiginit", StaticBoxSizer_swiginit, METH_VARARGS, NULL},
54124 { (char *)"new_GridSizer", (PyCFunction) _wrap_new_GridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54125 { (char *)"GridSizer_SetCols", (PyCFunction) _wrap_GridSizer_SetCols, METH_VARARGS | METH_KEYWORDS, NULL},
54126 { (char *)"GridSizer_SetRows", (PyCFunction) _wrap_GridSizer_SetRows, METH_VARARGS | METH_KEYWORDS, NULL},
54127 { (char *)"GridSizer_SetVGap", (PyCFunction) _wrap_GridSizer_SetVGap, METH_VARARGS | METH_KEYWORDS, NULL},
54128 { (char *)"GridSizer_SetHGap", (PyCFunction) _wrap_GridSizer_SetHGap, METH_VARARGS | METH_KEYWORDS, NULL},
54129 { (char *)"GridSizer_GetCols", (PyCFunction)_wrap_GridSizer_GetCols, METH_O, NULL},
54130 { (char *)"GridSizer_GetRows", (PyCFunction)_wrap_GridSizer_GetRows, METH_O, NULL},
54131 { (char *)"GridSizer_GetVGap", (PyCFunction)_wrap_GridSizer_GetVGap, METH_O, NULL},
54132 { (char *)"GridSizer_GetHGap", (PyCFunction)_wrap_GridSizer_GetHGap, METH_O, NULL},
54133 { (char *)"GridSizer_swigregister", GridSizer_swigregister, METH_VARARGS, NULL},
54134 { (char *)"GridSizer_swiginit", GridSizer_swiginit, METH_VARARGS, NULL},
54135 { (char *)"new_FlexGridSizer", (PyCFunction) _wrap_new_FlexGridSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54136 { (char *)"FlexGridSizer_AddGrowableRow", (PyCFunction) _wrap_FlexGridSizer_AddGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54137 { (char *)"FlexGridSizer_RemoveGrowableRow", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableRow, METH_VARARGS | METH_KEYWORDS, NULL},
54138 { (char *)"FlexGridSizer_AddGrowableCol", (PyCFunction) _wrap_FlexGridSizer_AddGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54139 { (char *)"FlexGridSizer_RemoveGrowableCol", (PyCFunction) _wrap_FlexGridSizer_RemoveGrowableCol, METH_VARARGS | METH_KEYWORDS, NULL},
54140 { (char *)"FlexGridSizer_SetFlexibleDirection", (PyCFunction) _wrap_FlexGridSizer_SetFlexibleDirection, METH_VARARGS | METH_KEYWORDS, NULL},
54141 { (char *)"FlexGridSizer_GetFlexibleDirection", (PyCFunction)_wrap_FlexGridSizer_GetFlexibleDirection, METH_O, NULL},
54142 { (char *)"FlexGridSizer_SetNonFlexibleGrowMode", (PyCFunction) _wrap_FlexGridSizer_SetNonFlexibleGrowMode, METH_VARARGS | METH_KEYWORDS, NULL},
54143 { (char *)"FlexGridSizer_GetNonFlexibleGrowMode", (PyCFunction)_wrap_FlexGridSizer_GetNonFlexibleGrowMode, METH_O, NULL},
54144 { (char *)"FlexGridSizer_GetRowHeights", (PyCFunction)_wrap_FlexGridSizer_GetRowHeights, METH_O, NULL},
54145 { (char *)"FlexGridSizer_GetColWidths", (PyCFunction)_wrap_FlexGridSizer_GetColWidths, METH_O, NULL},
54146 { (char *)"FlexGridSizer_swigregister", FlexGridSizer_swigregister, METH_VARARGS, NULL},
54147 { (char *)"FlexGridSizer_swiginit", FlexGridSizer_swiginit, METH_VARARGS, NULL},
54148 { (char *)"new_StdDialogButtonSizer", (PyCFunction)_wrap_new_StdDialogButtonSizer, METH_NOARGS, NULL},
54149 { (char *)"StdDialogButtonSizer_AddButton", (PyCFunction) _wrap_StdDialogButtonSizer_AddButton, METH_VARARGS | METH_KEYWORDS, NULL},
54150 { (char *)"StdDialogButtonSizer_Realize", (PyCFunction)_wrap_StdDialogButtonSizer_Realize, METH_O, NULL},
54151 { (char *)"StdDialogButtonSizer_SetAffirmativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetAffirmativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54152 { (char *)"StdDialogButtonSizer_SetNegativeButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetNegativeButton, METH_VARARGS | METH_KEYWORDS, NULL},
54153 { (char *)"StdDialogButtonSizer_SetCancelButton", (PyCFunction) _wrap_StdDialogButtonSizer_SetCancelButton, METH_VARARGS | METH_KEYWORDS, NULL},
54154 { (char *)"StdDialogButtonSizer_GetAffirmativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetAffirmativeButton, METH_O, NULL},
54155 { (char *)"StdDialogButtonSizer_GetApplyButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetApplyButton, METH_O, NULL},
54156 { (char *)"StdDialogButtonSizer_GetNegativeButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetNegativeButton, METH_O, NULL},
54157 { (char *)"StdDialogButtonSizer_GetCancelButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetCancelButton, METH_O, NULL},
54158 { (char *)"StdDialogButtonSizer_GetHelpButton", (PyCFunction)_wrap_StdDialogButtonSizer_GetHelpButton, METH_O, NULL},
54159 { (char *)"StdDialogButtonSizer_swigregister", StdDialogButtonSizer_swigregister, METH_VARARGS, NULL},
54160 { (char *)"StdDialogButtonSizer_swiginit", StdDialogButtonSizer_swiginit, METH_VARARGS, NULL},
54161 { (char *)"new_GBPosition", (PyCFunction) _wrap_new_GBPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54162 { (char *)"delete_GBPosition", (PyCFunction)_wrap_delete_GBPosition, METH_O, NULL},
54163 { (char *)"GBPosition_GetRow", (PyCFunction)_wrap_GBPosition_GetRow, METH_O, NULL},
54164 { (char *)"GBPosition_GetCol", (PyCFunction)_wrap_GBPosition_GetCol, METH_O, NULL},
54165 { (char *)"GBPosition_SetRow", (PyCFunction) _wrap_GBPosition_SetRow, METH_VARARGS | METH_KEYWORDS, NULL},
54166 { (char *)"GBPosition_SetCol", (PyCFunction) _wrap_GBPosition_SetCol, METH_VARARGS | METH_KEYWORDS, NULL},
54167 { (char *)"GBPosition___eq__", (PyCFunction) _wrap_GBPosition___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54168 { (char *)"GBPosition___ne__", (PyCFunction) _wrap_GBPosition___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54169 { (char *)"GBPosition_Set", (PyCFunction) _wrap_GBPosition_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54170 { (char *)"GBPosition_Get", (PyCFunction)_wrap_GBPosition_Get, METH_O, NULL},
54171 { (char *)"GBPosition_swigregister", GBPosition_swigregister, METH_VARARGS, NULL},
54172 { (char *)"GBPosition_swiginit", GBPosition_swiginit, METH_VARARGS, NULL},
54173 { (char *)"new_GBSpan", (PyCFunction) _wrap_new_GBSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54174 { (char *)"delete_GBSpan", (PyCFunction)_wrap_delete_GBSpan, METH_O, NULL},
54175 { (char *)"GBSpan_GetRowspan", (PyCFunction)_wrap_GBSpan_GetRowspan, METH_O, NULL},
54176 { (char *)"GBSpan_GetColspan", (PyCFunction)_wrap_GBSpan_GetColspan, METH_O, NULL},
54177 { (char *)"GBSpan_SetRowspan", (PyCFunction) _wrap_GBSpan_SetRowspan, METH_VARARGS | METH_KEYWORDS, NULL},
54178 { (char *)"GBSpan_SetColspan", (PyCFunction) _wrap_GBSpan_SetColspan, METH_VARARGS | METH_KEYWORDS, NULL},
54179 { (char *)"GBSpan___eq__", (PyCFunction) _wrap_GBSpan___eq__, METH_VARARGS | METH_KEYWORDS, NULL},
54180 { (char *)"GBSpan___ne__", (PyCFunction) _wrap_GBSpan___ne__, METH_VARARGS | METH_KEYWORDS, NULL},
54181 { (char *)"GBSpan_Set", (PyCFunction) _wrap_GBSpan_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54182 { (char *)"GBSpan_Get", (PyCFunction)_wrap_GBSpan_Get, METH_O, NULL},
54183 { (char *)"GBSpan_swigregister", GBSpan_swigregister, METH_VARARGS, NULL},
54184 { (char *)"GBSpan_swiginit", GBSpan_swiginit, METH_VARARGS, NULL},
54185 { (char *)"new_GBSizerItem", (PyCFunction)_wrap_new_GBSizerItem, METH_NOARGS, NULL},
54186 { (char *)"delete_GBSizerItem", (PyCFunction)_wrap_delete_GBSizerItem, METH_O, NULL},
54187 { (char *)"new_GBSizerItemWindow", (PyCFunction) _wrap_new_GBSizerItemWindow, METH_VARARGS | METH_KEYWORDS, NULL},
54188 { (char *)"new_GBSizerItemSizer", (PyCFunction) _wrap_new_GBSizerItemSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54189 { (char *)"new_GBSizerItemSpacer", (PyCFunction) _wrap_new_GBSizerItemSpacer, METH_VARARGS | METH_KEYWORDS, NULL},
54190 { (char *)"GBSizerItem_GetPos", (PyCFunction)_wrap_GBSizerItem_GetPos, METH_O, NULL},
54191 { (char *)"GBSizerItem_GetSpan", (PyCFunction)_wrap_GBSizerItem_GetSpan, METH_O, NULL},
54192 { (char *)"GBSizerItem_SetPos", (PyCFunction) _wrap_GBSizerItem_SetPos, METH_VARARGS | METH_KEYWORDS, NULL},
54193 { (char *)"GBSizerItem_SetSpan", (PyCFunction) _wrap_GBSizerItem_SetSpan, METH_VARARGS | METH_KEYWORDS, NULL},
54194 { (char *)"GBSizerItem_Intersects", (PyCFunction) _wrap_GBSizerItem_Intersects, METH_VARARGS | METH_KEYWORDS, NULL},
54195 { (char *)"GBSizerItem_IntersectsPos", (PyCFunction) _wrap_GBSizerItem_IntersectsPos, METH_VARARGS | METH_KEYWORDS, NULL},
54196 { (char *)"GBSizerItem_GetEndPos", (PyCFunction)_wrap_GBSizerItem_GetEndPos, METH_O, NULL},
54197 { (char *)"GBSizerItem_GetGBSizer", (PyCFunction)_wrap_GBSizerItem_GetGBSizer, METH_O, NULL},
54198 { (char *)"GBSizerItem_SetGBSizer", (PyCFunction) _wrap_GBSizerItem_SetGBSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54199 { (char *)"GBSizerItem_swigregister", GBSizerItem_swigregister, METH_VARARGS, NULL},
54200 { (char *)"GBSizerItem_swiginit", GBSizerItem_swiginit, METH_VARARGS, NULL},
54201 { (char *)"new_GridBagSizer", (PyCFunction) _wrap_new_GridBagSizer, METH_VARARGS | METH_KEYWORDS, NULL},
54202 { (char *)"GridBagSizer_Add", (PyCFunction) _wrap_GridBagSizer_Add, METH_VARARGS | METH_KEYWORDS, NULL},
54203 { (char *)"GridBagSizer_AddItem", (PyCFunction) _wrap_GridBagSizer_AddItem, METH_VARARGS | METH_KEYWORDS, NULL},
54204 { (char *)"GridBagSizer_GetCellSize", (PyCFunction) _wrap_GridBagSizer_GetCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54205 { (char *)"GridBagSizer_GetEmptyCellSize", (PyCFunction)_wrap_GridBagSizer_GetEmptyCellSize, METH_O, NULL},
54206 { (char *)"GridBagSizer_SetEmptyCellSize", (PyCFunction) _wrap_GridBagSizer_SetEmptyCellSize, METH_VARARGS | METH_KEYWORDS, NULL},
54207 { (char *)"GridBagSizer_GetItemPosition", _wrap_GridBagSizer_GetItemPosition, METH_VARARGS, NULL},
54208 { (char *)"GridBagSizer_SetItemPosition", _wrap_GridBagSizer_SetItemPosition, METH_VARARGS, NULL},
54209 { (char *)"GridBagSizer_GetItemSpan", _wrap_GridBagSizer_GetItemSpan, METH_VARARGS, NULL},
54210 { (char *)"GridBagSizer_SetItemSpan", _wrap_GridBagSizer_SetItemSpan, METH_VARARGS, NULL},
54211 { (char *)"GridBagSizer_FindItem", _wrap_GridBagSizer_FindItem, METH_VARARGS, NULL},
54212 { (char *)"GridBagSizer_FindItemAtPosition", (PyCFunction) _wrap_GridBagSizer_FindItemAtPosition, METH_VARARGS | METH_KEYWORDS, NULL},
54213 { (char *)"GridBagSizer_FindItemAtPoint", (PyCFunction) _wrap_GridBagSizer_FindItemAtPoint, METH_VARARGS | METH_KEYWORDS, NULL},
54214 { (char *)"GridBagSizer_CheckForIntersection", (PyCFunction) _wrap_GridBagSizer_CheckForIntersection, METH_VARARGS | METH_KEYWORDS, NULL},
54215 { (char *)"GridBagSizer_CheckForIntersectionPos", (PyCFunction) _wrap_GridBagSizer_CheckForIntersectionPos, METH_VARARGS | METH_KEYWORDS, NULL},
54216 { (char *)"GridBagSizer_swigregister", GridBagSizer_swigregister, METH_VARARGS, NULL},
54217 { (char *)"GridBagSizer_swiginit", GridBagSizer_swiginit, METH_VARARGS, NULL},
54218 { (char *)"IndividualLayoutConstraint_Set", (PyCFunction) _wrap_IndividualLayoutConstraint_Set, METH_VARARGS | METH_KEYWORDS, NULL},
54219 { (char *)"IndividualLayoutConstraint_LeftOf", (PyCFunction) _wrap_IndividualLayoutConstraint_LeftOf, METH_VARARGS | METH_KEYWORDS, NULL},
54220 { (char *)"IndividualLayoutConstraint_RightOf", (PyCFunction) _wrap_IndividualLayoutConstraint_RightOf, METH_VARARGS | METH_KEYWORDS, NULL},
54221 { (char *)"IndividualLayoutConstraint_Above", (PyCFunction) _wrap_IndividualLayoutConstraint_Above, METH_VARARGS | METH_KEYWORDS, NULL},
54222 { (char *)"IndividualLayoutConstraint_Below", (PyCFunction) _wrap_IndividualLayoutConstraint_Below, METH_VARARGS | METH_KEYWORDS, NULL},
54223 { (char *)"IndividualLayoutConstraint_SameAs", (PyCFunction) _wrap_IndividualLayoutConstraint_SameAs, METH_VARARGS | METH_KEYWORDS, NULL},
54224 { (char *)"IndividualLayoutConstraint_PercentOf", (PyCFunction) _wrap_IndividualLayoutConstraint_PercentOf, METH_VARARGS | METH_KEYWORDS, NULL},
54225 { (char *)"IndividualLayoutConstraint_Absolute", (PyCFunction) _wrap_IndividualLayoutConstraint_Absolute, METH_VARARGS | METH_KEYWORDS, NULL},
54226 { (char *)"IndividualLayoutConstraint_Unconstrained", (PyCFunction)_wrap_IndividualLayoutConstraint_Unconstrained, METH_O, NULL},
54227 { (char *)"IndividualLayoutConstraint_AsIs", (PyCFunction)_wrap_IndividualLayoutConstraint_AsIs, METH_O, NULL},
54228 { (char *)"IndividualLayoutConstraint_GetOtherWindow", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherWindow, METH_O, NULL},
54229 { (char *)"IndividualLayoutConstraint_GetMyEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMyEdge, METH_O, NULL},
54230 { (char *)"IndividualLayoutConstraint_SetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_SetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54231 { (char *)"IndividualLayoutConstraint_SetValue", (PyCFunction) _wrap_IndividualLayoutConstraint_SetValue, METH_VARARGS | METH_KEYWORDS, NULL},
54232 { (char *)"IndividualLayoutConstraint_GetMargin", (PyCFunction)_wrap_IndividualLayoutConstraint_GetMargin, METH_O, NULL},
54233 { (char *)"IndividualLayoutConstraint_SetMargin", (PyCFunction) _wrap_IndividualLayoutConstraint_SetMargin, METH_VARARGS | METH_KEYWORDS, NULL},
54234 { (char *)"IndividualLayoutConstraint_GetValue", (PyCFunction)_wrap_IndividualLayoutConstraint_GetValue, METH_O, NULL},
54235 { (char *)"IndividualLayoutConstraint_GetPercent", (PyCFunction)_wrap_IndividualLayoutConstraint_GetPercent, METH_O, NULL},
54236 { (char *)"IndividualLayoutConstraint_GetOtherEdge", (PyCFunction)_wrap_IndividualLayoutConstraint_GetOtherEdge, METH_O, NULL},
54237 { (char *)"IndividualLayoutConstraint_GetDone", (PyCFunction)_wrap_IndividualLayoutConstraint_GetDone, METH_O, NULL},
54238 { (char *)"IndividualLayoutConstraint_SetDone", (PyCFunction) _wrap_IndividualLayoutConstraint_SetDone, METH_VARARGS | METH_KEYWORDS, NULL},
54239 { (char *)"IndividualLayoutConstraint_GetRelationship", (PyCFunction)_wrap_IndividualLayoutConstraint_GetRelationship, METH_O, NULL},
54240 { (char *)"IndividualLayoutConstraint_SetRelationship", (PyCFunction) _wrap_IndividualLayoutConstraint_SetRelationship, METH_VARARGS | METH_KEYWORDS, NULL},
54241 { (char *)"IndividualLayoutConstraint_ResetIfWin", (PyCFunction) _wrap_IndividualLayoutConstraint_ResetIfWin, METH_VARARGS | METH_KEYWORDS, NULL},
54242 { (char *)"IndividualLayoutConstraint_SatisfyConstraint", (PyCFunction) _wrap_IndividualLayoutConstraint_SatisfyConstraint, METH_VARARGS | METH_KEYWORDS, NULL},
54243 { (char *)"IndividualLayoutConstraint_GetEdge", (PyCFunction) _wrap_IndividualLayoutConstraint_GetEdge, METH_VARARGS | METH_KEYWORDS, NULL},
54244 { (char *)"IndividualLayoutConstraint_swigregister", IndividualLayoutConstraint_swigregister, METH_VARARGS, NULL},
54245 { (char *)"LayoutConstraints_left_get", (PyCFunction)_wrap_LayoutConstraints_left_get, METH_O, NULL},
54246 { (char *)"LayoutConstraints_top_get", (PyCFunction)_wrap_LayoutConstraints_top_get, METH_O, NULL},
54247 { (char *)"LayoutConstraints_right_get", (PyCFunction)_wrap_LayoutConstraints_right_get, METH_O, NULL},
54248 { (char *)"LayoutConstraints_bottom_get", (PyCFunction)_wrap_LayoutConstraints_bottom_get, METH_O, NULL},
54249 { (char *)"LayoutConstraints_width_get", (PyCFunction)_wrap_LayoutConstraints_width_get, METH_O, NULL},
54250 { (char *)"LayoutConstraints_height_get", (PyCFunction)_wrap_LayoutConstraints_height_get, METH_O, NULL},
54251 { (char *)"LayoutConstraints_centreX_get", (PyCFunction)_wrap_LayoutConstraints_centreX_get, METH_O, NULL},
54252 { (char *)"LayoutConstraints_centreY_get", (PyCFunction)_wrap_LayoutConstraints_centreY_get, METH_O, NULL},
54253 { (char *)"new_LayoutConstraints", (PyCFunction)_wrap_new_LayoutConstraints, METH_NOARGS, NULL},
54254 { (char *)"delete_LayoutConstraints", (PyCFunction)_wrap_delete_LayoutConstraints, METH_O, NULL},
54255 { (char *)"LayoutConstraints_SatisfyConstraints", (PyCFunction) _wrap_LayoutConstraints_SatisfyConstraints, METH_VARARGS | METH_KEYWORDS, NULL},
54256 { (char *)"LayoutConstraints_AreSatisfied", (PyCFunction)_wrap_LayoutConstraints_AreSatisfied, METH_O, NULL},
54257 { (char *)"LayoutConstraints_swigregister", LayoutConstraints_swigregister, METH_VARARGS, NULL},
54258 { (char *)"LayoutConstraints_swiginit", LayoutConstraints_swiginit, METH_VARARGS, NULL},
54259 { NULL, NULL, 0, NULL }
54260 };
54261
54262
54263 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */
54264
54265 static void *_p_wxGBSizerItemTo_p_wxSizerItem(void *x) {
54266 return (void *)((wxSizerItem *) ((wxGBSizerItem *) x));
54267 }
54268 static void *_p_wxBoxSizerTo_p_wxSizer(void *x) {
54269 return (void *)((wxSizer *) ((wxBoxSizer *) x));
54270 }
54271 static void *_p_wxStaticBoxSizerTo_p_wxSizer(void *x) {
54272 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStaticBoxSizer *) x));
54273 }
54274 static void *_p_wxStdDialogButtonSizerTo_p_wxSizer(void *x) {
54275 return (void *)((wxSizer *) (wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54276 }
54277 static void *_p_wxGridBagSizerTo_p_wxSizer(void *x) {
54278 return (void *)((wxSizer *) (wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54279 }
54280 static void *_p_wxGridSizerTo_p_wxSizer(void *x) {
54281 return (void *)((wxSizer *) ((wxGridSizer *) x));
54282 }
54283 static void *_p_wxFlexGridSizerTo_p_wxSizer(void *x) {
54284 return (void *)((wxSizer *) (wxGridSizer *) ((wxFlexGridSizer *) x));
54285 }
54286 static void *_p_wxPySizerTo_p_wxSizer(void *x) {
54287 return (void *)((wxSizer *) ((wxPySizer *) x));
54288 }
54289 static void *_p_wxStaticBoxSizerTo_p_wxBoxSizer(void *x) {
54290 return (void *)((wxBoxSizer *) ((wxStaticBoxSizer *) x));
54291 }
54292 static void *_p_wxStdDialogButtonSizerTo_p_wxBoxSizer(void *x) {
54293 return (void *)((wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54294 }
54295 static void *_p_wxContextMenuEventTo_p_wxEvent(void *x) {
54296 return (void *)((wxEvent *) (wxCommandEvent *) ((wxContextMenuEvent *) x));
54297 }
54298 static void *_p_wxMenuEventTo_p_wxEvent(void *x) {
54299 return (void *)((wxEvent *) ((wxMenuEvent *) x));
54300 }
54301 static void *_p_wxCloseEventTo_p_wxEvent(void *x) {
54302 return (void *)((wxEvent *) ((wxCloseEvent *) x));
54303 }
54304 static void *_p_wxMouseEventTo_p_wxEvent(void *x) {
54305 return (void *)((wxEvent *) ((wxMouseEvent *) x));
54306 }
54307 static void *_p_wxEraseEventTo_p_wxEvent(void *x) {
54308 return (void *)((wxEvent *) ((wxEraseEvent *) x));
54309 }
54310 static void *_p_wxSetCursorEventTo_p_wxEvent(void *x) {
54311 return (void *)((wxEvent *) ((wxSetCursorEvent *) x));
54312 }
54313 static void *_p_wxInitDialogEventTo_p_wxEvent(void *x) {
54314 return (void *)((wxEvent *) ((wxInitDialogEvent *) x));
54315 }
54316 static void *_p_wxScrollEventTo_p_wxEvent(void *x) {
54317 return (void *)((wxEvent *) (wxCommandEvent *) ((wxScrollEvent *) x));
54318 }
54319 static void *_p_wxNotifyEventTo_p_wxEvent(void *x) {
54320 return (void *)((wxEvent *) (wxCommandEvent *) ((wxNotifyEvent *) x));
54321 }
54322 static void *_p_wxMouseCaptureLostEventTo_p_wxEvent(void *x) {
54323 return (void *)((wxEvent *) ((wxMouseCaptureLostEvent *) x));
54324 }
54325 static void *_p_wxPyEventTo_p_wxEvent(void *x) {
54326 return (void *)((wxEvent *) ((wxPyEvent *) x));
54327 }
54328 static void *_p_wxIdleEventTo_p_wxEvent(void *x) {
54329 return (void *)((wxEvent *) ((wxIdleEvent *) x));
54330 }
54331 static void *_p_wxWindowCreateEventTo_p_wxEvent(void *x) {
54332 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowCreateEvent *) x));
54333 }
54334 static void *_p_wxQueryNewPaletteEventTo_p_wxEvent(void *x) {
54335 return (void *)((wxEvent *) ((wxQueryNewPaletteEvent *) x));
54336 }
54337 static void *_p_wxMaximizeEventTo_p_wxEvent(void *x) {
54338 return (void *)((wxEvent *) ((wxMaximizeEvent *) x));
54339 }
54340 static void *_p_wxIconizeEventTo_p_wxEvent(void *x) {
54341 return (void *)((wxEvent *) ((wxIconizeEvent *) x));
54342 }
54343 static void *_p_wxActivateEventTo_p_wxEvent(void *x) {
54344 return (void *)((wxEvent *) ((wxActivateEvent *) x));
54345 }
54346 static void *_p_wxSizeEventTo_p_wxEvent(void *x) {
54347 return (void *)((wxEvent *) ((wxSizeEvent *) x));
54348 }
54349 static void *_p_wxMoveEventTo_p_wxEvent(void *x) {
54350 return (void *)((wxEvent *) ((wxMoveEvent *) x));
54351 }
54352 static void *_p_wxDateEventTo_p_wxEvent(void *x) {
54353 return (void *)((wxEvent *) (wxCommandEvent *) ((wxDateEvent *) x));
54354 }
54355 static void *_p_wxPaintEventTo_p_wxEvent(void *x) {
54356 return (void *)((wxEvent *) ((wxPaintEvent *) x));
54357 }
54358 static void *_p_wxNcPaintEventTo_p_wxEvent(void *x) {
54359 return (void *)((wxEvent *) ((wxNcPaintEvent *) x));
54360 }
54361 static void *_p_wxClipboardTextEventTo_p_wxEvent(void *x) {
54362 return (void *)((wxEvent *) (wxCommandEvent *) ((wxClipboardTextEvent *) x));
54363 }
54364 static void *_p_wxUpdateUIEventTo_p_wxEvent(void *x) {
54365 return (void *)((wxEvent *) (wxCommandEvent *) ((wxUpdateUIEvent *) x));
54366 }
54367 static void *_p_wxPaletteChangedEventTo_p_wxEvent(void *x) {
54368 return (void *)((wxEvent *) ((wxPaletteChangedEvent *) x));
54369 }
54370 static void *_p_wxDisplayChangedEventTo_p_wxEvent(void *x) {
54371 return (void *)((wxEvent *) ((wxDisplayChangedEvent *) x));
54372 }
54373 static void *_p_wxMouseCaptureChangedEventTo_p_wxEvent(void *x) {
54374 return (void *)((wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54375 }
54376 static void *_p_wxSysColourChangedEventTo_p_wxEvent(void *x) {
54377 return (void *)((wxEvent *) ((wxSysColourChangedEvent *) x));
54378 }
54379 static void *_p_wxDropFilesEventTo_p_wxEvent(void *x) {
54380 return (void *)((wxEvent *) ((wxDropFilesEvent *) x));
54381 }
54382 static void *_p_wxFocusEventTo_p_wxEvent(void *x) {
54383 return (void *)((wxEvent *) ((wxFocusEvent *) x));
54384 }
54385 static void *_p_wxChildFocusEventTo_p_wxEvent(void *x) {
54386 return (void *)((wxEvent *) (wxCommandEvent *) ((wxChildFocusEvent *) x));
54387 }
54388 static void *_p_wxShowEventTo_p_wxEvent(void *x) {
54389 return (void *)((wxEvent *) ((wxShowEvent *) x));
54390 }
54391 static void *_p_wxCommandEventTo_p_wxEvent(void *x) {
54392 return (void *)((wxEvent *) ((wxCommandEvent *) x));
54393 }
54394 static void *_p_wxPyCommandEventTo_p_wxEvent(void *x) {
54395 return (void *)((wxEvent *) (wxCommandEvent *) ((wxPyCommandEvent *) x));
54396 }
54397 static void *_p_wxWindowDestroyEventTo_p_wxEvent(void *x) {
54398 return (void *)((wxEvent *) (wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54399 }
54400 static void *_p_wxNavigationKeyEventTo_p_wxEvent(void *x) {
54401 return (void *)((wxEvent *) ((wxNavigationKeyEvent *) x));
54402 }
54403 static void *_p_wxKeyEventTo_p_wxEvent(void *x) {
54404 return (void *)((wxEvent *) ((wxKeyEvent *) x));
54405 }
54406 static void *_p_wxScrollWinEventTo_p_wxEvent(void *x) {
54407 return (void *)((wxEvent *) ((wxScrollWinEvent *) x));
54408 }
54409 static void *_p_wxGridBagSizerTo_p_wxGridSizer(void *x) {
54410 return (void *)((wxGridSizer *) (wxFlexGridSizer *) ((wxGridBagSizer *) x));
54411 }
54412 static void *_p_wxFlexGridSizerTo_p_wxGridSizer(void *x) {
54413 return (void *)((wxGridSizer *) ((wxFlexGridSizer *) x));
54414 }
54415 static void *_p_wxGridBagSizerTo_p_wxFlexGridSizer(void *x) {
54416 return (void *)((wxFlexGridSizer *) ((wxGridBagSizer *) x));
54417 }
54418 static void *_p_wxControlWithItemsTo_p_wxItemContainer(void *x) {
54419 return (void *)((wxItemContainer *) ((wxControlWithItems *) x));
54420 }
54421 static void *_p_wxControlWithItemsTo_p_wxControl(void *x) {
54422 return (void *)((wxControl *) ((wxControlWithItems *) x));
54423 }
54424 static void *_p_wxControlTo_p_wxEvtHandler(void *x) {
54425 return (void *)((wxEvtHandler *) (wxWindow *) ((wxControl *) x));
54426 }
54427 static void *_p_wxWindowTo_p_wxEvtHandler(void *x) {
54428 return (void *)((wxEvtHandler *) ((wxWindow *) x));
54429 }
54430 static void *_p_wxControlWithItemsTo_p_wxEvtHandler(void *x) {
54431 return (void *)((wxEvtHandler *) (wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54432 }
54433 static void *_p_wxPyAppTo_p_wxEvtHandler(void *x) {
54434 return (void *)((wxEvtHandler *) ((wxPyApp *) x));
54435 }
54436 static void *_p_wxValidatorTo_p_wxEvtHandler(void *x) {
54437 return (void *)((wxEvtHandler *) ((wxValidator *) x));
54438 }
54439 static void *_p_wxPyValidatorTo_p_wxEvtHandler(void *x) {
54440 return (void *)((wxEvtHandler *) (wxValidator *) ((wxPyValidator *) x));
54441 }
54442 static void *_p_wxMenuBarTo_p_wxEvtHandler(void *x) {
54443 return (void *)((wxEvtHandler *) (wxWindow *) ((wxMenuBar *) x));
54444 }
54445 static void *_p_wxMenuTo_p_wxEvtHandler(void *x) {
54446 return (void *)((wxEvtHandler *) ((wxMenu *) x));
54447 }
54448 static void *_p_wxANIHandlerTo_p_wxCURHandler(void *x) {
54449 return (void *)((wxCURHandler *) ((wxANIHandler *) x));
54450 }
54451 static void *_p_wxCURHandlerTo_p_wxICOHandler(void *x) {
54452 return (void *)((wxICOHandler *) ((wxCURHandler *) x));
54453 }
54454 static void *_p_wxANIHandlerTo_p_wxICOHandler(void *x) {
54455 return (void *)((wxICOHandler *) (wxCURHandler *) ((wxANIHandler *) x));
54456 }
54457 static void *_p_wxICOHandlerTo_p_wxBMPHandler(void *x) {
54458 return (void *)((wxBMPHandler *) ((wxICOHandler *) x));
54459 }
54460 static void *_p_wxCURHandlerTo_p_wxBMPHandler(void *x) {
54461 return (void *)((wxBMPHandler *) (wxICOHandler *) ((wxCURHandler *) x));
54462 }
54463 static void *_p_wxANIHandlerTo_p_wxBMPHandler(void *x) {
54464 return (void *)((wxBMPHandler *) (wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54465 }
54466 static void *_p_wxPyImageHandlerTo_p_wxImageHandler(void *x) {
54467 return (void *)((wxImageHandler *) ((wxPyImageHandler *) x));
54468 }
54469 static void *_p_wxBMPHandlerTo_p_wxImageHandler(void *x) {
54470 return (void *)((wxImageHandler *) ((wxBMPHandler *) x));
54471 }
54472 static void *_p_wxICOHandlerTo_p_wxImageHandler(void *x) {
54473 return (void *)((wxImageHandler *) (wxBMPHandler *) ((wxICOHandler *) x));
54474 }
54475 static void *_p_wxCURHandlerTo_p_wxImageHandler(void *x) {
54476 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54477 }
54478 static void *_p_wxANIHandlerTo_p_wxImageHandler(void *x) {
54479 return (void *)((wxImageHandler *) (wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54480 }
54481 static void *_p_wxPNGHandlerTo_p_wxImageHandler(void *x) {
54482 return (void *)((wxImageHandler *) ((wxPNGHandler *) x));
54483 }
54484 static void *_p_wxGIFHandlerTo_p_wxImageHandler(void *x) {
54485 return (void *)((wxImageHandler *) ((wxGIFHandler *) x));
54486 }
54487 static void *_p_wxPCXHandlerTo_p_wxImageHandler(void *x) {
54488 return (void *)((wxImageHandler *) ((wxPCXHandler *) x));
54489 }
54490 static void *_p_wxJPEGHandlerTo_p_wxImageHandler(void *x) {
54491 return (void *)((wxImageHandler *) ((wxJPEGHandler *) x));
54492 }
54493 static void *_p_wxPNMHandlerTo_p_wxImageHandler(void *x) {
54494 return (void *)((wxImageHandler *) ((wxPNMHandler *) x));
54495 }
54496 static void *_p_wxXPMHandlerTo_p_wxImageHandler(void *x) {
54497 return (void *)((wxImageHandler *) ((wxXPMHandler *) x));
54498 }
54499 static void *_p_wxTIFFHandlerTo_p_wxImageHandler(void *x) {
54500 return (void *)((wxImageHandler *) ((wxTIFFHandler *) x));
54501 }
54502 static void *_p_wxPyFileSystemHandlerTo_p_wxFileSystemHandler(void *x) {
54503 return (void *)((wxFileSystemHandler *) ((wxPyFileSystemHandler *) x));
54504 }
54505 static void *_p_wxInternetFSHandlerTo_p_wxFileSystemHandler(void *x) {
54506 return (void *)((wxFileSystemHandler *) ((wxInternetFSHandler *) x));
54507 }
54508 static void *_p_wxZipFSHandlerTo_p_wxFileSystemHandler(void *x) {
54509 return (void *)((wxFileSystemHandler *) ((wxZipFSHandler *) x));
54510 }
54511 static void *_p_wxMemoryFSHandlerTo_p_wxFileSystemHandler(void *x) {
54512 return (void *)((wxFileSystemHandler *) ((wxMemoryFSHandler *) x));
54513 }
54514 static void *_p_wxLayoutConstraintsTo_p_wxObject(void *x) {
54515 return (void *)((wxObject *) ((wxLayoutConstraints *) x));
54516 }
54517 static void *_p_wxSizerItemTo_p_wxObject(void *x) {
54518 return (void *)((wxObject *) ((wxSizerItem *) x));
54519 }
54520 static void *_p_wxGBSizerItemTo_p_wxObject(void *x) {
54521 return (void *)((wxObject *) (wxSizerItem *) ((wxGBSizerItem *) x));
54522 }
54523 static void *_p_wxScrollEventTo_p_wxObject(void *x) {
54524 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxScrollEvent *) x));
54525 }
54526 static void *_p_wxIndividualLayoutConstraintTo_p_wxObject(void *x) {
54527 return (void *)((wxObject *) ((wxIndividualLayoutConstraint *) x));
54528 }
54529 static void *_p_wxStaticBoxSizerTo_p_wxObject(void *x) {
54530 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStaticBoxSizer *) x));
54531 }
54532 static void *_p_wxBoxSizerTo_p_wxObject(void *x) {
54533 return (void *)((wxObject *) (wxSizer *) ((wxBoxSizer *) x));
54534 }
54535 static void *_p_wxSizerTo_p_wxObject(void *x) {
54536 return (void *)((wxObject *) ((wxSizer *) x));
54537 }
54538 static void *_p_wxGridBagSizerTo_p_wxObject(void *x) {
54539 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *)(wxFlexGridSizer *) ((wxGridBagSizer *) x));
54540 }
54541 static void *_p_wxUpdateUIEventTo_p_wxObject(void *x) {
54542 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxUpdateUIEvent *) x));
54543 }
54544 static void *_p_wxEventTo_p_wxObject(void *x) {
54545 return (void *)((wxObject *) ((wxEvent *) x));
54546 }
54547 static void *_p_wxFlexGridSizerTo_p_wxObject(void *x) {
54548 return (void *)((wxObject *) (wxSizer *)(wxGridSizer *) ((wxFlexGridSizer *) x));
54549 }
54550 static void *_p_wxGridSizerTo_p_wxObject(void *x) {
54551 return (void *)((wxObject *) (wxSizer *) ((wxGridSizer *) x));
54552 }
54553 static void *_p_wxInitDialogEventTo_p_wxObject(void *x) {
54554 return (void *)((wxObject *) (wxEvent *) ((wxInitDialogEvent *) x));
54555 }
54556 static void *_p_wxClipboardTextEventTo_p_wxObject(void *x) {
54557 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxClipboardTextEvent *) x));
54558 }
54559 static void *_p_wxPaintEventTo_p_wxObject(void *x) {
54560 return (void *)((wxObject *) (wxEvent *) ((wxPaintEvent *) x));
54561 }
54562 static void *_p_wxNcPaintEventTo_p_wxObject(void *x) {
54563 return (void *)((wxObject *) (wxEvent *) ((wxNcPaintEvent *) x));
54564 }
54565 static void *_p_wxPaletteChangedEventTo_p_wxObject(void *x) {
54566 return (void *)((wxObject *) (wxEvent *) ((wxPaletteChangedEvent *) x));
54567 }
54568 static void *_p_wxDisplayChangedEventTo_p_wxObject(void *x) {
54569 return (void *)((wxObject *) (wxEvent *) ((wxDisplayChangedEvent *) x));
54570 }
54571 static void *_p_wxMouseCaptureChangedEventTo_p_wxObject(void *x) {
54572 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureChangedEvent *) x));
54573 }
54574 static void *_p_wxSysColourChangedEventTo_p_wxObject(void *x) {
54575 return (void *)((wxObject *) (wxEvent *) ((wxSysColourChangedEvent *) x));
54576 }
54577 static void *_p_wxControlTo_p_wxObject(void *x) {
54578 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxControl *) x));
54579 }
54580 static void *_p_wxSetCursorEventTo_p_wxObject(void *x) {
54581 return (void *)((wxObject *) (wxEvent *) ((wxSetCursorEvent *) x));
54582 }
54583 static void *_p_wxFSFileTo_p_wxObject(void *x) {
54584 return (void *)((wxObject *) ((wxFSFile *) x));
54585 }
54586 static void *_p_wxPySizerTo_p_wxObject(void *x) {
54587 return (void *)((wxObject *) (wxSizer *) ((wxPySizer *) x));
54588 }
54589 static void *_p_wxPyEventTo_p_wxObject(void *x) {
54590 return (void *)((wxObject *) (wxEvent *) ((wxPyEvent *) x));
54591 }
54592 static void *_p_wxNotifyEventTo_p_wxObject(void *x) {
54593 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxNotifyEvent *) x));
54594 }
54595 static void *_p_wxShowEventTo_p_wxObject(void *x) {
54596 return (void *)((wxObject *) (wxEvent *) ((wxShowEvent *) x));
54597 }
54598 static void *_p_wxMenuItemTo_p_wxObject(void *x) {
54599 return (void *)((wxObject *) ((wxMenuItem *) x));
54600 }
54601 static void *_p_wxDateEventTo_p_wxObject(void *x) {
54602 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxDateEvent *) x));
54603 }
54604 static void *_p_wxIdleEventTo_p_wxObject(void *x) {
54605 return (void *)((wxObject *) (wxEvent *) ((wxIdleEvent *) x));
54606 }
54607 static void *_p_wxWindowCreateEventTo_p_wxObject(void *x) {
54608 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowCreateEvent *) x));
54609 }
54610 static void *_p_wxQueryNewPaletteEventTo_p_wxObject(void *x) {
54611 return (void *)((wxObject *) (wxEvent *) ((wxQueryNewPaletteEvent *) x));
54612 }
54613 static void *_p_wxMaximizeEventTo_p_wxObject(void *x) {
54614 return (void *)((wxObject *) (wxEvent *) ((wxMaximizeEvent *) x));
54615 }
54616 static void *_p_wxIconizeEventTo_p_wxObject(void *x) {
54617 return (void *)((wxObject *) (wxEvent *) ((wxIconizeEvent *) x));
54618 }
54619 static void *_p_wxSizeEventTo_p_wxObject(void *x) {
54620 return (void *)((wxObject *) (wxEvent *) ((wxSizeEvent *) x));
54621 }
54622 static void *_p_wxMoveEventTo_p_wxObject(void *x) {
54623 return (void *)((wxObject *) (wxEvent *) ((wxMoveEvent *) x));
54624 }
54625 static void *_p_wxActivateEventTo_p_wxObject(void *x) {
54626 return (void *)((wxObject *) (wxEvent *) ((wxActivateEvent *) x));
54627 }
54628 static void *_p_wxPNMHandlerTo_p_wxObject(void *x) {
54629 return (void *)((wxObject *) (wxImageHandler *) ((wxPNMHandler *) x));
54630 }
54631 static void *_p_wxJPEGHandlerTo_p_wxObject(void *x) {
54632 return (void *)((wxObject *) (wxImageHandler *) ((wxJPEGHandler *) x));
54633 }
54634 static void *_p_wxPCXHandlerTo_p_wxObject(void *x) {
54635 return (void *)((wxObject *) (wxImageHandler *) ((wxPCXHandler *) x));
54636 }
54637 static void *_p_wxGIFHandlerTo_p_wxObject(void *x) {
54638 return (void *)((wxObject *) (wxImageHandler *) ((wxGIFHandler *) x));
54639 }
54640 static void *_p_wxPNGHandlerTo_p_wxObject(void *x) {
54641 return (void *)((wxObject *) (wxImageHandler *) ((wxPNGHandler *) x));
54642 }
54643 static void *_p_wxANIHandlerTo_p_wxObject(void *x) {
54644 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *)(wxCURHandler *) ((wxANIHandler *) x));
54645 }
54646 static void *_p_wxCURHandlerTo_p_wxObject(void *x) {
54647 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *)(wxICOHandler *) ((wxCURHandler *) x));
54648 }
54649 static void *_p_wxICOHandlerTo_p_wxObject(void *x) {
54650 return (void *)((wxObject *) (wxImageHandler *)(wxBMPHandler *) ((wxICOHandler *) x));
54651 }
54652 static void *_p_wxBMPHandlerTo_p_wxObject(void *x) {
54653 return (void *)((wxObject *) (wxImageHandler *) ((wxBMPHandler *) x));
54654 }
54655 static void *_p_wxPyImageHandlerTo_p_wxObject(void *x) {
54656 return (void *)((wxObject *) (wxImageHandler *) ((wxPyImageHandler *) x));
54657 }
54658 static void *_p_wxImageHandlerTo_p_wxObject(void *x) {
54659 return (void *)((wxObject *) ((wxImageHandler *) x));
54660 }
54661 static void *_p_wxXPMHandlerTo_p_wxObject(void *x) {
54662 return (void *)((wxObject *) (wxImageHandler *) ((wxXPMHandler *) x));
54663 }
54664 static void *_p_wxTIFFHandlerTo_p_wxObject(void *x) {
54665 return (void *)((wxObject *) (wxImageHandler *) ((wxTIFFHandler *) x));
54666 }
54667 static void *_p_wxEvtHandlerTo_p_wxObject(void *x) {
54668 return (void *)((wxObject *) ((wxEvtHandler *) x));
54669 }
54670 static void *_p_wxMouseCaptureLostEventTo_p_wxObject(void *x) {
54671 return (void *)((wxObject *) (wxEvent *) ((wxMouseCaptureLostEvent *) x));
54672 }
54673 static void *_p_wxStdDialogButtonSizerTo_p_wxObject(void *x) {
54674 return (void *)((wxObject *) (wxSizer *)(wxBoxSizer *) ((wxStdDialogButtonSizer *) x));
54675 }
54676 static void *_p_wxAcceleratorTableTo_p_wxObject(void *x) {
54677 return (void *)((wxObject *) ((wxAcceleratorTable *) x));
54678 }
54679 static void *_p_wxImageTo_p_wxObject(void *x) {
54680 return (void *)((wxObject *) ((wxImage *) x));
54681 }
54682 static void *_p_wxScrollWinEventTo_p_wxObject(void *x) {
54683 return (void *)((wxObject *) (wxEvent *) ((wxScrollWinEvent *) x));
54684 }
54685 static void *_p_wxWindowDestroyEventTo_p_wxObject(void *x) {
54686 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54687 }
54688 static void *_p_wxNavigationKeyEventTo_p_wxObject(void *x) {
54689 return (void *)((wxObject *) (wxEvent *) ((wxNavigationKeyEvent *) x));
54690 }
54691 static void *_p_wxKeyEventTo_p_wxObject(void *x) {
54692 return (void *)((wxObject *) (wxEvent *) ((wxKeyEvent *) x));
54693 }
54694 static void *_p_wxWindowTo_p_wxObject(void *x) {
54695 return (void *)((wxObject *) (wxEvtHandler *) ((wxWindow *) x));
54696 }
54697 static void *_p_wxMenuTo_p_wxObject(void *x) {
54698 return (void *)((wxObject *) (wxEvtHandler *) ((wxMenu *) x));
54699 }
54700 static void *_p_wxMenuBarTo_p_wxObject(void *x) {
54701 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *) ((wxMenuBar *) x));
54702 }
54703 static void *_p_wxFileSystemTo_p_wxObject(void *x) {
54704 return (void *)((wxObject *) ((wxFileSystem *) x));
54705 }
54706 static void *_p_wxContextMenuEventTo_p_wxObject(void *x) {
54707 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxContextMenuEvent *) x));
54708 }
54709 static void *_p_wxMenuEventTo_p_wxObject(void *x) {
54710 return (void *)((wxObject *) (wxEvent *) ((wxMenuEvent *) x));
54711 }
54712 static void *_p_wxPyAppTo_p_wxObject(void *x) {
54713 return (void *)((wxObject *) (wxEvtHandler *) ((wxPyApp *) x));
54714 }
54715 static void *_p_wxCloseEventTo_p_wxObject(void *x) {
54716 return (void *)((wxObject *) (wxEvent *) ((wxCloseEvent *) x));
54717 }
54718 static void *_p_wxMouseEventTo_p_wxObject(void *x) {
54719 return (void *)((wxObject *) (wxEvent *) ((wxMouseEvent *) x));
54720 }
54721 static void *_p_wxEraseEventTo_p_wxObject(void *x) {
54722 return (void *)((wxObject *) (wxEvent *) ((wxEraseEvent *) x));
54723 }
54724 static void *_p_wxPyCommandEventTo_p_wxObject(void *x) {
54725 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxPyCommandEvent *) x));
54726 }
54727 static void *_p_wxCommandEventTo_p_wxObject(void *x) {
54728 return (void *)((wxObject *) (wxEvent *) ((wxCommandEvent *) x));
54729 }
54730 static void *_p_wxDropFilesEventTo_p_wxObject(void *x) {
54731 return (void *)((wxObject *) (wxEvent *) ((wxDropFilesEvent *) x));
54732 }
54733 static void *_p_wxFocusEventTo_p_wxObject(void *x) {
54734 return (void *)((wxObject *) (wxEvent *) ((wxFocusEvent *) x));
54735 }
54736 static void *_p_wxChildFocusEventTo_p_wxObject(void *x) {
54737 return (void *)((wxObject *) (wxEvent *)(wxCommandEvent *) ((wxChildFocusEvent *) x));
54738 }
54739 static void *_p_wxControlWithItemsTo_p_wxObject(void *x) {
54740 return (void *)((wxObject *) (wxEvtHandler *)(wxWindow *)(wxControl *) ((wxControlWithItems *) x));
54741 }
54742 static void *_p_wxPyValidatorTo_p_wxObject(void *x) {
54743 return (void *)((wxObject *) (wxEvtHandler *)(wxValidator *) ((wxPyValidator *) x));
54744 }
54745 static void *_p_wxValidatorTo_p_wxObject(void *x) {
54746 return (void *)((wxObject *) (wxEvtHandler *) ((wxValidator *) x));
54747 }
54748 static void *_p_wxControlTo_p_wxWindow(void *x) {
54749 return (void *)((wxWindow *) ((wxControl *) x));
54750 }
54751 static void *_p_wxControlWithItemsTo_p_wxWindow(void *x) {
54752 return (void *)((wxWindow *) (wxControl *) ((wxControlWithItems *) x));
54753 }
54754 static void *_p_wxMenuBarTo_p_wxWindow(void *x) {
54755 return (void *)((wxWindow *) ((wxMenuBar *) x));
54756 }
54757 static void *_p_wxChildFocusEventTo_p_wxCommandEvent(void *x) {
54758 return (void *)((wxCommandEvent *) ((wxChildFocusEvent *) x));
54759 }
54760 static void *_p_wxScrollEventTo_p_wxCommandEvent(void *x) {
54761 return (void *)((wxCommandEvent *) ((wxScrollEvent *) x));
54762 }
54763 static void *_p_wxWindowCreateEventTo_p_wxCommandEvent(void *x) {
54764 return (void *)((wxCommandEvent *) ((wxWindowCreateEvent *) x));
54765 }
54766 static void *_p_wxDateEventTo_p_wxCommandEvent(void *x) {
54767 return (void *)((wxCommandEvent *) ((wxDateEvent *) x));
54768 }
54769 static void *_p_wxUpdateUIEventTo_p_wxCommandEvent(void *x) {
54770 return (void *)((wxCommandEvent *) ((wxUpdateUIEvent *) x));
54771 }
54772 static void *_p_wxClipboardTextEventTo_p_wxCommandEvent(void *x) {
54773 return (void *)((wxCommandEvent *) ((wxClipboardTextEvent *) x));
54774 }
54775 static void *_p_wxWindowDestroyEventTo_p_wxCommandEvent(void *x) {
54776 return (void *)((wxCommandEvent *) ((wxWindowDestroyEvent *) x));
54777 }
54778 static void *_p_wxContextMenuEventTo_p_wxCommandEvent(void *x) {
54779 return (void *)((wxCommandEvent *) ((wxContextMenuEvent *) x));
54780 }
54781 static void *_p_wxNotifyEventTo_p_wxCommandEvent(void *x) {
54782 return (void *)((wxCommandEvent *) ((wxNotifyEvent *) x));
54783 }
54784 static void *_p_wxPyCommandEventTo_p_wxCommandEvent(void *x) {
54785 return (void *)((wxCommandEvent *) ((wxPyCommandEvent *) x));
54786 }
54787 static void *_p_wxPyValidatorTo_p_wxValidator(void *x) {
54788 return (void *)((wxValidator *) ((wxPyValidator *) x));
54789 }
54790 static swig_type_info _swigt__p_buffer = {"_p_buffer", "buffer *", 0, 0, (void*)0, 0};
54791 static swig_type_info _swigt__p_char = {"_p_char", "char *", 0, 0, (void*)0, 0};
54792 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};
54793 static swig_type_info _swigt__p_int = {"_p_int", "int *", 0, 0, (void*)0, 0};
54794 static swig_type_info _swigt__p_long = {"_p_long", "long *", 0, 0, (void*)0, 0};
54795 static swig_type_info _swigt__p_unsigned_char = {"_p_unsigned_char", "unsigned char *|byte *", 0, 0, (void*)0, 0};
54796 static swig_type_info _swigt__p_unsigned_int = {"_p_unsigned_int", "unsigned int *|time_t *", 0, 0, (void*)0, 0};
54797 static swig_type_info _swigt__p_unsigned_long = {"_p_unsigned_long", "unsigned long *|wxUIntPtr *", 0, 0, (void*)0, 0};
54798 static swig_type_info _swigt__p_wxANIHandler = {"_p_wxANIHandler", "wxANIHandler *", 0, 0, (void*)0, 0};
54799 static swig_type_info _swigt__p_wxAcceleratorEntry = {"_p_wxAcceleratorEntry", "wxAcceleratorEntry *", 0, 0, (void*)0, 0};
54800 static swig_type_info _swigt__p_wxAcceleratorTable = {"_p_wxAcceleratorTable", "wxAcceleratorTable *", 0, 0, (void*)0, 0};
54801 static swig_type_info _swigt__p_wxActivateEvent = {"_p_wxActivateEvent", "wxActivateEvent *", 0, 0, (void*)0, 0};
54802 static swig_type_info _swigt__p_wxAppTraits = {"_p_wxAppTraits", "wxAppTraits *", 0, 0, (void*)0, 0};
54803 static swig_type_info _swigt__p_wxArrayString = {"_p_wxArrayString", "wxArrayString *", 0, 0, (void*)0, 0};
54804 static swig_type_info _swigt__p_wxBMPHandler = {"_p_wxBMPHandler", "wxBMPHandler *", 0, 0, (void*)0, 0};
54805 static swig_type_info _swigt__p_wxBitmap = {"_p_wxBitmap", "wxBitmap *", 0, 0, (void*)0, 0};
54806 static swig_type_info _swigt__p_wxBoxSizer = {"_p_wxBoxSizer", "wxBoxSizer *", 0, 0, (void*)0, 0};
54807 static swig_type_info _swigt__p_wxButton = {"_p_wxButton", "wxButton *", 0, 0, (void*)0, 0};
54808 static swig_type_info _swigt__p_wxCURHandler = {"_p_wxCURHandler", "wxCURHandler *", 0, 0, (void*)0, 0};
54809 static swig_type_info _swigt__p_wxCaret = {"_p_wxCaret", "wxCaret *", 0, 0, (void*)0, 0};
54810 static swig_type_info _swigt__p_wxChildFocusEvent = {"_p_wxChildFocusEvent", "wxChildFocusEvent *", 0, 0, (void*)0, 0};
54811 static swig_type_info _swigt__p_wxClipboardTextEvent = {"_p_wxClipboardTextEvent", "wxClipboardTextEvent *", 0, 0, (void*)0, 0};
54812 static swig_type_info _swigt__p_wxCloseEvent = {"_p_wxCloseEvent", "wxCloseEvent *", 0, 0, (void*)0, 0};
54813 static swig_type_info _swigt__p_wxColour = {"_p_wxColour", "wxColour *", 0, 0, (void*)0, 0};
54814 static swig_type_info _swigt__p_wxCommandEvent = {"_p_wxCommandEvent", "wxCommandEvent *", 0, 0, (void*)0, 0};
54815 static swig_type_info _swigt__p_wxContextMenuEvent = {"_p_wxContextMenuEvent", "wxContextMenuEvent *", 0, 0, (void*)0, 0};
54816 static swig_type_info _swigt__p_wxControl = {"_p_wxControl", "wxControl *", 0, 0, (void*)0, 0};
54817 static swig_type_info _swigt__p_wxControlWithItems = {"_p_wxControlWithItems", "wxControlWithItems *", 0, 0, (void*)0, 0};
54818 static swig_type_info _swigt__p_wxCursor = {"_p_wxCursor", "wxCursor *", 0, 0, (void*)0, 0};
54819 static swig_type_info _swigt__p_wxDC = {"_p_wxDC", "wxDC *", 0, 0, (void*)0, 0};
54820 static swig_type_info _swigt__p_wxDateEvent = {"_p_wxDateEvent", "wxDateEvent *", 0, 0, (void*)0, 0};
54821 static swig_type_info _swigt__p_wxDateTime = {"_p_wxDateTime", "wxDateTime *", 0, 0, (void*)0, 0};
54822 static swig_type_info _swigt__p_wxDisplayChangedEvent = {"_p_wxDisplayChangedEvent", "wxDisplayChangedEvent *", 0, 0, (void*)0, 0};
54823 static swig_type_info _swigt__p_wxDropFilesEvent = {"_p_wxDropFilesEvent", "wxDropFilesEvent *", 0, 0, (void*)0, 0};
54824 static swig_type_info _swigt__p_wxDuplexMode = {"_p_wxDuplexMode", "enum wxDuplexMode *|wxDuplexMode *", 0, 0, (void*)0, 0};
54825 static swig_type_info _swigt__p_wxEraseEvent = {"_p_wxEraseEvent", "wxEraseEvent *", 0, 0, (void*)0, 0};
54826 static swig_type_info _swigt__p_wxEvent = {"_p_wxEvent", "wxEvent *", 0, 0, (void*)0, 0};
54827 static swig_type_info _swigt__p_wxEventLoop = {"_p_wxEventLoop", "wxEventLoop *", 0, 0, (void*)0, 0};
54828 static swig_type_info _swigt__p_wxEventLoopActivator = {"_p_wxEventLoopActivator", "wxEventLoopActivator *", 0, 0, (void*)0, 0};
54829 static swig_type_info _swigt__p_wxEvtHandler = {"_p_wxEvtHandler", "wxEvtHandler *", 0, 0, (void*)0, 0};
54830 static swig_type_info _swigt__p_wxFSFile = {"_p_wxFSFile", "wxFSFile *", 0, 0, (void*)0, 0};
54831 static swig_type_info _swigt__p_wxFileSystem = {"_p_wxFileSystem", "wxFileSystem *", 0, 0, (void*)0, 0};
54832 static swig_type_info _swigt__p_wxFileSystemHandler = {"_p_wxFileSystemHandler", "wxFileSystemHandler *", 0, 0, (void*)0, 0};
54833 static swig_type_info _swigt__p_wxFlexGridSizer = {"_p_wxFlexGridSizer", "wxFlexGridSizer *", 0, 0, (void*)0, 0};
54834 static swig_type_info _swigt__p_wxFocusEvent = {"_p_wxFocusEvent", "wxFocusEvent *", 0, 0, (void*)0, 0};
54835 static swig_type_info _swigt__p_wxFont = {"_p_wxFont", "wxFont *", 0, 0, (void*)0, 0};
54836 static swig_type_info _swigt__p_wxFrame = {"_p_wxFrame", "wxFrame *", 0, 0, (void*)0, 0};
54837 static swig_type_info _swigt__p_wxGBPosition = {"_p_wxGBPosition", "wxGBPosition *", 0, 0, (void*)0, 0};
54838 static swig_type_info _swigt__p_wxGBSizerItem = {"_p_wxGBSizerItem", "wxGBSizerItem *", 0, 0, (void*)0, 0};
54839 static swig_type_info _swigt__p_wxGBSpan = {"_p_wxGBSpan", "wxGBSpan *", 0, 0, (void*)0, 0};
54840 static swig_type_info _swigt__p_wxGIFHandler = {"_p_wxGIFHandler", "wxGIFHandler *", 0, 0, (void*)0, 0};
54841 static swig_type_info _swigt__p_wxGridBagSizer = {"_p_wxGridBagSizer", "wxGridBagSizer *", 0, 0, (void*)0, 0};
54842 static swig_type_info _swigt__p_wxGridSizer = {"_p_wxGridSizer", "wxGridSizer *", 0, 0, (void*)0, 0};
54843 static swig_type_info _swigt__p_wxHelpEvent__Origin = {"_p_wxHelpEvent__Origin", "wxHelpEvent::Origin *", 0, 0, (void*)0, 0};
54844 static swig_type_info _swigt__p_wxICOHandler = {"_p_wxICOHandler", "wxICOHandler *", 0, 0, (void*)0, 0};
54845 static swig_type_info _swigt__p_wxIconizeEvent = {"_p_wxIconizeEvent", "wxIconizeEvent *", 0, 0, (void*)0, 0};
54846 static swig_type_info _swigt__p_wxIdleEvent = {"_p_wxIdleEvent", "wxIdleEvent *", 0, 0, (void*)0, 0};
54847 static swig_type_info _swigt__p_wxImage = {"_p_wxImage", "wxImage *", 0, 0, (void*)0, 0};
54848 static swig_type_info _swigt__p_wxImageHandler = {"_p_wxImageHandler", "wxImageHandler *", 0, 0, (void*)0, 0};
54849 static swig_type_info _swigt__p_wxImageHistogram = {"_p_wxImageHistogram", "wxImageHistogram *", 0, 0, (void*)0, 0};
54850 static swig_type_info _swigt__p_wxImage_HSVValue = {"_p_wxImage_HSVValue", "wxImage_HSVValue *", 0, 0, (void*)0, 0};
54851 static swig_type_info _swigt__p_wxImage_RGBValue = {"_p_wxImage_RGBValue", "wxImage_RGBValue *", 0, 0, (void*)0, 0};
54852 static swig_type_info _swigt__p_wxIndividualLayoutConstraint = {"_p_wxIndividualLayoutConstraint", "wxIndividualLayoutConstraint *", 0, 0, (void*)0, 0};
54853 static swig_type_info _swigt__p_wxInitDialogEvent = {"_p_wxInitDialogEvent", "wxInitDialogEvent *", 0, 0, (void*)0, 0};
54854 static swig_type_info _swigt__p_wxInputStream = {"_p_wxInputStream", "wxInputStream *", 0, 0, (void*)0, 0};
54855 static swig_type_info _swigt__p_wxInternetFSHandler = {"_p_wxInternetFSHandler", "wxInternetFSHandler *", 0, 0, (void*)0, 0};
54856 static swig_type_info _swigt__p_wxItemContainer = {"_p_wxItemContainer", "wxItemContainer *", 0, 0, (void*)0, 0};
54857 static swig_type_info _swigt__p_wxJPEGHandler = {"_p_wxJPEGHandler", "wxJPEGHandler *", 0, 0, (void*)0, 0};
54858 static swig_type_info _swigt__p_wxKeyEvent = {"_p_wxKeyEvent", "wxKeyEvent *", 0, 0, (void*)0, 0};
54859 static swig_type_info _swigt__p_wxLayoutConstraints = {"_p_wxLayoutConstraints", "wxLayoutConstraints *", 0, 0, (void*)0, 0};
54860 static swig_type_info _swigt__p_wxMaximizeEvent = {"_p_wxMaximizeEvent", "wxMaximizeEvent *", 0, 0, (void*)0, 0};
54861 static swig_type_info _swigt__p_wxMemoryFSHandler = {"_p_wxMemoryFSHandler", "wxMemoryFSHandler *", 0, 0, (void*)0, 0};
54862 static swig_type_info _swigt__p_wxMenu = {"_p_wxMenu", "wxMenu *", 0, 0, (void*)0, 0};
54863 static swig_type_info _swigt__p_wxMenuBar = {"_p_wxMenuBar", "wxMenuBar *", 0, 0, (void*)0, 0};
54864 static swig_type_info _swigt__p_wxMenuBarBase = {"_p_wxMenuBarBase", "wxMenuBarBase *", 0, 0, (void*)0, 0};
54865 static swig_type_info _swigt__p_wxMenuEvent = {"_p_wxMenuEvent", "wxMenuEvent *", 0, 0, (void*)0, 0};
54866 static swig_type_info _swigt__p_wxMenuItem = {"_p_wxMenuItem", "wxMenuItem *", 0, 0, (void*)0, 0};
54867 static swig_type_info _swigt__p_wxMouseCaptureChangedEvent = {"_p_wxMouseCaptureChangedEvent", "wxMouseCaptureChangedEvent *", 0, 0, (void*)0, 0};
54868 static swig_type_info _swigt__p_wxMouseCaptureLostEvent = {"_p_wxMouseCaptureLostEvent", "wxMouseCaptureLostEvent *", 0, 0, (void*)0, 0};
54869 static swig_type_info _swigt__p_wxMouseEvent = {"_p_wxMouseEvent", "wxMouseEvent *", 0, 0, (void*)0, 0};
54870 static swig_type_info _swigt__p_wxMoveEvent = {"_p_wxMoveEvent", "wxMoveEvent *", 0, 0, (void*)0, 0};
54871 static swig_type_info _swigt__p_wxNavigationKeyEvent = {"_p_wxNavigationKeyEvent", "wxNavigationKeyEvent *", 0, 0, (void*)0, 0};
54872 static swig_type_info _swigt__p_wxNcPaintEvent = {"_p_wxNcPaintEvent", "wxNcPaintEvent *", 0, 0, (void*)0, 0};
54873 static swig_type_info _swigt__p_wxNotifyEvent = {"_p_wxNotifyEvent", "wxNotifyEvent *", 0, 0, (void*)0, 0};
54874 static swig_type_info _swigt__p_wxObject = {"_p_wxObject", "wxObject *", 0, 0, (void*)0, 0};
54875 static swig_type_info _swigt__p_wxOutputStream = {"_p_wxOutputStream", "wxOutputStream *", 0, 0, (void*)0, 0};
54876 static swig_type_info _swigt__p_wxPCXHandler = {"_p_wxPCXHandler", "wxPCXHandler *", 0, 0, (void*)0, 0};
54877 static swig_type_info _swigt__p_wxPNGHandler = {"_p_wxPNGHandler", "wxPNGHandler *", 0, 0, (void*)0, 0};
54878 static swig_type_info _swigt__p_wxPNMHandler = {"_p_wxPNMHandler", "wxPNMHandler *", 0, 0, (void*)0, 0};
54879 static swig_type_info _swigt__p_wxPaintEvent = {"_p_wxPaintEvent", "wxPaintEvent *", 0, 0, (void*)0, 0};
54880 static swig_type_info _swigt__p_wxPaletteChangedEvent = {"_p_wxPaletteChangedEvent", "wxPaletteChangedEvent *", 0, 0, (void*)0, 0};
54881 static swig_type_info _swigt__p_wxPaperSize = {"_p_wxPaperSize", "enum wxPaperSize *|wxPaperSize *", 0, 0, (void*)0, 0};
54882 static swig_type_info _swigt__p_wxPoint = {"_p_wxPoint", "wxPoint *", 0, 0, (void*)0, 0};
54883 static swig_type_info _swigt__p_wxPoint2D = {"_p_wxPoint2D", "wxPoint2D *", 0, 0, (void*)0, 0};
54884 static swig_type_info _swigt__p_wxPropagateOnce = {"_p_wxPropagateOnce", "wxPropagateOnce *", 0, 0, (void*)0, 0};
54885 static swig_type_info _swigt__p_wxPropagationDisabler = {"_p_wxPropagationDisabler", "wxPropagationDisabler *", 0, 0, (void*)0, 0};
54886 static swig_type_info _swigt__p_wxPyApp = {"_p_wxPyApp", "wxPyApp *", 0, 0, (void*)0, 0};
54887 static swig_type_info _swigt__p_wxPyCommandEvent = {"_p_wxPyCommandEvent", "wxPyCommandEvent *", 0, 0, (void*)0, 0};
54888 static swig_type_info _swigt__p_wxPyDropTarget = {"_p_wxPyDropTarget", "wxPyDropTarget *", 0, 0, (void*)0, 0};
54889 static swig_type_info _swigt__p_wxPyEvent = {"_p_wxPyEvent", "wxPyEvent *", 0, 0, (void*)0, 0};
54890 static swig_type_info _swigt__p_wxPyFileSystemHandler = {"_p_wxPyFileSystemHandler", "wxPyFileSystemHandler *", 0, 0, (void*)0, 0};
54891 static swig_type_info _swigt__p_wxPyImageHandler = {"_p_wxPyImageHandler", "wxPyImageHandler *", 0, 0, (void*)0, 0};
54892 static swig_type_info _swigt__p_wxPyInputStream = {"_p_wxPyInputStream", "wxPyInputStream *", 0, 0, (void*)0, 0};
54893 static swig_type_info _swigt__p_wxPySizer = {"_p_wxPySizer", "wxPySizer *", 0, 0, (void*)0, 0};
54894 static swig_type_info _swigt__p_wxPyValidator = {"_p_wxPyValidator", "wxPyValidator *", 0, 0, (void*)0, 0};
54895 static swig_type_info _swigt__p_wxQuantize = {"_p_wxQuantize", "wxQuantize *", 0, 0, (void*)0, 0};
54896 static swig_type_info _swigt__p_wxQueryNewPaletteEvent = {"_p_wxQueryNewPaletteEvent", "wxQueryNewPaletteEvent *", 0, 0, (void*)0, 0};
54897 static swig_type_info _swigt__p_wxRealPoint = {"_p_wxRealPoint", "wxRealPoint *", 0, 0, (void*)0, 0};
54898 static swig_type_info _swigt__p_wxRect = {"_p_wxRect", "wxRect *", 0, 0, (void*)0, 0};
54899 static swig_type_info _swigt__p_wxRegion = {"_p_wxRegion", "wxRegion *", 0, 0, (void*)0, 0};
54900 static swig_type_info _swigt__p_wxScrollEvent = {"_p_wxScrollEvent", "wxScrollEvent *", 0, 0, (void*)0, 0};
54901 static swig_type_info _swigt__p_wxScrollWinEvent = {"_p_wxScrollWinEvent", "wxScrollWinEvent *", 0, 0, (void*)0, 0};
54902 static swig_type_info _swigt__p_wxSetCursorEvent = {"_p_wxSetCursorEvent", "wxSetCursorEvent *", 0, 0, (void*)0, 0};
54903 static swig_type_info _swigt__p_wxShowEvent = {"_p_wxShowEvent", "wxShowEvent *", 0, 0, (void*)0, 0};
54904 static swig_type_info _swigt__p_wxSize = {"_p_wxSize", "wxSize *", 0, 0, (void*)0, 0};
54905 static swig_type_info _swigt__p_wxSizeEvent = {"_p_wxSizeEvent", "wxSizeEvent *", 0, 0, (void*)0, 0};
54906 static swig_type_info _swigt__p_wxSizer = {"_p_wxSizer", "wxSizer *", 0, 0, (void*)0, 0};
54907 static swig_type_info _swigt__p_wxSizerItem = {"_p_wxSizerItem", "wxSizerItem *", 0, 0, (void*)0, 0};
54908 static swig_type_info _swigt__p_wxStaticBox = {"_p_wxStaticBox", "wxStaticBox *", 0, 0, (void*)0, 0};
54909 static swig_type_info _swigt__p_wxStaticBoxSizer = {"_p_wxStaticBoxSizer", "wxStaticBoxSizer *", 0, 0, (void*)0, 0};
54910 static swig_type_info _swigt__p_wxStdDialogButtonSizer = {"_p_wxStdDialogButtonSizer", "wxStdDialogButtonSizer *", 0, 0, (void*)0, 0};
54911 static swig_type_info _swigt__p_wxSysColourChangedEvent = {"_p_wxSysColourChangedEvent", "wxSysColourChangedEvent *", 0, 0, (void*)0, 0};
54912 static swig_type_info _swigt__p_wxTIFFHandler = {"_p_wxTIFFHandler", "wxTIFFHandler *", 0, 0, (void*)0, 0};
54913 static swig_type_info _swigt__p_wxToolTip = {"_p_wxToolTip", "wxToolTip *", 0, 0, (void*)0, 0};
54914 static swig_type_info _swigt__p_wxUpdateUIEvent = {"_p_wxUpdateUIEvent", "wxUpdateUIEvent *", 0, 0, (void*)0, 0};
54915 static swig_type_info _swigt__p_wxValidator = {"_p_wxValidator", "wxValidator *", 0, 0, (void*)0, 0};
54916 static swig_type_info _swigt__p_wxVisualAttributes = {"_p_wxVisualAttributes", "wxVisualAttributes *", 0, 0, (void*)0, 0};
54917 static swig_type_info _swigt__p_wxWindow = {"_p_wxWindow", "wxWindow *", 0, 0, (void*)0, 0};
54918 static swig_type_info _swigt__p_wxWindowCreateEvent = {"_p_wxWindowCreateEvent", "wxWindowCreateEvent *", 0, 0, (void*)0, 0};
54919 static swig_type_info _swigt__p_wxWindowDestroyEvent = {"_p_wxWindowDestroyEvent", "wxWindowDestroyEvent *", 0, 0, (void*)0, 0};
54920 static swig_type_info _swigt__p_wxXPMHandler = {"_p_wxXPMHandler", "wxXPMHandler *", 0, 0, (void*)0, 0};
54921 static swig_type_info _swigt__p_wxZipFSHandler = {"_p_wxZipFSHandler", "wxZipFSHandler *", 0, 0, (void*)0, 0};
54922
54923 static swig_type_info *swig_type_initial[] = {
54924 &_swigt__p_buffer,
54925 &_swigt__p_char,
54926 &_swigt__p_form_ops_t,
54927 &_swigt__p_int,
54928 &_swigt__p_long,
54929 &_swigt__p_unsigned_char,
54930 &_swigt__p_unsigned_int,
54931 &_swigt__p_unsigned_long,
54932 &_swigt__p_wxANIHandler,
54933 &_swigt__p_wxAcceleratorEntry,
54934 &_swigt__p_wxAcceleratorTable,
54935 &_swigt__p_wxActivateEvent,
54936 &_swigt__p_wxAppTraits,
54937 &_swigt__p_wxArrayString,
54938 &_swigt__p_wxBMPHandler,
54939 &_swigt__p_wxBitmap,
54940 &_swigt__p_wxBoxSizer,
54941 &_swigt__p_wxButton,
54942 &_swigt__p_wxCURHandler,
54943 &_swigt__p_wxCaret,
54944 &_swigt__p_wxChildFocusEvent,
54945 &_swigt__p_wxClipboardTextEvent,
54946 &_swigt__p_wxCloseEvent,
54947 &_swigt__p_wxColour,
54948 &_swigt__p_wxCommandEvent,
54949 &_swigt__p_wxContextMenuEvent,
54950 &_swigt__p_wxControl,
54951 &_swigt__p_wxControlWithItems,
54952 &_swigt__p_wxCursor,
54953 &_swigt__p_wxDC,
54954 &_swigt__p_wxDateEvent,
54955 &_swigt__p_wxDateTime,
54956 &_swigt__p_wxDisplayChangedEvent,
54957 &_swigt__p_wxDropFilesEvent,
54958 &_swigt__p_wxDuplexMode,
54959 &_swigt__p_wxEraseEvent,
54960 &_swigt__p_wxEvent,
54961 &_swigt__p_wxEventLoop,
54962 &_swigt__p_wxEventLoopActivator,
54963 &_swigt__p_wxEvtHandler,
54964 &_swigt__p_wxFSFile,
54965 &_swigt__p_wxFileSystem,
54966 &_swigt__p_wxFileSystemHandler,
54967 &_swigt__p_wxFlexGridSizer,
54968 &_swigt__p_wxFocusEvent,
54969 &_swigt__p_wxFont,
54970 &_swigt__p_wxFrame,
54971 &_swigt__p_wxGBPosition,
54972 &_swigt__p_wxGBSizerItem,
54973 &_swigt__p_wxGBSpan,
54974 &_swigt__p_wxGIFHandler,
54975 &_swigt__p_wxGridBagSizer,
54976 &_swigt__p_wxGridSizer,
54977 &_swigt__p_wxHelpEvent__Origin,
54978 &_swigt__p_wxICOHandler,
54979 &_swigt__p_wxIconizeEvent,
54980 &_swigt__p_wxIdleEvent,
54981 &_swigt__p_wxImage,
54982 &_swigt__p_wxImageHandler,
54983 &_swigt__p_wxImageHistogram,
54984 &_swigt__p_wxImage_HSVValue,
54985 &_swigt__p_wxImage_RGBValue,
54986 &_swigt__p_wxIndividualLayoutConstraint,
54987 &_swigt__p_wxInitDialogEvent,
54988 &_swigt__p_wxInputStream,
54989 &_swigt__p_wxInternetFSHandler,
54990 &_swigt__p_wxItemContainer,
54991 &_swigt__p_wxJPEGHandler,
54992 &_swigt__p_wxKeyEvent,
54993 &_swigt__p_wxLayoutConstraints,
54994 &_swigt__p_wxMaximizeEvent,
54995 &_swigt__p_wxMemoryFSHandler,
54996 &_swigt__p_wxMenu,
54997 &_swigt__p_wxMenuBar,
54998 &_swigt__p_wxMenuBarBase,
54999 &_swigt__p_wxMenuEvent,
55000 &_swigt__p_wxMenuItem,
55001 &_swigt__p_wxMouseCaptureChangedEvent,
55002 &_swigt__p_wxMouseCaptureLostEvent,
55003 &_swigt__p_wxMouseEvent,
55004 &_swigt__p_wxMoveEvent,
55005 &_swigt__p_wxNavigationKeyEvent,
55006 &_swigt__p_wxNcPaintEvent,
55007 &_swigt__p_wxNotifyEvent,
55008 &_swigt__p_wxObject,
55009 &_swigt__p_wxOutputStream,
55010 &_swigt__p_wxPCXHandler,
55011 &_swigt__p_wxPNGHandler,
55012 &_swigt__p_wxPNMHandler,
55013 &_swigt__p_wxPaintEvent,
55014 &_swigt__p_wxPaletteChangedEvent,
55015 &_swigt__p_wxPaperSize,
55016 &_swigt__p_wxPoint,
55017 &_swigt__p_wxPoint2D,
55018 &_swigt__p_wxPropagateOnce,
55019 &_swigt__p_wxPropagationDisabler,
55020 &_swigt__p_wxPyApp,
55021 &_swigt__p_wxPyCommandEvent,
55022 &_swigt__p_wxPyDropTarget,
55023 &_swigt__p_wxPyEvent,
55024 &_swigt__p_wxPyFileSystemHandler,
55025 &_swigt__p_wxPyImageHandler,
55026 &_swigt__p_wxPyInputStream,
55027 &_swigt__p_wxPySizer,
55028 &_swigt__p_wxPyValidator,
55029 &_swigt__p_wxQuantize,
55030 &_swigt__p_wxQueryNewPaletteEvent,
55031 &_swigt__p_wxRealPoint,
55032 &_swigt__p_wxRect,
55033 &_swigt__p_wxRegion,
55034 &_swigt__p_wxScrollEvent,
55035 &_swigt__p_wxScrollWinEvent,
55036 &_swigt__p_wxSetCursorEvent,
55037 &_swigt__p_wxShowEvent,
55038 &_swigt__p_wxSize,
55039 &_swigt__p_wxSizeEvent,
55040 &_swigt__p_wxSizer,
55041 &_swigt__p_wxSizerItem,
55042 &_swigt__p_wxStaticBox,
55043 &_swigt__p_wxStaticBoxSizer,
55044 &_swigt__p_wxStdDialogButtonSizer,
55045 &_swigt__p_wxSysColourChangedEvent,
55046 &_swigt__p_wxTIFFHandler,
55047 &_swigt__p_wxToolTip,
55048 &_swigt__p_wxUpdateUIEvent,
55049 &_swigt__p_wxValidator,
55050 &_swigt__p_wxVisualAttributes,
55051 &_swigt__p_wxWindow,
55052 &_swigt__p_wxWindowCreateEvent,
55053 &_swigt__p_wxWindowDestroyEvent,
55054 &_swigt__p_wxXPMHandler,
55055 &_swigt__p_wxZipFSHandler,
55056 };
55057
55058 static swig_cast_info _swigc__p_buffer[] = { {&_swigt__p_buffer, 0, 0, 0},{0, 0, 0, 0}};
55059 static swig_cast_info _swigc__p_char[] = { {&_swigt__p_char, 0, 0, 0},{0, 0, 0, 0}};
55060 static swig_cast_info _swigc__p_form_ops_t[] = { {&_swigt__p_form_ops_t, 0, 0, 0},{0, 0, 0, 0}};
55061 static swig_cast_info _swigc__p_int[] = { {&_swigt__p_int, 0, 0, 0},{0, 0, 0, 0}};
55062 static swig_cast_info _swigc__p_long[] = { {&_swigt__p_long, 0, 0, 0},{0, 0, 0, 0}};
55063 static swig_cast_info _swigc__p_unsigned_char[] = { {&_swigt__p_unsigned_char, 0, 0, 0},{0, 0, 0, 0}};
55064 static swig_cast_info _swigc__p_unsigned_int[] = { {&_swigt__p_unsigned_int, 0, 0, 0},{0, 0, 0, 0}};
55065 static swig_cast_info _swigc__p_unsigned_long[] = { {&_swigt__p_unsigned_long, 0, 0, 0},{0, 0, 0, 0}};
55066 static swig_cast_info _swigc__p_wxANIHandler[] = { {&_swigt__p_wxANIHandler, 0, 0, 0},{0, 0, 0, 0}};
55067 static swig_cast_info _swigc__p_wxAcceleratorEntry[] = { {&_swigt__p_wxAcceleratorEntry, 0, 0, 0},{0, 0, 0, 0}};
55068 static swig_cast_info _swigc__p_wxAcceleratorTable[] = { {&_swigt__p_wxAcceleratorTable, 0, 0, 0},{0, 0, 0, 0}};
55069 static swig_cast_info _swigc__p_wxActivateEvent[] = { {&_swigt__p_wxActivateEvent, 0, 0, 0},{0, 0, 0, 0}};
55070 static swig_cast_info _swigc__p_wxAppTraits[] = { {&_swigt__p_wxAppTraits, 0, 0, 0},{0, 0, 0, 0}};
55071 static swig_cast_info _swigc__p_wxArrayString[] = { {&_swigt__p_wxArrayString, 0, 0, 0},{0, 0, 0, 0}};
55072 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}};
55073 static swig_cast_info _swigc__p_wxBitmap[] = { {&_swigt__p_wxBitmap, 0, 0, 0},{0, 0, 0, 0}};
55074 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}};
55075 static swig_cast_info _swigc__p_wxButton[] = { {&_swigt__p_wxButton, 0, 0, 0},{0, 0, 0, 0}};
55076 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}};
55077 static swig_cast_info _swigc__p_wxCaret[] = { {&_swigt__p_wxCaret, 0, 0, 0},{0, 0, 0, 0}};
55078 static swig_cast_info _swigc__p_wxChildFocusEvent[] = { {&_swigt__p_wxChildFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55079 static swig_cast_info _swigc__p_wxClipboardTextEvent[] = { {&_swigt__p_wxClipboardTextEvent, 0, 0, 0},{0, 0, 0, 0}};
55080 static swig_cast_info _swigc__p_wxCloseEvent[] = { {&_swigt__p_wxCloseEvent, 0, 0, 0},{0, 0, 0, 0}};
55081 static swig_cast_info _swigc__p_wxColour[] = { {&_swigt__p_wxColour, 0, 0, 0},{0, 0, 0, 0}};
55082 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}};
55083 static swig_cast_info _swigc__p_wxContextMenuEvent[] = { {&_swigt__p_wxContextMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55084 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}};
55085 static swig_cast_info _swigc__p_wxControlWithItems[] = { {&_swigt__p_wxControlWithItems, 0, 0, 0},{0, 0, 0, 0}};
55086 static swig_cast_info _swigc__p_wxCursor[] = { {&_swigt__p_wxCursor, 0, 0, 0},{0, 0, 0, 0}};
55087 static swig_cast_info _swigc__p_wxDC[] = { {&_swigt__p_wxDC, 0, 0, 0},{0, 0, 0, 0}};
55088 static swig_cast_info _swigc__p_wxDateEvent[] = { {&_swigt__p_wxDateEvent, 0, 0, 0},{0, 0, 0, 0}};
55089 static swig_cast_info _swigc__p_wxDateTime[] = { {&_swigt__p_wxDateTime, 0, 0, 0},{0, 0, 0, 0}};
55090 static swig_cast_info _swigc__p_wxDisplayChangedEvent[] = { {&_swigt__p_wxDisplayChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55091 static swig_cast_info _swigc__p_wxDropFilesEvent[] = { {&_swigt__p_wxDropFilesEvent, 0, 0, 0},{0, 0, 0, 0}};
55092 static swig_cast_info _swigc__p_wxDuplexMode[] = { {&_swigt__p_wxDuplexMode, 0, 0, 0},{0, 0, 0, 0}};
55093 static swig_cast_info _swigc__p_wxEraseEvent[] = { {&_swigt__p_wxEraseEvent, 0, 0, 0},{0, 0, 0, 0}};
55094 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}};
55095 static swig_cast_info _swigc__p_wxEventLoop[] = { {&_swigt__p_wxEventLoop, 0, 0, 0},{0, 0, 0, 0}};
55096 static swig_cast_info _swigc__p_wxEventLoopActivator[] = { {&_swigt__p_wxEventLoopActivator, 0, 0, 0},{0, 0, 0, 0}};
55097 static swig_cast_info _swigc__p_wxEvtHandler[] = { {&_swigt__p_wxControl, _p_wxControlTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxControlWithItems, _p_wxControlWithItemsTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxEvtHandler, 0, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxValidator, _p_wxValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxPyValidator, _p_wxPyValidatorTo_p_wxEvtHandler, 0, 0}, {&_swigt__p_wxMenu, _p_wxMenuTo_p_wxEvtHandler, 0, 0},{0, 0, 0, 0}};
55098 static swig_cast_info _swigc__p_wxFSFile[] = { {&_swigt__p_wxFSFile, 0, 0, 0},{0, 0, 0, 0}};
55099 static swig_cast_info _swigc__p_wxFileSystem[] = { {&_swigt__p_wxFileSystem, 0, 0, 0},{0, 0, 0, 0}};
55100 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}};
55101 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}};
55102 static swig_cast_info _swigc__p_wxFocusEvent[] = { {&_swigt__p_wxFocusEvent, 0, 0, 0},{0, 0, 0, 0}};
55103 static swig_cast_info _swigc__p_wxFont[] = { {&_swigt__p_wxFont, 0, 0, 0},{0, 0, 0, 0}};
55104 static swig_cast_info _swigc__p_wxFrame[] = { {&_swigt__p_wxFrame, 0, 0, 0},{0, 0, 0, 0}};
55105 static swig_cast_info _swigc__p_wxGBPosition[] = { {&_swigt__p_wxGBPosition, 0, 0, 0},{0, 0, 0, 0}};
55106 static swig_cast_info _swigc__p_wxGBSizerItem[] = { {&_swigt__p_wxGBSizerItem, 0, 0, 0},{0, 0, 0, 0}};
55107 static swig_cast_info _swigc__p_wxGBSpan[] = { {&_swigt__p_wxGBSpan, 0, 0, 0},{0, 0, 0, 0}};
55108 static swig_cast_info _swigc__p_wxGIFHandler[] = { {&_swigt__p_wxGIFHandler, 0, 0, 0},{0, 0, 0, 0}};
55109 static swig_cast_info _swigc__p_wxGridBagSizer[] = { {&_swigt__p_wxGridBagSizer, 0, 0, 0},{0, 0, 0, 0}};
55110 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}};
55111 static swig_cast_info _swigc__p_wxHelpEvent__Origin[] = { {&_swigt__p_wxHelpEvent__Origin, 0, 0, 0},{0, 0, 0, 0}};
55112 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}};
55113 static swig_cast_info _swigc__p_wxIconizeEvent[] = { {&_swigt__p_wxIconizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55114 static swig_cast_info _swigc__p_wxIdleEvent[] = { {&_swigt__p_wxIdleEvent, 0, 0, 0},{0, 0, 0, 0}};
55115 static swig_cast_info _swigc__p_wxImage[] = { {&_swigt__p_wxImage, 0, 0, 0},{0, 0, 0, 0}};
55116 static swig_cast_info _swigc__p_wxImageHandler[] = { {&_swigt__p_wxImageHandler, 0, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxImageHandler, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxImageHandler, 0, 0},{0, 0, 0, 0}};
55117 static swig_cast_info _swigc__p_wxImageHistogram[] = { {&_swigt__p_wxImageHistogram, 0, 0, 0},{0, 0, 0, 0}};
55118 static swig_cast_info _swigc__p_wxImage_HSVValue[] = { {&_swigt__p_wxImage_HSVValue, 0, 0, 0},{0, 0, 0, 0}};
55119 static swig_cast_info _swigc__p_wxImage_RGBValue[] = { {&_swigt__p_wxImage_RGBValue, 0, 0, 0},{0, 0, 0, 0}};
55120 static swig_cast_info _swigc__p_wxIndividualLayoutConstraint[] = { {&_swigt__p_wxIndividualLayoutConstraint, 0, 0, 0},{0, 0, 0, 0}};
55121 static swig_cast_info _swigc__p_wxInitDialogEvent[] = { {&_swigt__p_wxInitDialogEvent, 0, 0, 0},{0, 0, 0, 0}};
55122 static swig_cast_info _swigc__p_wxInputStream[] = { {&_swigt__p_wxInputStream, 0, 0, 0},{0, 0, 0, 0}};
55123 static swig_cast_info _swigc__p_wxInternetFSHandler[] = { {&_swigt__p_wxInternetFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55124 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}};
55125 static swig_cast_info _swigc__p_wxJPEGHandler[] = { {&_swigt__p_wxJPEGHandler, 0, 0, 0},{0, 0, 0, 0}};
55126 static swig_cast_info _swigc__p_wxKeyEvent[] = { {&_swigt__p_wxKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55127 static swig_cast_info _swigc__p_wxLayoutConstraints[] = { {&_swigt__p_wxLayoutConstraints, 0, 0, 0},{0, 0, 0, 0}};
55128 static swig_cast_info _swigc__p_wxMaximizeEvent[] = { {&_swigt__p_wxMaximizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55129 static swig_cast_info _swigc__p_wxMemoryFSHandler[] = { {&_swigt__p_wxMemoryFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55130 static swig_cast_info _swigc__p_wxMenu[] = { {&_swigt__p_wxMenu, 0, 0, 0},{0, 0, 0, 0}};
55131 static swig_cast_info _swigc__p_wxMenuBar[] = { {&_swigt__p_wxMenuBar, 0, 0, 0},{0, 0, 0, 0}};
55132 static swig_cast_info _swigc__p_wxMenuBarBase[] = { {&_swigt__p_wxMenuBarBase, 0, 0, 0},{0, 0, 0, 0}};
55133 static swig_cast_info _swigc__p_wxMenuEvent[] = { {&_swigt__p_wxMenuEvent, 0, 0, 0},{0, 0, 0, 0}};
55134 static swig_cast_info _swigc__p_wxMenuItem[] = { {&_swigt__p_wxMenuItem, 0, 0, 0},{0, 0, 0, 0}};
55135 static swig_cast_info _swigc__p_wxMouseCaptureChangedEvent[] = { {&_swigt__p_wxMouseCaptureChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55136 static swig_cast_info _swigc__p_wxMouseCaptureLostEvent[] = { {&_swigt__p_wxMouseCaptureLostEvent, 0, 0, 0},{0, 0, 0, 0}};
55137 static swig_cast_info _swigc__p_wxMouseEvent[] = { {&_swigt__p_wxMouseEvent, 0, 0, 0},{0, 0, 0, 0}};
55138 static swig_cast_info _swigc__p_wxMoveEvent[] = { {&_swigt__p_wxMoveEvent, 0, 0, 0},{0, 0, 0, 0}};
55139 static swig_cast_info _swigc__p_wxNavigationKeyEvent[] = { {&_swigt__p_wxNavigationKeyEvent, 0, 0, 0},{0, 0, 0, 0}};
55140 static swig_cast_info _swigc__p_wxNcPaintEvent[] = { {&_swigt__p_wxNcPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55141 static swig_cast_info _swigc__p_wxNotifyEvent[] = { {&_swigt__p_wxNotifyEvent, 0, 0, 0},{0, 0, 0, 0}};
55142 static swig_cast_info _swigc__p_wxObject[] = { {&_swigt__p_wxLayoutConstraints, _p_wxLayoutConstraintsTo_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_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_wxQueryNewPaletteEvent, _p_wxQueryNewPaletteEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPCXHandler, _p_wxPCXHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxGIFHandler, _p_wxGIFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNGHandler, _p_wxPNGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxANIHandler, _p_wxANIHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxCURHandler, _p_wxCURHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxICOHandler, _p_wxICOHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxBMPHandler, _p_wxBMPHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyImageHandler, _p_wxPyImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxImageHandler, _p_wxImageHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxXPMHandler, _p_wxXPMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxTIFFHandler, _p_wxTIFFHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxEvtHandler, _p_wxEvtHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseCaptureLostEvent, _p_wxMouseCaptureLostEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxJPEGHandler, _p_wxJPEGHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxPNMHandler, _p_wxPNMHandlerTo_p_wxObject, 0, 0}, {&_swigt__p_wxStdDialogButtonSizer, _p_wxStdDialogButtonSizerTo_p_wxObject, 0, 0}, {&_swigt__p_wxAcceleratorTable, _p_wxAcceleratorTableTo_p_wxObject, 0, 0}, {&_swigt__p_wxImage, _p_wxImageTo_p_wxObject, 0, 0}, {&_swigt__p_wxScrollWinEvent, _p_wxScrollWinEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxObject, 0, 0, 0}, {&_swigt__p_wxKeyEvent, _p_wxKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxNavigationKeyEvent, _p_wxNavigationKeyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindowDestroyEvent, _p_wxWindowDestroyEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxWindow, _p_wxWindowTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuBar, _p_wxMenuBarTo_p_wxObject, 0, 0}, {&_swigt__p_wxFileSystem, _p_wxFileSystemTo_p_wxObject, 0, 0}, {&_swigt__p_wxContextMenuEvent, _p_wxContextMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMenuEvent, _p_wxMenuEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxPyApp, _p_wxPyAppTo_p_wxObject, 0, 0}, {&_swigt__p_wxCloseEvent, _p_wxCloseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxMouseEvent, _p_wxMouseEventTo_p_wxObject, 0, 0}, {&_swigt__p_wxEraseEvent, _p_wxEraseEventTo_p_wxObject, 0, 0}, {&_swigt__p_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}};
55143 static swig_cast_info _swigc__p_wxOutputStream[] = { {&_swigt__p_wxOutputStream, 0, 0, 0},{0, 0, 0, 0}};
55144 static swig_cast_info _swigc__p_wxPCXHandler[] = { {&_swigt__p_wxPCXHandler, 0, 0, 0},{0, 0, 0, 0}};
55145 static swig_cast_info _swigc__p_wxPNGHandler[] = { {&_swigt__p_wxPNGHandler, 0, 0, 0},{0, 0, 0, 0}};
55146 static swig_cast_info _swigc__p_wxPNMHandler[] = { {&_swigt__p_wxPNMHandler, 0, 0, 0},{0, 0, 0, 0}};
55147 static swig_cast_info _swigc__p_wxPaintEvent[] = { {&_swigt__p_wxPaintEvent, 0, 0, 0},{0, 0, 0, 0}};
55148 static swig_cast_info _swigc__p_wxPaletteChangedEvent[] = { {&_swigt__p_wxPaletteChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55149 static swig_cast_info _swigc__p_wxPaperSize[] = { {&_swigt__p_wxPaperSize, 0, 0, 0},{0, 0, 0, 0}};
55150 static swig_cast_info _swigc__p_wxPoint[] = { {&_swigt__p_wxPoint, 0, 0, 0},{0, 0, 0, 0}};
55151 static swig_cast_info _swigc__p_wxPoint2D[] = { {&_swigt__p_wxPoint2D, 0, 0, 0},{0, 0, 0, 0}};
55152 static swig_cast_info _swigc__p_wxPropagateOnce[] = { {&_swigt__p_wxPropagateOnce, 0, 0, 0},{0, 0, 0, 0}};
55153 static swig_cast_info _swigc__p_wxPropagationDisabler[] = { {&_swigt__p_wxPropagationDisabler, 0, 0, 0},{0, 0, 0, 0}};
55154 static swig_cast_info _swigc__p_wxPyApp[] = { {&_swigt__p_wxPyApp, 0, 0, 0},{0, 0, 0, 0}};
55155 static swig_cast_info _swigc__p_wxPyCommandEvent[] = { {&_swigt__p_wxPyCommandEvent, 0, 0, 0},{0, 0, 0, 0}};
55156 static swig_cast_info _swigc__p_wxPyDropTarget[] = { {&_swigt__p_wxPyDropTarget, 0, 0, 0},{0, 0, 0, 0}};
55157 static swig_cast_info _swigc__p_wxPyEvent[] = { {&_swigt__p_wxPyEvent, 0, 0, 0},{0, 0, 0, 0}};
55158 static swig_cast_info _swigc__p_wxPyFileSystemHandler[] = { {&_swigt__p_wxPyFileSystemHandler, 0, 0, 0},{0, 0, 0, 0}};
55159 static swig_cast_info _swigc__p_wxPyImageHandler[] = { {&_swigt__p_wxPyImageHandler, 0, 0, 0},{0, 0, 0, 0}};
55160 static swig_cast_info _swigc__p_wxPyInputStream[] = { {&_swigt__p_wxPyInputStream, 0, 0, 0},{0, 0, 0, 0}};
55161 static swig_cast_info _swigc__p_wxPySizer[] = { {&_swigt__p_wxPySizer, 0, 0, 0},{0, 0, 0, 0}};
55162 static swig_cast_info _swigc__p_wxPyValidator[] = { {&_swigt__p_wxPyValidator, 0, 0, 0},{0, 0, 0, 0}};
55163 static swig_cast_info _swigc__p_wxQuantize[] = { {&_swigt__p_wxQuantize, 0, 0, 0},{0, 0, 0, 0}};
55164 static swig_cast_info _swigc__p_wxQueryNewPaletteEvent[] = { {&_swigt__p_wxQueryNewPaletteEvent, 0, 0, 0},{0, 0, 0, 0}};
55165 static swig_cast_info _swigc__p_wxRealPoint[] = { {&_swigt__p_wxRealPoint, 0, 0, 0},{0, 0, 0, 0}};
55166 static swig_cast_info _swigc__p_wxRect[] = { {&_swigt__p_wxRect, 0, 0, 0},{0, 0, 0, 0}};
55167 static swig_cast_info _swigc__p_wxRegion[] = { {&_swigt__p_wxRegion, 0, 0, 0},{0, 0, 0, 0}};
55168 static swig_cast_info _swigc__p_wxScrollEvent[] = { {&_swigt__p_wxScrollEvent, 0, 0, 0},{0, 0, 0, 0}};
55169 static swig_cast_info _swigc__p_wxScrollWinEvent[] = { {&_swigt__p_wxScrollWinEvent, 0, 0, 0},{0, 0, 0, 0}};
55170 static swig_cast_info _swigc__p_wxSetCursorEvent[] = { {&_swigt__p_wxSetCursorEvent, 0, 0, 0},{0, 0, 0, 0}};
55171 static swig_cast_info _swigc__p_wxShowEvent[] = { {&_swigt__p_wxShowEvent, 0, 0, 0},{0, 0, 0, 0}};
55172 static swig_cast_info _swigc__p_wxSize[] = { {&_swigt__p_wxSize, 0, 0, 0},{0, 0, 0, 0}};
55173 static swig_cast_info _swigc__p_wxSizeEvent[] = { {&_swigt__p_wxSizeEvent, 0, 0, 0},{0, 0, 0, 0}};
55174 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}};
55175 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}};
55176 static swig_cast_info _swigc__p_wxStaticBox[] = { {&_swigt__p_wxStaticBox, 0, 0, 0},{0, 0, 0, 0}};
55177 static swig_cast_info _swigc__p_wxStaticBoxSizer[] = { {&_swigt__p_wxStaticBoxSizer, 0, 0, 0},{0, 0, 0, 0}};
55178 static swig_cast_info _swigc__p_wxStdDialogButtonSizer[] = { {&_swigt__p_wxStdDialogButtonSizer, 0, 0, 0},{0, 0, 0, 0}};
55179 static swig_cast_info _swigc__p_wxSysColourChangedEvent[] = { {&_swigt__p_wxSysColourChangedEvent, 0, 0, 0},{0, 0, 0, 0}};
55180 static swig_cast_info _swigc__p_wxTIFFHandler[] = { {&_swigt__p_wxTIFFHandler, 0, 0, 0},{0, 0, 0, 0}};
55181 static swig_cast_info _swigc__p_wxToolTip[] = { {&_swigt__p_wxToolTip, 0, 0, 0},{0, 0, 0, 0}};
55182 static swig_cast_info _swigc__p_wxUpdateUIEvent[] = { {&_swigt__p_wxUpdateUIEvent, 0, 0, 0},{0, 0, 0, 0}};
55183 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}};
55184 static swig_cast_info _swigc__p_wxVisualAttributes[] = { {&_swigt__p_wxVisualAttributes, 0, 0, 0},{0, 0, 0, 0}};
55185 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}};
55186 static swig_cast_info _swigc__p_wxWindowCreateEvent[] = { {&_swigt__p_wxWindowCreateEvent, 0, 0, 0},{0, 0, 0, 0}};
55187 static swig_cast_info _swigc__p_wxWindowDestroyEvent[] = { {&_swigt__p_wxWindowDestroyEvent, 0, 0, 0},{0, 0, 0, 0}};
55188 static swig_cast_info _swigc__p_wxXPMHandler[] = { {&_swigt__p_wxXPMHandler, 0, 0, 0},{0, 0, 0, 0}};
55189 static swig_cast_info _swigc__p_wxZipFSHandler[] = { {&_swigt__p_wxZipFSHandler, 0, 0, 0},{0, 0, 0, 0}};
55190
55191 static swig_cast_info *swig_cast_initial[] = {
55192 _swigc__p_buffer,
55193 _swigc__p_char,
55194 _swigc__p_form_ops_t,
55195 _swigc__p_int,
55196 _swigc__p_long,
55197 _swigc__p_unsigned_char,
55198 _swigc__p_unsigned_int,
55199 _swigc__p_unsigned_long,
55200 _swigc__p_wxANIHandler,
55201 _swigc__p_wxAcceleratorEntry,
55202 _swigc__p_wxAcceleratorTable,
55203 _swigc__p_wxActivateEvent,
55204 _swigc__p_wxAppTraits,
55205 _swigc__p_wxArrayString,
55206 _swigc__p_wxBMPHandler,
55207 _swigc__p_wxBitmap,
55208 _swigc__p_wxBoxSizer,
55209 _swigc__p_wxButton,
55210 _swigc__p_wxCURHandler,
55211 _swigc__p_wxCaret,
55212 _swigc__p_wxChildFocusEvent,
55213 _swigc__p_wxClipboardTextEvent,
55214 _swigc__p_wxCloseEvent,
55215 _swigc__p_wxColour,
55216 _swigc__p_wxCommandEvent,
55217 _swigc__p_wxContextMenuEvent,
55218 _swigc__p_wxControl,
55219 _swigc__p_wxControlWithItems,
55220 _swigc__p_wxCursor,
55221 _swigc__p_wxDC,
55222 _swigc__p_wxDateEvent,
55223 _swigc__p_wxDateTime,
55224 _swigc__p_wxDisplayChangedEvent,
55225 _swigc__p_wxDropFilesEvent,
55226 _swigc__p_wxDuplexMode,
55227 _swigc__p_wxEraseEvent,
55228 _swigc__p_wxEvent,
55229 _swigc__p_wxEventLoop,
55230 _swigc__p_wxEventLoopActivator,
55231 _swigc__p_wxEvtHandler,
55232 _swigc__p_wxFSFile,
55233 _swigc__p_wxFileSystem,
55234 _swigc__p_wxFileSystemHandler,
55235 _swigc__p_wxFlexGridSizer,
55236 _swigc__p_wxFocusEvent,
55237 _swigc__p_wxFont,
55238 _swigc__p_wxFrame,
55239 _swigc__p_wxGBPosition,
55240 _swigc__p_wxGBSizerItem,
55241 _swigc__p_wxGBSpan,
55242 _swigc__p_wxGIFHandler,
55243 _swigc__p_wxGridBagSizer,
55244 _swigc__p_wxGridSizer,
55245 _swigc__p_wxHelpEvent__Origin,
55246 _swigc__p_wxICOHandler,
55247 _swigc__p_wxIconizeEvent,
55248 _swigc__p_wxIdleEvent,
55249 _swigc__p_wxImage,
55250 _swigc__p_wxImageHandler,
55251 _swigc__p_wxImageHistogram,
55252 _swigc__p_wxImage_HSVValue,
55253 _swigc__p_wxImage_RGBValue,
55254 _swigc__p_wxIndividualLayoutConstraint,
55255 _swigc__p_wxInitDialogEvent,
55256 _swigc__p_wxInputStream,
55257 _swigc__p_wxInternetFSHandler,
55258 _swigc__p_wxItemContainer,
55259 _swigc__p_wxJPEGHandler,
55260 _swigc__p_wxKeyEvent,
55261 _swigc__p_wxLayoutConstraints,
55262 _swigc__p_wxMaximizeEvent,
55263 _swigc__p_wxMemoryFSHandler,
55264 _swigc__p_wxMenu,
55265 _swigc__p_wxMenuBar,
55266 _swigc__p_wxMenuBarBase,
55267 _swigc__p_wxMenuEvent,
55268 _swigc__p_wxMenuItem,
55269 _swigc__p_wxMouseCaptureChangedEvent,
55270 _swigc__p_wxMouseCaptureLostEvent,
55271 _swigc__p_wxMouseEvent,
55272 _swigc__p_wxMoveEvent,
55273 _swigc__p_wxNavigationKeyEvent,
55274 _swigc__p_wxNcPaintEvent,
55275 _swigc__p_wxNotifyEvent,
55276 _swigc__p_wxObject,
55277 _swigc__p_wxOutputStream,
55278 _swigc__p_wxPCXHandler,
55279 _swigc__p_wxPNGHandler,
55280 _swigc__p_wxPNMHandler,
55281 _swigc__p_wxPaintEvent,
55282 _swigc__p_wxPaletteChangedEvent,
55283 _swigc__p_wxPaperSize,
55284 _swigc__p_wxPoint,
55285 _swigc__p_wxPoint2D,
55286 _swigc__p_wxPropagateOnce,
55287 _swigc__p_wxPropagationDisabler,
55288 _swigc__p_wxPyApp,
55289 _swigc__p_wxPyCommandEvent,
55290 _swigc__p_wxPyDropTarget,
55291 _swigc__p_wxPyEvent,
55292 _swigc__p_wxPyFileSystemHandler,
55293 _swigc__p_wxPyImageHandler,
55294 _swigc__p_wxPyInputStream,
55295 _swigc__p_wxPySizer,
55296 _swigc__p_wxPyValidator,
55297 _swigc__p_wxQuantize,
55298 _swigc__p_wxQueryNewPaletteEvent,
55299 _swigc__p_wxRealPoint,
55300 _swigc__p_wxRect,
55301 _swigc__p_wxRegion,
55302 _swigc__p_wxScrollEvent,
55303 _swigc__p_wxScrollWinEvent,
55304 _swigc__p_wxSetCursorEvent,
55305 _swigc__p_wxShowEvent,
55306 _swigc__p_wxSize,
55307 _swigc__p_wxSizeEvent,
55308 _swigc__p_wxSizer,
55309 _swigc__p_wxSizerItem,
55310 _swigc__p_wxStaticBox,
55311 _swigc__p_wxStaticBoxSizer,
55312 _swigc__p_wxStdDialogButtonSizer,
55313 _swigc__p_wxSysColourChangedEvent,
55314 _swigc__p_wxTIFFHandler,
55315 _swigc__p_wxToolTip,
55316 _swigc__p_wxUpdateUIEvent,
55317 _swigc__p_wxValidator,
55318 _swigc__p_wxVisualAttributes,
55319 _swigc__p_wxWindow,
55320 _swigc__p_wxWindowCreateEvent,
55321 _swigc__p_wxWindowDestroyEvent,
55322 _swigc__p_wxXPMHandler,
55323 _swigc__p_wxZipFSHandler,
55324 };
55325
55326
55327 /* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */
55328
55329 static swig_const_info swig_const_table[] = {
55330 {0, 0, 0, 0.0, 0, 0}};
55331
55332 #ifdef __cplusplus
55333 }
55334 #endif
55335 /* -----------------------------------------------------------------------------
55336 * Type initialization:
55337 * This problem is tough by the requirement that no dynamic
55338 * memory is used. Also, since swig_type_info structures store pointers to
55339 * swig_cast_info structures and swig_cast_info structures store pointers back
55340 * to swig_type_info structures, we need some lookup code at initialization.
55341 * The idea is that swig generates all the structures that are needed.
55342 * The runtime then collects these partially filled structures.
55343 * The SWIG_InitializeModule function takes these initial arrays out of
55344 * swig_module, and does all the lookup, filling in the swig_module.types
55345 * array with the correct data and linking the correct swig_cast_info
55346 * structures together.
55347 *
55348 * The generated swig_type_info structures are assigned staticly to an initial
55349 * array. We just loop though that array, and handle each type individually.
55350 * First we lookup if this type has been already loaded, and if so, use the
55351 * loaded structure instead of the generated one. Then we have to fill in the
55352 * cast linked list. The cast data is initially stored in something like a
55353 * two-dimensional array. Each row corresponds to a type (there are the same
55354 * number of rows as there are in the swig_type_initial array). Each entry in
55355 * a column is one of the swig_cast_info structures for that type.
55356 * The cast_initial array is actually an array of arrays, because each row has
55357 * a variable number of columns. So to actually build the cast linked list,
55358 * we find the array of casts associated with the type, and loop through it
55359 * adding the casts to the list. The one last trick we need to do is making
55360 * sure the type pointer in the swig_cast_info struct is correct.
55361 *
55362 * First off, we lookup the cast->type name to see if it is already loaded.
55363 * There are three cases to handle:
55364 * 1) If the cast->type has already been loaded AND the type we are adding
55365 * casting info to has not been loaded (it is in this module), THEN we
55366 * replace the cast->type pointer with the type pointer that has already
55367 * been loaded.
55368 * 2) If BOTH types (the one we are adding casting info to, and the
55369 * cast->type) are loaded, THEN the cast info has already been loaded by
55370 * the previous module so we just ignore it.
55371 * 3) Finally, if cast->type has not already been loaded, then we add that
55372 * swig_cast_info to the linked list (because the cast->type) pointer will
55373 * be correct.
55374 * ----------------------------------------------------------------------------- */
55375
55376 #ifdef __cplusplus
55377 extern "C" {
55378 #if 0
55379 } /* c-mode */
55380 #endif
55381 #endif
55382
55383 #if 0
55384 #define SWIGRUNTIME_DEBUG
55385 #endif
55386
55387 SWIGRUNTIME void
55388 SWIG_InitializeModule(void *clientdata) {
55389 size_t i;
55390 swig_module_info *module_head;
55391 static int init_run = 0;
55392
55393 clientdata = clientdata;
55394
55395 if (init_run) return;
55396 init_run = 1;
55397
55398 /* Initialize the swig_module */
55399 swig_module.type_initial = swig_type_initial;
55400 swig_module.cast_initial = swig_cast_initial;
55401
55402 /* Try and load any already created modules */
55403 module_head = SWIG_GetModule(clientdata);
55404 if (module_head) {
55405 swig_module.next = module_head->next;
55406 module_head->next = &swig_module;
55407 } else {
55408 /* This is the first module loaded */
55409 swig_module.next = &swig_module;
55410 SWIG_SetModule(clientdata, &swig_module);
55411 }
55412
55413 /* Now work on filling in swig_module.types */
55414 #ifdef SWIGRUNTIME_DEBUG
55415 printf("SWIG_InitializeModule: size %d\n", swig_module.size);
55416 #endif
55417 for (i = 0; i < swig_module.size; ++i) {
55418 swig_type_info *type = 0;
55419 swig_type_info *ret;
55420 swig_cast_info *cast;
55421
55422 #ifdef SWIGRUNTIME_DEBUG
55423 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55424 #endif
55425
55426 /* if there is another module already loaded */
55427 if (swig_module.next != &swig_module) {
55428 type = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, swig_module.type_initial[i]->name);
55429 }
55430 if (type) {
55431 /* Overwrite clientdata field */
55432 #ifdef SWIGRUNTIME_DEBUG
55433 printf("SWIG_InitializeModule: found type %s\n", type->name);
55434 #endif
55435 if (swig_module.type_initial[i]->clientdata) {
55436 type->clientdata = swig_module.type_initial[i]->clientdata;
55437 #ifdef SWIGRUNTIME_DEBUG
55438 printf("SWIG_InitializeModule: found and overwrite type %s \n", type->name);
55439 #endif
55440 }
55441 } else {
55442 type = swig_module.type_initial[i];
55443 }
55444
55445 /* Insert casting types */
55446 cast = swig_module.cast_initial[i];
55447 while (cast->type) {
55448 /* Don't need to add information already in the list */
55449 ret = 0;
55450 #ifdef SWIGRUNTIME_DEBUG
55451 printf("SWIG_InitializeModule: look cast %s\n", cast->type->name);
55452 #endif
55453 if (swig_module.next != &swig_module) {
55454 ret = SWIG_MangledTypeQueryModule(swig_module.next, &swig_module, cast->type->name);
55455 #ifdef SWIGRUNTIME_DEBUG
55456 if (ret) printf("SWIG_InitializeModule: found cast %s\n", ret->name);
55457 #endif
55458 }
55459 if (ret) {
55460 if (type == swig_module.type_initial[i]) {
55461 #ifdef SWIGRUNTIME_DEBUG
55462 printf("SWIG_InitializeModule: skip old type %s\n", ret->name);
55463 #endif
55464 cast->type = ret;
55465 ret = 0;
55466 } else {
55467 /* Check for casting already in the list */
55468 swig_cast_info *ocast = SWIG_TypeCheck(ret->name, type);
55469 #ifdef SWIGRUNTIME_DEBUG
55470 if (ocast) printf("SWIG_InitializeModule: skip old cast %s\n", ret->name);
55471 #endif
55472 if (!ocast) ret = 0;
55473 }
55474 }
55475
55476 if (!ret) {
55477 #ifdef SWIGRUNTIME_DEBUG
55478 printf("SWIG_InitializeModule: adding cast %s\n", cast->type->name);
55479 #endif
55480 if (type->cast) {
55481 type->cast->prev = cast;
55482 cast->next = type->cast;
55483 }
55484 type->cast = cast;
55485 }
55486 cast++;
55487 }
55488 /* Set entry in modules->types array equal to the type */
55489 swig_module.types[i] = type;
55490 }
55491 swig_module.types[i] = 0;
55492
55493 #ifdef SWIGRUNTIME_DEBUG
55494 printf("**** SWIG_InitializeModule: Cast List ******\n");
55495 for (i = 0; i < swig_module.size; ++i) {
55496 int j = 0;
55497 swig_cast_info *cast = swig_module.cast_initial[i];
55498 printf("SWIG_InitializeModule: type %d %s\n", i, swig_module.type_initial[i]->name);
55499 while (cast->type) {
55500 printf("SWIG_InitializeModule: cast type %s\n", cast->type->name);
55501 cast++;
55502 ++j;
55503 }
55504 printf("---- Total casts: %d\n",j);
55505 }
55506 printf("**** SWIG_InitializeModule: Cast List ******\n");
55507 #endif
55508 }
55509
55510 /* This function will propagate the clientdata field of type to
55511 * any new swig_type_info structures that have been added into the list
55512 * of equivalent types. It is like calling
55513 * SWIG_TypeClientData(type, clientdata) a second time.
55514 */
55515 SWIGRUNTIME void
55516 SWIG_PropagateClientData(void) {
55517 size_t i;
55518 swig_cast_info *equiv;
55519 static int init_run = 0;
55520
55521 if (init_run) return;
55522 init_run = 1;
55523
55524 for (i = 0; i < swig_module.size; i++) {
55525 if (swig_module.types[i]->clientdata) {
55526 equiv = swig_module.types[i]->cast;
55527 while (equiv) {
55528 if (!equiv->converter) {
55529 if (equiv->type && !equiv->type->clientdata)
55530 SWIG_TypeClientData(equiv->type, swig_module.types[i]->clientdata);
55531 }
55532 equiv = equiv->next;
55533 }
55534 }
55535 }
55536 }
55537
55538 #ifdef __cplusplus
55539 #if 0
55540 {
55541 /* c-mode */
55542 #endif
55543 }
55544 #endif
55545
55546
55547
55548 #ifdef __cplusplus
55549 extern "C" {
55550 #endif
55551
55552 /* Python-specific SWIG API */
55553 #define SWIG_newvarlink() SWIG_Python_newvarlink()
55554 #define SWIG_addvarlink(p, name, get_attr, set_attr) SWIG_Python_addvarlink(p, name, get_attr, set_attr)
55555 #define SWIG_InstallConstants(d, constants) SWIG_Python_InstallConstants(d, constants)
55556
55557 /* -----------------------------------------------------------------------------
55558 * global variable support code.
55559 * ----------------------------------------------------------------------------- */
55560
55561 typedef struct swig_globalvar {
55562 char *name; /* Name of global variable */
55563 PyObject *(*get_attr)(void); /* Return the current value */
55564 int (*set_attr)(PyObject *); /* Set the value */
55565 struct swig_globalvar *next;
55566 } swig_globalvar;
55567
55568 typedef struct swig_varlinkobject {
55569 PyObject_HEAD
55570 swig_globalvar *vars;
55571 } swig_varlinkobject;
55572
55573 SWIGINTERN PyObject *
55574 swig_varlink_repr(swig_varlinkobject *SWIGUNUSEDPARM(v)) {
55575 return PyString_FromString("<Swig global variables>");
55576 }
55577
55578 SWIGINTERN PyObject *
55579 swig_varlink_str(swig_varlinkobject *v) {
55580 PyObject *str = PyString_FromString("(");
55581 swig_globalvar *var;
55582 for (var = v->vars; var; var=var->next) {
55583 PyString_ConcatAndDel(&str,PyString_FromString(var->name));
55584 if (var->next) PyString_ConcatAndDel(&str,PyString_FromString(", "));
55585 }
55586 PyString_ConcatAndDel(&str,PyString_FromString(")"));
55587 return str;
55588 }
55589
55590 SWIGINTERN int
55591 swig_varlink_print(swig_varlinkobject *v, FILE *fp, int SWIGUNUSEDPARM(flags)) {
55592 PyObject *str = swig_varlink_str(v);
55593 fprintf(fp,"Swig global variables ");
55594 fprintf(fp,"%s\n", PyString_AsString(str));
55595 Py_DECREF(str);
55596 return 0;
55597 }
55598
55599 SWIGINTERN void
55600 swig_varlink_dealloc(swig_varlinkobject *v) {
55601 swig_globalvar *var = v->vars;
55602 while (var) {
55603 swig_globalvar *n = var->next;
55604 free(var->name);
55605 free(var);
55606 var = n;
55607 }
55608 }
55609
55610 SWIGINTERN PyObject *
55611 swig_varlink_getattr(swig_varlinkobject *v, char *n) {
55612 PyObject *res = NULL;
55613 swig_globalvar *var = v->vars;
55614 while (var) {
55615 if (strcmp(var->name,n) == 0) {
55616 res = (*var->get_attr)();
55617 break;
55618 }
55619 var = var->next;
55620 }
55621 if (res == NULL && !PyErr_Occurred()) {
55622 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55623 }
55624 return res;
55625 }
55626
55627 SWIGINTERN int
55628 swig_varlink_setattr(swig_varlinkobject *v, char *n, PyObject *p) {
55629 int res = 1;
55630 swig_globalvar *var = v->vars;
55631 while (var) {
55632 if (strcmp(var->name,n) == 0) {
55633 res = (*var->set_attr)(p);
55634 break;
55635 }
55636 var = var->next;
55637 }
55638 if (res == 1 && !PyErr_Occurred()) {
55639 PyErr_SetString(PyExc_NameError,"Unknown C global variable");
55640 }
55641 return res;
55642 }
55643
55644 SWIGINTERN PyTypeObject*
55645 swig_varlink_type(void) {
55646 static char varlink__doc__[] = "Swig var link object";
55647 static PyTypeObject varlink_type;
55648 static int type_init = 0;
55649 if (!type_init) {
55650 const PyTypeObject tmp
55651 = {
55652 PyObject_HEAD_INIT(NULL)
55653 0, /* Number of items in variable part (ob_size) */
55654 (char *)"swigvarlink", /* Type name (tp_name) */
55655 sizeof(swig_varlinkobject), /* Basic size (tp_basicsize) */
55656 0, /* Itemsize (tp_itemsize) */
55657 (destructor) swig_varlink_dealloc, /* Deallocator (tp_dealloc) */
55658 (printfunc) swig_varlink_print, /* Print (tp_print) */
55659 (getattrfunc) swig_varlink_getattr, /* get attr (tp_getattr) */
55660 (setattrfunc) swig_varlink_setattr, /* Set attr (tp_setattr) */
55661 0, /* tp_compare */
55662 (reprfunc) swig_varlink_repr, /* tp_repr */
55663 0, /* tp_as_number */
55664 0, /* tp_as_sequence */
55665 0, /* tp_as_mapping */
55666 0, /* tp_hash */
55667 0, /* tp_call */
55668 (reprfunc)swig_varlink_str, /* tp_str */
55669 0, /* tp_getattro */
55670 0, /* tp_setattro */
55671 0, /* tp_as_buffer */
55672 0, /* tp_flags */
55673 varlink__doc__, /* tp_doc */
55674 0, /* tp_traverse */
55675 0, /* tp_clear */
55676 0, /* tp_richcompare */
55677 0, /* tp_weaklistoffset */
55678 #if PY_VERSION_HEX >= 0x02020000
55679 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, /* tp_iter -> tp_weaklist */
55680 #endif
55681 #if PY_VERSION_HEX >= 0x02030000
55682 0, /* tp_del */
55683 #endif
55684 #ifdef COUNT_ALLOCS
55685 0,0,0,0 /* tp_alloc -> tp_next */
55686 #endif
55687 };
55688 varlink_type = tmp;
55689 varlink_type.ob_type = &PyType_Type;
55690 type_init = 1;
55691 }
55692 return &varlink_type;
55693 }
55694
55695 /* Create a variable linking object for use later */
55696 SWIGINTERN PyObject *
55697 SWIG_Python_newvarlink(void) {
55698 swig_varlinkobject *result = PyObject_NEW(swig_varlinkobject, swig_varlink_type());
55699 if (result) {
55700 result->vars = 0;
55701 }
55702 return ((PyObject*) result);
55703 }
55704
55705 SWIGINTERN void
55706 SWIG_Python_addvarlink(PyObject *p, char *name, PyObject *(*get_attr)(void), int (*set_attr)(PyObject *p)) {
55707 swig_varlinkobject *v = (swig_varlinkobject *) p;
55708 swig_globalvar *gv = (swig_globalvar *) malloc(sizeof(swig_globalvar));
55709 if (gv) {
55710 size_t size = strlen(name)+1;
55711 gv->name = (char *)malloc(size);
55712 if (gv->name) {
55713 strncpy(gv->name,name,size);
55714 gv->get_attr = get_attr;
55715 gv->set_attr = set_attr;
55716 gv->next = v->vars;
55717 }
55718 }
55719 v->vars = gv;
55720 }
55721
55722 SWIGINTERN PyObject *
55723 SWIG_globals() {
55724 static PyObject *_SWIG_globals = 0;
55725 if (!_SWIG_globals) _SWIG_globals = SWIG_newvarlink();
55726 return _SWIG_globals;
55727 }
55728
55729 /* -----------------------------------------------------------------------------
55730 * constants/methods manipulation
55731 * ----------------------------------------------------------------------------- */
55732
55733 /* Install Constants */
55734 SWIGINTERN void
55735 SWIG_Python_InstallConstants(PyObject *d, swig_const_info constants[]) {
55736 PyObject *obj = 0;
55737 size_t i;
55738 for (i = 0; constants[i].type; ++i) {
55739 switch(constants[i].type) {
55740 case SWIG_PY_POINTER:
55741 obj = SWIG_NewPointerObj(constants[i].pvalue, *(constants[i]).ptype,0);
55742 break;
55743 case SWIG_PY_BINARY:
55744 obj = SWIG_NewPackedObj(constants[i].pvalue, constants[i].lvalue, *(constants[i].ptype));
55745 break;
55746 default:
55747 obj = 0;
55748 break;
55749 }
55750 if (obj) {
55751 PyDict_SetItemString(d, constants[i].name, obj);
55752 Py_DECREF(obj);
55753 }
55754 }
55755 }
55756
55757 /* -----------------------------------------------------------------------------*/
55758 /* Fix SwigMethods to carry the callback ptrs when needed */
55759 /* -----------------------------------------------------------------------------*/
55760
55761 SWIGINTERN void
55762 SWIG_Python_FixMethods(PyMethodDef *methods,
55763 swig_const_info *const_table,
55764 swig_type_info **types,
55765 swig_type_info **types_initial) {
55766 size_t i;
55767 for (i = 0; methods[i].ml_name; ++i) {
55768 const char *c = methods[i].ml_doc;
55769 if (c && (c = strstr(c, "swig_ptr: "))) {
55770 int j;
55771 swig_const_info *ci = 0;
55772 const char *name = c + 10;
55773 for (j = 0; const_table[j].type; ++j) {
55774 if (strncmp(const_table[j].name, name,
55775 strlen(const_table[j].name)) == 0) {
55776 ci = &(const_table[j]);
55777 break;
55778 }
55779 }
55780 if (ci) {
55781 size_t shift = (ci->ptype) - types;
55782 swig_type_info *ty = types_initial[shift];
55783 size_t ldoc = (c - methods[i].ml_doc);
55784 size_t lptr = strlen(ty->name)+2*sizeof(void*)+2;
55785 char *ndoc = (char*)malloc(ldoc + lptr + 10);
55786 if (ndoc) {
55787 char *buff = ndoc;
55788 void *ptr = (ci->type == SWIG_PY_POINTER) ? ci->pvalue : 0;
55789 if (ptr) {
55790 strncpy(buff, methods[i].ml_doc, ldoc);
55791 buff += ldoc;
55792 strncpy(buff, "swig_ptr: ", 10);
55793 buff += 10;
55794 SWIG_PackVoidPtr(buff, ptr, ty->name, lptr);
55795 methods[i].ml_doc = ndoc;
55796 }
55797 }
55798 }
55799 }
55800 }
55801 }
55802
55803 #ifdef __cplusplus
55804 }
55805 #endif
55806
55807 /* -----------------------------------------------------------------------------*
55808 * Partial Init method
55809 * -----------------------------------------------------------------------------*/
55810
55811 #ifdef __cplusplus
55812 extern "C"
55813 #endif
55814 SWIGEXPORT void SWIG_init(void) {
55815 PyObject *m, *d;
55816
55817 /* Fix SwigMethods to carry the callback ptrs when needed */
55818 SWIG_Python_FixMethods(SwigMethods, swig_const_table, swig_types, swig_type_initial);
55819
55820 m = Py_InitModule((char *) SWIG_name, SwigMethods);
55821 d = PyModule_GetDict(m);
55822
55823 SWIG_InitializeModule(0);
55824 SWIG_InstallConstants(d,swig_const_table);
55825
55826
55827
55828 #ifndef wxPyUSE_EXPORT
55829 // Make our API structure a CObject so other modules can import it
55830 // from this module.
55831 PyObject* cobj = PyCObject_FromVoidPtr(&API, NULL);
55832 PyDict_SetItemString(d,"_wxPyCoreAPI", cobj);
55833 Py_XDECREF(cobj);
55834 #endif
55835
55836 SWIG_Python_SetConstant(d, "NOT_FOUND",SWIG_From_int(static_cast< int >(wxNOT_FOUND)));
55837 SWIG_Python_SetConstant(d, "VSCROLL",SWIG_From_int(static_cast< int >(wxVSCROLL)));
55838 SWIG_Python_SetConstant(d, "HSCROLL",SWIG_From_int(static_cast< int >(wxHSCROLL)));
55839 SWIG_Python_SetConstant(d, "CAPTION",SWIG_From_int(static_cast< int >(wxCAPTION)));
55840 SWIG_Python_SetConstant(d, "DOUBLE_BORDER",SWIG_From_int(static_cast< int >(wxDOUBLE_BORDER)));
55841 SWIG_Python_SetConstant(d, "SUNKEN_BORDER",SWIG_From_int(static_cast< int >(wxSUNKEN_BORDER)));
55842 SWIG_Python_SetConstant(d, "RAISED_BORDER",SWIG_From_int(static_cast< int >(wxRAISED_BORDER)));
55843 SWIG_Python_SetConstant(d, "BORDER",SWIG_From_int(static_cast< int >(wxBORDER)));
55844 SWIG_Python_SetConstant(d, "SIMPLE_BORDER",SWIG_From_int(static_cast< int >(wxSIMPLE_BORDER)));
55845 SWIG_Python_SetConstant(d, "STATIC_BORDER",SWIG_From_int(static_cast< int >(wxSTATIC_BORDER)));
55846 SWIG_Python_SetConstant(d, "TRANSPARENT_WINDOW",SWIG_From_int(static_cast< int >(wxTRANSPARENT_WINDOW)));
55847 SWIG_Python_SetConstant(d, "NO_BORDER",SWIG_From_int(static_cast< int >(wxNO_BORDER)));
55848 SWIG_Python_SetConstant(d, "DEFAULT_CONTROL_BORDER",SWIG_From_int(static_cast< int >(wxDEFAULT_CONTROL_BORDER)));
55849 SWIG_Python_SetConstant(d, "DEFAULT_STATUSBAR_STYLE",SWIG_From_int(static_cast< int >(wxDEFAULT_STATUSBAR_STYLE)));
55850 SWIG_Python_SetConstant(d, "TAB_TRAVERSAL",SWIG_From_int(static_cast< int >(wxTAB_TRAVERSAL)));
55851 SWIG_Python_SetConstant(d, "WANTS_CHARS",SWIG_From_int(static_cast< int >(wxWANTS_CHARS)));
55852 SWIG_Python_SetConstant(d, "POPUP_WINDOW",SWIG_From_int(static_cast< int >(wxPOPUP_WINDOW)));
55853 SWIG_Python_SetConstant(d, "CENTER_FRAME",SWIG_From_int(static_cast< int >(wxCENTER_FRAME)));
55854 SWIG_Python_SetConstant(d, "CENTRE_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTRE_ON_SCREEN)));
55855 SWIG_Python_SetConstant(d, "CENTER_ON_SCREEN",SWIG_From_int(static_cast< int >(wxCENTER_ON_SCREEN)));
55856 SWIG_Python_SetConstant(d, "CLIP_CHILDREN",SWIG_From_int(static_cast< int >(wxCLIP_CHILDREN)));
55857 SWIG_Python_SetConstant(d, "CLIP_SIBLINGS",SWIG_From_int(static_cast< int >(wxCLIP_SIBLINGS)));
55858 SWIG_Python_SetConstant(d, "WINDOW_STYLE_MASK",SWIG_From_int(static_cast< int >(wxWINDOW_STYLE_MASK)));
55859 SWIG_Python_SetConstant(d, "ALWAYS_SHOW_SB",SWIG_From_int(static_cast< int >(wxALWAYS_SHOW_SB)));
55860 SWIG_Python_SetConstant(d, "RETAINED",SWIG_From_int(static_cast< int >(wxRETAINED)));
55861 SWIG_Python_SetConstant(d, "BACKINGSTORE",SWIG_From_int(static_cast< int >(wxBACKINGSTORE)));
55862 SWIG_Python_SetConstant(d, "COLOURED",SWIG_From_int(static_cast< int >(wxCOLOURED)));
55863 SWIG_Python_SetConstant(d, "FIXED_LENGTH",SWIG_From_int(static_cast< int >(wxFIXED_LENGTH)));
55864 SWIG_Python_SetConstant(d, "LB_NEEDED_SB",SWIG_From_int(static_cast< int >(wxLB_NEEDED_SB)));
55865 SWIG_Python_SetConstant(d, "LB_ALWAYS_SB",SWIG_From_int(static_cast< int >(wxLB_ALWAYS_SB)));
55866 SWIG_Python_SetConstant(d, "LB_SORT",SWIG_From_int(static_cast< int >(wxLB_SORT)));
55867 SWIG_Python_SetConstant(d, "LB_SINGLE",SWIG_From_int(static_cast< int >(wxLB_SINGLE)));
55868 SWIG_Python_SetConstant(d, "LB_MULTIPLE",SWIG_From_int(static_cast< int >(wxLB_MULTIPLE)));
55869 SWIG_Python_SetConstant(d, "LB_EXTENDED",SWIG_From_int(static_cast< int >(wxLB_EXTENDED)));
55870 SWIG_Python_SetConstant(d, "LB_OWNERDRAW",SWIG_From_int(static_cast< int >(wxLB_OWNERDRAW)));
55871 SWIG_Python_SetConstant(d, "LB_HSCROLL",SWIG_From_int(static_cast< int >(wxLB_HSCROLL)));
55872 SWIG_Python_SetConstant(d, "PROCESS_ENTER",SWIG_From_int(static_cast< int >(wxPROCESS_ENTER)));
55873 SWIG_Python_SetConstant(d, "PASSWORD",SWIG_From_int(static_cast< int >(wxPASSWORD)));
55874 SWIG_Python_SetConstant(d, "CB_SIMPLE",SWIG_From_int(static_cast< int >(wxCB_SIMPLE)));
55875 SWIG_Python_SetConstant(d, "CB_DROPDOWN",SWIG_From_int(static_cast< int >(wxCB_DROPDOWN)));
55876 SWIG_Python_SetConstant(d, "CB_SORT",SWIG_From_int(static_cast< int >(wxCB_SORT)));
55877 SWIG_Python_SetConstant(d, "CB_READONLY",SWIG_From_int(static_cast< int >(wxCB_READONLY)));
55878 SWIG_Python_SetConstant(d, "CB_FILENAME",SWIG_From_int(static_cast< int >(wxCB_FILENAME)));
55879 SWIG_Python_SetConstant(d, "RA_HORIZONTAL",SWIG_From_int(static_cast< int >(wxRA_HORIZONTAL)));
55880 SWIG_Python_SetConstant(d, "RA_VERTICAL",SWIG_From_int(static_cast< int >(wxRA_VERTICAL)));
55881 SWIG_Python_SetConstant(d, "RA_SPECIFY_ROWS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_ROWS)));
55882 SWIG_Python_SetConstant(d, "RA_SPECIFY_COLS",SWIG_From_int(static_cast< int >(wxRA_SPECIFY_COLS)));
55883 SWIG_Python_SetConstant(d, "RA_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRA_USE_CHECKBOX)));
55884 SWIG_Python_SetConstant(d, "RB_GROUP",SWIG_From_int(static_cast< int >(wxRB_GROUP)));
55885 SWIG_Python_SetConstant(d, "RB_SINGLE",SWIG_From_int(static_cast< int >(wxRB_SINGLE)));
55886 SWIG_Python_SetConstant(d, "SB_HORIZONTAL",SWIG_From_int(static_cast< int >(wxSB_HORIZONTAL)));
55887 SWIG_Python_SetConstant(d, "SB_VERTICAL",SWIG_From_int(static_cast< int >(wxSB_VERTICAL)));
55888 SWIG_Python_SetConstant(d, "RB_USE_CHECKBOX",SWIG_From_int(static_cast< int >(wxRB_USE_CHECKBOX)));
55889 SWIG_Python_SetConstant(d, "ST_SIZEGRIP",SWIG_From_int(static_cast< int >(wxST_SIZEGRIP)));
55890 SWIG_Python_SetConstant(d, "ST_NO_AUTORESIZE",SWIG_From_int(static_cast< int >(wxST_NO_AUTORESIZE)));
55891 SWIG_Python_SetConstant(d, "ST_DOTS_MIDDLE",SWIG_From_int(static_cast< int >(wxST_DOTS_MIDDLE)));
55892 SWIG_Python_SetConstant(d, "ST_DOTS_END",SWIG_From_int(static_cast< int >(wxST_DOTS_END)));
55893 SWIG_Python_SetConstant(d, "FLOOD_SURFACE",SWIG_From_int(static_cast< int >(wxFLOOD_SURFACE)));
55894 SWIG_Python_SetConstant(d, "FLOOD_BORDER",SWIG_From_int(static_cast< int >(wxFLOOD_BORDER)));
55895 SWIG_Python_SetConstant(d, "ODDEVEN_RULE",SWIG_From_int(static_cast< int >(wxODDEVEN_RULE)));
55896 SWIG_Python_SetConstant(d, "WINDING_RULE",SWIG_From_int(static_cast< int >(wxWINDING_RULE)));
55897 SWIG_Python_SetConstant(d, "TOOL_TOP",SWIG_From_int(static_cast< int >(wxTOOL_TOP)));
55898 SWIG_Python_SetConstant(d, "TOOL_BOTTOM",SWIG_From_int(static_cast< int >(wxTOOL_BOTTOM)));
55899 SWIG_Python_SetConstant(d, "TOOL_LEFT",SWIG_From_int(static_cast< int >(wxTOOL_LEFT)));
55900 SWIG_Python_SetConstant(d, "TOOL_RIGHT",SWIG_From_int(static_cast< int >(wxTOOL_RIGHT)));
55901 SWIG_Python_SetConstant(d, "OK",SWIG_From_int(static_cast< int >(wxOK)));
55902 SWIG_Python_SetConstant(d, "YES_NO",SWIG_From_int(static_cast< int >(wxYES_NO)));
55903 SWIG_Python_SetConstant(d, "CANCEL",SWIG_From_int(static_cast< int >(wxCANCEL)));
55904 SWIG_Python_SetConstant(d, "YES",SWIG_From_int(static_cast< int >(wxYES)));
55905 SWIG_Python_SetConstant(d, "NO",SWIG_From_int(static_cast< int >(wxNO)));
55906 SWIG_Python_SetConstant(d, "NO_DEFAULT",SWIG_From_int(static_cast< int >(wxNO_DEFAULT)));
55907 SWIG_Python_SetConstant(d, "YES_DEFAULT",SWIG_From_int(static_cast< int >(wxYES_DEFAULT)));
55908 SWIG_Python_SetConstant(d, "ICON_EXCLAMATION",SWIG_From_int(static_cast< int >(wxICON_EXCLAMATION)));
55909 SWIG_Python_SetConstant(d, "ICON_HAND",SWIG_From_int(static_cast< int >(wxICON_HAND)));
55910 SWIG_Python_SetConstant(d, "ICON_QUESTION",SWIG_From_int(static_cast< int >(wxICON_QUESTION)));
55911 SWIG_Python_SetConstant(d, "ICON_INFORMATION",SWIG_From_int(static_cast< int >(wxICON_INFORMATION)));
55912 SWIG_Python_SetConstant(d, "ICON_STOP",SWIG_From_int(static_cast< int >(wxICON_STOP)));
55913 SWIG_Python_SetConstant(d, "ICON_ASTERISK",SWIG_From_int(static_cast< int >(wxICON_ASTERISK)));
55914 SWIG_Python_SetConstant(d, "ICON_MASK",SWIG_From_int(static_cast< int >(wxICON_MASK)));
55915 SWIG_Python_SetConstant(d, "ICON_WARNING",SWIG_From_int(static_cast< int >(wxICON_WARNING)));
55916 SWIG_Python_SetConstant(d, "ICON_ERROR",SWIG_From_int(static_cast< int >(wxICON_ERROR)));
55917 SWIG_Python_SetConstant(d, "FORWARD",SWIG_From_int(static_cast< int >(wxFORWARD)));
55918 SWIG_Python_SetConstant(d, "BACKWARD",SWIG_From_int(static_cast< int >(wxBACKWARD)));
55919 SWIG_Python_SetConstant(d, "RESET",SWIG_From_int(static_cast< int >(wxRESET)));
55920 SWIG_Python_SetConstant(d, "HELP",SWIG_From_int(static_cast< int >(wxHELP)));
55921 SWIG_Python_SetConstant(d, "MORE",SWIG_From_int(static_cast< int >(wxMORE)));
55922 SWIG_Python_SetConstant(d, "SETUP",SWIG_From_int(static_cast< int >(wxSETUP)));
55923 SWIG_Python_SetConstant(d, "SIZE_AUTO_WIDTH",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_WIDTH)));
55924 SWIG_Python_SetConstant(d, "SIZE_AUTO_HEIGHT",SWIG_From_int(static_cast< int >(wxSIZE_AUTO_HEIGHT)));
55925 SWIG_Python_SetConstant(d, "SIZE_AUTO",SWIG_From_int(static_cast< int >(wxSIZE_AUTO)));
55926 SWIG_Python_SetConstant(d, "SIZE_USE_EXISTING",SWIG_From_int(static_cast< int >(wxSIZE_USE_EXISTING)));
55927 SWIG_Python_SetConstant(d, "SIZE_ALLOW_MINUS_ONE",SWIG_From_int(static_cast< int >(wxSIZE_ALLOW_MINUS_ONE)));
55928 SWIG_Python_SetConstant(d, "SIZE_FORCE",SWIG_From_int(static_cast< int >(wxSIZE_FORCE)));
55929 SWIG_Python_SetConstant(d, "PORTRAIT",SWIG_From_int(static_cast< int >(wxPORTRAIT)));
55930 SWIG_Python_SetConstant(d, "LANDSCAPE",SWIG_From_int(static_cast< int >(wxLANDSCAPE)));
55931 SWIG_Python_SetConstant(d, "PRINT_QUALITY_HIGH",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_HIGH)));
55932 SWIG_Python_SetConstant(d, "PRINT_QUALITY_MEDIUM",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_MEDIUM)));
55933 SWIG_Python_SetConstant(d, "PRINT_QUALITY_LOW",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_LOW)));
55934 SWIG_Python_SetConstant(d, "PRINT_QUALITY_DRAFT",SWIG_From_int(static_cast< int >(wxPRINT_QUALITY_DRAFT)));
55935 SWIG_Python_SetConstant(d, "ID_ANY",SWIG_From_int(static_cast< int >(wxID_ANY)));
55936 SWIG_Python_SetConstant(d, "ID_SEPARATOR",SWIG_From_int(static_cast< int >(wxID_SEPARATOR)));
55937 SWIG_Python_SetConstant(d, "ID_NONE",SWIG_From_int(static_cast< int >(wxID_NONE)));
55938 SWIG_Python_SetConstant(d, "ID_LOWEST",SWIG_From_int(static_cast< int >(wxID_LOWEST)));
55939 SWIG_Python_SetConstant(d, "ID_OPEN",SWIG_From_int(static_cast< int >(wxID_OPEN)));
55940 SWIG_Python_SetConstant(d, "ID_CLOSE",SWIG_From_int(static_cast< int >(wxID_CLOSE)));
55941 SWIG_Python_SetConstant(d, "ID_NEW",SWIG_From_int(static_cast< int >(wxID_NEW)));
55942 SWIG_Python_SetConstant(d, "ID_SAVE",SWIG_From_int(static_cast< int >(wxID_SAVE)));
55943 SWIG_Python_SetConstant(d, "ID_SAVEAS",SWIG_From_int(static_cast< int >(wxID_SAVEAS)));
55944 SWIG_Python_SetConstant(d, "ID_REVERT",SWIG_From_int(static_cast< int >(wxID_REVERT)));
55945 SWIG_Python_SetConstant(d, "ID_EXIT",SWIG_From_int(static_cast< int >(wxID_EXIT)));
55946 SWIG_Python_SetConstant(d, "ID_UNDO",SWIG_From_int(static_cast< int >(wxID_UNDO)));
55947 SWIG_Python_SetConstant(d, "ID_REDO",SWIG_From_int(static_cast< int >(wxID_REDO)));
55948 SWIG_Python_SetConstant(d, "ID_HELP",SWIG_From_int(static_cast< int >(wxID_HELP)));
55949 SWIG_Python_SetConstant(d, "ID_PRINT",SWIG_From_int(static_cast< int >(wxID_PRINT)));
55950 SWIG_Python_SetConstant(d, "ID_PRINT_SETUP",SWIG_From_int(static_cast< int >(wxID_PRINT_SETUP)));
55951 SWIG_Python_SetConstant(d, "ID_PREVIEW",SWIG_From_int(static_cast< int >(wxID_PREVIEW)));
55952 SWIG_Python_SetConstant(d, "ID_ABOUT",SWIG_From_int(static_cast< int >(wxID_ABOUT)));
55953 SWIG_Python_SetConstant(d, "ID_HELP_CONTENTS",SWIG_From_int(static_cast< int >(wxID_HELP_CONTENTS)));
55954 SWIG_Python_SetConstant(d, "ID_HELP_COMMANDS",SWIG_From_int(static_cast< int >(wxID_HELP_COMMANDS)));
55955 SWIG_Python_SetConstant(d, "ID_HELP_PROCEDURES",SWIG_From_int(static_cast< int >(wxID_HELP_PROCEDURES)));
55956 SWIG_Python_SetConstant(d, "ID_HELP_CONTEXT",SWIG_From_int(static_cast< int >(wxID_HELP_CONTEXT)));
55957 SWIG_Python_SetConstant(d, "ID_HELP_INDEX",SWIG_From_int(static_cast< int >(wxID_HELP_INDEX)));
55958 SWIG_Python_SetConstant(d, "ID_HELP_SEARCH",SWIG_From_int(static_cast< int >(wxID_HELP_SEARCH)));
55959 SWIG_Python_SetConstant(d, "ID_CLOSE_ALL",SWIG_From_int(static_cast< int >(wxID_CLOSE_ALL)));
55960 SWIG_Python_SetConstant(d, "ID_PREFERENCES",SWIG_From_int(static_cast< int >(wxID_PREFERENCES)));
55961 SWIG_Python_SetConstant(d, "ID_CUT",SWIG_From_int(static_cast< int >(wxID_CUT)));
55962 SWIG_Python_SetConstant(d, "ID_COPY",SWIG_From_int(static_cast< int >(wxID_COPY)));
55963 SWIG_Python_SetConstant(d, "ID_PASTE",SWIG_From_int(static_cast< int >(wxID_PASTE)));
55964 SWIG_Python_SetConstant(d, "ID_CLEAR",SWIG_From_int(static_cast< int >(wxID_CLEAR)));
55965 SWIG_Python_SetConstant(d, "ID_FIND",SWIG_From_int(static_cast< int >(wxID_FIND)));
55966 SWIG_Python_SetConstant(d, "ID_DUPLICATE",SWIG_From_int(static_cast< int >(wxID_DUPLICATE)));
55967 SWIG_Python_SetConstant(d, "ID_SELECTALL",SWIG_From_int(static_cast< int >(wxID_SELECTALL)));
55968 SWIG_Python_SetConstant(d, "ID_DELETE",SWIG_From_int(static_cast< int >(wxID_DELETE)));
55969 SWIG_Python_SetConstant(d, "ID_REPLACE",SWIG_From_int(static_cast< int >(wxID_REPLACE)));
55970 SWIG_Python_SetConstant(d, "ID_REPLACE_ALL",SWIG_From_int(static_cast< int >(wxID_REPLACE_ALL)));
55971 SWIG_Python_SetConstant(d, "ID_PROPERTIES",SWIG_From_int(static_cast< int >(wxID_PROPERTIES)));
55972 SWIG_Python_SetConstant(d, "ID_VIEW_DETAILS",SWIG_From_int(static_cast< int >(wxID_VIEW_DETAILS)));
55973 SWIG_Python_SetConstant(d, "ID_VIEW_LARGEICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_LARGEICONS)));
55974 SWIG_Python_SetConstant(d, "ID_VIEW_SMALLICONS",SWIG_From_int(static_cast< int >(wxID_VIEW_SMALLICONS)));
55975 SWIG_Python_SetConstant(d, "ID_VIEW_LIST",SWIG_From_int(static_cast< int >(wxID_VIEW_LIST)));
55976 SWIG_Python_SetConstant(d, "ID_VIEW_SORTDATE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTDATE)));
55977 SWIG_Python_SetConstant(d, "ID_VIEW_SORTNAME",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTNAME)));
55978 SWIG_Python_SetConstant(d, "ID_VIEW_SORTSIZE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTSIZE)));
55979 SWIG_Python_SetConstant(d, "ID_VIEW_SORTTYPE",SWIG_From_int(static_cast< int >(wxID_VIEW_SORTTYPE)));
55980 SWIG_Python_SetConstant(d, "ID_FILE1",SWIG_From_int(static_cast< int >(wxID_FILE1)));
55981 SWIG_Python_SetConstant(d, "ID_FILE2",SWIG_From_int(static_cast< int >(wxID_FILE2)));
55982 SWIG_Python_SetConstant(d, "ID_FILE3",SWIG_From_int(static_cast< int >(wxID_FILE3)));
55983 SWIG_Python_SetConstant(d, "ID_FILE4",SWIG_From_int(static_cast< int >(wxID_FILE4)));
55984 SWIG_Python_SetConstant(d, "ID_FILE5",SWIG_From_int(static_cast< int >(wxID_FILE5)));
55985 SWIG_Python_SetConstant(d, "ID_FILE6",SWIG_From_int(static_cast< int >(wxID_FILE6)));
55986 SWIG_Python_SetConstant(d, "ID_FILE7",SWIG_From_int(static_cast< int >(wxID_FILE7)));
55987 SWIG_Python_SetConstant(d, "ID_FILE8",SWIG_From_int(static_cast< int >(wxID_FILE8)));
55988 SWIG_Python_SetConstant(d, "ID_FILE9",SWIG_From_int(static_cast< int >(wxID_FILE9)));
55989 SWIG_Python_SetConstant(d, "ID_OK",SWIG_From_int(static_cast< int >(wxID_OK)));
55990 SWIG_Python_SetConstant(d, "ID_CANCEL",SWIG_From_int(static_cast< int >(wxID_CANCEL)));
55991 SWIG_Python_SetConstant(d, "ID_APPLY",SWIG_From_int(static_cast< int >(wxID_APPLY)));
55992 SWIG_Python_SetConstant(d, "ID_YES",SWIG_From_int(static_cast< int >(wxID_YES)));
55993 SWIG_Python_SetConstant(d, "ID_NO",SWIG_From_int(static_cast< int >(wxID_NO)));
55994 SWIG_Python_SetConstant(d, "ID_STATIC",SWIG_From_int(static_cast< int >(wxID_STATIC)));
55995 SWIG_Python_SetConstant(d, "ID_FORWARD",SWIG_From_int(static_cast< int >(wxID_FORWARD)));
55996 SWIG_Python_SetConstant(d, "ID_BACKWARD",SWIG_From_int(static_cast< int >(wxID_BACKWARD)));
55997 SWIG_Python_SetConstant(d, "ID_DEFAULT",SWIG_From_int(static_cast< int >(wxID_DEFAULT)));
55998 SWIG_Python_SetConstant(d, "ID_MORE",SWIG_From_int(static_cast< int >(wxID_MORE)));
55999 SWIG_Python_SetConstant(d, "ID_SETUP",SWIG_From_int(static_cast< int >(wxID_SETUP)));
56000 SWIG_Python_SetConstant(d, "ID_RESET",SWIG_From_int(static_cast< int >(wxID_RESET)));
56001 SWIG_Python_SetConstant(d, "ID_CONTEXT_HELP",SWIG_From_int(static_cast< int >(wxID_CONTEXT_HELP)));
56002 SWIG_Python_SetConstant(d, "ID_YESTOALL",SWIG_From_int(static_cast< int >(wxID_YESTOALL)));
56003 SWIG_Python_SetConstant(d, "ID_NOTOALL",SWIG_From_int(static_cast< int >(wxID_NOTOALL)));
56004 SWIG_Python_SetConstant(d, "ID_ABORT",SWIG_From_int(static_cast< int >(wxID_ABORT)));
56005 SWIG_Python_SetConstant(d, "ID_RETRY",SWIG_From_int(static_cast< int >(wxID_RETRY)));
56006 SWIG_Python_SetConstant(d, "ID_IGNORE",SWIG_From_int(static_cast< int >(wxID_IGNORE)));
56007 SWIG_Python_SetConstant(d, "ID_ADD",SWIG_From_int(static_cast< int >(wxID_ADD)));
56008 SWIG_Python_SetConstant(d, "ID_REMOVE",SWIG_From_int(static_cast< int >(wxID_REMOVE)));
56009 SWIG_Python_SetConstant(d, "ID_UP",SWIG_From_int(static_cast< int >(wxID_UP)));
56010 SWIG_Python_SetConstant(d, "ID_DOWN",SWIG_From_int(static_cast< int >(wxID_DOWN)));
56011 SWIG_Python_SetConstant(d, "ID_HOME",SWIG_From_int(static_cast< int >(wxID_HOME)));
56012 SWIG_Python_SetConstant(d, "ID_REFRESH",SWIG_From_int(static_cast< int >(wxID_REFRESH)));
56013 SWIG_Python_SetConstant(d, "ID_STOP",SWIG_From_int(static_cast< int >(wxID_STOP)));
56014 SWIG_Python_SetConstant(d, "ID_INDEX",SWIG_From_int(static_cast< int >(wxID_INDEX)));
56015 SWIG_Python_SetConstant(d, "ID_BOLD",SWIG_From_int(static_cast< int >(wxID_BOLD)));
56016 SWIG_Python_SetConstant(d, "ID_ITALIC",SWIG_From_int(static_cast< int >(wxID_ITALIC)));
56017 SWIG_Python_SetConstant(d, "ID_JUSTIFY_CENTER",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_CENTER)));
56018 SWIG_Python_SetConstant(d, "ID_JUSTIFY_FILL",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_FILL)));
56019 SWIG_Python_SetConstant(d, "ID_JUSTIFY_RIGHT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_RIGHT)));
56020 SWIG_Python_SetConstant(d, "ID_JUSTIFY_LEFT",SWIG_From_int(static_cast< int >(wxID_JUSTIFY_LEFT)));
56021 SWIG_Python_SetConstant(d, "ID_UNDERLINE",SWIG_From_int(static_cast< int >(wxID_UNDERLINE)));
56022 SWIG_Python_SetConstant(d, "ID_INDENT",SWIG_From_int(static_cast< int >(wxID_INDENT)));
56023 SWIG_Python_SetConstant(d, "ID_UNINDENT",SWIG_From_int(static_cast< int >(wxID_UNINDENT)));
56024 SWIG_Python_SetConstant(d, "ID_ZOOM_100",SWIG_From_int(static_cast< int >(wxID_ZOOM_100)));
56025 SWIG_Python_SetConstant(d, "ID_ZOOM_FIT",SWIG_From_int(static_cast< int >(wxID_ZOOM_FIT)));
56026 SWIG_Python_SetConstant(d, "ID_ZOOM_IN",SWIG_From_int(static_cast< int >(wxID_ZOOM_IN)));
56027 SWIG_Python_SetConstant(d, "ID_ZOOM_OUT",SWIG_From_int(static_cast< int >(wxID_ZOOM_OUT)));
56028 SWIG_Python_SetConstant(d, "ID_UNDELETE",SWIG_From_int(static_cast< int >(wxID_UNDELETE)));
56029 SWIG_Python_SetConstant(d, "ID_REVERT_TO_SAVED",SWIG_From_int(static_cast< int >(wxID_REVERT_TO_SAVED)));
56030 SWIG_Python_SetConstant(d, "ID_HIGHEST",SWIG_From_int(static_cast< int >(wxID_HIGHEST)));
56031 SWIG_Python_SetConstant(d, "ACCEL_ALT",SWIG_From_int(static_cast< int >(wxACCEL_ALT)));
56032 SWIG_Python_SetConstant(d, "ACCEL_CTRL",SWIG_From_int(static_cast< int >(wxACCEL_CTRL)));
56033 SWIG_Python_SetConstant(d, "ACCEL_SHIFT",SWIG_From_int(static_cast< int >(wxACCEL_SHIFT)));
56034 SWIG_Python_SetConstant(d, "ACCEL_NORMAL",SWIG_From_int(static_cast< int >(wxACCEL_NORMAL)));
56035 SWIG_Python_SetConstant(d, "PD_AUTO_HIDE",SWIG_From_int(static_cast< int >(wxPD_AUTO_HIDE)));
56036 SWIG_Python_SetConstant(d, "PD_APP_MODAL",SWIG_From_int(static_cast< int >(wxPD_APP_MODAL)));
56037 SWIG_Python_SetConstant(d, "PD_CAN_ABORT",SWIG_From_int(static_cast< int >(wxPD_CAN_ABORT)));
56038 SWIG_Python_SetConstant(d, "PD_ELAPSED_TIME",SWIG_From_int(static_cast< int >(wxPD_ELAPSED_TIME)));
56039 SWIG_Python_SetConstant(d, "PD_ESTIMATED_TIME",SWIG_From_int(static_cast< int >(wxPD_ESTIMATED_TIME)));
56040 SWIG_Python_SetConstant(d, "PD_REMAINING_TIME",SWIG_From_int(static_cast< int >(wxPD_REMAINING_TIME)));
56041 SWIG_Python_SetConstant(d, "PD_SMOOTH",SWIG_From_int(static_cast< int >(wxPD_SMOOTH)));
56042 SWIG_Python_SetConstant(d, "PD_CAN_SKIP",SWIG_From_int(static_cast< int >(wxPD_CAN_SKIP)));
56043 SWIG_Python_SetConstant(d, "MENU_TEAROFF",SWIG_From_int(static_cast< int >(wxMENU_TEAROFF)));
56044 SWIG_Python_SetConstant(d, "MB_DOCKABLE",SWIG_From_int(static_cast< int >(wxMB_DOCKABLE)));
56045 SWIG_Python_SetConstant(d, "NO_FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxNO_FULL_REPAINT_ON_RESIZE)));
56046 SWIG_Python_SetConstant(d, "FULL_REPAINT_ON_RESIZE",SWIG_From_int(static_cast< int >(wxFULL_REPAINT_ON_RESIZE)));
56047 SWIG_Python_SetConstant(d, "LI_HORIZONTAL",SWIG_From_int(static_cast< int >(wxLI_HORIZONTAL)));
56048 SWIG_Python_SetConstant(d, "LI_VERTICAL",SWIG_From_int(static_cast< int >(wxLI_VERTICAL)));
56049 SWIG_Python_SetConstant(d, "WS_EX_VALIDATE_RECURSIVELY",SWIG_From_int(static_cast< int >(wxWS_EX_VALIDATE_RECURSIVELY)));
56050 SWIG_Python_SetConstant(d, "WS_EX_BLOCK_EVENTS",SWIG_From_int(static_cast< int >(wxWS_EX_BLOCK_EVENTS)));
56051 SWIG_Python_SetConstant(d, "WS_EX_TRANSIENT",SWIG_From_int(static_cast< int >(wxWS_EX_TRANSIENT)));
56052 SWIG_Python_SetConstant(d, "WS_EX_THEMED_BACKGROUND",SWIG_From_int(static_cast< int >(wxWS_EX_THEMED_BACKGROUND)));
56053 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_IDLE",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_IDLE)));
56054 SWIG_Python_SetConstant(d, "WS_EX_PROCESS_UI_UPDATES",SWIG_From_int(static_cast< int >(wxWS_EX_PROCESS_UI_UPDATES)));
56055 SWIG_Python_SetConstant(d, "MM_TEXT",SWIG_From_int(static_cast< int >(wxMM_TEXT)));
56056 SWIG_Python_SetConstant(d, "MM_LOMETRIC",SWIG_From_int(static_cast< int >(wxMM_LOMETRIC)));
56057 SWIG_Python_SetConstant(d, "MM_HIMETRIC",SWIG_From_int(static_cast< int >(wxMM_HIMETRIC)));
56058 SWIG_Python_SetConstant(d, "MM_LOENGLISH",SWIG_From_int(static_cast< int >(wxMM_LOENGLISH)));
56059 SWIG_Python_SetConstant(d, "MM_HIENGLISH",SWIG_From_int(static_cast< int >(wxMM_HIENGLISH)));
56060 SWIG_Python_SetConstant(d, "MM_TWIPS",SWIG_From_int(static_cast< int >(wxMM_TWIPS)));
56061 SWIG_Python_SetConstant(d, "MM_ISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ISOTROPIC)));
56062 SWIG_Python_SetConstant(d, "MM_ANISOTROPIC",SWIG_From_int(static_cast< int >(wxMM_ANISOTROPIC)));
56063 SWIG_Python_SetConstant(d, "MM_POINTS",SWIG_From_int(static_cast< int >(wxMM_POINTS)));
56064 SWIG_Python_SetConstant(d, "MM_METRIC",SWIG_From_int(static_cast< int >(wxMM_METRIC)));
56065 SWIG_Python_SetConstant(d, "CENTRE",SWIG_From_int(static_cast< int >(wxCENTRE)));
56066 SWIG_Python_SetConstant(d, "CENTER",SWIG_From_int(static_cast< int >(wxCENTER)));
56067 SWIG_Python_SetConstant(d, "HORIZONTAL",SWIG_From_int(static_cast< int >(wxHORIZONTAL)));
56068 SWIG_Python_SetConstant(d, "VERTICAL",SWIG_From_int(static_cast< int >(wxVERTICAL)));
56069 SWIG_Python_SetConstant(d, "BOTH",SWIG_From_int(static_cast< int >(wxBOTH)));
56070 SWIG_Python_SetConstant(d, "LEFT",SWIG_From_int(static_cast< int >(wxLEFT)));
56071 SWIG_Python_SetConstant(d, "RIGHT",SWIG_From_int(static_cast< int >(wxRIGHT)));
56072 SWIG_Python_SetConstant(d, "UP",SWIG_From_int(static_cast< int >(wxUP)));
56073 SWIG_Python_SetConstant(d, "DOWN",SWIG_From_int(static_cast< int >(wxDOWN)));
56074 SWIG_Python_SetConstant(d, "TOP",SWIG_From_int(static_cast< int >(wxTOP)));
56075 SWIG_Python_SetConstant(d, "BOTTOM",SWIG_From_int(static_cast< int >(wxBOTTOM)));
56076 SWIG_Python_SetConstant(d, "NORTH",SWIG_From_int(static_cast< int >(wxNORTH)));
56077 SWIG_Python_SetConstant(d, "SOUTH",SWIG_From_int(static_cast< int >(wxSOUTH)));
56078 SWIG_Python_SetConstant(d, "WEST",SWIG_From_int(static_cast< int >(wxWEST)));
56079 SWIG_Python_SetConstant(d, "EAST",SWIG_From_int(static_cast< int >(wxEAST)));
56080 SWIG_Python_SetConstant(d, "ALL",SWIG_From_int(static_cast< int >(wxALL)));
56081 SWIG_Python_SetConstant(d, "ALIGN_NOT",SWIG_From_int(static_cast< int >(wxALIGN_NOT)));
56082 SWIG_Python_SetConstant(d, "ALIGN_CENTER_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_HORIZONTAL)));
56083 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_HORIZONTAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_HORIZONTAL)));
56084 SWIG_Python_SetConstant(d, "ALIGN_LEFT",SWIG_From_int(static_cast< int >(wxALIGN_LEFT)));
56085 SWIG_Python_SetConstant(d, "ALIGN_TOP",SWIG_From_int(static_cast< int >(wxALIGN_TOP)));
56086 SWIG_Python_SetConstant(d, "ALIGN_RIGHT",SWIG_From_int(static_cast< int >(wxALIGN_RIGHT)));
56087 SWIG_Python_SetConstant(d, "ALIGN_BOTTOM",SWIG_From_int(static_cast< int >(wxALIGN_BOTTOM)));
56088 SWIG_Python_SetConstant(d, "ALIGN_CENTER_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTER_VERTICAL)));
56089 SWIG_Python_SetConstant(d, "ALIGN_CENTRE_VERTICAL",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE_VERTICAL)));
56090 SWIG_Python_SetConstant(d, "ALIGN_CENTER",SWIG_From_int(static_cast< int >(wxALIGN_CENTER)));
56091 SWIG_Python_SetConstant(d, "ALIGN_CENTRE",SWIG_From_int(static_cast< int >(wxALIGN_CENTRE)));
56092 SWIG_Python_SetConstant(d, "ALIGN_MASK",SWIG_From_int(static_cast< int >(wxALIGN_MASK)));
56093 SWIG_Python_SetConstant(d, "STRETCH_NOT",SWIG_From_int(static_cast< int >(wxSTRETCH_NOT)));
56094 SWIG_Python_SetConstant(d, "SHRINK",SWIG_From_int(static_cast< int >(wxSHRINK)));
56095 SWIG_Python_SetConstant(d, "GROW",SWIG_From_int(static_cast< int >(wxGROW)));
56096 SWIG_Python_SetConstant(d, "EXPAND",SWIG_From_int(static_cast< int >(wxEXPAND)));
56097 SWIG_Python_SetConstant(d, "SHAPED",SWIG_From_int(static_cast< int >(wxSHAPED)));
56098 SWIG_Python_SetConstant(d, "FIXED_MINSIZE",SWIG_From_int(static_cast< int >(wxFIXED_MINSIZE)));
56099 SWIG_Python_SetConstant(d, "TILE",SWIG_From_int(static_cast< int >(wxTILE)));
56100 SWIG_Python_SetConstant(d, "ADJUST_MINSIZE",SWIG_From_int(static_cast< int >(wxADJUST_MINSIZE)));
56101 SWIG_Python_SetConstant(d, "BORDER_DEFAULT",SWIG_From_int(static_cast< int >(wxBORDER_DEFAULT)));
56102 SWIG_Python_SetConstant(d, "BORDER_NONE",SWIG_From_int(static_cast< int >(wxBORDER_NONE)));
56103 SWIG_Python_SetConstant(d, "BORDER_STATIC",SWIG_From_int(static_cast< int >(wxBORDER_STATIC)));
56104 SWIG_Python_SetConstant(d, "BORDER_SIMPLE",SWIG_From_int(static_cast< int >(wxBORDER_SIMPLE)));
56105 SWIG_Python_SetConstant(d, "BORDER_RAISED",SWIG_From_int(static_cast< int >(wxBORDER_RAISED)));
56106 SWIG_Python_SetConstant(d, "BORDER_SUNKEN",SWIG_From_int(static_cast< int >(wxBORDER_SUNKEN)));
56107 SWIG_Python_SetConstant(d, "BORDER_DOUBLE",SWIG_From_int(static_cast< int >(wxBORDER_DOUBLE)));
56108 SWIG_Python_SetConstant(d, "BORDER_MASK",SWIG_From_int(static_cast< int >(wxBORDER_MASK)));
56109 SWIG_Python_SetConstant(d, "BG_STYLE_SYSTEM",SWIG_From_int(static_cast< int >(wxBG_STYLE_SYSTEM)));
56110 SWIG_Python_SetConstant(d, "BG_STYLE_COLOUR",SWIG_From_int(static_cast< int >(wxBG_STYLE_COLOUR)));
56111 SWIG_Python_SetConstant(d, "BG_STYLE_CUSTOM",SWIG_From_int(static_cast< int >(wxBG_STYLE_CUSTOM)));
56112 SWIG_Python_SetConstant(d, "DEFAULT",SWIG_From_int(static_cast< int >(wxDEFAULT)));
56113 SWIG_Python_SetConstant(d, "DECORATIVE",SWIG_From_int(static_cast< int >(wxDECORATIVE)));
56114 SWIG_Python_SetConstant(d, "ROMAN",SWIG_From_int(static_cast< int >(wxROMAN)));
56115 SWIG_Python_SetConstant(d, "SCRIPT",SWIG_From_int(static_cast< int >(wxSCRIPT)));
56116 SWIG_Python_SetConstant(d, "SWISS",SWIG_From_int(static_cast< int >(wxSWISS)));
56117 SWIG_Python_SetConstant(d, "MODERN",SWIG_From_int(static_cast< int >(wxMODERN)));
56118 SWIG_Python_SetConstant(d, "TELETYPE",SWIG_From_int(static_cast< int >(wxTELETYPE)));
56119 SWIG_Python_SetConstant(d, "VARIABLE",SWIG_From_int(static_cast< int >(wxVARIABLE)));
56120 SWIG_Python_SetConstant(d, "FIXED",SWIG_From_int(static_cast< int >(wxFIXED)));
56121 SWIG_Python_SetConstant(d, "NORMAL",SWIG_From_int(static_cast< int >(wxNORMAL)));
56122 SWIG_Python_SetConstant(d, "LIGHT",SWIG_From_int(static_cast< int >(wxLIGHT)));
56123 SWIG_Python_SetConstant(d, "BOLD",SWIG_From_int(static_cast< int >(wxBOLD)));
56124 SWIG_Python_SetConstant(d, "ITALIC",SWIG_From_int(static_cast< int >(wxITALIC)));
56125 SWIG_Python_SetConstant(d, "SLANT",SWIG_From_int(static_cast< int >(wxSLANT)));
56126 SWIG_Python_SetConstant(d, "SOLID",SWIG_From_int(static_cast< int >(wxSOLID)));
56127 SWIG_Python_SetConstant(d, "DOT",SWIG_From_int(static_cast< int >(wxDOT)));
56128 SWIG_Python_SetConstant(d, "LONG_DASH",SWIG_From_int(static_cast< int >(wxLONG_DASH)));
56129 SWIG_Python_SetConstant(d, "SHORT_DASH",SWIG_From_int(static_cast< int >(wxSHORT_DASH)));
56130 SWIG_Python_SetConstant(d, "DOT_DASH",SWIG_From_int(static_cast< int >(wxDOT_DASH)));
56131 SWIG_Python_SetConstant(d, "USER_DASH",SWIG_From_int(static_cast< int >(wxUSER_DASH)));
56132 SWIG_Python_SetConstant(d, "TRANSPARENT",SWIG_From_int(static_cast< int >(wxTRANSPARENT)));
56133 SWIG_Python_SetConstant(d, "STIPPLE",SWIG_From_int(static_cast< int >(wxSTIPPLE)));
56134 SWIG_Python_SetConstant(d, "STIPPLE_MASK",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK)));
56135 SWIG_Python_SetConstant(d, "STIPPLE_MASK_OPAQUE",SWIG_From_int(static_cast< int >(wxSTIPPLE_MASK_OPAQUE)));
56136 SWIG_Python_SetConstant(d, "BDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxBDIAGONAL_HATCH)));
56137 SWIG_Python_SetConstant(d, "CROSSDIAG_HATCH",SWIG_From_int(static_cast< int >(wxCROSSDIAG_HATCH)));
56138 SWIG_Python_SetConstant(d, "FDIAGONAL_HATCH",SWIG_From_int(static_cast< int >(wxFDIAGONAL_HATCH)));
56139 SWIG_Python_SetConstant(d, "CROSS_HATCH",SWIG_From_int(static_cast< int >(wxCROSS_HATCH)));
56140 SWIG_Python_SetConstant(d, "HORIZONTAL_HATCH",SWIG_From_int(static_cast< int >(wxHORIZONTAL_HATCH)));
56141 SWIG_Python_SetConstant(d, "VERTICAL_HATCH",SWIG_From_int(static_cast< int >(wxVERTICAL_HATCH)));
56142 SWIG_Python_SetConstant(d, "JOIN_BEVEL",SWIG_From_int(static_cast< int >(wxJOIN_BEVEL)));
56143 SWIG_Python_SetConstant(d, "JOIN_MITER",SWIG_From_int(static_cast< int >(wxJOIN_MITER)));
56144 SWIG_Python_SetConstant(d, "JOIN_ROUND",SWIG_From_int(static_cast< int >(wxJOIN_ROUND)));
56145 SWIG_Python_SetConstant(d, "CAP_ROUND",SWIG_From_int(static_cast< int >(wxCAP_ROUND)));
56146 SWIG_Python_SetConstant(d, "CAP_PROJECTING",SWIG_From_int(static_cast< int >(wxCAP_PROJECTING)));
56147 SWIG_Python_SetConstant(d, "CAP_BUTT",SWIG_From_int(static_cast< int >(wxCAP_BUTT)));
56148 SWIG_Python_SetConstant(d, "CLEAR",SWIG_From_int(static_cast< int >(wxCLEAR)));
56149 SWIG_Python_SetConstant(d, "XOR",SWIG_From_int(static_cast< int >(wxXOR)));
56150 SWIG_Python_SetConstant(d, "INVERT",SWIG_From_int(static_cast< int >(wxINVERT)));
56151 SWIG_Python_SetConstant(d, "OR_REVERSE",SWIG_From_int(static_cast< int >(wxOR_REVERSE)));
56152 SWIG_Python_SetConstant(d, "AND_REVERSE",SWIG_From_int(static_cast< int >(wxAND_REVERSE)));
56153 SWIG_Python_SetConstant(d, "COPY",SWIG_From_int(static_cast< int >(wxCOPY)));
56154 SWIG_Python_SetConstant(d, "AND",SWIG_From_int(static_cast< int >(wxAND)));
56155 SWIG_Python_SetConstant(d, "AND_INVERT",SWIG_From_int(static_cast< int >(wxAND_INVERT)));
56156 SWIG_Python_SetConstant(d, "NO_OP",SWIG_From_int(static_cast< int >(wxNO_OP)));
56157 SWIG_Python_SetConstant(d, "NOR",SWIG_From_int(static_cast< int >(wxNOR)));
56158 SWIG_Python_SetConstant(d, "EQUIV",SWIG_From_int(static_cast< int >(wxEQUIV)));
56159 SWIG_Python_SetConstant(d, "SRC_INVERT",SWIG_From_int(static_cast< int >(wxSRC_INVERT)));
56160 SWIG_Python_SetConstant(d, "OR_INVERT",SWIG_From_int(static_cast< int >(wxOR_INVERT)));
56161 SWIG_Python_SetConstant(d, "NAND",SWIG_From_int(static_cast< int >(wxNAND)));
56162 SWIG_Python_SetConstant(d, "OR",SWIG_From_int(static_cast< int >(wxOR)));
56163 SWIG_Python_SetConstant(d, "SET",SWIG_From_int(static_cast< int >(wxSET)));
56164 SWIG_Python_SetConstant(d, "WXK_BACK",SWIG_From_int(static_cast< int >(WXK_BACK)));
56165 SWIG_Python_SetConstant(d, "WXK_TAB",SWIG_From_int(static_cast< int >(WXK_TAB)));
56166 SWIG_Python_SetConstant(d, "WXK_RETURN",SWIG_From_int(static_cast< int >(WXK_RETURN)));
56167 SWIG_Python_SetConstant(d, "WXK_ESCAPE",SWIG_From_int(static_cast< int >(WXK_ESCAPE)));
56168 SWIG_Python_SetConstant(d, "WXK_SPACE",SWIG_From_int(static_cast< int >(WXK_SPACE)));
56169 SWIG_Python_SetConstant(d, "WXK_DELETE",SWIG_From_int(static_cast< int >(WXK_DELETE)));
56170 SWIG_Python_SetConstant(d, "WXK_START",SWIG_From_int(static_cast< int >(WXK_START)));
56171 SWIG_Python_SetConstant(d, "WXK_LBUTTON",SWIG_From_int(static_cast< int >(WXK_LBUTTON)));
56172 SWIG_Python_SetConstant(d, "WXK_RBUTTON",SWIG_From_int(static_cast< int >(WXK_RBUTTON)));
56173 SWIG_Python_SetConstant(d, "WXK_CANCEL",SWIG_From_int(static_cast< int >(WXK_CANCEL)));
56174 SWIG_Python_SetConstant(d, "WXK_MBUTTON",SWIG_From_int(static_cast< int >(WXK_MBUTTON)));
56175 SWIG_Python_SetConstant(d, "WXK_CLEAR",SWIG_From_int(static_cast< int >(WXK_CLEAR)));
56176 SWIG_Python_SetConstant(d, "WXK_SHIFT",SWIG_From_int(static_cast< int >(WXK_SHIFT)));
56177 SWIG_Python_SetConstant(d, "WXK_ALT",SWIG_From_int(static_cast< int >(WXK_ALT)));
56178 SWIG_Python_SetConstant(d, "WXK_CONTROL",SWIG_From_int(static_cast< int >(WXK_CONTROL)));
56179 SWIG_Python_SetConstant(d, "WXK_MENU",SWIG_From_int(static_cast< int >(WXK_MENU)));
56180 SWIG_Python_SetConstant(d, "WXK_PAUSE",SWIG_From_int(static_cast< int >(WXK_PAUSE)));
56181 SWIG_Python_SetConstant(d, "WXK_CAPITAL",SWIG_From_int(static_cast< int >(WXK_CAPITAL)));
56182 SWIG_Python_SetConstant(d, "WXK_PRIOR",SWIG_From_int(static_cast< int >(WXK_PRIOR)));
56183 SWIG_Python_SetConstant(d, "WXK_NEXT",SWIG_From_int(static_cast< int >(WXK_NEXT)));
56184 SWIG_Python_SetConstant(d, "WXK_END",SWIG_From_int(static_cast< int >(WXK_END)));
56185 SWIG_Python_SetConstant(d, "WXK_HOME",SWIG_From_int(static_cast< int >(WXK_HOME)));
56186 SWIG_Python_SetConstant(d, "WXK_LEFT",SWIG_From_int(static_cast< int >(WXK_LEFT)));
56187 SWIG_Python_SetConstant(d, "WXK_UP",SWIG_From_int(static_cast< int >(WXK_UP)));
56188 SWIG_Python_SetConstant(d, "WXK_RIGHT",SWIG_From_int(static_cast< int >(WXK_RIGHT)));
56189 SWIG_Python_SetConstant(d, "WXK_DOWN",SWIG_From_int(static_cast< int >(WXK_DOWN)));
56190 SWIG_Python_SetConstant(d, "WXK_SELECT",SWIG_From_int(static_cast< int >(WXK_SELECT)));
56191 SWIG_Python_SetConstant(d, "WXK_PRINT",SWIG_From_int(static_cast< int >(WXK_PRINT)));
56192 SWIG_Python_SetConstant(d, "WXK_EXECUTE",SWIG_From_int(static_cast< int >(WXK_EXECUTE)));
56193 SWIG_Python_SetConstant(d, "WXK_SNAPSHOT",SWIG_From_int(static_cast< int >(WXK_SNAPSHOT)));
56194 SWIG_Python_SetConstant(d, "WXK_INSERT",SWIG_From_int(static_cast< int >(WXK_INSERT)));
56195 SWIG_Python_SetConstant(d, "WXK_HELP",SWIG_From_int(static_cast< int >(WXK_HELP)));
56196 SWIG_Python_SetConstant(d, "WXK_NUMPAD0",SWIG_From_int(static_cast< int >(WXK_NUMPAD0)));
56197 SWIG_Python_SetConstant(d, "WXK_NUMPAD1",SWIG_From_int(static_cast< int >(WXK_NUMPAD1)));
56198 SWIG_Python_SetConstant(d, "WXK_NUMPAD2",SWIG_From_int(static_cast< int >(WXK_NUMPAD2)));
56199 SWIG_Python_SetConstant(d, "WXK_NUMPAD3",SWIG_From_int(static_cast< int >(WXK_NUMPAD3)));
56200 SWIG_Python_SetConstant(d, "WXK_NUMPAD4",SWIG_From_int(static_cast< int >(WXK_NUMPAD4)));
56201 SWIG_Python_SetConstant(d, "WXK_NUMPAD5",SWIG_From_int(static_cast< int >(WXK_NUMPAD5)));
56202 SWIG_Python_SetConstant(d, "WXK_NUMPAD6",SWIG_From_int(static_cast< int >(WXK_NUMPAD6)));
56203 SWIG_Python_SetConstant(d, "WXK_NUMPAD7",SWIG_From_int(static_cast< int >(WXK_NUMPAD7)));
56204 SWIG_Python_SetConstant(d, "WXK_NUMPAD8",SWIG_From_int(static_cast< int >(WXK_NUMPAD8)));
56205 SWIG_Python_SetConstant(d, "WXK_NUMPAD9",SWIG_From_int(static_cast< int >(WXK_NUMPAD9)));
56206 SWIG_Python_SetConstant(d, "WXK_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_MULTIPLY)));
56207 SWIG_Python_SetConstant(d, "WXK_ADD",SWIG_From_int(static_cast< int >(WXK_ADD)));
56208 SWIG_Python_SetConstant(d, "WXK_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_SEPARATOR)));
56209 SWIG_Python_SetConstant(d, "WXK_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_SUBTRACT)));
56210 SWIG_Python_SetConstant(d, "WXK_DECIMAL",SWIG_From_int(static_cast< int >(WXK_DECIMAL)));
56211 SWIG_Python_SetConstant(d, "WXK_DIVIDE",SWIG_From_int(static_cast< int >(WXK_DIVIDE)));
56212 SWIG_Python_SetConstant(d, "WXK_F1",SWIG_From_int(static_cast< int >(WXK_F1)));
56213 SWIG_Python_SetConstant(d, "WXK_F2",SWIG_From_int(static_cast< int >(WXK_F2)));
56214 SWIG_Python_SetConstant(d, "WXK_F3",SWIG_From_int(static_cast< int >(WXK_F3)));
56215 SWIG_Python_SetConstant(d, "WXK_F4",SWIG_From_int(static_cast< int >(WXK_F4)));
56216 SWIG_Python_SetConstant(d, "WXK_F5",SWIG_From_int(static_cast< int >(WXK_F5)));
56217 SWIG_Python_SetConstant(d, "WXK_F6",SWIG_From_int(static_cast< int >(WXK_F6)));
56218 SWIG_Python_SetConstant(d, "WXK_F7",SWIG_From_int(static_cast< int >(WXK_F7)));
56219 SWIG_Python_SetConstant(d, "WXK_F8",SWIG_From_int(static_cast< int >(WXK_F8)));
56220 SWIG_Python_SetConstant(d, "WXK_F9",SWIG_From_int(static_cast< int >(WXK_F9)));
56221 SWIG_Python_SetConstant(d, "WXK_F10",SWIG_From_int(static_cast< int >(WXK_F10)));
56222 SWIG_Python_SetConstant(d, "WXK_F11",SWIG_From_int(static_cast< int >(WXK_F11)));
56223 SWIG_Python_SetConstant(d, "WXK_F12",SWIG_From_int(static_cast< int >(WXK_F12)));
56224 SWIG_Python_SetConstant(d, "WXK_F13",SWIG_From_int(static_cast< int >(WXK_F13)));
56225 SWIG_Python_SetConstant(d, "WXK_F14",SWIG_From_int(static_cast< int >(WXK_F14)));
56226 SWIG_Python_SetConstant(d, "WXK_F15",SWIG_From_int(static_cast< int >(WXK_F15)));
56227 SWIG_Python_SetConstant(d, "WXK_F16",SWIG_From_int(static_cast< int >(WXK_F16)));
56228 SWIG_Python_SetConstant(d, "WXK_F17",SWIG_From_int(static_cast< int >(WXK_F17)));
56229 SWIG_Python_SetConstant(d, "WXK_F18",SWIG_From_int(static_cast< int >(WXK_F18)));
56230 SWIG_Python_SetConstant(d, "WXK_F19",SWIG_From_int(static_cast< int >(WXK_F19)));
56231 SWIG_Python_SetConstant(d, "WXK_F20",SWIG_From_int(static_cast< int >(WXK_F20)));
56232 SWIG_Python_SetConstant(d, "WXK_F21",SWIG_From_int(static_cast< int >(WXK_F21)));
56233 SWIG_Python_SetConstant(d, "WXK_F22",SWIG_From_int(static_cast< int >(WXK_F22)));
56234 SWIG_Python_SetConstant(d, "WXK_F23",SWIG_From_int(static_cast< int >(WXK_F23)));
56235 SWIG_Python_SetConstant(d, "WXK_F24",SWIG_From_int(static_cast< int >(WXK_F24)));
56236 SWIG_Python_SetConstant(d, "WXK_NUMLOCK",SWIG_From_int(static_cast< int >(WXK_NUMLOCK)));
56237 SWIG_Python_SetConstant(d, "WXK_SCROLL",SWIG_From_int(static_cast< int >(WXK_SCROLL)));
56238 SWIG_Python_SetConstant(d, "WXK_PAGEUP",SWIG_From_int(static_cast< int >(WXK_PAGEUP)));
56239 SWIG_Python_SetConstant(d, "WXK_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_PAGEDOWN)));
56240 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SPACE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SPACE)));
56241 SWIG_Python_SetConstant(d, "WXK_NUMPAD_TAB",SWIG_From_int(static_cast< int >(WXK_NUMPAD_TAB)));
56242 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ENTER",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ENTER)));
56243 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F1",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F1)));
56244 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F2",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F2)));
56245 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F3",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F3)));
56246 SWIG_Python_SetConstant(d, "WXK_NUMPAD_F4",SWIG_From_int(static_cast< int >(WXK_NUMPAD_F4)));
56247 SWIG_Python_SetConstant(d, "WXK_NUMPAD_HOME",SWIG_From_int(static_cast< int >(WXK_NUMPAD_HOME)));
56248 SWIG_Python_SetConstant(d, "WXK_NUMPAD_LEFT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_LEFT)));
56249 SWIG_Python_SetConstant(d, "WXK_NUMPAD_UP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_UP)));
56250 SWIG_Python_SetConstant(d, "WXK_NUMPAD_RIGHT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_RIGHT)));
56251 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DOWN)));
56252 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PRIOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PRIOR)));
56253 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEUP",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEUP)));
56254 SWIG_Python_SetConstant(d, "WXK_NUMPAD_NEXT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_NEXT)));
56255 SWIG_Python_SetConstant(d, "WXK_NUMPAD_PAGEDOWN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_PAGEDOWN)));
56256 SWIG_Python_SetConstant(d, "WXK_NUMPAD_END",SWIG_From_int(static_cast< int >(WXK_NUMPAD_END)));
56257 SWIG_Python_SetConstant(d, "WXK_NUMPAD_BEGIN",SWIG_From_int(static_cast< int >(WXK_NUMPAD_BEGIN)));
56258 SWIG_Python_SetConstant(d, "WXK_NUMPAD_INSERT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_INSERT)));
56259 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DELETE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DELETE)));
56260 SWIG_Python_SetConstant(d, "WXK_NUMPAD_EQUAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_EQUAL)));
56261 SWIG_Python_SetConstant(d, "WXK_NUMPAD_MULTIPLY",SWIG_From_int(static_cast< int >(WXK_NUMPAD_MULTIPLY)));
56262 SWIG_Python_SetConstant(d, "WXK_NUMPAD_ADD",SWIG_From_int(static_cast< int >(WXK_NUMPAD_ADD)));
56263 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SEPARATOR",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SEPARATOR)));
56264 SWIG_Python_SetConstant(d, "WXK_NUMPAD_SUBTRACT",SWIG_From_int(static_cast< int >(WXK_NUMPAD_SUBTRACT)));
56265 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DECIMAL",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DECIMAL)));
56266 SWIG_Python_SetConstant(d, "WXK_NUMPAD_DIVIDE",SWIG_From_int(static_cast< int >(WXK_NUMPAD_DIVIDE)));
56267 SWIG_Python_SetConstant(d, "WXK_WINDOWS_LEFT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_LEFT)));
56268 SWIG_Python_SetConstant(d, "WXK_WINDOWS_RIGHT",SWIG_From_int(static_cast< int >(WXK_WINDOWS_RIGHT)));
56269 SWIG_Python_SetConstant(d, "WXK_WINDOWS_MENU",SWIG_From_int(static_cast< int >(WXK_WINDOWS_MENU)));
56270 SWIG_Python_SetConstant(d, "WXK_COMMAND",SWIG_From_int(static_cast< int >(WXK_COMMAND)));
56271 SWIG_Python_SetConstant(d, "WXK_SPECIAL1",SWIG_From_int(static_cast< int >(WXK_SPECIAL1)));
56272 SWIG_Python_SetConstant(d, "WXK_SPECIAL2",SWIG_From_int(static_cast< int >(WXK_SPECIAL2)));
56273 SWIG_Python_SetConstant(d, "WXK_SPECIAL3",SWIG_From_int(static_cast< int >(WXK_SPECIAL3)));
56274 SWIG_Python_SetConstant(d, "WXK_SPECIAL4",SWIG_From_int(static_cast< int >(WXK_SPECIAL4)));
56275 SWIG_Python_SetConstant(d, "WXK_SPECIAL5",SWIG_From_int(static_cast< int >(WXK_SPECIAL5)));
56276 SWIG_Python_SetConstant(d, "WXK_SPECIAL6",SWIG_From_int(static_cast< int >(WXK_SPECIAL6)));
56277 SWIG_Python_SetConstant(d, "WXK_SPECIAL7",SWIG_From_int(static_cast< int >(WXK_SPECIAL7)));
56278 SWIG_Python_SetConstant(d, "WXK_SPECIAL8",SWIG_From_int(static_cast< int >(WXK_SPECIAL8)));
56279 SWIG_Python_SetConstant(d, "WXK_SPECIAL9",SWIG_From_int(static_cast< int >(WXK_SPECIAL9)));
56280 SWIG_Python_SetConstant(d, "WXK_SPECIAL10",SWIG_From_int(static_cast< int >(WXK_SPECIAL10)));
56281 SWIG_Python_SetConstant(d, "WXK_SPECIAL11",SWIG_From_int(static_cast< int >(WXK_SPECIAL11)));
56282 SWIG_Python_SetConstant(d, "WXK_SPECIAL12",SWIG_From_int(static_cast< int >(WXK_SPECIAL12)));
56283 SWIG_Python_SetConstant(d, "WXK_SPECIAL13",SWIG_From_int(static_cast< int >(WXK_SPECIAL13)));
56284 SWIG_Python_SetConstant(d, "WXK_SPECIAL14",SWIG_From_int(static_cast< int >(WXK_SPECIAL14)));
56285 SWIG_Python_SetConstant(d, "WXK_SPECIAL15",SWIG_From_int(static_cast< int >(WXK_SPECIAL15)));
56286 SWIG_Python_SetConstant(d, "WXK_SPECIAL16",SWIG_From_int(static_cast< int >(WXK_SPECIAL16)));
56287 SWIG_Python_SetConstant(d, "WXK_SPECIAL17",SWIG_From_int(static_cast< int >(WXK_SPECIAL17)));
56288 SWIG_Python_SetConstant(d, "WXK_SPECIAL18",SWIG_From_int(static_cast< int >(WXK_SPECIAL18)));
56289 SWIG_Python_SetConstant(d, "WXK_SPECIAL19",SWIG_From_int(static_cast< int >(WXK_SPECIAL19)));
56290 SWIG_Python_SetConstant(d, "WXK_SPECIAL20",SWIG_From_int(static_cast< int >(WXK_SPECIAL20)));
56291 SWIG_Python_SetConstant(d, "PAPER_NONE",SWIG_From_int(static_cast< int >(wxPAPER_NONE)));
56292 SWIG_Python_SetConstant(d, "PAPER_LETTER",SWIG_From_int(static_cast< int >(wxPAPER_LETTER)));
56293 SWIG_Python_SetConstant(d, "PAPER_LEGAL",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL)));
56294 SWIG_Python_SetConstant(d, "PAPER_A4",SWIG_From_int(static_cast< int >(wxPAPER_A4)));
56295 SWIG_Python_SetConstant(d, "PAPER_CSHEET",SWIG_From_int(static_cast< int >(wxPAPER_CSHEET)));
56296 SWIG_Python_SetConstant(d, "PAPER_DSHEET",SWIG_From_int(static_cast< int >(wxPAPER_DSHEET)));
56297 SWIG_Python_SetConstant(d, "PAPER_ESHEET",SWIG_From_int(static_cast< int >(wxPAPER_ESHEET)));
56298 SWIG_Python_SetConstant(d, "PAPER_LETTERSMALL",SWIG_From_int(static_cast< int >(wxPAPER_LETTERSMALL)));
56299 SWIG_Python_SetConstant(d, "PAPER_TABLOID",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID)));
56300 SWIG_Python_SetConstant(d, "PAPER_LEDGER",SWIG_From_int(static_cast< int >(wxPAPER_LEDGER)));
56301 SWIG_Python_SetConstant(d, "PAPER_STATEMENT",SWIG_From_int(static_cast< int >(wxPAPER_STATEMENT)));
56302 SWIG_Python_SetConstant(d, "PAPER_EXECUTIVE",SWIG_From_int(static_cast< int >(wxPAPER_EXECUTIVE)));
56303 SWIG_Python_SetConstant(d, "PAPER_A3",SWIG_From_int(static_cast< int >(wxPAPER_A3)));
56304 SWIG_Python_SetConstant(d, "PAPER_A4SMALL",SWIG_From_int(static_cast< int >(wxPAPER_A4SMALL)));
56305 SWIG_Python_SetConstant(d, "PAPER_A5",SWIG_From_int(static_cast< int >(wxPAPER_A5)));
56306 SWIG_Python_SetConstant(d, "PAPER_B4",SWIG_From_int(static_cast< int >(wxPAPER_B4)));
56307 SWIG_Python_SetConstant(d, "PAPER_B5",SWIG_From_int(static_cast< int >(wxPAPER_B5)));
56308 SWIG_Python_SetConstant(d, "PAPER_FOLIO",SWIG_From_int(static_cast< int >(wxPAPER_FOLIO)));
56309 SWIG_Python_SetConstant(d, "PAPER_QUARTO",SWIG_From_int(static_cast< int >(wxPAPER_QUARTO)));
56310 SWIG_Python_SetConstant(d, "PAPER_10X14",SWIG_From_int(static_cast< int >(wxPAPER_10X14)));
56311 SWIG_Python_SetConstant(d, "PAPER_11X17",SWIG_From_int(static_cast< int >(wxPAPER_11X17)));
56312 SWIG_Python_SetConstant(d, "PAPER_NOTE",SWIG_From_int(static_cast< int >(wxPAPER_NOTE)));
56313 SWIG_Python_SetConstant(d, "PAPER_ENV_9",SWIG_From_int(static_cast< int >(wxPAPER_ENV_9)));
56314 SWIG_Python_SetConstant(d, "PAPER_ENV_10",SWIG_From_int(static_cast< int >(wxPAPER_ENV_10)));
56315 SWIG_Python_SetConstant(d, "PAPER_ENV_11",SWIG_From_int(static_cast< int >(wxPAPER_ENV_11)));
56316 SWIG_Python_SetConstant(d, "PAPER_ENV_12",SWIG_From_int(static_cast< int >(wxPAPER_ENV_12)));
56317 SWIG_Python_SetConstant(d, "PAPER_ENV_14",SWIG_From_int(static_cast< int >(wxPAPER_ENV_14)));
56318 SWIG_Python_SetConstant(d, "PAPER_ENV_DL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_DL)));
56319 SWIG_Python_SetConstant(d, "PAPER_ENV_C5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C5)));
56320 SWIG_Python_SetConstant(d, "PAPER_ENV_C3",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C3)));
56321 SWIG_Python_SetConstant(d, "PAPER_ENV_C4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C4)));
56322 SWIG_Python_SetConstant(d, "PAPER_ENV_C6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C6)));
56323 SWIG_Python_SetConstant(d, "PAPER_ENV_C65",SWIG_From_int(static_cast< int >(wxPAPER_ENV_C65)));
56324 SWIG_Python_SetConstant(d, "PAPER_ENV_B4",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B4)));
56325 SWIG_Python_SetConstant(d, "PAPER_ENV_B5",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B5)));
56326 SWIG_Python_SetConstant(d, "PAPER_ENV_B6",SWIG_From_int(static_cast< int >(wxPAPER_ENV_B6)));
56327 SWIG_Python_SetConstant(d, "PAPER_ENV_ITALY",SWIG_From_int(static_cast< int >(wxPAPER_ENV_ITALY)));
56328 SWIG_Python_SetConstant(d, "PAPER_ENV_MONARCH",SWIG_From_int(static_cast< int >(wxPAPER_ENV_MONARCH)));
56329 SWIG_Python_SetConstant(d, "PAPER_ENV_PERSONAL",SWIG_From_int(static_cast< int >(wxPAPER_ENV_PERSONAL)));
56330 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_US",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_US)));
56331 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_STD_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_STD_GERMAN)));
56332 SWIG_Python_SetConstant(d, "PAPER_FANFOLD_LGL_GERMAN",SWIG_From_int(static_cast< int >(wxPAPER_FANFOLD_LGL_GERMAN)));
56333 SWIG_Python_SetConstant(d, "PAPER_ISO_B4",SWIG_From_int(static_cast< int >(wxPAPER_ISO_B4)));
56334 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD)));
56335 SWIG_Python_SetConstant(d, "PAPER_9X11",SWIG_From_int(static_cast< int >(wxPAPER_9X11)));
56336 SWIG_Python_SetConstant(d, "PAPER_10X11",SWIG_From_int(static_cast< int >(wxPAPER_10X11)));
56337 SWIG_Python_SetConstant(d, "PAPER_15X11",SWIG_From_int(static_cast< int >(wxPAPER_15X11)));
56338 SWIG_Python_SetConstant(d, "PAPER_ENV_INVITE",SWIG_From_int(static_cast< int >(wxPAPER_ENV_INVITE)));
56339 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA)));
56340 SWIG_Python_SetConstant(d, "PAPER_LEGAL_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_LEGAL_EXTRA)));
56341 SWIG_Python_SetConstant(d, "PAPER_TABLOID_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_TABLOID_EXTRA)));
56342 SWIG_Python_SetConstant(d, "PAPER_A4_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A4_EXTRA)));
56343 SWIG_Python_SetConstant(d, "PAPER_LETTER_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_TRANSVERSE)));
56344 SWIG_Python_SetConstant(d, "PAPER_A4_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A4_TRANSVERSE)));
56345 SWIG_Python_SetConstant(d, "PAPER_LETTER_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_EXTRA_TRANSVERSE)));
56346 SWIG_Python_SetConstant(d, "PAPER_A_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A_PLUS)));
56347 SWIG_Python_SetConstant(d, "PAPER_B_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_B_PLUS)));
56348 SWIG_Python_SetConstant(d, "PAPER_LETTER_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_PLUS)));
56349 SWIG_Python_SetConstant(d, "PAPER_A4_PLUS",SWIG_From_int(static_cast< int >(wxPAPER_A4_PLUS)));
56350 SWIG_Python_SetConstant(d, "PAPER_A5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A5_TRANSVERSE)));
56351 SWIG_Python_SetConstant(d, "PAPER_B5_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_B5_TRANSVERSE)));
56352 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA)));
56353 SWIG_Python_SetConstant(d, "PAPER_A5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_A5_EXTRA)));
56354 SWIG_Python_SetConstant(d, "PAPER_B5_EXTRA",SWIG_From_int(static_cast< int >(wxPAPER_B5_EXTRA)));
56355 SWIG_Python_SetConstant(d, "PAPER_A2",SWIG_From_int(static_cast< int >(wxPAPER_A2)));
56356 SWIG_Python_SetConstant(d, "PAPER_A3_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_TRANSVERSE)));
56357 SWIG_Python_SetConstant(d, "PAPER_A3_EXTRA_TRANSVERSE",SWIG_From_int(static_cast< int >(wxPAPER_A3_EXTRA_TRANSVERSE)));
56358 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD)));
56359 SWIG_Python_SetConstant(d, "PAPER_A6",SWIG_From_int(static_cast< int >(wxPAPER_A6)));
56360 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2)));
56361 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3)));
56362 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3)));
56363 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4)));
56364 SWIG_Python_SetConstant(d, "PAPER_LETTER_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_LETTER_ROTATED)));
56365 SWIG_Python_SetConstant(d, "PAPER_A3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A3_ROTATED)));
56366 SWIG_Python_SetConstant(d, "PAPER_A4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A4_ROTATED)));
56367 SWIG_Python_SetConstant(d, "PAPER_A5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A5_ROTATED)));
56368 SWIG_Python_SetConstant(d, "PAPER_B4_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B4_JIS_ROTATED)));
56369 SWIG_Python_SetConstant(d, "PAPER_B5_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B5_JIS_ROTATED)));
56370 SWIG_Python_SetConstant(d, "PAPER_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JAPANESE_POSTCARD_ROTATED)));
56371 SWIG_Python_SetConstant(d, "PAPER_DBL_JAPANESE_POSTCARD_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_DBL_JAPANESE_POSTCARD_ROTATED)));
56372 SWIG_Python_SetConstant(d, "PAPER_A6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_A6_ROTATED)));
56373 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU2_ROTATED)));
56374 SWIG_Python_SetConstant(d, "PAPER_JENV_KAKU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_KAKU3_ROTATED)));
56375 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU3_ROTATED)));
56376 SWIG_Python_SetConstant(d, "PAPER_JENV_CHOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_CHOU4_ROTATED)));
56377 SWIG_Python_SetConstant(d, "PAPER_B6_JIS",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS)));
56378 SWIG_Python_SetConstant(d, "PAPER_B6_JIS_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_B6_JIS_ROTATED)));
56379 SWIG_Python_SetConstant(d, "PAPER_12X11",SWIG_From_int(static_cast< int >(wxPAPER_12X11)));
56380 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4)));
56381 SWIG_Python_SetConstant(d, "PAPER_JENV_YOU4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_JENV_YOU4_ROTATED)));
56382 SWIG_Python_SetConstant(d, "PAPER_P16K",SWIG_From_int(static_cast< int >(wxPAPER_P16K)));
56383 SWIG_Python_SetConstant(d, "PAPER_P32K",SWIG_From_int(static_cast< int >(wxPAPER_P32K)));
56384 SWIG_Python_SetConstant(d, "PAPER_P32KBIG",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG)));
56385 SWIG_Python_SetConstant(d, "PAPER_PENV_1",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1)));
56386 SWIG_Python_SetConstant(d, "PAPER_PENV_2",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2)));
56387 SWIG_Python_SetConstant(d, "PAPER_PENV_3",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3)));
56388 SWIG_Python_SetConstant(d, "PAPER_PENV_4",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4)));
56389 SWIG_Python_SetConstant(d, "PAPER_PENV_5",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5)));
56390 SWIG_Python_SetConstant(d, "PAPER_PENV_6",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6)));
56391 SWIG_Python_SetConstant(d, "PAPER_PENV_7",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7)));
56392 SWIG_Python_SetConstant(d, "PAPER_PENV_8",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8)));
56393 SWIG_Python_SetConstant(d, "PAPER_PENV_9",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9)));
56394 SWIG_Python_SetConstant(d, "PAPER_PENV_10",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10)));
56395 SWIG_Python_SetConstant(d, "PAPER_P16K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P16K_ROTATED)));
56396 SWIG_Python_SetConstant(d, "PAPER_P32K_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32K_ROTATED)));
56397 SWIG_Python_SetConstant(d, "PAPER_P32KBIG_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_P32KBIG_ROTATED)));
56398 SWIG_Python_SetConstant(d, "PAPER_PENV_1_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_1_ROTATED)));
56399 SWIG_Python_SetConstant(d, "PAPER_PENV_2_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_2_ROTATED)));
56400 SWIG_Python_SetConstant(d, "PAPER_PENV_3_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_3_ROTATED)));
56401 SWIG_Python_SetConstant(d, "PAPER_PENV_4_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_4_ROTATED)));
56402 SWIG_Python_SetConstant(d, "PAPER_PENV_5_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_5_ROTATED)));
56403 SWIG_Python_SetConstant(d, "PAPER_PENV_6_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_6_ROTATED)));
56404 SWIG_Python_SetConstant(d, "PAPER_PENV_7_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_7_ROTATED)));
56405 SWIG_Python_SetConstant(d, "PAPER_PENV_8_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_8_ROTATED)));
56406 SWIG_Python_SetConstant(d, "PAPER_PENV_9_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_9_ROTATED)));
56407 SWIG_Python_SetConstant(d, "PAPER_PENV_10_ROTATED",SWIG_From_int(static_cast< int >(wxPAPER_PENV_10_ROTATED)));
56408 SWIG_Python_SetConstant(d, "DUPLEX_SIMPLEX",SWIG_From_int(static_cast< int >(wxDUPLEX_SIMPLEX)));
56409 SWIG_Python_SetConstant(d, "DUPLEX_HORIZONTAL",SWIG_From_int(static_cast< int >(wxDUPLEX_HORIZONTAL)));
56410 SWIG_Python_SetConstant(d, "DUPLEX_VERTICAL",SWIG_From_int(static_cast< int >(wxDUPLEX_VERTICAL)));
56411 SWIG_Python_SetConstant(d, "ITEM_SEPARATOR",SWIG_From_int(static_cast< int >(wxITEM_SEPARATOR)));
56412 SWIG_Python_SetConstant(d, "ITEM_NORMAL",SWIG_From_int(static_cast< int >(wxITEM_NORMAL)));
56413 SWIG_Python_SetConstant(d, "ITEM_CHECK",SWIG_From_int(static_cast< int >(wxITEM_CHECK)));
56414 SWIG_Python_SetConstant(d, "ITEM_RADIO",SWIG_From_int(static_cast< int >(wxITEM_RADIO)));
56415 SWIG_Python_SetConstant(d, "ITEM_MAX",SWIG_From_int(static_cast< int >(wxITEM_MAX)));
56416 SWIG_Python_SetConstant(d, "HT_NOWHERE",SWIG_From_int(static_cast< int >(wxHT_NOWHERE)));
56417 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_FIRST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_FIRST)));
56418 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_1)));
56419 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_LINE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_LINE_2)));
56420 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_1)));
56421 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_ARROW_PAGE_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_ARROW_PAGE_2)));
56422 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_THUMB",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_THUMB)));
56423 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_1",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_1)));
56424 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_BAR_2",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_BAR_2)));
56425 SWIG_Python_SetConstant(d, "HT_SCROLLBAR_LAST",SWIG_From_int(static_cast< int >(wxHT_SCROLLBAR_LAST)));
56426 SWIG_Python_SetConstant(d, "HT_WINDOW_OUTSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_OUTSIDE)));
56427 SWIG_Python_SetConstant(d, "HT_WINDOW_INSIDE",SWIG_From_int(static_cast< int >(wxHT_WINDOW_INSIDE)));
56428 SWIG_Python_SetConstant(d, "HT_WINDOW_VERT_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_VERT_SCROLLBAR)));
56429 SWIG_Python_SetConstant(d, "HT_WINDOW_HORZ_SCROLLBAR",SWIG_From_int(static_cast< int >(wxHT_WINDOW_HORZ_SCROLLBAR)));
56430 SWIG_Python_SetConstant(d, "HT_WINDOW_CORNER",SWIG_From_int(static_cast< int >(wxHT_WINDOW_CORNER)));
56431 SWIG_Python_SetConstant(d, "HT_MAX",SWIG_From_int(static_cast< int >(wxHT_MAX)));
56432 SWIG_Python_SetConstant(d, "MOD_NONE",SWIG_From_int(static_cast< int >(wxMOD_NONE)));
56433 SWIG_Python_SetConstant(d, "MOD_ALT",SWIG_From_int(static_cast< int >(wxMOD_ALT)));
56434 SWIG_Python_SetConstant(d, "MOD_CONTROL",SWIG_From_int(static_cast< int >(wxMOD_CONTROL)));
56435 SWIG_Python_SetConstant(d, "MOD_ALTGR",SWIG_From_int(static_cast< int >(wxMOD_ALTGR)));
56436 SWIG_Python_SetConstant(d, "MOD_SHIFT",SWIG_From_int(static_cast< int >(wxMOD_SHIFT)));
56437 SWIG_Python_SetConstant(d, "MOD_META",SWIG_From_int(static_cast< int >(wxMOD_META)));
56438 SWIG_Python_SetConstant(d, "MOD_WIN",SWIG_From_int(static_cast< int >(wxMOD_WIN)));
56439 SWIG_Python_SetConstant(d, "MOD_CMD",SWIG_From_int(static_cast< int >(wxMOD_CMD)));
56440 SWIG_Python_SetConstant(d, "MOD_ALL",SWIG_From_int(static_cast< int >(wxMOD_ALL)));
56441 SWIG_Python_SetConstant(d, "UPDATE_UI_NONE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_NONE)));
56442 SWIG_Python_SetConstant(d, "UPDATE_UI_RECURSE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_RECURSE)));
56443 SWIG_Python_SetConstant(d, "UPDATE_UI_FROMIDLE",SWIG_From_int(static_cast< int >(wxUPDATE_UI_FROMIDLE)));
56444 PyDict_SetItemString(d,(char*)"cvar", SWIG_globals());
56445 SWIG_addvarlink(SWIG_globals(),(char*)"EmptyString",EmptyString_get, EmptyString_set);
56446 SWIG_Python_SetConstant(d, "BITMAP_TYPE_INVALID",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_INVALID)));
56447 SWIG_Python_SetConstant(d, "BITMAP_TYPE_BMP",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_BMP)));
56448 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICO",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICO)));
56449 SWIG_Python_SetConstant(d, "BITMAP_TYPE_CUR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_CUR)));
56450 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM)));
56451 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XBM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XBM_DATA)));
56452 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM)));
56453 SWIG_Python_SetConstant(d, "BITMAP_TYPE_XPM_DATA",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_XPM_DATA)));
56454 SWIG_Python_SetConstant(d, "BITMAP_TYPE_TIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_TIF)));
56455 SWIG_Python_SetConstant(d, "BITMAP_TYPE_GIF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_GIF)));
56456 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNG)));
56457 SWIG_Python_SetConstant(d, "BITMAP_TYPE_JPEG",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_JPEG)));
56458 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PNM",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PNM)));
56459 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PCX",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PCX)));
56460 SWIG_Python_SetConstant(d, "BITMAP_TYPE_PICT",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_PICT)));
56461 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ICON",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ICON)));
56462 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANI",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANI)));
56463 SWIG_Python_SetConstant(d, "BITMAP_TYPE_IFF",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_IFF)));
56464 SWIG_Python_SetConstant(d, "BITMAP_TYPE_MACCURSOR",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_MACCURSOR)));
56465 SWIG_Python_SetConstant(d, "BITMAP_TYPE_ANY",SWIG_From_int(static_cast< int >(wxBITMAP_TYPE_ANY)));
56466 SWIG_Python_SetConstant(d, "CURSOR_NONE",SWIG_From_int(static_cast< int >(wxCURSOR_NONE)));
56467 SWIG_Python_SetConstant(d, "CURSOR_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_ARROW)));
56468 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_ARROW)));
56469 SWIG_Python_SetConstant(d, "CURSOR_BULLSEYE",SWIG_From_int(static_cast< int >(wxCURSOR_BULLSEYE)));
56470 SWIG_Python_SetConstant(d, "CURSOR_CHAR",SWIG_From_int(static_cast< int >(wxCURSOR_CHAR)));
56471 SWIG_Python_SetConstant(d, "CURSOR_CROSS",SWIG_From_int(static_cast< int >(wxCURSOR_CROSS)));
56472 SWIG_Python_SetConstant(d, "CURSOR_HAND",SWIG_From_int(static_cast< int >(wxCURSOR_HAND)));
56473 SWIG_Python_SetConstant(d, "CURSOR_IBEAM",SWIG_From_int(static_cast< int >(wxCURSOR_IBEAM)));
56474 SWIG_Python_SetConstant(d, "CURSOR_LEFT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_LEFT_BUTTON)));
56475 SWIG_Python_SetConstant(d, "CURSOR_MAGNIFIER",SWIG_From_int(static_cast< int >(wxCURSOR_MAGNIFIER)));
56476 SWIG_Python_SetConstant(d, "CURSOR_MIDDLE_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_MIDDLE_BUTTON)));
56477 SWIG_Python_SetConstant(d, "CURSOR_NO_ENTRY",SWIG_From_int(static_cast< int >(wxCURSOR_NO_ENTRY)));
56478 SWIG_Python_SetConstant(d, "CURSOR_PAINT_BRUSH",SWIG_From_int(static_cast< int >(wxCURSOR_PAINT_BRUSH)));
56479 SWIG_Python_SetConstant(d, "CURSOR_PENCIL",SWIG_From_int(static_cast< int >(wxCURSOR_PENCIL)));
56480 SWIG_Python_SetConstant(d, "CURSOR_POINT_LEFT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_LEFT)));
56481 SWIG_Python_SetConstant(d, "CURSOR_POINT_RIGHT",SWIG_From_int(static_cast< int >(wxCURSOR_POINT_RIGHT)));
56482 SWIG_Python_SetConstant(d, "CURSOR_QUESTION_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_QUESTION_ARROW)));
56483 SWIG_Python_SetConstant(d, "CURSOR_RIGHT_BUTTON",SWIG_From_int(static_cast< int >(wxCURSOR_RIGHT_BUTTON)));
56484 SWIG_Python_SetConstant(d, "CURSOR_SIZENESW",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENESW)));
56485 SWIG_Python_SetConstant(d, "CURSOR_SIZENS",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENS)));
56486 SWIG_Python_SetConstant(d, "CURSOR_SIZENWSE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZENWSE)));
56487 SWIG_Python_SetConstant(d, "CURSOR_SIZEWE",SWIG_From_int(static_cast< int >(wxCURSOR_SIZEWE)));
56488 SWIG_Python_SetConstant(d, "CURSOR_SIZING",SWIG_From_int(static_cast< int >(wxCURSOR_SIZING)));
56489 SWIG_Python_SetConstant(d, "CURSOR_SPRAYCAN",SWIG_From_int(static_cast< int >(wxCURSOR_SPRAYCAN)));
56490 SWIG_Python_SetConstant(d, "CURSOR_WAIT",SWIG_From_int(static_cast< int >(wxCURSOR_WAIT)));
56491 SWIG_Python_SetConstant(d, "CURSOR_WATCH",SWIG_From_int(static_cast< int >(wxCURSOR_WATCH)));
56492 SWIG_Python_SetConstant(d, "CURSOR_BLANK",SWIG_From_int(static_cast< int >(wxCURSOR_BLANK)));
56493 SWIG_Python_SetConstant(d, "CURSOR_DEFAULT",SWIG_From_int(static_cast< int >(wxCURSOR_DEFAULT)));
56494 SWIG_Python_SetConstant(d, "CURSOR_COPY_ARROW",SWIG_From_int(static_cast< int >(wxCURSOR_COPY_ARROW)));
56495 SWIG_Python_SetConstant(d, "CURSOR_ARROWWAIT",SWIG_From_int(static_cast< int >(wxCURSOR_ARROWWAIT)));
56496 SWIG_Python_SetConstant(d, "CURSOR_MAX",SWIG_From_int(static_cast< int >(wxCURSOR_MAX)));
56497 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultPosition",DefaultPosition_get, DefaultPosition_set);
56498 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSize",DefaultSize_get, DefaultSize_set);
56499 SWIG_Python_SetConstant(d, "FromStart",SWIG_From_int(static_cast< int >(wxFromStart)));
56500 SWIG_Python_SetConstant(d, "FromCurrent",SWIG_From_int(static_cast< int >(wxFromCurrent)));
56501 SWIG_Python_SetConstant(d, "FromEnd",SWIG_From_int(static_cast< int >(wxFromEnd)));
56502
56503 wxPyPtrTypeMap_Add("wxInputStream", "wxPyInputStream");
56504
56505
56506 wxPyPtrTypeMap_Add("wxFileSystemHandler", "wxPyFileSystemHandler");
56507
56508 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_TRANSPARENT",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_TRANSPARENT)));
56509 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_THRESHOLD",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_THRESHOLD)));
56510 SWIG_Python_SetConstant(d, "IMAGE_ALPHA_OPAQUE",SWIG_From_int(static_cast< int >(wxIMAGE_ALPHA_OPAQUE)));
56511 SWIG_addvarlink(SWIG_globals(),(char*)"NullImage",NullImage_get, NullImage_set);
56512 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_FILENAME",IMAGE_OPTION_FILENAME_get, IMAGE_OPTION_FILENAME_set);
56513 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BMP_FORMAT",IMAGE_OPTION_BMP_FORMAT_get, IMAGE_OPTION_BMP_FORMAT_set);
56514 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_X",IMAGE_OPTION_CUR_HOTSPOT_X_get, IMAGE_OPTION_CUR_HOTSPOT_X_set);
56515 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_CUR_HOTSPOT_Y",IMAGE_OPTION_CUR_HOTSPOT_Y_get, IMAGE_OPTION_CUR_HOTSPOT_Y_set);
56516 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTION",IMAGE_OPTION_RESOLUTION_get, IMAGE_OPTION_RESOLUTION_set);
56517 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONX",IMAGE_OPTION_RESOLUTIONX_get, IMAGE_OPTION_RESOLUTIONX_set);
56518 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONY",IMAGE_OPTION_RESOLUTIONY_get, IMAGE_OPTION_RESOLUTIONY_set);
56519 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_RESOLUTIONUNIT",IMAGE_OPTION_RESOLUTIONUNIT_get, IMAGE_OPTION_RESOLUTIONUNIT_set);
56520 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_QUALITY",IMAGE_OPTION_QUALITY_get, IMAGE_OPTION_QUALITY_set);
56521 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_INCHES",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_INCHES)));
56522 SWIG_Python_SetConstant(d, "IMAGE_RESOLUTION_CM",SWIG_From_int(static_cast< int >(wxIMAGE_RESOLUTION_CM)));
56523 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_BITSPERSAMPLE",IMAGE_OPTION_BITSPERSAMPLE_get, IMAGE_OPTION_BITSPERSAMPLE_set);
56524 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_SAMPLESPERPIXEL",IMAGE_OPTION_SAMPLESPERPIXEL_get, IMAGE_OPTION_SAMPLESPERPIXEL_set);
56525 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_COMPRESSION",IMAGE_OPTION_COMPRESSION_get, IMAGE_OPTION_COMPRESSION_set);
56526 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_IMAGEDESCRIPTOR",IMAGE_OPTION_IMAGEDESCRIPTOR_get, IMAGE_OPTION_IMAGEDESCRIPTOR_set);
56527 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_FORMAT",IMAGE_OPTION_PNG_FORMAT_get, IMAGE_OPTION_PNG_FORMAT_set);
56528 SWIG_addvarlink(SWIG_globals(),(char*)"IMAGE_OPTION_PNG_BITDEPTH",IMAGE_OPTION_PNG_BITDEPTH_get, IMAGE_OPTION_PNG_BITDEPTH_set);
56529 SWIG_Python_SetConstant(d, "PNG_TYPE_COLOUR",SWIG_From_int(static_cast< int >(wxPNG_TYPE_COLOUR)));
56530 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY)));
56531 SWIG_Python_SetConstant(d, "PNG_TYPE_GREY_RED",SWIG_From_int(static_cast< int >(wxPNG_TYPE_GREY_RED)));
56532 SWIG_Python_SetConstant(d, "BMP_24BPP",SWIG_From_int(static_cast< int >(wxBMP_24BPP)));
56533 SWIG_Python_SetConstant(d, "BMP_8BPP",SWIG_From_int(static_cast< int >(wxBMP_8BPP)));
56534 SWIG_Python_SetConstant(d, "BMP_8BPP_GREY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GREY)));
56535 SWIG_Python_SetConstant(d, "BMP_8BPP_GRAY",SWIG_From_int(static_cast< int >(wxBMP_8BPP_GRAY)));
56536 SWIG_Python_SetConstant(d, "BMP_8BPP_RED",SWIG_From_int(static_cast< int >(wxBMP_8BPP_RED)));
56537 SWIG_Python_SetConstant(d, "BMP_8BPP_PALETTE",SWIG_From_int(static_cast< int >(wxBMP_8BPP_PALETTE)));
56538 SWIG_Python_SetConstant(d, "BMP_4BPP",SWIG_From_int(static_cast< int >(wxBMP_4BPP)));
56539 SWIG_Python_SetConstant(d, "BMP_1BPP",SWIG_From_int(static_cast< int >(wxBMP_1BPP)));
56540 SWIG_Python_SetConstant(d, "BMP_1BPP_BW",SWIG_From_int(static_cast< int >(wxBMP_1BPP_BW)));
56541 SWIG_Python_SetConstant(d, "QUANTIZE_INCLUDE_WINDOWS_COLOURS",SWIG_From_int(static_cast< int >(wxQUANTIZE_INCLUDE_WINDOWS_COLOURS)));
56542 SWIG_Python_SetConstant(d, "QUANTIZE_FILL_DESTINATION_IMAGE",SWIG_From_int(static_cast< int >(wxQUANTIZE_FILL_DESTINATION_IMAGE)));
56543 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_NONE",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_NONE)));
56544 SWIG_Python_SetConstant(d, "EVENT_PROPAGATE_MAX",SWIG_From_int(static_cast< int >(wxEVENT_PROPAGATE_MAX)));
56545 PyDict_SetItemString(d, "wxEVT_NULL", PyInt_FromLong(wxEVT_NULL));
56546 PyDict_SetItemString(d, "wxEVT_FIRST", PyInt_FromLong(wxEVT_FIRST));
56547 PyDict_SetItemString(d, "wxEVT_USER_FIRST", PyInt_FromLong(wxEVT_USER_FIRST));
56548 PyDict_SetItemString(d, "wxEVT_COMMAND_BUTTON_CLICKED", PyInt_FromLong(wxEVT_COMMAND_BUTTON_CLICKED));
56549 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKBOX_CLICKED", PyInt_FromLong(wxEVT_COMMAND_CHECKBOX_CLICKED));
56550 PyDict_SetItemString(d, "wxEVT_COMMAND_CHOICE_SELECTED", PyInt_FromLong(wxEVT_COMMAND_CHOICE_SELECTED));
56551 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_SELECTED));
56552 PyDict_SetItemString(d, "wxEVT_COMMAND_LISTBOX_DOUBLECLICKED", PyInt_FromLong(wxEVT_COMMAND_LISTBOX_DOUBLECLICKED));
56553 PyDict_SetItemString(d, "wxEVT_COMMAND_CHECKLISTBOX_TOGGLED", PyInt_FromLong(wxEVT_COMMAND_CHECKLISTBOX_TOGGLED));
56554 PyDict_SetItemString(d, "wxEVT_COMMAND_MENU_SELECTED", PyInt_FromLong(wxEVT_COMMAND_MENU_SELECTED));
56555 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_CLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_CLICKED));
56556 PyDict_SetItemString(d, "wxEVT_COMMAND_SLIDER_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SLIDER_UPDATED));
56557 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBOX_SELECTED));
56558 PyDict_SetItemString(d, "wxEVT_COMMAND_RADIOBUTTON_SELECTED", PyInt_FromLong(wxEVT_COMMAND_RADIOBUTTON_SELECTED));
56559 PyDict_SetItemString(d, "wxEVT_COMMAND_SCROLLBAR_UPDATED", PyInt_FromLong(wxEVT_COMMAND_SCROLLBAR_UPDATED));
56560 PyDict_SetItemString(d, "wxEVT_COMMAND_VLBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_VLBOX_SELECTED));
56561 PyDict_SetItemString(d, "wxEVT_COMMAND_COMBOBOX_SELECTED", PyInt_FromLong(wxEVT_COMMAND_COMBOBOX_SELECTED));
56562 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_RCLICKED", PyInt_FromLong(wxEVT_COMMAND_TOOL_RCLICKED));
56563 PyDict_SetItemString(d, "wxEVT_COMMAND_TOOL_ENTER", PyInt_FromLong(wxEVT_COMMAND_TOOL_ENTER));
56564 PyDict_SetItemString(d, "wxEVT_LEFT_DOWN", PyInt_FromLong(wxEVT_LEFT_DOWN));
56565 PyDict_SetItemString(d, "wxEVT_LEFT_UP", PyInt_FromLong(wxEVT_LEFT_UP));
56566 PyDict_SetItemString(d, "wxEVT_MIDDLE_DOWN", PyInt_FromLong(wxEVT_MIDDLE_DOWN));
56567 PyDict_SetItemString(d, "wxEVT_MIDDLE_UP", PyInt_FromLong(wxEVT_MIDDLE_UP));
56568 PyDict_SetItemString(d, "wxEVT_RIGHT_DOWN", PyInt_FromLong(wxEVT_RIGHT_DOWN));
56569 PyDict_SetItemString(d, "wxEVT_RIGHT_UP", PyInt_FromLong(wxEVT_RIGHT_UP));
56570 PyDict_SetItemString(d, "wxEVT_MOTION", PyInt_FromLong(wxEVT_MOTION));
56571 PyDict_SetItemString(d, "wxEVT_ENTER_WINDOW", PyInt_FromLong(wxEVT_ENTER_WINDOW));
56572 PyDict_SetItemString(d, "wxEVT_LEAVE_WINDOW", PyInt_FromLong(wxEVT_LEAVE_WINDOW));
56573 PyDict_SetItemString(d, "wxEVT_LEFT_DCLICK", PyInt_FromLong(wxEVT_LEFT_DCLICK));
56574 PyDict_SetItemString(d, "wxEVT_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_MIDDLE_DCLICK));
56575 PyDict_SetItemString(d, "wxEVT_RIGHT_DCLICK", PyInt_FromLong(wxEVT_RIGHT_DCLICK));
56576 PyDict_SetItemString(d, "wxEVT_SET_FOCUS", PyInt_FromLong(wxEVT_SET_FOCUS));
56577 PyDict_SetItemString(d, "wxEVT_KILL_FOCUS", PyInt_FromLong(wxEVT_KILL_FOCUS));
56578 PyDict_SetItemString(d, "wxEVT_CHILD_FOCUS", PyInt_FromLong(wxEVT_CHILD_FOCUS));
56579 PyDict_SetItemString(d, "wxEVT_MOUSEWHEEL", PyInt_FromLong(wxEVT_MOUSEWHEEL));
56580 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DOWN", PyInt_FromLong(wxEVT_NC_LEFT_DOWN));
56581 PyDict_SetItemString(d, "wxEVT_NC_LEFT_UP", PyInt_FromLong(wxEVT_NC_LEFT_UP));
56582 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DOWN", PyInt_FromLong(wxEVT_NC_MIDDLE_DOWN));
56583 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_UP", PyInt_FromLong(wxEVT_NC_MIDDLE_UP));
56584 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DOWN", PyInt_FromLong(wxEVT_NC_RIGHT_DOWN));
56585 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_UP", PyInt_FromLong(wxEVT_NC_RIGHT_UP));
56586 PyDict_SetItemString(d, "wxEVT_NC_MOTION", PyInt_FromLong(wxEVT_NC_MOTION));
56587 PyDict_SetItemString(d, "wxEVT_NC_ENTER_WINDOW", PyInt_FromLong(wxEVT_NC_ENTER_WINDOW));
56588 PyDict_SetItemString(d, "wxEVT_NC_LEAVE_WINDOW", PyInt_FromLong(wxEVT_NC_LEAVE_WINDOW));
56589 PyDict_SetItemString(d, "wxEVT_NC_LEFT_DCLICK", PyInt_FromLong(wxEVT_NC_LEFT_DCLICK));
56590 PyDict_SetItemString(d, "wxEVT_NC_MIDDLE_DCLICK", PyInt_FromLong(wxEVT_NC_MIDDLE_DCLICK));
56591 PyDict_SetItemString(d, "wxEVT_NC_RIGHT_DCLICK", PyInt_FromLong(wxEVT_NC_RIGHT_DCLICK));
56592 PyDict_SetItemString(d, "wxEVT_CHAR", PyInt_FromLong(wxEVT_CHAR));
56593 PyDict_SetItemString(d, "wxEVT_CHAR_HOOK", PyInt_FromLong(wxEVT_CHAR_HOOK));
56594 PyDict_SetItemString(d, "wxEVT_NAVIGATION_KEY", PyInt_FromLong(wxEVT_NAVIGATION_KEY));
56595 PyDict_SetItemString(d, "wxEVT_KEY_DOWN", PyInt_FromLong(wxEVT_KEY_DOWN));
56596 PyDict_SetItemString(d, "wxEVT_KEY_UP", PyInt_FromLong(wxEVT_KEY_UP));
56597 PyDict_SetItemString(d, "wxEVT_HOTKEY", PyInt_FromLong(wxEVT_HOTKEY));
56598 PyDict_SetItemString(d, "wxEVT_SET_CURSOR", PyInt_FromLong(wxEVT_SET_CURSOR));
56599 PyDict_SetItemString(d, "wxEVT_SCROLL_TOP", PyInt_FromLong(wxEVT_SCROLL_TOP));
56600 PyDict_SetItemString(d, "wxEVT_SCROLL_BOTTOM", PyInt_FromLong(wxEVT_SCROLL_BOTTOM));
56601 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEUP", PyInt_FromLong(wxEVT_SCROLL_LINEUP));
56602 PyDict_SetItemString(d, "wxEVT_SCROLL_LINEDOWN", PyInt_FromLong(wxEVT_SCROLL_LINEDOWN));
56603 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEUP", PyInt_FromLong(wxEVT_SCROLL_PAGEUP));
56604 PyDict_SetItemString(d, "wxEVT_SCROLL_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLL_PAGEDOWN));
56605 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLL_THUMBTRACK));
56606 PyDict_SetItemString(d, "wxEVT_SCROLL_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLL_THUMBRELEASE));
56607 PyDict_SetItemString(d, "wxEVT_SCROLL_CHANGED", PyInt_FromLong(wxEVT_SCROLL_CHANGED));
56608 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_TOP", PyInt_FromLong(wxEVT_SCROLLWIN_TOP));
56609 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_BOTTOM", PyInt_FromLong(wxEVT_SCROLLWIN_BOTTOM));
56610 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEUP", PyInt_FromLong(wxEVT_SCROLLWIN_LINEUP));
56611 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_LINEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_LINEDOWN));
56612 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEUP", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEUP));
56613 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_PAGEDOWN", PyInt_FromLong(wxEVT_SCROLLWIN_PAGEDOWN));
56614 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBTRACK", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBTRACK));
56615 PyDict_SetItemString(d, "wxEVT_SCROLLWIN_THUMBRELEASE", PyInt_FromLong(wxEVT_SCROLLWIN_THUMBRELEASE));
56616 PyDict_SetItemString(d, "wxEVT_SIZE", PyInt_FromLong(wxEVT_SIZE));
56617 PyDict_SetItemString(d, "wxEVT_MOVE", PyInt_FromLong(wxEVT_MOVE));
56618 PyDict_SetItemString(d, "wxEVT_CLOSE_WINDOW", PyInt_FromLong(wxEVT_CLOSE_WINDOW));
56619 PyDict_SetItemString(d, "wxEVT_END_SESSION", PyInt_FromLong(wxEVT_END_SESSION));
56620 PyDict_SetItemString(d, "wxEVT_QUERY_END_SESSION", PyInt_FromLong(wxEVT_QUERY_END_SESSION));
56621 PyDict_SetItemString(d, "wxEVT_ACTIVATE_APP", PyInt_FromLong(wxEVT_ACTIVATE_APP));
56622 PyDict_SetItemString(d, "wxEVT_ACTIVATE", PyInt_FromLong(wxEVT_ACTIVATE));
56623 PyDict_SetItemString(d, "wxEVT_CREATE", PyInt_FromLong(wxEVT_CREATE));
56624 PyDict_SetItemString(d, "wxEVT_DESTROY", PyInt_FromLong(wxEVT_DESTROY));
56625 PyDict_SetItemString(d, "wxEVT_SHOW", PyInt_FromLong(wxEVT_SHOW));
56626 PyDict_SetItemString(d, "wxEVT_ICONIZE", PyInt_FromLong(wxEVT_ICONIZE));
56627 PyDict_SetItemString(d, "wxEVT_MAXIMIZE", PyInt_FromLong(wxEVT_MAXIMIZE));
56628 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_CHANGED", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_CHANGED));
56629 PyDict_SetItemString(d, "wxEVT_MOUSE_CAPTURE_LOST", PyInt_FromLong(wxEVT_MOUSE_CAPTURE_LOST));
56630 PyDict_SetItemString(d, "wxEVT_PAINT", PyInt_FromLong(wxEVT_PAINT));
56631 PyDict_SetItemString(d, "wxEVT_ERASE_BACKGROUND", PyInt_FromLong(wxEVT_ERASE_BACKGROUND));
56632 PyDict_SetItemString(d, "wxEVT_NC_PAINT", PyInt_FromLong(wxEVT_NC_PAINT));
56633 PyDict_SetItemString(d, "wxEVT_PAINT_ICON", PyInt_FromLong(wxEVT_PAINT_ICON));
56634 PyDict_SetItemString(d, "wxEVT_MENU_OPEN", PyInt_FromLong(wxEVT_MENU_OPEN));
56635 PyDict_SetItemString(d, "wxEVT_MENU_CLOSE", PyInt_FromLong(wxEVT_MENU_CLOSE));
56636 PyDict_SetItemString(d, "wxEVT_MENU_HIGHLIGHT", PyInt_FromLong(wxEVT_MENU_HIGHLIGHT));
56637 PyDict_SetItemString(d, "wxEVT_CONTEXT_MENU", PyInt_FromLong(wxEVT_CONTEXT_MENU));
56638 PyDict_SetItemString(d, "wxEVT_SYS_COLOUR_CHANGED", PyInt_FromLong(wxEVT_SYS_COLOUR_CHANGED));
56639 PyDict_SetItemString(d, "wxEVT_DISPLAY_CHANGED", PyInt_FromLong(wxEVT_DISPLAY_CHANGED));
56640 PyDict_SetItemString(d, "wxEVT_SETTING_CHANGED", PyInt_FromLong(wxEVT_SETTING_CHANGED));
56641 PyDict_SetItemString(d, "wxEVT_QUERY_NEW_PALETTE", PyInt_FromLong(wxEVT_QUERY_NEW_PALETTE));
56642 PyDict_SetItemString(d, "wxEVT_PALETTE_CHANGED", PyInt_FromLong(wxEVT_PALETTE_CHANGED));
56643 PyDict_SetItemString(d, "wxEVT_DROP_FILES", PyInt_FromLong(wxEVT_DROP_FILES));
56644 PyDict_SetItemString(d, "wxEVT_DRAW_ITEM", PyInt_FromLong(wxEVT_DRAW_ITEM));
56645 PyDict_SetItemString(d, "wxEVT_MEASURE_ITEM", PyInt_FromLong(wxEVT_MEASURE_ITEM));
56646 PyDict_SetItemString(d, "wxEVT_COMPARE_ITEM", PyInt_FromLong(wxEVT_COMPARE_ITEM));
56647 PyDict_SetItemString(d, "wxEVT_INIT_DIALOG", PyInt_FromLong(wxEVT_INIT_DIALOG));
56648 PyDict_SetItemString(d, "wxEVT_IDLE", PyInt_FromLong(wxEVT_IDLE));
56649 PyDict_SetItemString(d, "wxEVT_UPDATE_UI", PyInt_FromLong(wxEVT_UPDATE_UI));
56650 PyDict_SetItemString(d, "wxEVT_SIZING", PyInt_FromLong(wxEVT_SIZING));
56651 PyDict_SetItemString(d, "wxEVT_MOVING", PyInt_FromLong(wxEVT_MOVING));
56652 PyDict_SetItemString(d, "wxEVT_HIBERNATE", PyInt_FromLong(wxEVT_HIBERNATE));
56653 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_COPY", PyInt_FromLong(wxEVT_COMMAND_TEXT_COPY));
56654 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_CUT", PyInt_FromLong(wxEVT_COMMAND_TEXT_CUT));
56655 PyDict_SetItemString(d, "wxEVT_COMMAND_TEXT_PASTE", PyInt_FromLong(wxEVT_COMMAND_TEXT_PASTE));
56656 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_CLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_CLICK));
56657 PyDict_SetItemString(d, "wxEVT_COMMAND_LEFT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_LEFT_DCLICK));
56658 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_CLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_CLICK));
56659 PyDict_SetItemString(d, "wxEVT_COMMAND_RIGHT_DCLICK", PyInt_FromLong(wxEVT_COMMAND_RIGHT_DCLICK));
56660 PyDict_SetItemString(d, "wxEVT_COMMAND_SET_FOCUS", PyInt_FromLong(wxEVT_COMMAND_SET_FOCUS));
56661 PyDict_SetItemString(d, "wxEVT_COMMAND_KILL_FOCUS", PyInt_FromLong(wxEVT_COMMAND_KILL_FOCUS));
56662 PyDict_SetItemString(d, "wxEVT_COMMAND_ENTER", PyInt_FromLong(wxEVT_COMMAND_ENTER));
56663 SWIG_Python_SetConstant(d, "MOUSE_BTN_ANY",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_ANY)));
56664 SWIG_Python_SetConstant(d, "MOUSE_BTN_NONE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_NONE)));
56665 SWIG_Python_SetConstant(d, "MOUSE_BTN_LEFT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_LEFT)));
56666 SWIG_Python_SetConstant(d, "MOUSE_BTN_MIDDLE",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_MIDDLE)));
56667 SWIG_Python_SetConstant(d, "MOUSE_BTN_RIGHT",SWIG_From_int(static_cast< int >(wxMOUSE_BTN_RIGHT)));
56668 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_ALL)));
56669 SWIG_Python_SetConstant(d, "UPDATE_UI_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxUPDATE_UI_PROCESS_SPECIFIED)));
56670 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsBackward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsBackward)));
56671 SWIG_Python_SetConstant(d, "NavigationKeyEvent_IsForward",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::IsForward)));
56672 SWIG_Python_SetConstant(d, "NavigationKeyEvent_WinChange",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::WinChange)));
56673 SWIG_Python_SetConstant(d, "NavigationKeyEvent_FromTab",SWIG_From_int(static_cast< int >(wxNavigationKeyEvent::FromTab)));
56674 SWIG_Python_SetConstant(d, "IDLE_PROCESS_ALL",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_ALL)));
56675 SWIG_Python_SetConstant(d, "IDLE_PROCESS_SPECIFIED",SWIG_From_int(static_cast< int >(wxIDLE_PROCESS_SPECIFIED)));
56676 PyDict_SetItemString(d, "wxEVT_DATE_CHANGED", PyInt_FromLong(wxEVT_DATE_CHANGED));
56677 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_SUPPRESS",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_SUPPRESS)));
56678 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_EXCEPTION",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_EXCEPTION)));
56679 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_DIALOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_DIALOG)));
56680 SWIG_Python_SetConstant(d, "PYAPP_ASSERT_LOG",SWIG_From_int(static_cast< int >(wxPYAPP_ASSERT_LOG)));
56681 SWIG_Python_SetConstant(d, "PRINT_WINDOWS",SWIG_From_int(static_cast< int >(wxPRINT_WINDOWS)));
56682 SWIG_Python_SetConstant(d, "PRINT_POSTSCRIPT",SWIG_From_int(static_cast< int >(wxPRINT_POSTSCRIPT)));
56683 SWIG_addvarlink(SWIG_globals(),(char*)"NullAcceleratorTable",NullAcceleratorTable_get, NullAcceleratorTable_set);
56684 SWIG_addvarlink(SWIG_globals(),(char*)"PanelNameStr",PanelNameStr_get, PanelNameStr_set);
56685 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_NORMAL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_NORMAL)));
56686 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_SMALL",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_SMALL)));
56687 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MINI",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MINI)));
56688 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_LARGE",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_LARGE)));
56689 SWIG_Python_SetConstant(d, "WINDOW_VARIANT_MAX",SWIG_From_int(static_cast< int >(wxWINDOW_VARIANT_MAX)));
56690 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultValidator",DefaultValidator_get, DefaultValidator_set);
56691 SWIG_addvarlink(SWIG_globals(),(char*)"ControlNameStr",ControlNameStr_get, ControlNameStr_set);
56692 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_NONE",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_NONE)));
56693 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_SPECIFIED",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_SPECIFIED)));
56694 SWIG_Python_SetConstant(d, "FLEX_GROWMODE_ALL",SWIG_From_int(static_cast< int >(wxFLEX_GROWMODE_ALL)));
56695 SWIG_addvarlink(SWIG_globals(),(char*)"DefaultSpan",DefaultSpan_get, DefaultSpan_set);
56696 SWIG_Python_SetConstant(d, "Left",SWIG_From_int(static_cast< int >(wxLeft)));
56697 SWIG_Python_SetConstant(d, "Top",SWIG_From_int(static_cast< int >(wxTop)));
56698 SWIG_Python_SetConstant(d, "Right",SWIG_From_int(static_cast< int >(wxRight)));
56699 SWIG_Python_SetConstant(d, "Bottom",SWIG_From_int(static_cast< int >(wxBottom)));
56700 SWIG_Python_SetConstant(d, "Width",SWIG_From_int(static_cast< int >(wxWidth)));
56701 SWIG_Python_SetConstant(d, "Height",SWIG_From_int(static_cast< int >(wxHeight)));
56702 SWIG_Python_SetConstant(d, "Centre",SWIG_From_int(static_cast< int >(wxCentre)));
56703 SWIG_Python_SetConstant(d, "Center",SWIG_From_int(static_cast< int >(wxCenter)));
56704 SWIG_Python_SetConstant(d, "CentreX",SWIG_From_int(static_cast< int >(wxCentreX)));
56705 SWIG_Python_SetConstant(d, "CentreY",SWIG_From_int(static_cast< int >(wxCentreY)));
56706 SWIG_Python_SetConstant(d, "Unconstrained",SWIG_From_int(static_cast< int >(wxUnconstrained)));
56707 SWIG_Python_SetConstant(d, "AsIs",SWIG_From_int(static_cast< int >(wxAsIs)));
56708 SWIG_Python_SetConstant(d, "PercentOf",SWIG_From_int(static_cast< int >(wxPercentOf)));
56709 SWIG_Python_SetConstant(d, "Above",SWIG_From_int(static_cast< int >(wxAbove)));
56710 SWIG_Python_SetConstant(d, "Below",SWIG_From_int(static_cast< int >(wxBelow)));
56711 SWIG_Python_SetConstant(d, "LeftOf",SWIG_From_int(static_cast< int >(wxLeftOf)));
56712 SWIG_Python_SetConstant(d, "RightOf",SWIG_From_int(static_cast< int >(wxRightOf)));
56713 SWIG_Python_SetConstant(d, "SameAs",SWIG_From_int(static_cast< int >(wxSameAs)));
56714 SWIG_Python_SetConstant(d, "Absolute",SWIG_From_int(static_cast< int >(wxAbsolute)));
56715
56716 // Initialize threading, some globals and such
56717 __wxPyPreStart(d);
56718
56719
56720 // Although these are defined in __version__ they need to be here too so
56721 // that an assert can be done to ensure that the wxPython and the wxWindows
56722 // versions match.
56723 PyDict_SetItemString(d,"MAJOR_VERSION", PyInt_FromLong((long)wxMAJOR_VERSION ));
56724 PyDict_SetItemString(d,"MINOR_VERSION", PyInt_FromLong((long)wxMINOR_VERSION ));
56725 PyDict_SetItemString(d,"RELEASE_VERSION", PyInt_FromLong((long)wxRELEASE_NUMBER ));
56726
56727 }
56728
wxWidgets (Impactor)